1 /* -*- buffer-read-only: t -*- 2 * 3 * proto.h 4 * 5 * Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 6 * 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, by Larry Wall and others 7 * 8 * You may distribute under the terms of either the GNU General Public 9 * License or the Artistic License, as specified in the README file. 10 * 11 * !!!!!!! DO NOT EDIT THIS FILE !!!!!!! 12 * This file is built by embed.pl from data in embed.fnc, embed.pl, 13 * pp.sym, intrpvar.h, and perlvars.h. 14 * Any changes made here will be lost! 15 * 16 * Edit those files and run 'make regen_headers' to effect changes. 17 */ 18 19 START_EXTERN_C 20 21 #if defined(PERL_IMPLICIT_SYS) 22 PERL_CALLCONV PerlInterpreter* perl_alloc_using(struct IPerlMem *ipM, struct IPerlMem *ipMS, struct IPerlMem *ipMP, struct IPerlEnv *ipE, struct IPerlStdIO *ipStd, struct IPerlLIO *ipLIO, struct IPerlDir *ipD, struct IPerlSock *ipS, struct IPerlProc *ipP) 23 __attribute__nonnull__(1) 24 __attribute__nonnull__(2) 25 __attribute__nonnull__(3) 26 __attribute__nonnull__(4) 27 __attribute__nonnull__(5) 28 __attribute__nonnull__(6) 29 __attribute__nonnull__(7) 30 __attribute__nonnull__(8) 31 __attribute__nonnull__(9); 32 #define PERL_ARGS_ASSERT_PERL_ALLOC_USING \ 33 assert(ipM); assert(ipMS); assert(ipMP); assert(ipE); assert(ipStd); assert(ipLIO); assert(ipD); assert(ipS); assert(ipP) 34 35 #endif 36 PERL_CALLCONV PerlInterpreter* perl_alloc(void); 37 PERL_CALLCONV void perl_construct(PerlInterpreter *my_perl) 38 __attribute__nonnull__(1); 39 #define PERL_ARGS_ASSERT_PERL_CONSTRUCT \ 40 assert(my_perl) 41 42 PERL_CALLCONV int perl_destruct(PerlInterpreter *my_perl) 43 __attribute__nonnull__(1); 44 #define PERL_ARGS_ASSERT_PERL_DESTRUCT \ 45 assert(my_perl) 46 47 PERL_CALLCONV void perl_free(PerlInterpreter *my_perl) 48 __attribute__nonnull__(1); 49 #define PERL_ARGS_ASSERT_PERL_FREE \ 50 assert(my_perl) 51 52 PERL_CALLCONV int perl_run(PerlInterpreter *my_perl) 53 __attribute__nonnull__(1); 54 #define PERL_ARGS_ASSERT_PERL_RUN \ 55 assert(my_perl) 56 57 PERL_CALLCONV int perl_parse(PerlInterpreter *my_perl, XSINIT_t xsinit, int argc, char** argv, char** env) 58 __attribute__nonnull__(1); 59 #define PERL_ARGS_ASSERT_PERL_PARSE \ 60 assert(my_perl) 61 62 PERL_CALLCONV bool Perl_doing_taint(int argc, char** argv, char** env) 63 __attribute__warn_unused_result__; 64 65 #if defined(USE_ITHREADS) 66 PERL_CALLCONV PerlInterpreter* perl_clone(PerlInterpreter *proto_perl, UV flags) 67 __attribute__nonnull__(1); 68 #define PERL_ARGS_ASSERT_PERL_CLONE \ 69 assert(proto_perl) 70 71 # if defined(PERL_IMPLICIT_SYS) 72 PERL_CALLCONV PerlInterpreter* perl_clone_using(PerlInterpreter *proto_perl, UV flags, struct IPerlMem* ipM, struct IPerlMem* ipMS, struct IPerlMem* ipMP, struct IPerlEnv* ipE, struct IPerlStdIO* ipStd, struct IPerlLIO* ipLIO, struct IPerlDir* ipD, struct IPerlSock* ipS, struct IPerlProc* ipP) 73 __attribute__nonnull__(1) 74 __attribute__nonnull__(3) 75 __attribute__nonnull__(4) 76 __attribute__nonnull__(5) 77 __attribute__nonnull__(6) 78 __attribute__nonnull__(7) 79 __attribute__nonnull__(8) 80 __attribute__nonnull__(9) 81 __attribute__nonnull__(10) 82 __attribute__nonnull__(11); 83 #define PERL_ARGS_ASSERT_PERL_CLONE_USING \ 84 assert(proto_perl); assert(ipM); assert(ipMS); assert(ipMP); assert(ipE); assert(ipStd); assert(ipLIO); assert(ipD); assert(ipS); assert(ipP) 85 86 # endif 87 #endif 88 89 PERL_CALLCONV Malloc_t Perl_malloc(MEM_SIZE nbytes) 90 __attribute__malloc__ 91 __attribute__warn_unused_result__; 92 93 PERL_CALLCONV Malloc_t Perl_calloc(MEM_SIZE elements, MEM_SIZE size) 94 __attribute__malloc__ 95 __attribute__warn_unused_result__; 96 97 PERL_CALLCONV Malloc_t Perl_realloc(Malloc_t where, MEM_SIZE nbytes) 98 __attribute__malloc__ 99 __attribute__warn_unused_result__; 100 101 PERL_CALLCONV Free_t Perl_mfree(Malloc_t where); 102 #if defined(MYMALLOC) 103 PERL_CALLCONV MEM_SIZE Perl_malloced_size(void *p) 104 __attribute__warn_unused_result__ 105 __attribute__nonnull__(1); 106 #define PERL_ARGS_ASSERT_MALLOCED_SIZE \ 107 assert(p) 108 109 PERL_CALLCONV MEM_SIZE Perl_malloc_good_size(size_t nbytes) 110 __attribute__warn_unused_result__; 111 112 #endif 113 114 PERL_CALLCONV void* Perl_get_context(void) 115 __attribute__warn_unused_result__; 116 117 PERL_CALLCONV void Perl_set_context(void *t) 118 __attribute__nonnull__(1); 119 #define PERL_ARGS_ASSERT_SET_CONTEXT \ 120 assert(t) 121 122 PERL_CALLCONV I32 Perl_regcurly(const char *s) 123 __attribute__warn_unused_result__ 124 __attribute__pure__ 125 __attribute__nonnull__(1); 126 #define PERL_ARGS_ASSERT_REGCURLY \ 127 assert(s) 128 129 130 END_EXTERN_C 131 132 /* functions with flag 'n' should come before here */ 133 START_EXTERN_C 134 # include "pp_proto.h" 135 PERL_CALLCONV SV* Perl_amagic_call(pTHX_ SV* left, SV* right, int method, int dir) 136 __attribute__nonnull__(pTHX_1) 137 __attribute__nonnull__(pTHX_2); 138 #define PERL_ARGS_ASSERT_AMAGIC_CALL \ 139 assert(left); assert(right) 140 141 PERL_CALLCONV int Perl_Gv_AMupdate(pTHX_ HV* stash, bool destructing) 142 __attribute__nonnull__(pTHX_1); 143 #define PERL_ARGS_ASSERT_GV_AMUPDATE \ 144 assert(stash) 145 146 PERL_CALLCONV CV* Perl_gv_handler(pTHX_ HV* stash, I32 id) 147 __attribute__warn_unused_result__; 148 149 PERL_CALLCONV OP* Perl_append_elem(pTHX_ I32 optype, OP* first, OP* last); 150 PERL_CALLCONV OP* Perl_append_list(pTHX_ I32 optype, LISTOP* first, LISTOP* last); 151 PERL_CALLCONV I32 Perl_apply(pTHX_ I32 type, SV** mark, SV** sp) 152 __attribute__nonnull__(pTHX_2) 153 __attribute__nonnull__(pTHX_3); 154 #define PERL_ARGS_ASSERT_APPLY \ 155 assert(mark); assert(sp) 156 157 PERL_CALLCONV void Perl_apply_attrs_string(pTHX_ const char *stashpv, CV *cv, const char *attrstr, STRLEN len) 158 __attribute__nonnull__(pTHX_1) 159 __attribute__nonnull__(pTHX_2) 160 __attribute__nonnull__(pTHX_3); 161 #define PERL_ARGS_ASSERT_APPLY_ATTRS_STRING \ 162 assert(stashpv); assert(cv); assert(attrstr) 163 164 PERL_CALLCONV void Perl_av_clear(pTHX_ AV *av) 165 __attribute__nonnull__(pTHX_1); 166 #define PERL_ARGS_ASSERT_AV_CLEAR \ 167 assert(av) 168 169 PERL_CALLCONV SV* Perl_av_delete(pTHX_ AV *av, I32 key, I32 flags) 170 __attribute__nonnull__(pTHX_1); 171 #define PERL_ARGS_ASSERT_AV_DELETE \ 172 assert(av) 173 174 PERL_CALLCONV bool Perl_av_exists(pTHX_ AV *av, I32 key) 175 __attribute__warn_unused_result__ 176 __attribute__nonnull__(pTHX_1); 177 #define PERL_ARGS_ASSERT_AV_EXISTS \ 178 assert(av) 179 180 PERL_CALLCONV void Perl_av_extend(pTHX_ AV *av, I32 key) 181 __attribute__nonnull__(pTHX_1); 182 #define PERL_ARGS_ASSERT_AV_EXTEND \ 183 assert(av) 184 185 PERL_CALLCONV SV** Perl_av_fetch(pTHX_ AV *av, I32 key, I32 lval) 186 __attribute__warn_unused_result__ 187 __attribute__nonnull__(pTHX_1); 188 #define PERL_ARGS_ASSERT_AV_FETCH \ 189 assert(av) 190 191 PERL_CALLCONV void Perl_av_fill(pTHX_ AV *av, I32 fill) 192 __attribute__nonnull__(pTHX_1); 193 #define PERL_ARGS_ASSERT_AV_FILL \ 194 assert(av) 195 196 PERL_CALLCONV I32 Perl_av_len(pTHX_ AV *av) 197 __attribute__warn_unused_result__ 198 __attribute__nonnull__(pTHX_1); 199 #define PERL_ARGS_ASSERT_AV_LEN \ 200 assert(av) 201 202 PERL_CALLCONV AV* Perl_av_make(pTHX_ I32 size, SV **strp) 203 __attribute__warn_unused_result__ 204 __attribute__nonnull__(pTHX_2); 205 #define PERL_ARGS_ASSERT_AV_MAKE \ 206 assert(strp) 207 208 PERL_CALLCONV SV* Perl_av_pop(pTHX_ AV *av) 209 __attribute__nonnull__(pTHX_1); 210 #define PERL_ARGS_ASSERT_AV_POP \ 211 assert(av) 212 213 PERL_CALLCONV void Perl_av_create_and_push(pTHX_ AV **const avp, SV *const val) 214 __attribute__nonnull__(pTHX_1) 215 __attribute__nonnull__(pTHX_2); 216 #define PERL_ARGS_ASSERT_AV_CREATE_AND_PUSH \ 217 assert(avp); assert(val) 218 219 PERL_CALLCONV void Perl_av_push(pTHX_ AV *av, SV *val) 220 __attribute__nonnull__(pTHX_1) 221 __attribute__nonnull__(pTHX_2); 222 #define PERL_ARGS_ASSERT_AV_PUSH \ 223 assert(av); assert(val) 224 225 PERL_CALLCONV void Perl_av_reify(pTHX_ AV *av) 226 __attribute__nonnull__(pTHX_1); 227 #define PERL_ARGS_ASSERT_AV_REIFY \ 228 assert(av) 229 230 PERL_CALLCONV SV* Perl_av_shift(pTHX_ AV *av) 231 __attribute__warn_unused_result__ 232 __attribute__nonnull__(pTHX_1); 233 #define PERL_ARGS_ASSERT_AV_SHIFT \ 234 assert(av) 235 236 PERL_CALLCONV SV** Perl_av_store(pTHX_ AV *av, I32 key, SV *val) 237 __attribute__nonnull__(pTHX_1); 238 #define PERL_ARGS_ASSERT_AV_STORE \ 239 assert(av) 240 241 PERL_CALLCONV void Perl_av_undef(pTHX_ AV *av) 242 __attribute__nonnull__(pTHX_1); 243 #define PERL_ARGS_ASSERT_AV_UNDEF \ 244 assert(av) 245 246 PERL_CALLCONV SV** Perl_av_create_and_unshift_one(pTHX_ AV **const avp, SV *const val) 247 __attribute__nonnull__(pTHX_1) 248 __attribute__nonnull__(pTHX_2); 249 #define PERL_ARGS_ASSERT_AV_CREATE_AND_UNSHIFT_ONE \ 250 assert(avp); assert(val) 251 252 PERL_CALLCONV void Perl_av_unshift(pTHX_ AV *av, I32 num) 253 __attribute__nonnull__(pTHX_1); 254 #define PERL_ARGS_ASSERT_AV_UNSHIFT \ 255 assert(av) 256 257 PERL_CALLCONV SV** Perl_av_arylen_p(pTHX_ AV *av) 258 __attribute__nonnull__(pTHX_1); 259 #define PERL_ARGS_ASSERT_AV_ARYLEN_P \ 260 assert(av) 261 262 PERL_CALLCONV IV* Perl_av_iter_p(pTHX_ AV *av) 263 __attribute__nonnull__(pTHX_1); 264 #define PERL_ARGS_ASSERT_AV_ITER_P \ 265 assert(av) 266 267 #if defined(PERL_IN_AV_C) || defined(PERL_DECL_PROT) 268 STATIC MAGIC* S_get_aux_mg(pTHX_ AV *av) 269 __attribute__nonnull__(pTHX_1); 270 #define PERL_ARGS_ASSERT_GET_AUX_MG \ 271 assert(av) 272 273 #endif 274 PERL_CALLCONV OP* Perl_bind_match(pTHX_ I32 type, OP *left, OP *right) 275 __attribute__warn_unused_result__ 276 __attribute__nonnull__(pTHX_2) 277 __attribute__nonnull__(pTHX_3); 278 #define PERL_ARGS_ASSERT_BIND_MATCH \ 279 assert(left); assert(right) 280 281 PERL_CALLCONV OP* Perl_block_end(pTHX_ I32 floor, OP* seq) 282 __attribute__warn_unused_result__; 283 284 PERL_CALLCONV I32 Perl_block_gimme(pTHX) 285 __attribute__warn_unused_result__; 286 287 PERL_CALLCONV int Perl_block_start(pTHX_ int full) 288 __attribute__warn_unused_result__; 289 290 PERL_CALLCONV void Perl_boot_core_UNIVERSAL(pTHX); 291 PERL_CALLCONV void Perl_boot_core_PerlIO(pTHX); 292 PERL_CALLCONV void Perl_call_list(pTHX_ I32 oldscope, AV *paramList) 293 __attribute__nonnull__(pTHX_2); 294 #define PERL_ARGS_ASSERT_CALL_LIST \ 295 assert(paramList) 296 297 PERL_CALLCONV bool Perl_cando(pTHX_ Mode_t mode, bool effective, const Stat_t* statbufp) 298 __attribute__warn_unused_result__ 299 __attribute__nonnull__(pTHX_3); 300 #define PERL_ARGS_ASSERT_CANDO \ 301 assert(statbufp) 302 303 PERL_CALLCONV U32 Perl_cast_ulong(pTHX_ NV f) 304 __attribute__warn_unused_result__; 305 306 PERL_CALLCONV I32 Perl_cast_i32(pTHX_ NV f) 307 __attribute__warn_unused_result__; 308 309 PERL_CALLCONV IV Perl_cast_iv(pTHX_ NV f) 310 __attribute__warn_unused_result__; 311 312 PERL_CALLCONV UV Perl_cast_uv(pTHX_ NV f) 313 __attribute__warn_unused_result__; 314 315 #if !defined(HAS_TRUNCATE) && !defined(HAS_CHSIZE) && defined(F_FREESP) 316 PERL_CALLCONV I32 Perl_my_chsize(pTHX_ int fd, Off_t length) 317 __attribute__warn_unused_result__; 318 319 #endif 320 PERL_CALLCONV OP* Perl_convert(pTHX_ I32 optype, I32 flags, OP* o) 321 __attribute__warn_unused_result__; 322 323 PERL_CALLCONV PERL_CONTEXT* Perl_create_eval_scope(pTHX_ U32 flags); 324 PERL_CALLCONV void Perl_croak(pTHX_ const char* pat, ...) 325 __attribute__noreturn__ 326 __attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2); 327 328 PERL_CALLCONV void Perl_vcroak(pTHX_ const char* pat, va_list* args) 329 __attribute__noreturn__; 330 331 PERL_CALLCONV void Perl_croak_xs_usage(pTHX_ const CV *const cv, const char *const params) 332 __attribute__noreturn__ 333 __attribute__nonnull__(pTHX_1) 334 __attribute__nonnull__(pTHX_2); 335 #define PERL_ARGS_ASSERT_CROAK_XS_USAGE \ 336 assert(cv); assert(params) 337 338 339 #if defined(PERL_IMPLICIT_CONTEXT) 340 PERL_CALLCONV void Perl_croak_nocontext(const char* pat, ...) 341 __attribute__noreturn__ 342 __attribute__format__null_ok__(__printf__,1,2); 343 344 PERL_CALLCONV OP* Perl_die_nocontext(const char* pat, ...) 345 __attribute__format__null_ok__(__printf__,1,2); 346 347 PERL_CALLCONV void Perl_deb_nocontext(const char* pat, ...) 348 __attribute__format__(__printf__,1,2) 349 __attribute__nonnull__(1); 350 #define PERL_ARGS_ASSERT_DEB_NOCONTEXT \ 351 assert(pat) 352 353 PERL_CALLCONV char* Perl_form_nocontext(const char* pat, ...) 354 __attribute__format__(__printf__,1,2) 355 __attribute__nonnull__(1); 356 #define PERL_ARGS_ASSERT_FORM_NOCONTEXT \ 357 assert(pat) 358 359 PERL_CALLCONV void Perl_load_module_nocontext(U32 flags, SV* name, SV* ver, ...) 360 __attribute__nonnull__(2); 361 #define PERL_ARGS_ASSERT_LOAD_MODULE_NOCONTEXT \ 362 assert(name) 363 364 PERL_CALLCONV SV* Perl_mess_nocontext(const char* pat, ...) 365 __attribute__format__(__printf__,1,2) 366 __attribute__nonnull__(1); 367 #define PERL_ARGS_ASSERT_MESS_NOCONTEXT \ 368 assert(pat) 369 370 PERL_CALLCONV void Perl_warn_nocontext(const char* pat, ...) 371 __attribute__format__(__printf__,1,2) 372 __attribute__nonnull__(1); 373 #define PERL_ARGS_ASSERT_WARN_NOCONTEXT \ 374 assert(pat) 375 376 PERL_CALLCONV void Perl_warner_nocontext(U32 err, const char* pat, ...) 377 __attribute__format__(__printf__,2,3) 378 __attribute__nonnull__(2); 379 #define PERL_ARGS_ASSERT_WARNER_NOCONTEXT \ 380 assert(pat) 381 382 PERL_CALLCONV SV* Perl_newSVpvf_nocontext(const char *const pat, ...) 383 __attribute__format__(__printf__,1,2) 384 __attribute__nonnull__(1); 385 #define PERL_ARGS_ASSERT_NEWSVPVF_NOCONTEXT \ 386 assert(pat) 387 388 PERL_CALLCONV void Perl_sv_catpvf_nocontext(SV *const sv, const char *const pat, ...) 389 __attribute__format__(__printf__,2,3) 390 __attribute__nonnull__(1) 391 __attribute__nonnull__(2); 392 #define PERL_ARGS_ASSERT_SV_CATPVF_NOCONTEXT \ 393 assert(sv); assert(pat) 394 395 PERL_CALLCONV void Perl_sv_setpvf_nocontext(SV *const sv, const char *const pat, ...) 396 __attribute__format__(__printf__,2,3) 397 __attribute__nonnull__(1) 398 __attribute__nonnull__(2); 399 #define PERL_ARGS_ASSERT_SV_SETPVF_NOCONTEXT \ 400 assert(sv); assert(pat) 401 402 PERL_CALLCONV void Perl_sv_catpvf_mg_nocontext(SV *const sv, const char *const pat, ...) 403 __attribute__format__(__printf__,2,3) 404 __attribute__nonnull__(1) 405 __attribute__nonnull__(2); 406 #define PERL_ARGS_ASSERT_SV_CATPVF_MG_NOCONTEXT \ 407 assert(sv); assert(pat) 408 409 PERL_CALLCONV void Perl_sv_setpvf_mg_nocontext(SV *const sv, const char *const pat, ...) 410 __attribute__format__(__printf__,2,3) 411 __attribute__nonnull__(1) 412 __attribute__nonnull__(2); 413 #define PERL_ARGS_ASSERT_SV_SETPVF_MG_NOCONTEXT \ 414 assert(sv); assert(pat) 415 416 PERL_CALLCONV int Perl_fprintf_nocontext(PerlIO *stream, const char *format, ...) 417 __attribute__format__(__printf__,2,3) 418 __attribute__nonnull__(1) 419 __attribute__nonnull__(2); 420 #define PERL_ARGS_ASSERT_FPRINTF_NOCONTEXT \ 421 assert(stream); assert(format) 422 423 PERL_CALLCONV int Perl_printf_nocontext(const char *format, ...) 424 __attribute__format__(__printf__,1,2) 425 __attribute__nonnull__(1); 426 #define PERL_ARGS_ASSERT_PRINTF_NOCONTEXT \ 427 assert(format) 428 429 #endif 430 PERL_CALLCONV void Perl_cv_ckproto_len(pTHX_ const CV* cv, const GV* gv, const char* p, const STRLEN len) 431 __attribute__nonnull__(pTHX_1); 432 #define PERL_ARGS_ASSERT_CV_CKPROTO_LEN \ 433 assert(cv) 434 435 PERL_CALLCONV CV* Perl_cv_clone(pTHX_ CV* proto) 436 __attribute__nonnull__(pTHX_1); 437 #define PERL_ARGS_ASSERT_CV_CLONE \ 438 assert(proto) 439 440 PERL_CALLCONV SV* Perl_gv_const_sv(pTHX_ GV* gv) 441 __attribute__warn_unused_result__ 442 __attribute__nonnull__(pTHX_1); 443 #define PERL_ARGS_ASSERT_GV_CONST_SV \ 444 assert(gv) 445 446 PERL_CALLCONV SV* Perl_cv_const_sv(pTHX_ const CV *const cv) 447 __attribute__warn_unused_result__; 448 449 PERL_CALLCONV SV* Perl_op_const_sv(pTHX_ const OP* o, CV* cv) 450 __attribute__warn_unused_result__; 451 452 PERL_CALLCONV void Perl_cv_undef(pTHX_ CV* cv) 453 __attribute__nonnull__(pTHX_1); 454 #define PERL_ARGS_ASSERT_CV_UNDEF \ 455 assert(cv) 456 457 PERL_CALLCONV void Perl_cx_dump(pTHX_ PERL_CONTEXT* cx) 458 __attribute__nonnull__(pTHX_1); 459 #define PERL_ARGS_ASSERT_CX_DUMP \ 460 assert(cx) 461 462 PERL_CALLCONV SV* Perl_filter_add(pTHX_ filter_t funcp, SV* datasv); 463 PERL_CALLCONV void Perl_filter_del(pTHX_ filter_t funcp) 464 __attribute__nonnull__(pTHX_1); 465 #define PERL_ARGS_ASSERT_FILTER_DEL \ 466 assert(funcp) 467 468 PERL_CALLCONV I32 Perl_filter_read(pTHX_ int idx, SV *buf_sv, int maxlen) 469 __attribute__warn_unused_result__ 470 __attribute__nonnull__(pTHX_2); 471 #define PERL_ARGS_ASSERT_FILTER_READ \ 472 assert(buf_sv) 473 474 PERL_CALLCONV char** Perl_get_op_descs(pTHX) 475 __attribute__warn_unused_result__ 476 __attribute__pure__; 477 478 PERL_CALLCONV char** Perl_get_op_names(pTHX) 479 __attribute__warn_unused_result__ 480 __attribute__pure__; 481 482 PERL_CALLCONV const char* Perl_get_no_modify(pTHX) 483 __attribute__warn_unused_result__ 484 __attribute__pure__; 485 486 PERL_CALLCONV U32* Perl_get_opargs(pTHX) 487 __attribute__warn_unused_result__ 488 __attribute__pure__; 489 490 PERL_CALLCONV PPADDR_t* Perl_get_ppaddr(pTHX) 491 __attribute__warn_unused_result__ 492 __attribute__pure__; 493 494 PERL_CALLCONV I32 Perl_cxinc(pTHX) 495 __attribute__warn_unused_result__; 496 497 PERL_CALLCONV void Perl_deb(pTHX_ const char* pat, ...) 498 __attribute__format__(__printf__,pTHX_1,pTHX_2) 499 __attribute__nonnull__(pTHX_1); 500 #define PERL_ARGS_ASSERT_DEB \ 501 assert(pat) 502 503 PERL_CALLCONV void Perl_vdeb(pTHX_ const char* pat, va_list* args) 504 __attribute__nonnull__(pTHX_1); 505 #define PERL_ARGS_ASSERT_VDEB \ 506 assert(pat) 507 508 PERL_CALLCONV void Perl_debprofdump(pTHX); 509 PERL_CALLCONV I32 Perl_debop(pTHX_ const OP* o) 510 __attribute__nonnull__(pTHX_1); 511 #define PERL_ARGS_ASSERT_DEBOP \ 512 assert(o) 513 514 PERL_CALLCONV I32 Perl_debstack(pTHX); 515 PERL_CALLCONV I32 Perl_debstackptrs(pTHX); 516 PERL_CALLCONV char* Perl_delimcpy(char* to, const char* toend, const char* from, const char* fromend, int delim, I32* retlen) 517 __attribute__nonnull__(1) 518 __attribute__nonnull__(2) 519 __attribute__nonnull__(3) 520 __attribute__nonnull__(4) 521 __attribute__nonnull__(6); 522 #define PERL_ARGS_ASSERT_DELIMCPY \ 523 assert(to); assert(toend); assert(from); assert(fromend); assert(retlen) 524 525 PERL_CALLCONV void Perl_delete_eval_scope(pTHX); 526 PERL_CALLCONV OP* Perl_die(pTHX_ const char* pat, ...) 527 __attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2); 528 529 #if defined(PERL_IN_UTIL_C) || defined(PERL_DECL_PROT) 530 STATIC OP* S_vdie(pTHX_ const char* pat, va_list* args); 531 #endif 532 PERL_CALLCONV void Perl_die_where(pTHX_ SV* msv) 533 __attribute__noreturn__; 534 535 PERL_CALLCONV void Perl_dounwind(pTHX_ I32 cxix); 536 /* PERL_CALLCONV bool Perl_do_aexec(pTHX_ SV* really, SV** mark, SV** sp) 537 __attribute__nonnull__(pTHX_2) 538 __attribute__nonnull__(pTHX_3); */ 539 #define PERL_ARGS_ASSERT_DO_AEXEC \ 540 assert(mark); assert(sp) 541 542 PERL_CALLCONV bool Perl_do_aexec5(pTHX_ SV* really, SV** mark, SV** sp, int fd, int do_report) 543 __attribute__nonnull__(pTHX_2) 544 __attribute__nonnull__(pTHX_3); 545 #define PERL_ARGS_ASSERT_DO_AEXEC5 \ 546 assert(mark); assert(sp) 547 548 PERL_CALLCONV int Perl_do_binmode(pTHX_ PerlIO *fp, int iotype, int mode) 549 __attribute__nonnull__(pTHX_1); 550 #define PERL_ARGS_ASSERT_DO_BINMODE \ 551 assert(fp) 552 553 PERL_CALLCONV void Perl_do_chop(pTHX_ SV *astr, SV *sv) 554 __attribute__nonnull__(pTHX_1) 555 __attribute__nonnull__(pTHX_2); 556 #define PERL_ARGS_ASSERT_DO_CHOP \ 557 assert(astr); assert(sv) 558 559 PERL_CALLCONV bool Perl_do_close(pTHX_ GV* gv, bool not_implicit); 560 PERL_CALLCONV bool Perl_do_eof(pTHX_ GV* gv) 561 __attribute__nonnull__(pTHX_1); 562 #define PERL_ARGS_ASSERT_DO_EOF \ 563 assert(gv) 564 565 566 #ifdef PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION 567 /* PERL_CALLCONV bool Perl_do_exec(pTHX_ const char* cmd) 568 __attribute__nonnull__(pTHX_1); */ 569 #define PERL_ARGS_ASSERT_DO_EXEC \ 570 assert(cmd) 571 572 #else 573 PERL_CALLCONV bool Perl_do_exec(pTHX_ const char* cmd) 574 __attribute__nonnull__(pTHX_1); 575 #define PERL_ARGS_ASSERT_DO_EXEC \ 576 assert(cmd) 577 578 #endif 579 580 #if defined(WIN32) || defined(__SYMBIAN32__) || defined(VMS) 581 PERL_CALLCONV int Perl_do_aspawn(pTHX_ SV* really, SV** mark, SV** sp) 582 __attribute__nonnull__(pTHX_2) 583 __attribute__nonnull__(pTHX_3); 584 #define PERL_ARGS_ASSERT_DO_ASPAWN \ 585 assert(mark); assert(sp) 586 587 PERL_CALLCONV int Perl_do_spawn(pTHX_ char* cmd) 588 __attribute__nonnull__(pTHX_1); 589 #define PERL_ARGS_ASSERT_DO_SPAWN \ 590 assert(cmd) 591 592 PERL_CALLCONV int Perl_do_spawn_nowait(pTHX_ char* cmd) 593 __attribute__nonnull__(pTHX_1); 594 #define PERL_ARGS_ASSERT_DO_SPAWN_NOWAIT \ 595 assert(cmd) 596 597 #endif 598 #if !defined(WIN32) 599 PERL_CALLCONV bool Perl_do_exec3(pTHX_ const char *incmd, int fd, int do_report) 600 __attribute__nonnull__(pTHX_1); 601 #define PERL_ARGS_ASSERT_DO_EXEC3 \ 602 assert(incmd) 603 604 #endif 605 PERL_CALLCONV void Perl_do_execfree(pTHX); 606 #if defined(PERL_IN_DOIO_C) || defined(PERL_DECL_PROT) 607 STATIC void S_exec_failed(pTHX_ const char *cmd, int fd, int do_report) 608 __attribute__nonnull__(pTHX_1); 609 #define PERL_ARGS_ASSERT_EXEC_FAILED \ 610 assert(cmd) 611 612 #endif 613 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM) 614 PERL_CALLCONV I32 Perl_do_ipcctl(pTHX_ I32 optype, SV** mark, SV** sp) 615 __attribute__nonnull__(pTHX_2) 616 __attribute__nonnull__(pTHX_3); 617 #define PERL_ARGS_ASSERT_DO_IPCCTL \ 618 assert(mark); assert(sp) 619 620 PERL_CALLCONV I32 Perl_do_ipcget(pTHX_ I32 optype, SV** mark, SV** sp) 621 __attribute__nonnull__(pTHX_2) 622 __attribute__nonnull__(pTHX_3); 623 #define PERL_ARGS_ASSERT_DO_IPCGET \ 624 assert(mark); assert(sp) 625 626 PERL_CALLCONV I32 Perl_do_msgrcv(pTHX_ SV** mark, SV** sp) 627 __attribute__nonnull__(pTHX_1) 628 __attribute__nonnull__(pTHX_2); 629 #define PERL_ARGS_ASSERT_DO_MSGRCV \ 630 assert(mark); assert(sp) 631 632 PERL_CALLCONV I32 Perl_do_msgsnd(pTHX_ SV** mark, SV** sp) 633 __attribute__nonnull__(pTHX_1) 634 __attribute__nonnull__(pTHX_2); 635 #define PERL_ARGS_ASSERT_DO_MSGSND \ 636 assert(mark); assert(sp) 637 638 PERL_CALLCONV I32 Perl_do_semop(pTHX_ SV** mark, SV** sp) 639 __attribute__nonnull__(pTHX_1) 640 __attribute__nonnull__(pTHX_2); 641 #define PERL_ARGS_ASSERT_DO_SEMOP \ 642 assert(mark); assert(sp) 643 644 PERL_CALLCONV I32 Perl_do_shmio(pTHX_ I32 optype, SV** mark, SV** sp) 645 __attribute__nonnull__(pTHX_2) 646 __attribute__nonnull__(pTHX_3); 647 #define PERL_ARGS_ASSERT_DO_SHMIO \ 648 assert(mark); assert(sp) 649 650 #endif 651 PERL_CALLCONV void Perl_do_join(pTHX_ SV *sv, SV *delim, SV **mark, SV **sp) 652 __attribute__nonnull__(pTHX_1) 653 __attribute__nonnull__(pTHX_2) 654 __attribute__nonnull__(pTHX_3) 655 __attribute__nonnull__(pTHX_4); 656 #define PERL_ARGS_ASSERT_DO_JOIN \ 657 assert(sv); assert(delim); assert(mark); assert(sp) 658 659 PERL_CALLCONV OP* Perl_do_kv(pTHX); 660 /* PERL_CALLCONV bool Perl_do_open(pTHX_ GV* gv, const char* name, I32 len, int as_raw, int rawmode, int rawperm, PerlIO* supplied_fp) 661 __attribute__nonnull__(pTHX_1) 662 __attribute__nonnull__(pTHX_2); */ 663 #define PERL_ARGS_ASSERT_DO_OPEN \ 664 assert(gv); assert(name) 665 666 PERL_CALLCONV bool Perl_do_open9(pTHX_ GV *gv, const char *name, I32 len, int as_raw, int rawmode, int rawperm, PerlIO *supplied_fp, SV *svs, I32 num) 667 __attribute__nonnull__(pTHX_1) 668 __attribute__nonnull__(pTHX_2) 669 __attribute__nonnull__(pTHX_8); 670 #define PERL_ARGS_ASSERT_DO_OPEN9 \ 671 assert(gv); assert(name); assert(svs) 672 673 PERL_CALLCONV bool Perl_do_openn(pTHX_ GV *gv, const char *oname, I32 len, int as_raw, int rawmode, int rawperm, PerlIO *supplied_fp, SV **svp, I32 num) 674 __attribute__nonnull__(pTHX_1) 675 __attribute__nonnull__(pTHX_2); 676 #define PERL_ARGS_ASSERT_DO_OPENN \ 677 assert(gv); assert(oname) 678 679 PERL_CALLCONV bool Perl_do_print(pTHX_ SV* sv, PerlIO* fp) 680 __attribute__nonnull__(pTHX_2); 681 #define PERL_ARGS_ASSERT_DO_PRINT \ 682 assert(fp) 683 684 PERL_CALLCONV OP* Perl_do_readline(pTHX) 685 __attribute__warn_unused_result__; 686 687 PERL_CALLCONV I32 Perl_do_chomp(pTHX_ SV* sv) 688 __attribute__nonnull__(pTHX_1); 689 #define PERL_ARGS_ASSERT_DO_CHOMP \ 690 assert(sv) 691 692 PERL_CALLCONV bool Perl_do_seek(pTHX_ GV* gv, Off_t pos, int whence); 693 PERL_CALLCONV void Perl_do_sprintf(pTHX_ SV* sv, I32 len, SV** sarg) 694 __attribute__nonnull__(pTHX_1) 695 __attribute__nonnull__(pTHX_3); 696 #define PERL_ARGS_ASSERT_DO_SPRINTF \ 697 assert(sv); assert(sarg) 698 699 PERL_CALLCONV Off_t Perl_do_sysseek(pTHX_ GV* gv, Off_t pos, int whence) 700 __attribute__nonnull__(pTHX_1); 701 #define PERL_ARGS_ASSERT_DO_SYSSEEK \ 702 assert(gv) 703 704 PERL_CALLCONV Off_t Perl_do_tell(pTHX_ GV* gv) 705 __attribute__warn_unused_result__ 706 __attribute__nonnull__(pTHX_1); 707 #define PERL_ARGS_ASSERT_DO_TELL \ 708 assert(gv) 709 710 PERL_CALLCONV I32 Perl_do_trans(pTHX_ SV* sv) 711 __attribute__nonnull__(pTHX_1); 712 #define PERL_ARGS_ASSERT_DO_TRANS \ 713 assert(sv) 714 715 PERL_CALLCONV UV Perl_do_vecget(pTHX_ SV* sv, I32 offset, I32 size) 716 __attribute__nonnull__(pTHX_1); 717 #define PERL_ARGS_ASSERT_DO_VECGET \ 718 assert(sv) 719 720 PERL_CALLCONV void Perl_do_vecset(pTHX_ SV* sv) 721 __attribute__nonnull__(pTHX_1); 722 #define PERL_ARGS_ASSERT_DO_VECSET \ 723 assert(sv) 724 725 PERL_CALLCONV void Perl_do_vop(pTHX_ I32 optype, SV* sv, SV* left, SV* right) 726 __attribute__nonnull__(pTHX_2) 727 __attribute__nonnull__(pTHX_3) 728 __attribute__nonnull__(pTHX_4); 729 #define PERL_ARGS_ASSERT_DO_VOP \ 730 assert(sv); assert(left); assert(right) 731 732 PERL_CALLCONV OP* Perl_dofile(pTHX_ OP* term, I32 force_builtin) 733 __attribute__nonnull__(pTHX_1); 734 #define PERL_ARGS_ASSERT_DOFILE \ 735 assert(term) 736 737 PERL_CALLCONV I32 Perl_dowantarray(pTHX) 738 __attribute__warn_unused_result__; 739 740 PERL_CALLCONV void Perl_dump_all(pTHX); 741 PERL_CALLCONV void Perl_dump_all_perl(pTHX_ bool justperl); 742 PERL_CALLCONV void Perl_dump_eval(pTHX); 743 #if defined(DUMP_FDS) 744 PERL_CALLCONV void Perl_dump_fds(pTHX_ char* s) 745 __attribute__nonnull__(pTHX_1); 746 #define PERL_ARGS_ASSERT_DUMP_FDS \ 747 assert(s) 748 749 #endif 750 PERL_CALLCONV void Perl_dump_form(pTHX_ const GV* gv) 751 __attribute__nonnull__(pTHX_1); 752 #define PERL_ARGS_ASSERT_DUMP_FORM \ 753 assert(gv) 754 755 PERL_CALLCONV void Perl_gv_dump(pTHX_ GV* gv) 756 __attribute__nonnull__(pTHX_1); 757 #define PERL_ARGS_ASSERT_GV_DUMP \ 758 assert(gv) 759 760 PERL_CALLCONV void Perl_op_dump(pTHX_ const OP *o) 761 __attribute__nonnull__(pTHX_1); 762 #define PERL_ARGS_ASSERT_OP_DUMP \ 763 assert(o) 764 765 PERL_CALLCONV void Perl_pmop_dump(pTHX_ PMOP* pm); 766 PERL_CALLCONV void Perl_dump_packsubs(pTHX_ const HV* stash) 767 __attribute__nonnull__(pTHX_1); 768 #define PERL_ARGS_ASSERT_DUMP_PACKSUBS \ 769 assert(stash) 770 771 PERL_CALLCONV void Perl_dump_packsubs_perl(pTHX_ const HV* stash, bool justperl) 772 __attribute__nonnull__(pTHX_1); 773 #define PERL_ARGS_ASSERT_DUMP_PACKSUBS_PERL \ 774 assert(stash) 775 776 PERL_CALLCONV void Perl_dump_sub(pTHX_ const GV* gv) 777 __attribute__nonnull__(pTHX_1); 778 #define PERL_ARGS_ASSERT_DUMP_SUB \ 779 assert(gv) 780 781 PERL_CALLCONV void Perl_dump_sub_perl(pTHX_ const GV* gv, bool justperl) 782 __attribute__nonnull__(pTHX_1); 783 #define PERL_ARGS_ASSERT_DUMP_SUB_PERL \ 784 assert(gv) 785 786 PERL_CALLCONV void Perl_fbm_compile(pTHX_ SV* sv, U32 flags) 787 __attribute__nonnull__(pTHX_1); 788 #define PERL_ARGS_ASSERT_FBM_COMPILE \ 789 assert(sv) 790 791 PERL_CALLCONV char* Perl_fbm_instr(pTHX_ unsigned char* big, unsigned char* bigend, SV* littlestr, U32 flags) 792 __attribute__warn_unused_result__ 793 __attribute__nonnull__(pTHX_1) 794 __attribute__nonnull__(pTHX_2) 795 __attribute__nonnull__(pTHX_3); 796 #define PERL_ARGS_ASSERT_FBM_INSTR \ 797 assert(big); assert(bigend); assert(littlestr) 798 799 PERL_CALLCONV char* Perl_find_script(pTHX_ const char *scriptname, bool dosearch, const char *const *const search_ext, I32 flags) 800 __attribute__nonnull__(pTHX_1); 801 #define PERL_ARGS_ASSERT_FIND_SCRIPT \ 802 assert(scriptname) 803 804 #if defined(PERL_IN_OP_C) || defined(PERL_DECL_PROT) 805 STATIC OP* S_force_list(pTHX_ OP* arg); 806 STATIC OP* S_fold_constants(pTHX_ OP *o) 807 __attribute__nonnull__(pTHX_1); 808 #define PERL_ARGS_ASSERT_FOLD_CONSTANTS \ 809 assert(o) 810 811 #endif 812 PERL_CALLCONV char* Perl_form(pTHX_ const char* pat, ...) 813 __attribute__format__(__printf__,pTHX_1,pTHX_2) 814 __attribute__nonnull__(pTHX_1); 815 #define PERL_ARGS_ASSERT_FORM \ 816 assert(pat) 817 818 PERL_CALLCONV char* Perl_vform(pTHX_ const char* pat, va_list* args) 819 __attribute__nonnull__(pTHX_1); 820 #define PERL_ARGS_ASSERT_VFORM \ 821 assert(pat) 822 823 PERL_CALLCONV void Perl_free_tmps(pTHX); 824 #if defined(PERL_IN_OP_C) || defined(PERL_DECL_PROT) 825 STATIC OP* S_gen_constant_list(pTHX_ OP* o); 826 #endif 827 #if !defined(HAS_GETENV_LEN) 828 PERL_CALLCONV char* Perl_getenv_len(pTHX_ const char *env_elem, unsigned long *len) 829 __attribute__nonnull__(pTHX_1) 830 __attribute__nonnull__(pTHX_2); 831 #define PERL_ARGS_ASSERT_GETENV_LEN \ 832 assert(env_elem); assert(len) 833 834 #endif 835 PERL_CALLCONV void Perl_get_db_sub(pTHX_ SV **svp, CV *cv) 836 __attribute__nonnull__(pTHX_2); 837 #define PERL_ARGS_ASSERT_GET_DB_SUB \ 838 assert(cv) 839 840 PERL_CALLCONV void Perl_gp_free(pTHX_ GV* gv); 841 PERL_CALLCONV GP* Perl_gp_ref(pTHX_ GP* gp); 842 PERL_CALLCONV GV* Perl_gv_add_by_type(pTHX_ GV *gv, svtype type); 843 /* PERL_CALLCONV GV* Perl_gv_AVadd(pTHX_ GV *gv); */ 844 /* PERL_CALLCONV GV* Perl_gv_HVadd(pTHX_ GV *gv); */ 845 /* PERL_CALLCONV GV* Perl_gv_IOadd(pTHX_ GV* gv); */ 846 PERL_CALLCONV GV* Perl_gv_autoload4(pTHX_ HV* stash, const char* name, STRLEN len, I32 method) 847 __attribute__warn_unused_result__ 848 __attribute__nonnull__(pTHX_2); 849 #define PERL_ARGS_ASSERT_GV_AUTOLOAD4 \ 850 assert(name) 851 852 PERL_CALLCONV void Perl_gv_check(pTHX_ const HV* stash) 853 __attribute__nonnull__(pTHX_1); 854 #define PERL_ARGS_ASSERT_GV_CHECK \ 855 assert(stash) 856 857 PERL_CALLCONV void Perl_gv_efullname(pTHX_ SV* sv, const GV* gv) 858 __attribute__nonnull__(pTHX_1) 859 __attribute__nonnull__(pTHX_2); 860 #define PERL_ARGS_ASSERT_GV_EFULLNAME \ 861 assert(sv); assert(gv) 862 863 /* PERL_CALLCONV void Perl_gv_efullname3(pTHX_ SV* sv, const GV* gv, const char* prefix) 864 __attribute__nonnull__(pTHX_1) 865 __attribute__nonnull__(pTHX_2); */ 866 #define PERL_ARGS_ASSERT_GV_EFULLNAME3 \ 867 assert(sv); assert(gv) 868 869 PERL_CALLCONV void Perl_gv_efullname4(pTHX_ SV* sv, const GV* gv, const char* prefix, bool keepmain) 870 __attribute__nonnull__(pTHX_1) 871 __attribute__nonnull__(pTHX_2); 872 #define PERL_ARGS_ASSERT_GV_EFULLNAME4 \ 873 assert(sv); assert(gv) 874 875 PERL_CALLCONV GV* Perl_gv_fetchfile(pTHX_ const char* name) 876 __attribute__nonnull__(pTHX_1); 877 #define PERL_ARGS_ASSERT_GV_FETCHFILE \ 878 assert(name) 879 880 PERL_CALLCONV GV* Perl_gv_fetchfile_flags(pTHX_ const char *const name, const STRLEN len, const U32 flags) 881 __attribute__nonnull__(pTHX_1); 882 #define PERL_ARGS_ASSERT_GV_FETCHFILE_FLAGS \ 883 assert(name) 884 885 PERL_CALLCONV GV* Perl_gv_fetchmeth(pTHX_ HV* stash, const char* name, STRLEN len, I32 level) 886 __attribute__nonnull__(pTHX_2); 887 #define PERL_ARGS_ASSERT_GV_FETCHMETH \ 888 assert(name) 889 890 PERL_CALLCONV GV* Perl_gv_fetchmeth_autoload(pTHX_ HV* stash, const char* name, STRLEN len, I32 level) 891 __attribute__nonnull__(pTHX_2); 892 #define PERL_ARGS_ASSERT_GV_FETCHMETH_AUTOLOAD \ 893 assert(name) 894 895 /* PERL_CALLCONV GV* Perl_gv_fetchmethod(pTHX_ HV* stash, const char* name) 896 __attribute__nonnull__(pTHX_1) 897 __attribute__nonnull__(pTHX_2); */ 898 #define PERL_ARGS_ASSERT_GV_FETCHMETHOD \ 899 assert(stash); assert(name) 900 901 PERL_CALLCONV GV* Perl_gv_fetchmethod_autoload(pTHX_ HV* stash, const char* name, I32 autoload) 902 __attribute__nonnull__(pTHX_1) 903 __attribute__nonnull__(pTHX_2); 904 #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_AUTOLOAD \ 905 assert(stash); assert(name) 906 907 PERL_CALLCONV GV* Perl_gv_fetchmethod_flags(pTHX_ HV* stash, const char* name, U32 flags) 908 __attribute__nonnull__(pTHX_1) 909 __attribute__nonnull__(pTHX_2); 910 #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_FLAGS \ 911 assert(stash); assert(name) 912 913 PERL_CALLCONV GV* Perl_gv_fetchpv(pTHX_ const char *nambeg, I32 add, const svtype sv_type) 914 __attribute__nonnull__(pTHX_1); 915 #define PERL_ARGS_ASSERT_GV_FETCHPV \ 916 assert(nambeg) 917 918 PERL_CALLCONV void Perl_gv_fullname(pTHX_ SV* sv, const GV* gv) 919 __attribute__nonnull__(pTHX_1) 920 __attribute__nonnull__(pTHX_2); 921 #define PERL_ARGS_ASSERT_GV_FULLNAME \ 922 assert(sv); assert(gv) 923 924 /* PERL_CALLCONV void Perl_gv_fullname3(pTHX_ SV* sv, const GV* gv, const char* prefix) 925 __attribute__nonnull__(pTHX_1) 926 __attribute__nonnull__(pTHX_2); */ 927 #define PERL_ARGS_ASSERT_GV_FULLNAME3 \ 928 assert(sv); assert(gv) 929 930 PERL_CALLCONV void Perl_gv_fullname4(pTHX_ SV* sv, const GV* gv, const char* prefix, bool keepmain) 931 __attribute__nonnull__(pTHX_1) 932 __attribute__nonnull__(pTHX_2); 933 #define PERL_ARGS_ASSERT_GV_FULLNAME4 \ 934 assert(sv); assert(gv) 935 936 PERL_CALLCONV GP * Perl_newGP(pTHX_ GV *const gv) 937 __attribute__nonnull__(pTHX_1); 938 #define PERL_ARGS_ASSERT_NEWGP \ 939 assert(gv) 940 941 PERL_CALLCONV void Perl_gv_init(pTHX_ GV* gv, HV* stash, const char* name, STRLEN len, int multi) 942 __attribute__nonnull__(pTHX_1) 943 __attribute__nonnull__(pTHX_3); 944 #define PERL_ARGS_ASSERT_GV_INIT \ 945 assert(gv); assert(name) 946 947 PERL_CALLCONV void Perl_gv_name_set(pTHX_ GV* gv, const char *name, U32 len, U32 flags) 948 __attribute__nonnull__(pTHX_1) 949 __attribute__nonnull__(pTHX_2); 950 #define PERL_ARGS_ASSERT_GV_NAME_SET \ 951 assert(gv); assert(name) 952 953 PERL_CALLCONV void Perl_gv_try_downgrade(pTHX_ GV* gv) 954 __attribute__nonnull__(pTHX_1); 955 #define PERL_ARGS_ASSERT_GV_TRY_DOWNGRADE \ 956 assert(gv) 957 958 PERL_CALLCONV HV* Perl_gv_stashpv(pTHX_ const char* name, I32 flags) 959 __attribute__nonnull__(pTHX_1); 960 #define PERL_ARGS_ASSERT_GV_STASHPV \ 961 assert(name) 962 963 PERL_CALLCONV HV* Perl_gv_stashpvn(pTHX_ const char* name, U32 namelen, I32 flags) 964 __attribute__nonnull__(pTHX_1); 965 #define PERL_ARGS_ASSERT_GV_STASHPVN \ 966 assert(name) 967 968 PERL_CALLCONV HV* Perl_gv_stashsv(pTHX_ SV* sv, I32 flags) 969 __attribute__nonnull__(pTHX_1); 970 #define PERL_ARGS_ASSERT_GV_STASHSV \ 971 assert(sv) 972 973 PERL_CALLCONV void Perl_hv_clear(pTHX_ HV *hv); 974 PERL_CALLCONV HV * Perl_hv_copy_hints_hv(pTHX_ HV *const ohv); 975 PERL_CALLCONV void Perl_hv_delayfree_ent(pTHX_ HV *hv, HE *entry) 976 __attribute__nonnull__(pTHX_1); 977 #define PERL_ARGS_ASSERT_HV_DELAYFREE_ENT \ 978 assert(hv) 979 980 /* PERL_CALLCONV SV* Perl_hv_delete(pTHX_ HV *hv, const char *key, I32 klen, I32 flags) 981 __attribute__nonnull__(pTHX_2); */ 982 #define PERL_ARGS_ASSERT_HV_DELETE \ 983 assert(key) 984 985 /* PERL_CALLCONV SV* Perl_hv_delete_ent(pTHX_ HV *hv, SV *keysv, I32 flags, U32 hash) 986 __attribute__nonnull__(pTHX_2); */ 987 #define PERL_ARGS_ASSERT_HV_DELETE_ENT \ 988 assert(keysv) 989 990 /* PERL_CALLCONV bool Perl_hv_exists(pTHX_ HV *hv, const char *key, I32 klen) 991 __attribute__warn_unused_result__ 992 __attribute__nonnull__(pTHX_2); */ 993 #define PERL_ARGS_ASSERT_HV_EXISTS \ 994 assert(key) 995 996 /* PERL_CALLCONV bool Perl_hv_exists_ent(pTHX_ HV *hv, SV *keysv, U32 hash) 997 __attribute__warn_unused_result__ 998 __attribute__nonnull__(pTHX_2); */ 999 #define PERL_ARGS_ASSERT_HV_EXISTS_ENT \ 1000 assert(keysv) 1001 1002 /* PERL_CALLCONV SV** Perl_hv_fetch(pTHX_ HV *hv, const char *key, I32 klen, I32 lval) 1003 __attribute__nonnull__(pTHX_2); */ 1004 #define PERL_ARGS_ASSERT_HV_FETCH \ 1005 assert(key) 1006 1007 /* PERL_CALLCONV HE* Perl_hv_fetch_ent(pTHX_ HV *hv, SV *keysv, I32 lval, U32 hash) 1008 __attribute__nonnull__(pTHX_2); */ 1009 #define PERL_ARGS_ASSERT_HV_FETCH_ENT \ 1010 assert(keysv) 1011 1012 PERL_CALLCONV void* Perl_hv_common(pTHX_ HV *hv, SV *keysv, const char* key, STRLEN klen, int flags, int action, SV *val, U32 hash); 1013 PERL_CALLCONV void* Perl_hv_common_key_len(pTHX_ HV *hv, const char *key, I32 klen_i32, const int action, SV *val, const U32 hash) 1014 __attribute__nonnull__(pTHX_2); 1015 #define PERL_ARGS_ASSERT_HV_COMMON_KEY_LEN \ 1016 assert(key) 1017 1018 PERL_CALLCONV void Perl_hv_free_ent(pTHX_ HV *hv, HE *entryK) 1019 __attribute__nonnull__(pTHX_1); 1020 #define PERL_ARGS_ASSERT_HV_FREE_ENT \ 1021 assert(hv) 1022 1023 PERL_CALLCONV I32 Perl_hv_iterinit(pTHX_ HV *hv) 1024 __attribute__nonnull__(pTHX_1); 1025 #define PERL_ARGS_ASSERT_HV_ITERINIT \ 1026 assert(hv) 1027 1028 PERL_CALLCONV char* Perl_hv_iterkey(pTHX_ HE* entry, I32* retlen) 1029 __attribute__warn_unused_result__ 1030 __attribute__nonnull__(pTHX_1) 1031 __attribute__nonnull__(pTHX_2); 1032 #define PERL_ARGS_ASSERT_HV_ITERKEY \ 1033 assert(entry); assert(retlen) 1034 1035 PERL_CALLCONV SV* Perl_hv_iterkeysv(pTHX_ HE* entry) 1036 __attribute__warn_unused_result__ 1037 __attribute__nonnull__(pTHX_1); 1038 #define PERL_ARGS_ASSERT_HV_ITERKEYSV \ 1039 assert(entry) 1040 1041 /* PERL_CALLCONV HE* Perl_hv_iternext(pTHX_ HV *hv) 1042 __attribute__warn_unused_result__ 1043 __attribute__nonnull__(pTHX_1); */ 1044 #define PERL_ARGS_ASSERT_HV_ITERNEXT \ 1045 assert(hv) 1046 1047 PERL_CALLCONV SV* Perl_hv_iternextsv(pTHX_ HV *hv, char **key, I32 *retlen) 1048 __attribute__warn_unused_result__ 1049 __attribute__nonnull__(pTHX_1) 1050 __attribute__nonnull__(pTHX_2) 1051 __attribute__nonnull__(pTHX_3); 1052 #define PERL_ARGS_ASSERT_HV_ITERNEXTSV \ 1053 assert(hv); assert(key); assert(retlen) 1054 1055 PERL_CALLCONV HE* Perl_hv_iternext_flags(pTHX_ HV *hv, I32 flags) 1056 __attribute__warn_unused_result__ 1057 __attribute__nonnull__(pTHX_1); 1058 #define PERL_ARGS_ASSERT_HV_ITERNEXT_FLAGS \ 1059 assert(hv) 1060 1061 PERL_CALLCONV SV* Perl_hv_iterval(pTHX_ HV *hv, HE *entry) 1062 __attribute__warn_unused_result__ 1063 __attribute__nonnull__(pTHX_1) 1064 __attribute__nonnull__(pTHX_2); 1065 #define PERL_ARGS_ASSERT_HV_ITERVAL \ 1066 assert(hv); assert(entry) 1067 1068 PERL_CALLCONV void Perl_hv_ksplit(pTHX_ HV *hv, IV newmax) 1069 __attribute__nonnull__(pTHX_1); 1070 #define PERL_ARGS_ASSERT_HV_KSPLIT \ 1071 assert(hv) 1072 1073 /* PERL_CALLCONV void Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how) 1074 __attribute__nonnull__(pTHX_1); */ 1075 #define PERL_ARGS_ASSERT_HV_MAGIC \ 1076 assert(hv) 1077 1078 PERL_CALLCONV HV * Perl_refcounted_he_chain_2hv(pTHX_ const struct refcounted_he *c); 1079 PERL_CALLCONV SV * Perl_refcounted_he_fetch(pTHX_ const struct refcounted_he *chain, SV *keysv, const char *key, STRLEN klen, int flags, U32 hash); 1080 PERL_CALLCONV void Perl_refcounted_he_free(pTHX_ struct refcounted_he *he); 1081 PERL_CALLCONV struct refcounted_he * Perl_refcounted_he_new(pTHX_ struct refcounted_he *const parent, SV *const key, SV *const value); 1082 #if defined(PERL_IN_HV_C) || defined(PERL_DECL_PROT) 1083 STATIC struct refcounted_he * S_refcounted_he_new_common(pTHX_ struct refcounted_he *const parent, const char *const key_p, const STRLEN key_len, const char flags, char value_type, const void *value, const STRLEN value_len) 1084 __attribute__nonnull__(pTHX_2) 1085 __attribute__nonnull__(pTHX_6); 1086 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_NEW_COMMON \ 1087 assert(key_p); assert(value) 1088 1089 #endif 1090 /* PERL_CALLCONV SV** Perl_hv_store(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash); */ 1091 /* PERL_CALLCONV HE* Perl_hv_store_ent(pTHX_ HV *hv, SV *key, SV *val, U32 hash); */ 1092 /* PERL_CALLCONV SV** Perl_hv_store_flags(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash, int flags); */ 1093 PERL_CALLCONV void Perl_hv_undef(pTHX_ HV *hv); 1094 PERL_CALLCONV I32 Perl_ibcmp(const char* a, const char* b, I32 len) 1095 __attribute__pure__ 1096 __attribute__nonnull__(1) 1097 __attribute__nonnull__(2); 1098 #define PERL_ARGS_ASSERT_IBCMP \ 1099 assert(a); assert(b) 1100 1101 PERL_CALLCONV I32 Perl_ibcmp_locale(const char* a, const char* b, I32 len) 1102 __attribute__pure__ 1103 __attribute__nonnull__(1) 1104 __attribute__nonnull__(2); 1105 #define PERL_ARGS_ASSERT_IBCMP_LOCALE \ 1106 assert(a); assert(b) 1107 1108 PERL_CALLCONV I32 Perl_ibcmp_utf8(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2) 1109 __attribute__nonnull__(pTHX_1) 1110 __attribute__nonnull__(pTHX_5); 1111 #define PERL_ARGS_ASSERT_IBCMP_UTF8 \ 1112 assert(s1); assert(s2) 1113 1114 #if defined(PERL_IN_DOIO_C) || defined(PERL_DECL_PROT) 1115 STATIC bool S_ingroup(pTHX_ Gid_t testgid, bool effective) 1116 __attribute__warn_unused_result__; 1117 1118 #endif 1119 PERL_CALLCONV void Perl_init_argv_symbols(pTHX_ int argc, char **argv) 1120 __attribute__nonnull__(pTHX_2); 1121 #define PERL_ARGS_ASSERT_INIT_ARGV_SYMBOLS \ 1122 assert(argv) 1123 1124 PERL_CALLCONV void Perl_init_dbargs(pTHX); 1125 PERL_CALLCONV void Perl_init_debugger(pTHX); 1126 PERL_CALLCONV void Perl_init_stacks(pTHX); 1127 PERL_CALLCONV void Perl_init_tm(pTHX_ struct tm *ptm) 1128 __attribute__nonnull__(pTHX_1); 1129 #define PERL_ARGS_ASSERT_INIT_TM \ 1130 assert(ptm) 1131 1132 PERL_CALLCONV U32 Perl_intro_my(pTHX); 1133 PERL_CALLCONV char* Perl_instr(const char* big, const char* little) 1134 __attribute__warn_unused_result__ 1135 __attribute__pure__ 1136 __attribute__nonnull__(1) 1137 __attribute__nonnull__(2); 1138 #define PERL_ARGS_ASSERT_INSTR \ 1139 assert(big); assert(little) 1140 1141 PERL_CALLCONV bool Perl_io_close(pTHX_ IO* io, bool not_implicit) 1142 __attribute__nonnull__(pTHX_1); 1143 #define PERL_ARGS_ASSERT_IO_CLOSE \ 1144 assert(io) 1145 1146 PERL_CALLCONV OP* Perl_invert(pTHX_ OP* cmd) 1147 __attribute__warn_unused_result__; 1148 1149 PERL_CALLCONV I32 Perl_is_lvalue_sub(pTHX) 1150 __attribute__warn_unused_result__; 1151 1152 PERL_CALLCONV U32 Perl_to_uni_upper_lc(pTHX_ U32 c) 1153 __attribute__warn_unused_result__ 1154 __attribute__pure__; 1155 1156 PERL_CALLCONV U32 Perl_to_uni_title_lc(pTHX_ U32 c) 1157 __attribute__warn_unused_result__ 1158 __attribute__pure__; 1159 1160 PERL_CALLCONV U32 Perl_to_uni_lower_lc(pTHX_ U32 c) 1161 __attribute__warn_unused_result__ 1162 __attribute__pure__; 1163 1164 PERL_CALLCONV bool Perl_is_uni_alnum(pTHX_ UV c) 1165 __attribute__warn_unused_result__ 1166 __attribute__pure__; 1167 1168 PERL_CALLCONV bool Perl_is_uni_idfirst(pTHX_ UV c) 1169 __attribute__warn_unused_result__ 1170 __attribute__pure__; 1171 1172 PERL_CALLCONV bool Perl_is_uni_alpha(pTHX_ UV c) 1173 __attribute__warn_unused_result__ 1174 __attribute__pure__; 1175 1176 PERL_CALLCONV bool Perl_is_uni_ascii(pTHX_ UV c) 1177 __attribute__warn_unused_result__ 1178 __attribute__pure__; 1179 1180 PERL_CALLCONV bool Perl_is_uni_space(pTHX_ UV c) 1181 __attribute__warn_unused_result__ 1182 __attribute__pure__; 1183 1184 PERL_CALLCONV bool Perl_is_uni_cntrl(pTHX_ UV c) 1185 __attribute__warn_unused_result__ 1186 __attribute__pure__; 1187 1188 PERL_CALLCONV bool Perl_is_uni_graph(pTHX_ UV c) 1189 __attribute__warn_unused_result__ 1190 __attribute__pure__; 1191 1192 PERL_CALLCONV bool Perl_is_uni_digit(pTHX_ UV c) 1193 __attribute__warn_unused_result__ 1194 __attribute__pure__; 1195 1196 PERL_CALLCONV bool Perl_is_uni_upper(pTHX_ UV c) 1197 __attribute__warn_unused_result__ 1198 __attribute__pure__; 1199 1200 PERL_CALLCONV bool Perl_is_uni_lower(pTHX_ UV c) 1201 __attribute__warn_unused_result__ 1202 __attribute__pure__; 1203 1204 PERL_CALLCONV bool Perl_is_uni_print(pTHX_ UV c) 1205 __attribute__warn_unused_result__ 1206 __attribute__pure__; 1207 1208 PERL_CALLCONV bool Perl_is_uni_punct(pTHX_ UV c) 1209 __attribute__warn_unused_result__ 1210 __attribute__pure__; 1211 1212 PERL_CALLCONV bool Perl_is_uni_xdigit(pTHX_ UV c) 1213 __attribute__warn_unused_result__ 1214 __attribute__pure__; 1215 1216 PERL_CALLCONV UV Perl_to_uni_upper(pTHX_ UV c, U8 *p, STRLEN *lenp) 1217 __attribute__nonnull__(pTHX_2) 1218 __attribute__nonnull__(pTHX_3); 1219 #define PERL_ARGS_ASSERT_TO_UNI_UPPER \ 1220 assert(p); assert(lenp) 1221 1222 PERL_CALLCONV UV Perl_to_uni_title(pTHX_ UV c, U8 *p, STRLEN *lenp) 1223 __attribute__nonnull__(pTHX_2) 1224 __attribute__nonnull__(pTHX_3); 1225 #define PERL_ARGS_ASSERT_TO_UNI_TITLE \ 1226 assert(p); assert(lenp) 1227 1228 PERL_CALLCONV UV Perl_to_uni_lower(pTHX_ UV c, U8 *p, STRLEN *lenp) 1229 __attribute__nonnull__(pTHX_2) 1230 __attribute__nonnull__(pTHX_3); 1231 #define PERL_ARGS_ASSERT_TO_UNI_LOWER \ 1232 assert(p); assert(lenp) 1233 1234 PERL_CALLCONV UV Perl_to_uni_fold(pTHX_ UV c, U8 *p, STRLEN *lenp) 1235 __attribute__nonnull__(pTHX_2) 1236 __attribute__nonnull__(pTHX_3); 1237 #define PERL_ARGS_ASSERT_TO_UNI_FOLD \ 1238 assert(p); assert(lenp) 1239 1240 PERL_CALLCONV bool Perl_is_uni_alnum_lc(pTHX_ UV c) 1241 __attribute__warn_unused_result__ 1242 __attribute__pure__; 1243 1244 PERL_CALLCONV bool Perl_is_uni_idfirst_lc(pTHX_ UV c) 1245 __attribute__warn_unused_result__ 1246 __attribute__pure__; 1247 1248 PERL_CALLCONV bool Perl_is_uni_alpha_lc(pTHX_ UV c) 1249 __attribute__warn_unused_result__ 1250 __attribute__pure__; 1251 1252 PERL_CALLCONV bool Perl_is_uni_ascii_lc(pTHX_ UV c) 1253 __attribute__warn_unused_result__ 1254 __attribute__pure__; 1255 1256 PERL_CALLCONV bool Perl_is_uni_space_lc(pTHX_ UV c) 1257 __attribute__warn_unused_result__ 1258 __attribute__pure__; 1259 1260 PERL_CALLCONV bool Perl_is_uni_cntrl_lc(pTHX_ UV c) 1261 __attribute__warn_unused_result__ 1262 __attribute__pure__; 1263 1264 PERL_CALLCONV bool Perl_is_uni_graph_lc(pTHX_ UV c) 1265 __attribute__warn_unused_result__ 1266 __attribute__pure__; 1267 1268 PERL_CALLCONV bool Perl_is_uni_digit_lc(pTHX_ UV c) 1269 __attribute__warn_unused_result__ 1270 __attribute__pure__; 1271 1272 PERL_CALLCONV bool Perl_is_uni_upper_lc(pTHX_ UV c) 1273 __attribute__warn_unused_result__ 1274 __attribute__pure__; 1275 1276 PERL_CALLCONV bool Perl_is_uni_lower_lc(pTHX_ UV c) 1277 __attribute__warn_unused_result__ 1278 __attribute__pure__; 1279 1280 PERL_CALLCONV bool Perl_is_uni_print_lc(pTHX_ UV c) 1281 __attribute__warn_unused_result__ 1282 __attribute__pure__; 1283 1284 PERL_CALLCONV bool Perl_is_uni_punct_lc(pTHX_ UV c) 1285 __attribute__warn_unused_result__ 1286 __attribute__pure__; 1287 1288 PERL_CALLCONV bool Perl_is_uni_xdigit_lc(pTHX_ UV c) 1289 __attribute__warn_unused_result__ 1290 __attribute__pure__; 1291 1292 PERL_CALLCONV bool Perl_is_ascii_string(const U8 *s, STRLEN len) 1293 __attribute__nonnull__(1); 1294 #define PERL_ARGS_ASSERT_IS_ASCII_STRING \ 1295 assert(s) 1296 1297 PERL_CALLCONV STRLEN Perl_is_utf8_char(const U8 *s) 1298 __attribute__nonnull__(1); 1299 #define PERL_ARGS_ASSERT_IS_UTF8_CHAR \ 1300 assert(s) 1301 1302 PERL_CALLCONV bool Perl_is_utf8_string(const U8 *s, STRLEN len) 1303 __attribute__nonnull__(1); 1304 #define PERL_ARGS_ASSERT_IS_UTF8_STRING \ 1305 assert(s) 1306 1307 /* PERL_CALLCONV bool Perl_is_utf8_string_loc(const U8 *s, STRLEN len, const U8 **p) 1308 __attribute__nonnull__(1); */ 1309 #define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOC \ 1310 assert(s) 1311 1312 PERL_CALLCONV bool Perl_is_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el) 1313 __attribute__nonnull__(1); 1314 #define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOCLEN \ 1315 assert(s) 1316 1317 PERL_CALLCONV bool Perl_is_utf8_alnum(pTHX_ const U8 *p) 1318 __attribute__warn_unused_result__ 1319 __attribute__nonnull__(pTHX_1); 1320 #define PERL_ARGS_ASSERT_IS_UTF8_ALNUM \ 1321 assert(p) 1322 1323 PERL_CALLCONV bool Perl_is_utf8_idfirst(pTHX_ const U8 *p) 1324 __attribute__warn_unused_result__ 1325 __attribute__nonnull__(pTHX_1); 1326 #define PERL_ARGS_ASSERT_IS_UTF8_IDFIRST \ 1327 assert(p) 1328 1329 PERL_CALLCONV bool Perl_is_utf8_idcont(pTHX_ const U8 *p) 1330 __attribute__warn_unused_result__ 1331 __attribute__nonnull__(pTHX_1); 1332 #define PERL_ARGS_ASSERT_IS_UTF8_IDCONT \ 1333 assert(p) 1334 1335 PERL_CALLCONV bool Perl_is_utf8_alpha(pTHX_ const U8 *p) 1336 __attribute__warn_unused_result__ 1337 __attribute__nonnull__(pTHX_1); 1338 #define PERL_ARGS_ASSERT_IS_UTF8_ALPHA \ 1339 assert(p) 1340 1341 PERL_CALLCONV bool Perl_is_utf8_ascii(pTHX_ const U8 *p) 1342 __attribute__warn_unused_result__ 1343 __attribute__nonnull__(pTHX_1); 1344 #define PERL_ARGS_ASSERT_IS_UTF8_ASCII \ 1345 assert(p) 1346 1347 PERL_CALLCONV bool Perl_is_utf8_space(pTHX_ const U8 *p) 1348 __attribute__warn_unused_result__ 1349 __attribute__nonnull__(pTHX_1); 1350 #define PERL_ARGS_ASSERT_IS_UTF8_SPACE \ 1351 assert(p) 1352 1353 PERL_CALLCONV bool Perl_is_utf8_perl_space(pTHX_ const U8 *p) 1354 __attribute__warn_unused_result__ 1355 __attribute__nonnull__(pTHX_1); 1356 #define PERL_ARGS_ASSERT_IS_UTF8_PERL_SPACE \ 1357 assert(p) 1358 1359 PERL_CALLCONV bool Perl_is_utf8_perl_word(pTHX_ const U8 *p) 1360 __attribute__warn_unused_result__ 1361 __attribute__nonnull__(pTHX_1); 1362 #define PERL_ARGS_ASSERT_IS_UTF8_PERL_WORD \ 1363 assert(p) 1364 1365 PERL_CALLCONV bool Perl_is_utf8_cntrl(pTHX_ const U8 *p) 1366 __attribute__warn_unused_result__ 1367 __attribute__nonnull__(pTHX_1); 1368 #define PERL_ARGS_ASSERT_IS_UTF8_CNTRL \ 1369 assert(p) 1370 1371 PERL_CALLCONV bool Perl_is_utf8_digit(pTHX_ const U8 *p) 1372 __attribute__warn_unused_result__ 1373 __attribute__nonnull__(pTHX_1); 1374 #define PERL_ARGS_ASSERT_IS_UTF8_DIGIT \ 1375 assert(p) 1376 1377 PERL_CALLCONV bool Perl_is_utf8_posix_digit(pTHX_ const U8 *p) 1378 __attribute__warn_unused_result__ 1379 __attribute__nonnull__(pTHX_1); 1380 #define PERL_ARGS_ASSERT_IS_UTF8_POSIX_DIGIT \ 1381 assert(p) 1382 1383 PERL_CALLCONV bool Perl_is_utf8_graph(pTHX_ const U8 *p) 1384 __attribute__warn_unused_result__ 1385 __attribute__nonnull__(pTHX_1); 1386 #define PERL_ARGS_ASSERT_IS_UTF8_GRAPH \ 1387 assert(p) 1388 1389 PERL_CALLCONV bool Perl_is_utf8_upper(pTHX_ const U8 *p) 1390 __attribute__warn_unused_result__ 1391 __attribute__nonnull__(pTHX_1); 1392 #define PERL_ARGS_ASSERT_IS_UTF8_UPPER \ 1393 assert(p) 1394 1395 PERL_CALLCONV bool Perl_is_utf8_lower(pTHX_ const U8 *p) 1396 __attribute__warn_unused_result__ 1397 __attribute__nonnull__(pTHX_1); 1398 #define PERL_ARGS_ASSERT_IS_UTF8_LOWER \ 1399 assert(p) 1400 1401 PERL_CALLCONV bool Perl_is_utf8_print(pTHX_ const U8 *p) 1402 __attribute__warn_unused_result__ 1403 __attribute__nonnull__(pTHX_1); 1404 #define PERL_ARGS_ASSERT_IS_UTF8_PRINT \ 1405 assert(p) 1406 1407 PERL_CALLCONV bool Perl_is_utf8_punct(pTHX_ const U8 *p) 1408 __attribute__warn_unused_result__ 1409 __attribute__nonnull__(pTHX_1); 1410 #define PERL_ARGS_ASSERT_IS_UTF8_PUNCT \ 1411 assert(p) 1412 1413 PERL_CALLCONV bool Perl_is_utf8_xdigit(pTHX_ const U8 *p) 1414 __attribute__warn_unused_result__ 1415 __attribute__nonnull__(pTHX_1); 1416 #define PERL_ARGS_ASSERT_IS_UTF8_XDIGIT \ 1417 assert(p) 1418 1419 PERL_CALLCONV bool Perl_is_utf8_mark(pTHX_ const U8 *p) 1420 __attribute__warn_unused_result__ 1421 __attribute__nonnull__(pTHX_1); 1422 #define PERL_ARGS_ASSERT_IS_UTF8_MARK \ 1423 assert(p) 1424 1425 PERL_CALLCONV bool Perl_is_utf8_X_begin(pTHX_ const U8 *p) 1426 __attribute__warn_unused_result__ 1427 __attribute__nonnull__(pTHX_1); 1428 #define PERL_ARGS_ASSERT_IS_UTF8_X_BEGIN \ 1429 assert(p) 1430 1431 PERL_CALLCONV bool Perl_is_utf8_X_extend(pTHX_ const U8 *p) 1432 __attribute__warn_unused_result__ 1433 __attribute__nonnull__(pTHX_1); 1434 #define PERL_ARGS_ASSERT_IS_UTF8_X_EXTEND \ 1435 assert(p) 1436 1437 PERL_CALLCONV bool Perl_is_utf8_X_prepend(pTHX_ const U8 *p) 1438 __attribute__warn_unused_result__ 1439 __attribute__nonnull__(pTHX_1); 1440 #define PERL_ARGS_ASSERT_IS_UTF8_X_PREPEND \ 1441 assert(p) 1442 1443 PERL_CALLCONV bool Perl_is_utf8_X_non_hangul(pTHX_ const U8 *p) 1444 __attribute__warn_unused_result__ 1445 __attribute__nonnull__(pTHX_1); 1446 #define PERL_ARGS_ASSERT_IS_UTF8_X_NON_HANGUL \ 1447 assert(p) 1448 1449 PERL_CALLCONV bool Perl_is_utf8_X_L(pTHX_ const U8 *p) 1450 __attribute__warn_unused_result__ 1451 __attribute__nonnull__(pTHX_1); 1452 #define PERL_ARGS_ASSERT_IS_UTF8_X_L \ 1453 assert(p) 1454 1455 PERL_CALLCONV bool Perl_is_utf8_X_LV(pTHX_ const U8 *p) 1456 __attribute__warn_unused_result__ 1457 __attribute__nonnull__(pTHX_1); 1458 #define PERL_ARGS_ASSERT_IS_UTF8_X_LV \ 1459 assert(p) 1460 1461 PERL_CALLCONV bool Perl_is_utf8_X_LVT(pTHX_ const U8 *p) 1462 __attribute__warn_unused_result__ 1463 __attribute__nonnull__(pTHX_1); 1464 #define PERL_ARGS_ASSERT_IS_UTF8_X_LVT \ 1465 assert(p) 1466 1467 PERL_CALLCONV bool Perl_is_utf8_X_LV_LVT_V(pTHX_ const U8 *p) 1468 __attribute__warn_unused_result__ 1469 __attribute__nonnull__(pTHX_1); 1470 #define PERL_ARGS_ASSERT_IS_UTF8_X_LV_LVT_V \ 1471 assert(p) 1472 1473 PERL_CALLCONV bool Perl_is_utf8_X_T(pTHX_ const U8 *p) 1474 __attribute__warn_unused_result__ 1475 __attribute__nonnull__(pTHX_1); 1476 #define PERL_ARGS_ASSERT_IS_UTF8_X_T \ 1477 assert(p) 1478 1479 PERL_CALLCONV bool Perl_is_utf8_X_V(pTHX_ const U8 *p) 1480 __attribute__warn_unused_result__ 1481 __attribute__nonnull__(pTHX_1); 1482 #define PERL_ARGS_ASSERT_IS_UTF8_X_V \ 1483 assert(p) 1484 1485 PERL_CALLCONV OP* Perl_jmaybe(pTHX_ OP *o) 1486 __attribute__nonnull__(pTHX_1); 1487 #define PERL_ARGS_ASSERT_JMAYBE \ 1488 assert(o) 1489 1490 PERL_CALLCONV I32 Perl_keyword(pTHX_ const char *name, I32 len, bool all_keywords) 1491 __attribute__pure__ 1492 __attribute__nonnull__(pTHX_1); 1493 #define PERL_ARGS_ASSERT_KEYWORD \ 1494 assert(name) 1495 1496 #if defined(PERL_IN_OP_C) || defined(PERL_DECL_PROT) 1497 STATIC OP* S_opt_scalarhv(pTHX_ OP* rep_op) 1498 __attribute__nonnull__(pTHX_1); 1499 #define PERL_ARGS_ASSERT_OPT_SCALARHV \ 1500 assert(rep_op) 1501 1502 STATIC OP* S_is_inplace_av(pTHX_ OP* o, OP* oright) 1503 __attribute__nonnull__(pTHX_1); 1504 #define PERL_ARGS_ASSERT_IS_INPLACE_AV \ 1505 assert(o) 1506 1507 #endif 1508 PERL_CALLCONV void Perl_leave_scope(pTHX_ I32 base); 1509 PERL_CALLCONV void Perl_lex_end(pTHX); 1510 PERL_CALLCONV void Perl_lex_start(pTHX_ SV* line, PerlIO *rsfp, bool new_filter); 1511 PERL_CALLCONV bool Perl_lex_bufutf8(pTHX); 1512 PERL_CALLCONV char* Perl_lex_grow_linestr(pTHX_ STRLEN len); 1513 PERL_CALLCONV void Perl_lex_stuff_pvn(pTHX_ char* pv, STRLEN len, U32 flags) 1514 __attribute__nonnull__(pTHX_1); 1515 #define PERL_ARGS_ASSERT_LEX_STUFF_PVN \ 1516 assert(pv) 1517 1518 PERL_CALLCONV void Perl_lex_stuff_sv(pTHX_ SV* sv, U32 flags) 1519 __attribute__nonnull__(pTHX_1); 1520 #define PERL_ARGS_ASSERT_LEX_STUFF_SV \ 1521 assert(sv) 1522 1523 PERL_CALLCONV void Perl_lex_unstuff(pTHX_ char* ptr) 1524 __attribute__nonnull__(pTHX_1); 1525 #define PERL_ARGS_ASSERT_LEX_UNSTUFF \ 1526 assert(ptr) 1527 1528 PERL_CALLCONV void Perl_lex_read_to(pTHX_ char* ptr) 1529 __attribute__nonnull__(pTHX_1); 1530 #define PERL_ARGS_ASSERT_LEX_READ_TO \ 1531 assert(ptr) 1532 1533 PERL_CALLCONV void Perl_lex_discard_to(pTHX_ char* ptr) 1534 __attribute__nonnull__(pTHX_1); 1535 #define PERL_ARGS_ASSERT_LEX_DISCARD_TO \ 1536 assert(ptr) 1537 1538 PERL_CALLCONV bool Perl_lex_next_chunk(pTHX_ U32 flags); 1539 PERL_CALLCONV I32 Perl_lex_peek_unichar(pTHX_ U32 flags); 1540 PERL_CALLCONV I32 Perl_lex_read_unichar(pTHX_ U32 flags); 1541 PERL_CALLCONV void Perl_lex_read_space(pTHX_ U32 flags); 1542 PERL_CALLCONV void Perl_op_null(pTHX_ OP* o) 1543 __attribute__nonnull__(pTHX_1); 1544 #define PERL_ARGS_ASSERT_OP_NULL \ 1545 assert(o) 1546 1547 PERL_CALLCONV void Perl_op_clear(pTHX_ OP* o) 1548 __attribute__nonnull__(pTHX_1); 1549 #define PERL_ARGS_ASSERT_OP_CLEAR \ 1550 assert(o) 1551 1552 PERL_CALLCONV void Perl_op_refcnt_lock(pTHX); 1553 PERL_CALLCONV void Perl_op_refcnt_unlock(pTHX); 1554 #if defined(PERL_IN_OP_C) || defined(PERL_DECL_PROT) 1555 STATIC OP* S_linklist(pTHX_ OP *o) 1556 __attribute__nonnull__(pTHX_1); 1557 #define PERL_ARGS_ASSERT_LINKLIST \ 1558 assert(o) 1559 1560 STATIC OP* S_listkids(pTHX_ OP* o); 1561 #endif 1562 PERL_CALLCONV OP* Perl_list(pTHX_ OP* o); 1563 PERL_CALLCONV void Perl_load_module(pTHX_ U32 flags, SV* name, SV* ver, ...) 1564 __attribute__nonnull__(pTHX_2); 1565 #define PERL_ARGS_ASSERT_LOAD_MODULE \ 1566 assert(name) 1567 1568 PERL_CALLCONV void Perl_vload_module(pTHX_ U32 flags, SV* name, SV* ver, va_list* args) 1569 __attribute__nonnull__(pTHX_2); 1570 #define PERL_ARGS_ASSERT_VLOAD_MODULE \ 1571 assert(name) 1572 1573 PERL_CALLCONV OP* Perl_localize(pTHX_ OP *o, I32 lex) 1574 __attribute__nonnull__(pTHX_1); 1575 #define PERL_ARGS_ASSERT_LOCALIZE \ 1576 assert(o) 1577 1578 PERL_CALLCONV I32 Perl_looks_like_number(pTHX_ SV *const sv) 1579 __attribute__warn_unused_result__ 1580 __attribute__nonnull__(pTHX_1); 1581 #define PERL_ARGS_ASSERT_LOOKS_LIKE_NUMBER \ 1582 assert(sv) 1583 1584 PERL_CALLCONV UV Perl_grok_bin(pTHX_ const char* start, STRLEN* len_p, I32* flags, NV *result) 1585 __attribute__nonnull__(pTHX_1) 1586 __attribute__nonnull__(pTHX_2) 1587 __attribute__nonnull__(pTHX_3); 1588 #define PERL_ARGS_ASSERT_GROK_BIN \ 1589 assert(start); assert(len_p); assert(flags) 1590 1591 PERL_CALLCONV UV Perl_grok_hex(pTHX_ const char* start, STRLEN* len_p, I32* flags, NV *result) 1592 __attribute__nonnull__(pTHX_1) 1593 __attribute__nonnull__(pTHX_2) 1594 __attribute__nonnull__(pTHX_3); 1595 #define PERL_ARGS_ASSERT_GROK_HEX \ 1596 assert(start); assert(len_p); assert(flags) 1597 1598 PERL_CALLCONV int Perl_grok_number(pTHX_ const char *pv, STRLEN len, UV *valuep) 1599 __attribute__nonnull__(pTHX_1); 1600 #define PERL_ARGS_ASSERT_GROK_NUMBER \ 1601 assert(pv) 1602 1603 PERL_CALLCONV bool Perl_grok_numeric_radix(pTHX_ const char **sp, const char *send) 1604 __attribute__warn_unused_result__ 1605 __attribute__nonnull__(pTHX_1) 1606 __attribute__nonnull__(pTHX_2); 1607 #define PERL_ARGS_ASSERT_GROK_NUMERIC_RADIX \ 1608 assert(sp); assert(send) 1609 1610 PERL_CALLCONV UV Perl_grok_oct(pTHX_ const char* start, STRLEN* len_p, I32* flags, NV *result) 1611 __attribute__nonnull__(pTHX_1) 1612 __attribute__nonnull__(pTHX_2) 1613 __attribute__nonnull__(pTHX_3); 1614 #define PERL_ARGS_ASSERT_GROK_OCT \ 1615 assert(start); assert(len_p); assert(flags) 1616 1617 PERL_CALLCONV int Perl_magic_clearenv(pTHX_ SV* sv, MAGIC* mg) 1618 __attribute__nonnull__(pTHX_1) 1619 __attribute__nonnull__(pTHX_2); 1620 #define PERL_ARGS_ASSERT_MAGIC_CLEARENV \ 1621 assert(sv); assert(mg) 1622 1623 PERL_CALLCONV int Perl_magic_clear_all_env(pTHX_ SV* sv, MAGIC* mg) 1624 __attribute__nonnull__(pTHX_1) 1625 __attribute__nonnull__(pTHX_2); 1626 #define PERL_ARGS_ASSERT_MAGIC_CLEAR_ALL_ENV \ 1627 assert(sv); assert(mg) 1628 1629 PERL_CALLCONV int Perl_magic_clearhint(pTHX_ SV* sv, MAGIC* mg) 1630 __attribute__nonnull__(pTHX_1) 1631 __attribute__nonnull__(pTHX_2); 1632 #define PERL_ARGS_ASSERT_MAGIC_CLEARHINT \ 1633 assert(sv); assert(mg) 1634 1635 PERL_CALLCONV int Perl_magic_clearhints(pTHX_ SV* sv, MAGIC* mg) 1636 __attribute__nonnull__(pTHX_1) 1637 __attribute__nonnull__(pTHX_2); 1638 #define PERL_ARGS_ASSERT_MAGIC_CLEARHINTS \ 1639 assert(sv); assert(mg) 1640 1641 PERL_CALLCONV int Perl_magic_clearisa(pTHX_ SV* sv, MAGIC* mg) 1642 __attribute__nonnull__(pTHX_2); 1643 #define PERL_ARGS_ASSERT_MAGIC_CLEARISA \ 1644 assert(mg) 1645 1646 PERL_CALLCONV int Perl_magic_clearpack(pTHX_ SV* sv, MAGIC* mg) 1647 __attribute__nonnull__(pTHX_1) 1648 __attribute__nonnull__(pTHX_2); 1649 #define PERL_ARGS_ASSERT_MAGIC_CLEARPACK \ 1650 assert(sv); assert(mg) 1651 1652 PERL_CALLCONV int Perl_magic_clearsig(pTHX_ SV* sv, MAGIC* mg) 1653 __attribute__nonnull__(pTHX_1) 1654 __attribute__nonnull__(pTHX_2); 1655 #define PERL_ARGS_ASSERT_MAGIC_CLEARSIG \ 1656 assert(sv); assert(mg) 1657 1658 PERL_CALLCONV int Perl_magic_existspack(pTHX_ SV* sv, const MAGIC* mg) 1659 __attribute__nonnull__(pTHX_1) 1660 __attribute__nonnull__(pTHX_2); 1661 #define PERL_ARGS_ASSERT_MAGIC_EXISTSPACK \ 1662 assert(sv); assert(mg) 1663 1664 PERL_CALLCONV int Perl_magic_freeovrld(pTHX_ SV* sv, MAGIC* mg) 1665 __attribute__nonnull__(pTHX_1) 1666 __attribute__nonnull__(pTHX_2); 1667 #define PERL_ARGS_ASSERT_MAGIC_FREEOVRLD \ 1668 assert(sv); assert(mg) 1669 1670 PERL_CALLCONV int Perl_magic_get(pTHX_ SV* sv, MAGIC* mg) 1671 __attribute__nonnull__(pTHX_1) 1672 __attribute__nonnull__(pTHX_2); 1673 #define PERL_ARGS_ASSERT_MAGIC_GET \ 1674 assert(sv); assert(mg) 1675 1676 PERL_CALLCONV int Perl_magic_getarylen(pTHX_ SV* sv, const MAGIC* mg) 1677 __attribute__nonnull__(pTHX_1) 1678 __attribute__nonnull__(pTHX_2); 1679 #define PERL_ARGS_ASSERT_MAGIC_GETARYLEN \ 1680 assert(sv); assert(mg) 1681 1682 PERL_CALLCONV int Perl_magic_getdefelem(pTHX_ SV* sv, MAGIC* mg) 1683 __attribute__nonnull__(pTHX_1) 1684 __attribute__nonnull__(pTHX_2); 1685 #define PERL_ARGS_ASSERT_MAGIC_GETDEFELEM \ 1686 assert(sv); assert(mg) 1687 1688 PERL_CALLCONV int Perl_magic_getnkeys(pTHX_ SV* sv, MAGIC* mg) 1689 __attribute__nonnull__(pTHX_1) 1690 __attribute__nonnull__(pTHX_2); 1691 #define PERL_ARGS_ASSERT_MAGIC_GETNKEYS \ 1692 assert(sv); assert(mg) 1693 1694 PERL_CALLCONV int Perl_magic_getpack(pTHX_ SV* sv, MAGIC* mg) 1695 __attribute__nonnull__(pTHX_1) 1696 __attribute__nonnull__(pTHX_2); 1697 #define PERL_ARGS_ASSERT_MAGIC_GETPACK \ 1698 assert(sv); assert(mg) 1699 1700 PERL_CALLCONV int Perl_magic_getpos(pTHX_ SV* sv, MAGIC* mg) 1701 __attribute__nonnull__(pTHX_1) 1702 __attribute__nonnull__(pTHX_2); 1703 #define PERL_ARGS_ASSERT_MAGIC_GETPOS \ 1704 assert(sv); assert(mg) 1705 1706 PERL_CALLCONV int Perl_magic_getsig(pTHX_ SV* sv, MAGIC* mg) 1707 __attribute__nonnull__(pTHX_1) 1708 __attribute__nonnull__(pTHX_2); 1709 #define PERL_ARGS_ASSERT_MAGIC_GETSIG \ 1710 assert(sv); assert(mg) 1711 1712 PERL_CALLCONV int Perl_magic_getsubstr(pTHX_ SV* sv, MAGIC* mg) 1713 __attribute__nonnull__(pTHX_1) 1714 __attribute__nonnull__(pTHX_2); 1715 #define PERL_ARGS_ASSERT_MAGIC_GETSUBSTR \ 1716 assert(sv); assert(mg) 1717 1718 PERL_CALLCONV int Perl_magic_gettaint(pTHX_ SV* sv, MAGIC* mg) 1719 __attribute__nonnull__(pTHX_1) 1720 __attribute__nonnull__(pTHX_2); 1721 #define PERL_ARGS_ASSERT_MAGIC_GETTAINT \ 1722 assert(sv); assert(mg) 1723 1724 PERL_CALLCONV int Perl_magic_getuvar(pTHX_ SV* sv, MAGIC* mg) 1725 __attribute__nonnull__(pTHX_1) 1726 __attribute__nonnull__(pTHX_2); 1727 #define PERL_ARGS_ASSERT_MAGIC_GETUVAR \ 1728 assert(sv); assert(mg) 1729 1730 PERL_CALLCONV int Perl_magic_getvec(pTHX_ SV* sv, MAGIC* mg) 1731 __attribute__nonnull__(pTHX_1) 1732 __attribute__nonnull__(pTHX_2); 1733 #define PERL_ARGS_ASSERT_MAGIC_GETVEC \ 1734 assert(sv); assert(mg) 1735 1736 PERL_CALLCONV U32 Perl_magic_len(pTHX_ SV* sv, MAGIC* mg) 1737 __attribute__nonnull__(pTHX_1) 1738 __attribute__nonnull__(pTHX_2); 1739 #define PERL_ARGS_ASSERT_MAGIC_LEN \ 1740 assert(sv); assert(mg) 1741 1742 PERL_CALLCONV int Perl_magic_nextpack(pTHX_ SV *sv, MAGIC *mg, SV *key) 1743 __attribute__nonnull__(pTHX_1) 1744 __attribute__nonnull__(pTHX_2) 1745 __attribute__nonnull__(pTHX_3); 1746 #define PERL_ARGS_ASSERT_MAGIC_NEXTPACK \ 1747 assert(sv); assert(mg); assert(key) 1748 1749 PERL_CALLCONV U32 Perl_magic_regdata_cnt(pTHX_ SV* sv, MAGIC* mg) 1750 __attribute__nonnull__(pTHX_1) 1751 __attribute__nonnull__(pTHX_2); 1752 #define PERL_ARGS_ASSERT_MAGIC_REGDATA_CNT \ 1753 assert(sv); assert(mg) 1754 1755 PERL_CALLCONV int Perl_magic_regdatum_get(pTHX_ SV* sv, MAGIC* mg) 1756 __attribute__nonnull__(pTHX_1) 1757 __attribute__nonnull__(pTHX_2); 1758 #define PERL_ARGS_ASSERT_MAGIC_REGDATUM_GET \ 1759 assert(sv); assert(mg) 1760 1761 PERL_CALLCONV int Perl_magic_regdatum_set(pTHX_ SV* sv, MAGIC* mg) 1762 __attribute__noreturn__ 1763 __attribute__nonnull__(pTHX_1) 1764 __attribute__nonnull__(pTHX_2); 1765 #define PERL_ARGS_ASSERT_MAGIC_REGDATUM_SET \ 1766 assert(sv); assert(mg) 1767 1768 PERL_CALLCONV int Perl_magic_set(pTHX_ SV* sv, MAGIC* mg) 1769 __attribute__nonnull__(pTHX_1) 1770 __attribute__nonnull__(pTHX_2); 1771 #define PERL_ARGS_ASSERT_MAGIC_SET \ 1772 assert(sv); assert(mg) 1773 1774 PERL_CALLCONV int Perl_magic_setamagic(pTHX_ SV* sv, MAGIC* mg) 1775 __attribute__nonnull__(pTHX_1) 1776 __attribute__nonnull__(pTHX_2); 1777 #define PERL_ARGS_ASSERT_MAGIC_SETAMAGIC \ 1778 assert(sv); assert(mg) 1779 1780 PERL_CALLCONV int Perl_magic_setarylen(pTHX_ SV* sv, MAGIC* mg) 1781 __attribute__nonnull__(pTHX_1) 1782 __attribute__nonnull__(pTHX_2); 1783 #define PERL_ARGS_ASSERT_MAGIC_SETARYLEN \ 1784 assert(sv); assert(mg) 1785 1786 PERL_CALLCONV int Perl_magic_freearylen_p(pTHX_ SV* sv, MAGIC* mg) 1787 __attribute__nonnull__(pTHX_1) 1788 __attribute__nonnull__(pTHX_2); 1789 #define PERL_ARGS_ASSERT_MAGIC_FREEARYLEN_P \ 1790 assert(sv); assert(mg) 1791 1792 PERL_CALLCONV int Perl_magic_setdbline(pTHX_ SV* sv, MAGIC* mg) 1793 __attribute__nonnull__(pTHX_1) 1794 __attribute__nonnull__(pTHX_2); 1795 #define PERL_ARGS_ASSERT_MAGIC_SETDBLINE \ 1796 assert(sv); assert(mg) 1797 1798 PERL_CALLCONV int Perl_magic_setdefelem(pTHX_ SV* sv, MAGIC* mg) 1799 __attribute__nonnull__(pTHX_1) 1800 __attribute__nonnull__(pTHX_2); 1801 #define PERL_ARGS_ASSERT_MAGIC_SETDEFELEM \ 1802 assert(sv); assert(mg) 1803 1804 PERL_CALLCONV int Perl_magic_setenv(pTHX_ SV* sv, MAGIC* mg) 1805 __attribute__nonnull__(pTHX_1) 1806 __attribute__nonnull__(pTHX_2); 1807 #define PERL_ARGS_ASSERT_MAGIC_SETENV \ 1808 assert(sv); assert(mg) 1809 1810 PERL_CALLCONV int Perl_magic_sethint(pTHX_ SV* sv, MAGIC* mg) 1811 __attribute__nonnull__(pTHX_1) 1812 __attribute__nonnull__(pTHX_2); 1813 #define PERL_ARGS_ASSERT_MAGIC_SETHINT \ 1814 assert(sv); assert(mg) 1815 1816 PERL_CALLCONV int Perl_magic_setisa(pTHX_ SV* sv, MAGIC* mg) 1817 __attribute__nonnull__(pTHX_1) 1818 __attribute__nonnull__(pTHX_2); 1819 #define PERL_ARGS_ASSERT_MAGIC_SETISA \ 1820 assert(sv); assert(mg) 1821 1822 PERL_CALLCONV int Perl_magic_setmglob(pTHX_ SV* sv, MAGIC* mg) 1823 __attribute__nonnull__(pTHX_1) 1824 __attribute__nonnull__(pTHX_2); 1825 #define PERL_ARGS_ASSERT_MAGIC_SETMGLOB \ 1826 assert(sv); assert(mg) 1827 1828 PERL_CALLCONV int Perl_magic_setnkeys(pTHX_ SV* sv, MAGIC* mg) 1829 __attribute__nonnull__(pTHX_1) 1830 __attribute__nonnull__(pTHX_2); 1831 #define PERL_ARGS_ASSERT_MAGIC_SETNKEYS \ 1832 assert(sv); assert(mg) 1833 1834 PERL_CALLCONV int Perl_magic_setpack(pTHX_ SV* sv, MAGIC* mg) 1835 __attribute__nonnull__(pTHX_1) 1836 __attribute__nonnull__(pTHX_2); 1837 #define PERL_ARGS_ASSERT_MAGIC_SETPACK \ 1838 assert(sv); assert(mg) 1839 1840 PERL_CALLCONV int Perl_magic_setpos(pTHX_ SV* sv, MAGIC* mg) 1841 __attribute__nonnull__(pTHX_1) 1842 __attribute__nonnull__(pTHX_2); 1843 #define PERL_ARGS_ASSERT_MAGIC_SETPOS \ 1844 assert(sv); assert(mg) 1845 1846 PERL_CALLCONV int Perl_magic_setregexp(pTHX_ SV* sv, MAGIC* mg) 1847 __attribute__nonnull__(pTHX_1) 1848 __attribute__nonnull__(pTHX_2); 1849 #define PERL_ARGS_ASSERT_MAGIC_SETREGEXP \ 1850 assert(sv); assert(mg) 1851 1852 PERL_CALLCONV int Perl_magic_setsig(pTHX_ SV* sv, MAGIC* mg) 1853 __attribute__nonnull__(pTHX_2); 1854 #define PERL_ARGS_ASSERT_MAGIC_SETSIG \ 1855 assert(mg) 1856 1857 PERL_CALLCONV int Perl_magic_setsubstr(pTHX_ SV* sv, MAGIC* mg) 1858 __attribute__nonnull__(pTHX_1) 1859 __attribute__nonnull__(pTHX_2); 1860 #define PERL_ARGS_ASSERT_MAGIC_SETSUBSTR \ 1861 assert(sv); assert(mg) 1862 1863 PERL_CALLCONV int Perl_magic_settaint(pTHX_ SV* sv, MAGIC* mg) 1864 __attribute__nonnull__(pTHX_1) 1865 __attribute__nonnull__(pTHX_2); 1866 #define PERL_ARGS_ASSERT_MAGIC_SETTAINT \ 1867 assert(sv); assert(mg) 1868 1869 PERL_CALLCONV int Perl_magic_setuvar(pTHX_ SV* sv, MAGIC* mg) 1870 __attribute__nonnull__(pTHX_1) 1871 __attribute__nonnull__(pTHX_2); 1872 #define PERL_ARGS_ASSERT_MAGIC_SETUVAR \ 1873 assert(sv); assert(mg) 1874 1875 PERL_CALLCONV int Perl_magic_setvec(pTHX_ SV* sv, MAGIC* mg) 1876 __attribute__nonnull__(pTHX_1) 1877 __attribute__nonnull__(pTHX_2); 1878 #define PERL_ARGS_ASSERT_MAGIC_SETVEC \ 1879 assert(sv); assert(mg) 1880 1881 PERL_CALLCONV int Perl_magic_setutf8(pTHX_ SV* sv, MAGIC* mg) 1882 __attribute__nonnull__(pTHX_1) 1883 __attribute__nonnull__(pTHX_2); 1884 #define PERL_ARGS_ASSERT_MAGIC_SETUTF8 \ 1885 assert(sv); assert(mg) 1886 1887 PERL_CALLCONV int Perl_magic_set_all_env(pTHX_ SV* sv, MAGIC* mg) 1888 __attribute__nonnull__(pTHX_1) 1889 __attribute__nonnull__(pTHX_2); 1890 #define PERL_ARGS_ASSERT_MAGIC_SET_ALL_ENV \ 1891 assert(sv); assert(mg) 1892 1893 PERL_CALLCONV U32 Perl_magic_sizepack(pTHX_ SV* sv, MAGIC* mg) 1894 __attribute__nonnull__(pTHX_1) 1895 __attribute__nonnull__(pTHX_2); 1896 #define PERL_ARGS_ASSERT_MAGIC_SIZEPACK \ 1897 assert(sv); assert(mg) 1898 1899 PERL_CALLCONV int Perl_magic_wipepack(pTHX_ SV* sv, MAGIC* mg) 1900 __attribute__nonnull__(pTHX_1) 1901 __attribute__nonnull__(pTHX_2); 1902 #define PERL_ARGS_ASSERT_MAGIC_WIPEPACK \ 1903 assert(sv); assert(mg) 1904 1905 PERL_CALLCONV void Perl_markstack_grow(pTHX); 1906 #if defined(USE_LOCALE_COLLATE) 1907 PERL_CALLCONV int Perl_magic_setcollxfrm(pTHX_ SV* sv, MAGIC* mg) 1908 __attribute__nonnull__(pTHX_1) 1909 __attribute__nonnull__(pTHX_2); 1910 #define PERL_ARGS_ASSERT_MAGIC_SETCOLLXFRM \ 1911 assert(sv); assert(mg) 1912 1913 PERL_CALLCONV char* Perl_mem_collxfrm(pTHX_ const char* s, STRLEN len, STRLEN* xlen) 1914 __attribute__nonnull__(pTHX_1) 1915 __attribute__nonnull__(pTHX_3); 1916 #define PERL_ARGS_ASSERT_MEM_COLLXFRM \ 1917 assert(s); assert(xlen) 1918 1919 #endif 1920 PERL_CALLCONV SV* Perl_mess(pTHX_ const char* pat, ...) 1921 __attribute__format__(__printf__,pTHX_1,pTHX_2) 1922 __attribute__nonnull__(pTHX_1); 1923 #define PERL_ARGS_ASSERT_MESS \ 1924 assert(pat) 1925 1926 PERL_CALLCONV SV* Perl_vmess(pTHX_ const char* pat, va_list* args) 1927 __attribute__nonnull__(pTHX_1); 1928 #define PERL_ARGS_ASSERT_VMESS \ 1929 assert(pat) 1930 1931 PERL_CALLCONV void Perl_qerror(pTHX_ SV* err) 1932 __attribute__nonnull__(pTHX_1); 1933 #define PERL_ARGS_ASSERT_QERROR \ 1934 assert(err) 1935 1936 PERL_CALLCONV void Perl_sortsv(pTHX_ SV** array, size_t num_elts, SVCOMPARE_t cmp) 1937 __attribute__nonnull__(pTHX_3); 1938 #define PERL_ARGS_ASSERT_SORTSV \ 1939 assert(cmp) 1940 1941 PERL_CALLCONV void Perl_sortsv_flags(pTHX_ SV** array, size_t num_elts, SVCOMPARE_t cmp, U32 flags) 1942 __attribute__nonnull__(pTHX_3); 1943 #define PERL_ARGS_ASSERT_SORTSV_FLAGS \ 1944 assert(cmp) 1945 1946 PERL_CALLCONV int Perl_mg_clear(pTHX_ SV* sv) 1947 __attribute__nonnull__(pTHX_1); 1948 #define PERL_ARGS_ASSERT_MG_CLEAR \ 1949 assert(sv) 1950 1951 PERL_CALLCONV int Perl_mg_copy(pTHX_ SV *sv, SV *nsv, const char *key, I32 klen) 1952 __attribute__nonnull__(pTHX_1) 1953 __attribute__nonnull__(pTHX_2); 1954 #define PERL_ARGS_ASSERT_MG_COPY \ 1955 assert(sv); assert(nsv) 1956 1957 PERL_CALLCONV void Perl_mg_localize(pTHX_ SV* sv, SV* nsv, bool setmagic) 1958 __attribute__nonnull__(pTHX_1) 1959 __attribute__nonnull__(pTHX_2); 1960 #define PERL_ARGS_ASSERT_MG_LOCALIZE \ 1961 assert(sv); assert(nsv) 1962 1963 PERL_CALLCONV MAGIC* Perl_mg_find(pTHX_ const SV* sv, int type) 1964 __attribute__warn_unused_result__; 1965 1966 PERL_CALLCONV int Perl_mg_free(pTHX_ SV* sv) 1967 __attribute__nonnull__(pTHX_1); 1968 #define PERL_ARGS_ASSERT_MG_FREE \ 1969 assert(sv) 1970 1971 PERL_CALLCONV int Perl_mg_get(pTHX_ SV* sv) 1972 __attribute__nonnull__(pTHX_1); 1973 #define PERL_ARGS_ASSERT_MG_GET \ 1974 assert(sv) 1975 1976 PERL_CALLCONV U32 Perl_mg_length(pTHX_ SV* sv) 1977 __attribute__nonnull__(pTHX_1); 1978 #define PERL_ARGS_ASSERT_MG_LENGTH \ 1979 assert(sv) 1980 1981 PERL_CALLCONV void Perl_mg_magical(pTHX_ SV* sv) 1982 __attribute__nonnull__(pTHX_1); 1983 #define PERL_ARGS_ASSERT_MG_MAGICAL \ 1984 assert(sv) 1985 1986 PERL_CALLCONV int Perl_mg_set(pTHX_ SV* sv) 1987 __attribute__nonnull__(pTHX_1); 1988 #define PERL_ARGS_ASSERT_MG_SET \ 1989 assert(sv) 1990 1991 PERL_CALLCONV I32 Perl_mg_size(pTHX_ SV* sv) 1992 __attribute__nonnull__(pTHX_1); 1993 #define PERL_ARGS_ASSERT_MG_SIZE \ 1994 assert(sv) 1995 1996 PERL_CALLCONV void Perl_mini_mktime(pTHX_ struct tm *ptm) 1997 __attribute__nonnull__(pTHX_1); 1998 #define PERL_ARGS_ASSERT_MINI_MKTIME \ 1999 assert(ptm) 2000 2001 PERL_CALLCONV OP* Perl_mod(pTHX_ OP* o, I32 type); 2002 PERL_CALLCONV int Perl_mode_from_discipline(pTHX_ const char* s, STRLEN len); 2003 PERL_CALLCONV const char* Perl_moreswitches(pTHX_ const char* s) 2004 __attribute__nonnull__(pTHX_1); 2005 #define PERL_ARGS_ASSERT_MORESWITCHES \ 2006 assert(s) 2007 2008 PERL_CALLCONV NV Perl_my_atof(pTHX_ const char *s) 2009 __attribute__nonnull__(pTHX_1); 2010 #define PERL_ARGS_ASSERT_MY_ATOF \ 2011 assert(s) 2012 2013 #if (!defined(HAS_MEMCPY) && !defined(HAS_BCOPY)) || (!defined(HAS_MEMMOVE) && !defined(HAS_SAFE_MEMCPY) && !defined(HAS_SAFE_BCOPY)) 2014 PERL_CALLCONV char* Perl_my_bcopy(const char* from, char* to, I32 len) 2015 __attribute__nonnull__(1) 2016 __attribute__nonnull__(2); 2017 #define PERL_ARGS_ASSERT_MY_BCOPY \ 2018 assert(from); assert(to) 2019 2020 #endif 2021 #if !defined(HAS_BZERO) && !defined(HAS_MEMSET) 2022 PERL_CALLCONV char* Perl_my_bzero(char* loc, I32 len) 2023 __attribute__nonnull__(1); 2024 #define PERL_ARGS_ASSERT_MY_BZERO \ 2025 assert(loc) 2026 2027 #endif 2028 PERL_CALLCONV void Perl_my_exit(pTHX_ U32 status) 2029 __attribute__noreturn__; 2030 2031 PERL_CALLCONV void Perl_my_failure_exit(pTHX) 2032 __attribute__noreturn__; 2033 2034 PERL_CALLCONV I32 Perl_my_fflush_all(pTHX); 2035 PERL_CALLCONV Pid_t Perl_my_fork(void); 2036 PERL_CALLCONV void Perl_atfork_lock(void); 2037 PERL_CALLCONV void Perl_atfork_unlock(void); 2038 PERL_CALLCONV I32 Perl_my_lstat(pTHX); 2039 #if !defined(HAS_MEMCMP) || !defined(HAS_SANE_MEMCMP) 2040 PERL_CALLCONV I32 Perl_my_memcmp(const char* s1, const char* s2, I32 len) 2041 __attribute__pure__ 2042 __attribute__nonnull__(1) 2043 __attribute__nonnull__(2); 2044 #define PERL_ARGS_ASSERT_MY_MEMCMP \ 2045 assert(s1); assert(s2) 2046 2047 #endif 2048 #if !defined(HAS_MEMSET) 2049 PERL_CALLCONV void* Perl_my_memset(char* loc, I32 ch, I32 len) 2050 __attribute__nonnull__(1); 2051 #define PERL_ARGS_ASSERT_MY_MEMSET \ 2052 assert(loc) 2053 2054 #endif 2055 PERL_CALLCONV I32 Perl_my_pclose(pTHX_ PerlIO* ptr); 2056 PERL_CALLCONV PerlIO* Perl_my_popen(pTHX_ const char* cmd, const char* mode) 2057 __attribute__nonnull__(pTHX_1) 2058 __attribute__nonnull__(pTHX_2); 2059 #define PERL_ARGS_ASSERT_MY_POPEN \ 2060 assert(cmd); assert(mode) 2061 2062 PERL_CALLCONV PerlIO* Perl_my_popen_list(pTHX_ const char* mode, int n, SV ** args) 2063 __attribute__nonnull__(pTHX_1) 2064 __attribute__nonnull__(pTHX_3); 2065 #define PERL_ARGS_ASSERT_MY_POPEN_LIST \ 2066 assert(mode); assert(args) 2067 2068 PERL_CALLCONV void Perl_my_setenv(pTHX_ const char* nam, const char* val); 2069 PERL_CALLCONV I32 Perl_my_stat(pTHX); 2070 PERL_CALLCONV char * Perl_my_strftime(pTHX_ const char *fmt, int sec, int min, int hour, int mday, int mon, int year, int wday, int yday, int isdst) 2071 __attribute__nonnull__(pTHX_1); 2072 #define PERL_ARGS_ASSERT_MY_STRFTIME \ 2073 assert(fmt) 2074 2075 #if defined(MYSWAP) 2076 PERL_CALLCONV short Perl_my_swap(pTHX_ short s) 2077 __attribute__malloc__ 2078 __attribute__warn_unused_result__ 2079 __attribute__pure__; 2080 2081 PERL_CALLCONV long Perl_my_htonl(pTHX_ long l) 2082 __attribute__malloc__ 2083 __attribute__warn_unused_result__ 2084 __attribute__pure__; 2085 2086 PERL_CALLCONV long Perl_my_ntohl(pTHX_ long l) 2087 __attribute__malloc__ 2088 __attribute__warn_unused_result__ 2089 __attribute__pure__; 2090 2091 #endif 2092 PERL_CALLCONV void Perl_my_unexec(pTHX); 2093 PERL_CALLCONV OP* Perl_newANONLIST(pTHX_ OP* o) 2094 __attribute__malloc__ 2095 __attribute__warn_unused_result__; 2096 2097 PERL_CALLCONV OP* Perl_newANONHASH(pTHX_ OP* o) 2098 __attribute__malloc__ 2099 __attribute__warn_unused_result__; 2100 2101 PERL_CALLCONV OP* Perl_newANONSUB(pTHX_ I32 floor, OP* proto, OP* block); 2102 PERL_CALLCONV OP* Perl_newASSIGNOP(pTHX_ I32 flags, OP* left, I32 optype, OP* right) 2103 __attribute__malloc__ 2104 __attribute__warn_unused_result__; 2105 2106 PERL_CALLCONV OP* Perl_newCONDOP(pTHX_ I32 flags, OP* first, OP* trueop, OP* falseop) 2107 __attribute__malloc__ 2108 __attribute__warn_unused_result__ 2109 __attribute__nonnull__(pTHX_2); 2110 #define PERL_ARGS_ASSERT_NEWCONDOP \ 2111 assert(first) 2112 2113 PERL_CALLCONV CV* Perl_newCONSTSUB(pTHX_ HV* stash, const char* name, SV* sv); 2114 #ifdef PERL_MAD 2115 PERL_CALLCONV OP* Perl_newFORM(pTHX_ I32 floor, OP* o, OP* block); 2116 #else 2117 PERL_CALLCONV void Perl_newFORM(pTHX_ I32 floor, OP* o, OP* block); 2118 #endif 2119 PERL_CALLCONV OP* Perl_newFOROP(pTHX_ I32 flags, char* label, line_t forline, OP* sv, OP* expr, OP* block, OP* cont) 2120 __attribute__malloc__ 2121 __attribute__warn_unused_result__ 2122 __attribute__nonnull__(pTHX_5); 2123 #define PERL_ARGS_ASSERT_NEWFOROP \ 2124 assert(expr) 2125 2126 PERL_CALLCONV OP* Perl_newGIVENOP(pTHX_ OP* cond, OP* block, PADOFFSET defsv_off) 2127 __attribute__malloc__ 2128 __attribute__warn_unused_result__ 2129 __attribute__nonnull__(pTHX_1) 2130 __attribute__nonnull__(pTHX_2); 2131 #define PERL_ARGS_ASSERT_NEWGIVENOP \ 2132 assert(cond); assert(block) 2133 2134 PERL_CALLCONV OP* Perl_newLOGOP(pTHX_ I32 optype, I32 flags, OP *first, OP *other) 2135 __attribute__malloc__ 2136 __attribute__warn_unused_result__ 2137 __attribute__nonnull__(pTHX_3) 2138 __attribute__nonnull__(pTHX_4); 2139 #define PERL_ARGS_ASSERT_NEWLOGOP \ 2140 assert(first); assert(other) 2141 2142 PERL_CALLCONV OP* Perl_newLOOPEX(pTHX_ I32 type, OP* label) 2143 __attribute__malloc__ 2144 __attribute__warn_unused_result__ 2145 __attribute__nonnull__(pTHX_2); 2146 #define PERL_ARGS_ASSERT_NEWLOOPEX \ 2147 assert(label) 2148 2149 PERL_CALLCONV OP* Perl_newLOOPOP(pTHX_ I32 flags, I32 debuggable, OP* expr, OP* block) 2150 __attribute__malloc__ 2151 __attribute__warn_unused_result__; 2152 2153 PERL_CALLCONV OP* Perl_newNULLLIST(pTHX) 2154 __attribute__malloc__ 2155 __attribute__warn_unused_result__; 2156 2157 PERL_CALLCONV OP* Perl_newOP(pTHX_ I32 optype, I32 flags) 2158 __attribute__malloc__ 2159 __attribute__warn_unused_result__; 2160 2161 PERL_CALLCONV void Perl_newPROG(pTHX_ OP* o) 2162 __attribute__nonnull__(pTHX_1); 2163 #define PERL_ARGS_ASSERT_NEWPROG \ 2164 assert(o) 2165 2166 PERL_CALLCONV OP* Perl_newRANGE(pTHX_ I32 flags, OP* left, OP* right) 2167 __attribute__malloc__ 2168 __attribute__warn_unused_result__ 2169 __attribute__nonnull__(pTHX_2) 2170 __attribute__nonnull__(pTHX_3); 2171 #define PERL_ARGS_ASSERT_NEWRANGE \ 2172 assert(left); assert(right) 2173 2174 PERL_CALLCONV OP* Perl_newSLICEOP(pTHX_ I32 flags, OP* subscript, OP* listop) 2175 __attribute__malloc__ 2176 __attribute__warn_unused_result__; 2177 2178 PERL_CALLCONV OP* Perl_newSTATEOP(pTHX_ I32 flags, char* label, OP* o) 2179 __attribute__malloc__ 2180 __attribute__warn_unused_result__; 2181 2182 PERL_CALLCONV CV* Perl_newSUB(pTHX_ I32 floor, OP* o, OP* proto, OP* block); 2183 PERL_CALLCONV CV * Perl_newXS_flags(pTHX_ const char *name, XSUBADDR_t subaddr, const char *const filename, const char *const proto, U32 flags) 2184 __attribute__nonnull__(pTHX_2) 2185 __attribute__nonnull__(pTHX_3); 2186 #define PERL_ARGS_ASSERT_NEWXS_FLAGS \ 2187 assert(subaddr); assert(filename) 2188 2189 PERL_CALLCONV CV* Perl_newXS(pTHX_ const char *name, XSUBADDR_t subaddr, const char *filename) 2190 __attribute__nonnull__(pTHX_2) 2191 __attribute__nonnull__(pTHX_3); 2192 #define PERL_ARGS_ASSERT_NEWXS \ 2193 assert(subaddr); assert(filename) 2194 2195 /* PERL_CALLCONV AV* Perl_newAV(pTHX) 2196 __attribute__warn_unused_result__; */ 2197 2198 PERL_CALLCONV OP* Perl_newAVREF(pTHX_ OP* o) 2199 __attribute__malloc__ 2200 __attribute__warn_unused_result__ 2201 __attribute__nonnull__(pTHX_1); 2202 #define PERL_ARGS_ASSERT_NEWAVREF \ 2203 assert(o) 2204 2205 PERL_CALLCONV OP* Perl_newBINOP(pTHX_ I32 type, I32 flags, OP* first, OP* last) 2206 __attribute__malloc__ 2207 __attribute__warn_unused_result__; 2208 2209 PERL_CALLCONV OP* Perl_newCVREF(pTHX_ I32 flags, OP* o) 2210 __attribute__malloc__ 2211 __attribute__warn_unused_result__; 2212 2213 PERL_CALLCONV OP* Perl_newGVOP(pTHX_ I32 type, I32 flags, GV* gv) 2214 __attribute__malloc__ 2215 __attribute__warn_unused_result__ 2216 __attribute__nonnull__(pTHX_3); 2217 #define PERL_ARGS_ASSERT_NEWGVOP \ 2218 assert(gv) 2219 2220 PERL_CALLCONV GV* Perl_newGVgen(pTHX_ const char* pack) 2221 __attribute__malloc__ 2222 __attribute__warn_unused_result__ 2223 __attribute__nonnull__(pTHX_1); 2224 #define PERL_ARGS_ASSERT_NEWGVGEN \ 2225 assert(pack) 2226 2227 PERL_CALLCONV OP* Perl_newGVREF(pTHX_ I32 type, OP* o) 2228 __attribute__malloc__ 2229 __attribute__warn_unused_result__; 2230 2231 PERL_CALLCONV OP* Perl_newHVREF(pTHX_ OP* o) 2232 __attribute__malloc__ 2233 __attribute__warn_unused_result__ 2234 __attribute__nonnull__(pTHX_1); 2235 #define PERL_ARGS_ASSERT_NEWHVREF \ 2236 assert(o) 2237 2238 /* PERL_CALLCONV HV* Perl_newHV(pTHX) 2239 __attribute__warn_unused_result__; */ 2240 2241 PERL_CALLCONV HV* Perl_newHVhv(pTHX_ HV *hv) 2242 __attribute__malloc__ 2243 __attribute__warn_unused_result__; 2244 2245 /* PERL_CALLCONV IO* Perl_newIO(pTHX) 2246 __attribute__malloc__ 2247 __attribute__warn_unused_result__; */ 2248 2249 PERL_CALLCONV OP* Perl_newLISTOP(pTHX_ I32 type, I32 flags, OP* first, OP* last) 2250 __attribute__malloc__ 2251 __attribute__warn_unused_result__; 2252 2253 #ifdef USE_ITHREADS 2254 PERL_CALLCONV OP* Perl_newPADOP(pTHX_ I32 type, I32 flags, SV* sv) 2255 __attribute__malloc__ 2256 __attribute__warn_unused_result__ 2257 __attribute__nonnull__(pTHX_3); 2258 #define PERL_ARGS_ASSERT_NEWPADOP \ 2259 assert(sv) 2260 2261 #endif 2262 PERL_CALLCONV OP* Perl_newPMOP(pTHX_ I32 type, I32 flags) 2263 __attribute__malloc__ 2264 __attribute__warn_unused_result__; 2265 2266 PERL_CALLCONV OP* Perl_newPVOP(pTHX_ I32 type, I32 flags, char* pv) 2267 __attribute__malloc__ 2268 __attribute__warn_unused_result__; 2269 2270 PERL_CALLCONV SV* Perl_newRV(pTHX_ SV *const sv) 2271 __attribute__malloc__ 2272 __attribute__warn_unused_result__ 2273 __attribute__nonnull__(pTHX_1); 2274 #define PERL_ARGS_ASSERT_NEWRV \ 2275 assert(sv) 2276 2277 PERL_CALLCONV SV* Perl_newRV_noinc(pTHX_ SV *const sv) 2278 __attribute__malloc__ 2279 __attribute__warn_unused_result__ 2280 __attribute__nonnull__(pTHX_1); 2281 #define PERL_ARGS_ASSERT_NEWRV_NOINC \ 2282 assert(sv) 2283 2284 PERL_CALLCONV SV* Perl_newSV(pTHX_ const STRLEN len) 2285 __attribute__malloc__ 2286 __attribute__warn_unused_result__; 2287 2288 PERL_CALLCONV OP* Perl_newSVREF(pTHX_ OP* o) 2289 __attribute__malloc__ 2290 __attribute__warn_unused_result__ 2291 __attribute__nonnull__(pTHX_1); 2292 #define PERL_ARGS_ASSERT_NEWSVREF \ 2293 assert(o) 2294 2295 PERL_CALLCONV OP* Perl_newSVOP(pTHX_ I32 type, I32 flags, SV* sv) 2296 __attribute__malloc__ 2297 __attribute__warn_unused_result__ 2298 __attribute__nonnull__(pTHX_3); 2299 #define PERL_ARGS_ASSERT_NEWSVOP \ 2300 assert(sv) 2301 2302 PERL_CALLCONV SV* Perl_newSViv(pTHX_ const IV i) 2303 __attribute__malloc__ 2304 __attribute__warn_unused_result__; 2305 2306 PERL_CALLCONV SV* Perl_newSVuv(pTHX_ const UV u) 2307 __attribute__malloc__ 2308 __attribute__warn_unused_result__; 2309 2310 PERL_CALLCONV SV* Perl_newSVnv(pTHX_ const NV n) 2311 __attribute__malloc__ 2312 __attribute__warn_unused_result__; 2313 2314 PERL_CALLCONV SV* Perl_newSVpv(pTHX_ const char *const s, const STRLEN len) 2315 __attribute__malloc__ 2316 __attribute__warn_unused_result__; 2317 2318 PERL_CALLCONV SV* Perl_newSVpvn(pTHX_ const char *const s, const STRLEN len) 2319 __attribute__malloc__ 2320 __attribute__warn_unused_result__; 2321 2322 PERL_CALLCONV SV* Perl_newSVpvn_flags(pTHX_ const char *const s, const STRLEN len, const U32 flags) 2323 __attribute__malloc__ 2324 __attribute__warn_unused_result__; 2325 2326 PERL_CALLCONV SV* Perl_newSVhek(pTHX_ const HEK *const hek) 2327 __attribute__malloc__ 2328 __attribute__warn_unused_result__; 2329 2330 PERL_CALLCONV SV* Perl_newSVpvn_share(pTHX_ const char* s, I32 len, U32 hash) 2331 __attribute__malloc__ 2332 __attribute__warn_unused_result__; 2333 2334 PERL_CALLCONV SV* Perl_newSVpvf(pTHX_ const char *const pat, ...) 2335 __attribute__malloc__ 2336 __attribute__warn_unused_result__ 2337 __attribute__format__(__printf__,pTHX_1,pTHX_2) 2338 __attribute__nonnull__(pTHX_1); 2339 #define PERL_ARGS_ASSERT_NEWSVPVF \ 2340 assert(pat) 2341 2342 PERL_CALLCONV SV* Perl_vnewSVpvf(pTHX_ const char *const pat, va_list *const args) 2343 __attribute__malloc__ 2344 __attribute__warn_unused_result__ 2345 __attribute__nonnull__(pTHX_1); 2346 #define PERL_ARGS_ASSERT_VNEWSVPVF \ 2347 assert(pat) 2348 2349 PERL_CALLCONV SV* Perl_newSVrv(pTHX_ SV *const rv, const char *const classname) 2350 __attribute__nonnull__(pTHX_1); 2351 #define PERL_ARGS_ASSERT_NEWSVRV \ 2352 assert(rv) 2353 2354 PERL_CALLCONV SV* Perl_newSVsv(pTHX_ SV *const old) 2355 __attribute__malloc__ 2356 __attribute__warn_unused_result__; 2357 2358 PERL_CALLCONV SV* Perl_newSV_type(pTHX_ const svtype type) 2359 __attribute__malloc__ 2360 __attribute__warn_unused_result__; 2361 2362 PERL_CALLCONV OP* Perl_newUNOP(pTHX_ I32 type, I32 flags, OP* first) 2363 __attribute__malloc__ 2364 __attribute__warn_unused_result__; 2365 2366 PERL_CALLCONV OP* Perl_newWHENOP(pTHX_ OP* cond, OP* block) 2367 __attribute__malloc__ 2368 __attribute__warn_unused_result__ 2369 __attribute__nonnull__(pTHX_2); 2370 #define PERL_ARGS_ASSERT_NEWWHENOP \ 2371 assert(block) 2372 2373 PERL_CALLCONV OP* Perl_newWHILEOP(pTHX_ I32 flags, I32 debuggable, LOOP* loop, I32 whileline, OP* expr, OP* block, OP* cont, I32 has_my) 2374 __attribute__malloc__ 2375 __attribute__warn_unused_result__; 2376 2377 PERL_CALLCONV PERL_SI* Perl_new_stackinfo(pTHX_ I32 stitems, I32 cxitems) 2378 __attribute__malloc__ 2379 __attribute__warn_unused_result__; 2380 2381 PERL_CALLCONV char* Perl_scan_vstring(pTHX_ const char *s, const char *const e, SV *sv) 2382 __attribute__nonnull__(pTHX_1) 2383 __attribute__nonnull__(pTHX_2) 2384 __attribute__nonnull__(pTHX_3); 2385 #define PERL_ARGS_ASSERT_SCAN_VSTRING \ 2386 assert(s); assert(e); assert(sv) 2387 2388 PERL_CALLCONV const char* Perl_scan_version(pTHX_ const char *s, SV *rv, bool qv) 2389 __attribute__nonnull__(pTHX_1) 2390 __attribute__nonnull__(pTHX_2); 2391 #define PERL_ARGS_ASSERT_SCAN_VERSION \ 2392 assert(s); assert(rv) 2393 2394 PERL_CALLCONV const char* Perl_prescan_version(pTHX_ const char *s, bool strict, const char** errstr, bool *sqv, int *ssaw_decimal, int *swidth, bool *salpha) 2395 __attribute__nonnull__(pTHX_1); 2396 #define PERL_ARGS_ASSERT_PRESCAN_VERSION \ 2397 assert(s) 2398 2399 PERL_CALLCONV SV* Perl_new_version(pTHX_ SV *ver) 2400 __attribute__nonnull__(pTHX_1); 2401 #define PERL_ARGS_ASSERT_NEW_VERSION \ 2402 assert(ver) 2403 2404 PERL_CALLCONV SV* Perl_upg_version(pTHX_ SV *ver, bool qv) 2405 __attribute__nonnull__(pTHX_1); 2406 #define PERL_ARGS_ASSERT_UPG_VERSION \ 2407 assert(ver) 2408 2409 PERL_CALLCONV bool Perl_vverify(pTHX_ SV *vs) 2410 __attribute__nonnull__(pTHX_1); 2411 #define PERL_ARGS_ASSERT_VVERIFY \ 2412 assert(vs) 2413 2414 PERL_CALLCONV SV* Perl_vnumify(pTHX_ SV *vs) 2415 __attribute__nonnull__(pTHX_1); 2416 #define PERL_ARGS_ASSERT_VNUMIFY \ 2417 assert(vs) 2418 2419 PERL_CALLCONV SV* Perl_vnormal(pTHX_ SV *vs) 2420 __attribute__nonnull__(pTHX_1); 2421 #define PERL_ARGS_ASSERT_VNORMAL \ 2422 assert(vs) 2423 2424 PERL_CALLCONV SV* Perl_vstringify(pTHX_ SV *vs) 2425 __attribute__nonnull__(pTHX_1); 2426 #define PERL_ARGS_ASSERT_VSTRINGIFY \ 2427 assert(vs) 2428 2429 PERL_CALLCONV int Perl_vcmp(pTHX_ SV *lhv, SV *rhv) 2430 __attribute__nonnull__(pTHX_1) 2431 __attribute__nonnull__(pTHX_2); 2432 #define PERL_ARGS_ASSERT_VCMP \ 2433 assert(lhv); assert(rhv) 2434 2435 PERL_CALLCONV PerlIO* Perl_nextargv(pTHX_ GV* gv) 2436 __attribute__nonnull__(pTHX_1); 2437 #define PERL_ARGS_ASSERT_NEXTARGV \ 2438 assert(gv) 2439 2440 PERL_CALLCONV char* Perl_ninstr(const char* big, const char* bigend, const char* little, const char* lend) 2441 __attribute__pure__ 2442 __attribute__nonnull__(1) 2443 __attribute__nonnull__(2) 2444 __attribute__nonnull__(3) 2445 __attribute__nonnull__(4); 2446 #define PERL_ARGS_ASSERT_NINSTR \ 2447 assert(big); assert(bigend); assert(little); assert(lend) 2448 2449 PERL_CALLCONV void Perl_op_free(pTHX_ OP* arg); 2450 #ifdef PERL_MAD 2451 PERL_CALLCONV OP* Perl_package(pTHX_ OP* o) 2452 __attribute__nonnull__(pTHX_1); 2453 #define PERL_ARGS_ASSERT_PACKAGE \ 2454 assert(o) 2455 2456 #else 2457 PERL_CALLCONV void Perl_package(pTHX_ OP* o) 2458 __attribute__nonnull__(pTHX_1); 2459 #define PERL_ARGS_ASSERT_PACKAGE \ 2460 assert(o) 2461 2462 #endif 2463 PERL_CALLCONV void Perl_package_version(pTHX_ OP* v) 2464 __attribute__nonnull__(pTHX_1); 2465 #define PERL_ARGS_ASSERT_PACKAGE_VERSION \ 2466 assert(v) 2467 2468 PERL_CALLCONV PADOFFSET Perl_pad_alloc(pTHX_ I32 optype, U32 tmptype); 2469 PERL_CALLCONV PADOFFSET Perl_allocmy(pTHX_ const char *const name, const STRLEN len, const U32 flags) 2470 __attribute__nonnull__(pTHX_1); 2471 #define PERL_ARGS_ASSERT_ALLOCMY \ 2472 assert(name) 2473 2474 PERL_CALLCONV PADOFFSET Perl_pad_findmy(pTHX_ const char* name, STRLEN len, U32 flags) 2475 __attribute__warn_unused_result__ 2476 __attribute__nonnull__(pTHX_1); 2477 #define PERL_ARGS_ASSERT_PAD_FINDMY \ 2478 assert(name) 2479 2480 PERL_CALLCONV PADOFFSET Perl_find_rundefsvoffset(pTHX); 2481 PERL_CALLCONV OP* Perl_oopsAV(pTHX_ OP* o) 2482 __attribute__warn_unused_result__ 2483 __attribute__nonnull__(pTHX_1); 2484 #define PERL_ARGS_ASSERT_OOPSAV \ 2485 assert(o) 2486 2487 PERL_CALLCONV OP* Perl_oopsHV(pTHX_ OP* o) 2488 __attribute__warn_unused_result__ 2489 __attribute__nonnull__(pTHX_1); 2490 #define PERL_ARGS_ASSERT_OOPSHV \ 2491 assert(o) 2492 2493 PERL_CALLCONV void Perl_pad_leavemy(pTHX); 2494 #ifdef DEBUGGING 2495 PERL_CALLCONV SV* Perl_pad_sv(pTHX_ PADOFFSET po); 2496 #endif 2497 PERL_CALLCONV void Perl_pad_free(pTHX_ PADOFFSET po); 2498 #if defined(PERL_IN_PAD_C) || defined(PERL_DECL_PROT) 2499 STATIC void S_pad_reset(pTHX); 2500 #endif 2501 PERL_CALLCONV void Perl_pad_swipe(pTHX_ PADOFFSET po, bool refadjust); 2502 PERL_CALLCONV void Perl_peep(pTHX_ OP* o); 2503 PERL_CALLCONV PerlIO* Perl_start_glob(pTHX_ SV *tmpglob, IO *io) 2504 __attribute__nonnull__(pTHX_1) 2505 __attribute__nonnull__(pTHX_2); 2506 #define PERL_ARGS_ASSERT_START_GLOB \ 2507 assert(tmpglob); assert(io) 2508 2509 #if defined(USE_REENTRANT_API) 2510 PERL_CALLCONV void Perl_reentrant_size(pTHX); 2511 PERL_CALLCONV void Perl_reentrant_init(pTHX); 2512 PERL_CALLCONV void Perl_reentrant_free(pTHX); 2513 PERL_CALLCONV void* Perl_reentrant_retry(const char *f, ...) 2514 __attribute__nonnull__(1); 2515 #define PERL_ARGS_ASSERT_REENTRANT_RETRY \ 2516 assert(f) 2517 2518 #endif 2519 PERL_CALLCONV void Perl_call_atexit(pTHX_ ATEXIT_t fn, void *ptr); 2520 PERL_CALLCONV I32 Perl_call_argv(pTHX_ const char* sub_name, I32 flags, char** argv) 2521 __attribute__nonnull__(pTHX_1) 2522 __attribute__nonnull__(pTHX_3); 2523 #define PERL_ARGS_ASSERT_CALL_ARGV \ 2524 assert(sub_name); assert(argv) 2525 2526 PERL_CALLCONV I32 Perl_call_method(pTHX_ const char* methname, I32 flags) 2527 __attribute__nonnull__(pTHX_1); 2528 #define PERL_ARGS_ASSERT_CALL_METHOD \ 2529 assert(methname) 2530 2531 PERL_CALLCONV I32 Perl_call_pv(pTHX_ const char* sub_name, I32 flags) 2532 __attribute__nonnull__(pTHX_1); 2533 #define PERL_ARGS_ASSERT_CALL_PV \ 2534 assert(sub_name) 2535 2536 PERL_CALLCONV I32 Perl_call_sv(pTHX_ SV* sv, VOL I32 flags) 2537 __attribute__nonnull__(pTHX_1); 2538 #define PERL_ARGS_ASSERT_CALL_SV \ 2539 assert(sv) 2540 2541 PERL_CALLCONV void Perl_despatch_signals(pTHX); 2542 PERL_CALLCONV OP * Perl_doref(pTHX_ OP *o, I32 type, bool set_op_ref) 2543 __attribute__nonnull__(pTHX_1); 2544 #define PERL_ARGS_ASSERT_DOREF \ 2545 assert(o) 2546 2547 PERL_CALLCONV SV* Perl_eval_pv(pTHX_ const char* p, I32 croak_on_error) 2548 __attribute__nonnull__(pTHX_1); 2549 #define PERL_ARGS_ASSERT_EVAL_PV \ 2550 assert(p) 2551 2552 PERL_CALLCONV I32 Perl_eval_sv(pTHX_ SV* sv, I32 flags) 2553 __attribute__nonnull__(pTHX_1); 2554 #define PERL_ARGS_ASSERT_EVAL_SV \ 2555 assert(sv) 2556 2557 PERL_CALLCONV SV* Perl_get_sv(pTHX_ const char *name, I32 flags) 2558 __attribute__nonnull__(pTHX_1); 2559 #define PERL_ARGS_ASSERT_GET_SV \ 2560 assert(name) 2561 2562 PERL_CALLCONV AV* Perl_get_av(pTHX_ const char *name, I32 flags) 2563 __attribute__nonnull__(pTHX_1); 2564 #define PERL_ARGS_ASSERT_GET_AV \ 2565 assert(name) 2566 2567 PERL_CALLCONV HV* Perl_get_hv(pTHX_ const char *name, I32 flags) 2568 __attribute__nonnull__(pTHX_1); 2569 #define PERL_ARGS_ASSERT_GET_HV \ 2570 assert(name) 2571 2572 PERL_CALLCONV CV* Perl_get_cv(pTHX_ const char* name, I32 flags) 2573 __attribute__nonnull__(pTHX_1); 2574 #define PERL_ARGS_ASSERT_GET_CV \ 2575 assert(name) 2576 2577 PERL_CALLCONV CV* Perl_get_cvn_flags(pTHX_ const char* name, STRLEN len, I32 flags) 2578 __attribute__nonnull__(pTHX_1); 2579 #define PERL_ARGS_ASSERT_GET_CVN_FLAGS \ 2580 assert(name) 2581 2582 PERL_CALLCONV int Perl_init_i18nl10n(pTHX_ int printwarn); 2583 PERL_CALLCONV int Perl_init_i18nl14n(pTHX_ int printwarn); 2584 PERL_CALLCONV void Perl_new_collate(pTHX_ const char* newcoll); 2585 PERL_CALLCONV void Perl_new_ctype(pTHX_ const char* newctype) 2586 __attribute__nonnull__(pTHX_1); 2587 #define PERL_ARGS_ASSERT_NEW_CTYPE \ 2588 assert(newctype) 2589 2590 PERL_CALLCONV void Perl_new_numeric(pTHX_ const char* newcoll); 2591 PERL_CALLCONV void Perl_set_numeric_local(pTHX); 2592 PERL_CALLCONV void Perl_set_numeric_radix(pTHX); 2593 PERL_CALLCONV void Perl_set_numeric_standard(pTHX); 2594 PERL_CALLCONV void Perl_require_pv(pTHX_ const char* pv) 2595 __attribute__nonnull__(pTHX_1); 2596 #define PERL_ARGS_ASSERT_REQUIRE_PV \ 2597 assert(pv) 2598 2599 PERL_CALLCONV void Perl_pack_cat(pTHX_ SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist, SV ***next_in_list, U32 flags) 2600 __attribute__nonnull__(pTHX_1) 2601 __attribute__nonnull__(pTHX_2) 2602 __attribute__nonnull__(pTHX_3) 2603 __attribute__nonnull__(pTHX_4) 2604 __attribute__nonnull__(pTHX_5) 2605 __attribute__nonnull__(pTHX_6); 2606 #define PERL_ARGS_ASSERT_PACK_CAT \ 2607 assert(cat); assert(pat); assert(patend); assert(beglist); assert(endlist); assert(next_in_list) 2608 2609 PERL_CALLCONV void Perl_packlist(pTHX_ SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist) 2610 __attribute__nonnull__(pTHX_1) 2611 __attribute__nonnull__(pTHX_2) 2612 __attribute__nonnull__(pTHX_3) 2613 __attribute__nonnull__(pTHX_4) 2614 __attribute__nonnull__(pTHX_5); 2615 #define PERL_ARGS_ASSERT_PACKLIST \ 2616 assert(cat); assert(pat); assert(patend); assert(beglist); assert(endlist) 2617 2618 #if defined(PERL_USES_PL_PIDSTATUS) && defined(PERL_IN_UTIL_C) 2619 STATIC void S_pidgone(pTHX_ Pid_t pid, int status); 2620 #endif 2621 PERL_CALLCONV void Perl_pmflag(pTHX_ U32 *pmfl, int ch) 2622 __attribute__deprecated__ 2623 __attribute__nonnull__(pTHX_1); 2624 #define PERL_ARGS_ASSERT_PMFLAG \ 2625 assert(pmfl) 2626 2627 PERL_CALLCONV OP* Perl_pmruntime(pTHX_ OP *o, OP *expr, bool isreg) 2628 __attribute__nonnull__(pTHX_1) 2629 __attribute__nonnull__(pTHX_2); 2630 #define PERL_ARGS_ASSERT_PMRUNTIME \ 2631 assert(o); assert(expr) 2632 2633 #if defined(PERL_IN_OP_C) || defined(PERL_DECL_PROT) 2634 STATIC OP* S_pmtrans(pTHX_ OP* o, OP* expr, OP* repl) 2635 __attribute__nonnull__(pTHX_1) 2636 __attribute__nonnull__(pTHX_2) 2637 __attribute__nonnull__(pTHX_3); 2638 #define PERL_ARGS_ASSERT_PMTRANS \ 2639 assert(o); assert(expr); assert(repl) 2640 2641 #endif 2642 PERL_CALLCONV void Perl_pop_scope(pTHX); 2643 PERL_CALLCONV OP* Perl_prepend_elem(pTHX_ I32 optype, OP* head, OP* tail); 2644 PERL_CALLCONV void Perl_push_scope(pTHX); 2645 /* PERL_CALLCONV OP* Perl_ref(pTHX_ OP* o, I32 type); */ 2646 #if defined(PERL_IN_OP_C) || defined(PERL_DECL_PROT) 2647 STATIC OP* S_refkids(pTHX_ OP* o, I32 type); 2648 #endif 2649 PERL_CALLCONV void Perl_regdump(pTHX_ const regexp* r) 2650 __attribute__nonnull__(pTHX_1); 2651 #define PERL_ARGS_ASSERT_REGDUMP \ 2652 assert(r) 2653 2654 PERL_CALLCONV void Perl_regdump(pTHX_ const regexp* r) 2655 __attribute__nonnull__(pTHX_1); 2656 #define PERL_ARGS_ASSERT_REGDUMP \ 2657 assert(r) 2658 2659 PERL_CALLCONV SV* Perl_regclass_swash(pTHX_ const regexp *prog, const struct regnode *node, bool doinit, SV **listsvp, SV **altsvp) 2660 __attribute__nonnull__(pTHX_2); 2661 #define PERL_ARGS_ASSERT_REGCLASS_SWASH \ 2662 assert(node) 2663 2664 PERL_CALLCONV I32 Perl_pregexec(pTHX_ REGEXP * const prog, char* stringarg, char* strend, char* strbeg, I32 minend, SV* screamer, U32 nosave) 2665 __attribute__nonnull__(pTHX_1) 2666 __attribute__nonnull__(pTHX_2) 2667 __attribute__nonnull__(pTHX_3) 2668 __attribute__nonnull__(pTHX_4) 2669 __attribute__nonnull__(pTHX_6); 2670 #define PERL_ARGS_ASSERT_PREGEXEC \ 2671 assert(prog); assert(stringarg); assert(strend); assert(strbeg); assert(screamer) 2672 2673 PERL_CALLCONV void Perl_pregfree(pTHX_ REGEXP* r); 2674 PERL_CALLCONV void Perl_pregfree2(pTHX_ REGEXP *rx) 2675 __attribute__nonnull__(pTHX_1); 2676 #define PERL_ARGS_ASSERT_PREGFREE2 \ 2677 assert(rx) 2678 2679 PERL_CALLCONV REGEXP* Perl_reg_temp_copy(pTHX_ REGEXP* ret_x, REGEXP* rx) 2680 __attribute__nonnull__(pTHX_2); 2681 #define PERL_ARGS_ASSERT_REG_TEMP_COPY \ 2682 assert(rx) 2683 2684 PERL_CALLCONV void Perl_regfree_internal(pTHX_ REGEXP *const rx) 2685 __attribute__nonnull__(pTHX_1); 2686 #define PERL_ARGS_ASSERT_REGFREE_INTERNAL \ 2687 assert(rx) 2688 2689 #if defined(USE_ITHREADS) 2690 PERL_CALLCONV void* Perl_regdupe_internal(pTHX_ REGEXP * const r, CLONE_PARAMS* param) 2691 __attribute__nonnull__(pTHX_1) 2692 __attribute__nonnull__(pTHX_2); 2693 #define PERL_ARGS_ASSERT_REGDUPE_INTERNAL \ 2694 assert(r); assert(param) 2695 2696 #endif 2697 PERL_CALLCONV REGEXP* Perl_pregcomp(pTHX_ SV * const pattern, const U32 flags) 2698 __attribute__nonnull__(pTHX_1); 2699 #define PERL_ARGS_ASSERT_PREGCOMP \ 2700 assert(pattern) 2701 2702 PERL_CALLCONV REGEXP* Perl_re_compile(pTHX_ SV * const pattern, U32 flags) 2703 __attribute__nonnull__(pTHX_1); 2704 #define PERL_ARGS_ASSERT_RE_COMPILE \ 2705 assert(pattern) 2706 2707 PERL_CALLCONV char* Perl_re_intuit_start(pTHX_ REGEXP * const rx, SV* sv, char* strpos, char* strend, const U32 flags, re_scream_pos_data *data) 2708 __attribute__nonnull__(pTHX_1) 2709 __attribute__nonnull__(pTHX_3) 2710 __attribute__nonnull__(pTHX_4); 2711 #define PERL_ARGS_ASSERT_RE_INTUIT_START \ 2712 assert(rx); assert(strpos); assert(strend) 2713 2714 PERL_CALLCONV SV* Perl_re_intuit_string(pTHX_ REGEXP *const r) 2715 __attribute__nonnull__(pTHX_1); 2716 #define PERL_ARGS_ASSERT_RE_INTUIT_STRING \ 2717 assert(r) 2718 2719 PERL_CALLCONV I32 Perl_regexec_flags(pTHX_ REGEXP *const rx, char *stringarg, char *strend, char *strbeg, I32 minend, SV *sv, void *data, U32 flags) 2720 __attribute__nonnull__(pTHX_1) 2721 __attribute__nonnull__(pTHX_2) 2722 __attribute__nonnull__(pTHX_3) 2723 __attribute__nonnull__(pTHX_4) 2724 __attribute__nonnull__(pTHX_6); 2725 #define PERL_ARGS_ASSERT_REGEXEC_FLAGS \ 2726 assert(rx); assert(stringarg); assert(strend); assert(strbeg); assert(sv) 2727 2728 PERL_CALLCONV regnode* Perl_regnext(pTHX_ regnode* p) 2729 __attribute__warn_unused_result__; 2730 2731 2732 PERL_CALLCONV SV* Perl_reg_named_buff(pTHX_ REGEXP * const rx, SV * const key, SV * const value, const U32 flags) 2733 __attribute__nonnull__(pTHX_1); 2734 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF \ 2735 assert(rx) 2736 2737 PERL_CALLCONV SV* Perl_reg_named_buff_iter(pTHX_ REGEXP * const rx, const SV * const lastkey, const U32 flags) 2738 __attribute__nonnull__(pTHX_1); 2739 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_ITER \ 2740 assert(rx) 2741 2742 PERL_CALLCONV SV* Perl_reg_named_buff_fetch(pTHX_ REGEXP * const rx, SV * const namesv, const U32 flags) 2743 __attribute__nonnull__(pTHX_1) 2744 __attribute__nonnull__(pTHX_2); 2745 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_FETCH \ 2746 assert(rx); assert(namesv) 2747 2748 PERL_CALLCONV bool Perl_reg_named_buff_exists(pTHX_ REGEXP * const rx, SV * const key, const U32 flags) 2749 __attribute__nonnull__(pTHX_1) 2750 __attribute__nonnull__(pTHX_2); 2751 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_EXISTS \ 2752 assert(rx); assert(key) 2753 2754 PERL_CALLCONV SV* Perl_reg_named_buff_firstkey(pTHX_ REGEXP * const rx, const U32 flags) 2755 __attribute__nonnull__(pTHX_1); 2756 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_FIRSTKEY \ 2757 assert(rx) 2758 2759 PERL_CALLCONV SV* Perl_reg_named_buff_nextkey(pTHX_ REGEXP * const rx, const U32 flags) 2760 __attribute__nonnull__(pTHX_1); 2761 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_NEXTKEY \ 2762 assert(rx) 2763 2764 PERL_CALLCONV SV* Perl_reg_named_buff_scalar(pTHX_ REGEXP * const rx, const U32 flags) 2765 __attribute__nonnull__(pTHX_1); 2766 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_SCALAR \ 2767 assert(rx) 2768 2769 PERL_CALLCONV SV* Perl_reg_named_buff_all(pTHX_ REGEXP * const rx, const U32 flags) 2770 __attribute__nonnull__(pTHX_1); 2771 #define PERL_ARGS_ASSERT_REG_NAMED_BUFF_ALL \ 2772 assert(rx) 2773 2774 2775 PERL_CALLCONV void Perl_reg_numbered_buff_fetch(pTHX_ REGEXP * const rx, const I32 paren, SV * const sv) 2776 __attribute__nonnull__(pTHX_1); 2777 #define PERL_ARGS_ASSERT_REG_NUMBERED_BUFF_FETCH \ 2778 assert(rx) 2779 2780 PERL_CALLCONV void Perl_reg_numbered_buff_store(pTHX_ REGEXP * const rx, const I32 paren, SV const * const value) 2781 __attribute__nonnull__(pTHX_1); 2782 #define PERL_ARGS_ASSERT_REG_NUMBERED_BUFF_STORE \ 2783 assert(rx) 2784 2785 PERL_CALLCONV I32 Perl_reg_numbered_buff_length(pTHX_ REGEXP * const rx, const SV * const sv, const I32 paren) 2786 __attribute__nonnull__(pTHX_1) 2787 __attribute__nonnull__(pTHX_2); 2788 #define PERL_ARGS_ASSERT_REG_NUMBERED_BUFF_LENGTH \ 2789 assert(rx); assert(sv) 2790 2791 2792 PERL_CALLCONV SV* Perl_reg_qr_package(pTHX_ REGEXP * const rx) 2793 __attribute__nonnull__(pTHX_1); 2794 #define PERL_ARGS_ASSERT_REG_QR_PACKAGE \ 2795 assert(rx) 2796 2797 2798 PERL_CALLCONV void Perl_regprop(pTHX_ const regexp *prog, SV* sv, const regnode* o) 2799 __attribute__nonnull__(pTHX_2) 2800 __attribute__nonnull__(pTHX_3); 2801 #define PERL_ARGS_ASSERT_REGPROP \ 2802 assert(sv); assert(o) 2803 2804 PERL_CALLCONV void Perl_repeatcpy(char* to, const char* from, I32 len, I32 count) 2805 __attribute__nonnull__(1) 2806 __attribute__nonnull__(2); 2807 #define PERL_ARGS_ASSERT_REPEATCPY \ 2808 assert(to); assert(from) 2809 2810 PERL_CALLCONV char* Perl_rninstr(const char* big, const char* bigend, const char* little, const char* lend) 2811 __attribute__pure__ 2812 __attribute__nonnull__(1) 2813 __attribute__nonnull__(2) 2814 __attribute__nonnull__(3) 2815 __attribute__nonnull__(4); 2816 #define PERL_ARGS_ASSERT_RNINSTR \ 2817 assert(big); assert(bigend); assert(little); assert(lend) 2818 2819 PERL_CALLCONV Sighandler_t Perl_rsignal(pTHX_ int i, Sighandler_t t); 2820 PERL_CALLCONV int Perl_rsignal_restore(pTHX_ int i, Sigsave_t* t); 2821 PERL_CALLCONV int Perl_rsignal_save(pTHX_ int i, Sighandler_t t1, Sigsave_t* save) 2822 __attribute__nonnull__(pTHX_3); 2823 #define PERL_ARGS_ASSERT_RSIGNAL_SAVE \ 2824 assert(save) 2825 2826 PERL_CALLCONV Sighandler_t Perl_rsignal_state(pTHX_ int i); 2827 #if defined(PERL_IN_PP_CTL_C) || defined(PERL_DECL_PROT) 2828 STATIC void S_rxres_free(pTHX_ void** rsp) 2829 __attribute__nonnull__(pTHX_1); 2830 #define PERL_ARGS_ASSERT_RXRES_FREE \ 2831 assert(rsp) 2832 2833 STATIC void S_rxres_restore(pTHX_ void **rsp, REGEXP *rx) 2834 __attribute__nonnull__(pTHX_1) 2835 __attribute__nonnull__(pTHX_2); 2836 #define PERL_ARGS_ASSERT_RXRES_RESTORE \ 2837 assert(rsp); assert(rx) 2838 2839 #endif 2840 PERL_CALLCONV void Perl_rxres_save(pTHX_ void **rsp, REGEXP *rx) 2841 __attribute__nonnull__(pTHX_1) 2842 __attribute__nonnull__(pTHX_2); 2843 #define PERL_ARGS_ASSERT_RXRES_SAVE \ 2844 assert(rsp); assert(rx) 2845 2846 #if !defined(HAS_RENAME) 2847 PERL_CALLCONV I32 Perl_same_dirent(pTHX_ const char* a, const char* b) 2848 __attribute__nonnull__(pTHX_1) 2849 __attribute__nonnull__(pTHX_2); 2850 #define PERL_ARGS_ASSERT_SAME_DIRENT \ 2851 assert(a); assert(b) 2852 2853 #endif 2854 PERL_CALLCONV char* Perl_savepv(pTHX_ const char* pv) 2855 __attribute__malloc__ 2856 __attribute__warn_unused_result__; 2857 2858 PERL_CALLCONV char* Perl_savepvn(pTHX_ const char* pv, I32 len) 2859 __attribute__malloc__ 2860 __attribute__warn_unused_result__; 2861 2862 PERL_CALLCONV char* Perl_savesharedpv(pTHX_ const char* pv) 2863 __attribute__malloc__ 2864 __attribute__warn_unused_result__; 2865 2866 PERL_CALLCONV char* Perl_savesharedpvn(pTHX_ const char *const pv, const STRLEN len) 2867 __attribute__malloc__ 2868 __attribute__warn_unused_result__ 2869 __attribute__nonnull__(pTHX_1); 2870 #define PERL_ARGS_ASSERT_SAVESHAREDPVN \ 2871 assert(pv) 2872 2873 PERL_CALLCONV char* Perl_savesvpv(pTHX_ SV* sv) 2874 __attribute__malloc__ 2875 __attribute__warn_unused_result__ 2876 __attribute__nonnull__(pTHX_1); 2877 #define PERL_ARGS_ASSERT_SAVESVPV \ 2878 assert(sv) 2879 2880 PERL_CALLCONV void Perl_savestack_grow(pTHX); 2881 PERL_CALLCONV void Perl_savestack_grow_cnt(pTHX_ I32 need); 2882 /* PERL_CALLCONV void Perl_save_aelem(pTHX_ AV* av, I32 idx, SV **sptr) 2883 __attribute__nonnull__(pTHX_1) 2884 __attribute__nonnull__(pTHX_3); */ 2885 2886 PERL_CALLCONV void Perl_save_aelem_flags(pTHX_ AV* av, I32 idx, SV **sptr, const U32 flags) 2887 __attribute__nonnull__(pTHX_1) 2888 __attribute__nonnull__(pTHX_3); 2889 #define PERL_ARGS_ASSERT_SAVE_AELEM_FLAGS \ 2890 assert(av); assert(sptr) 2891 2892 PERL_CALLCONV I32 Perl_save_alloc(pTHX_ I32 size, I32 pad); 2893 PERL_CALLCONV void Perl_save_aptr(pTHX_ AV** aptr) 2894 __attribute__nonnull__(pTHX_1); 2895 #define PERL_ARGS_ASSERT_SAVE_APTR \ 2896 assert(aptr) 2897 2898 PERL_CALLCONV AV* Perl_save_ary(pTHX_ GV* gv) 2899 __attribute__nonnull__(pTHX_1); 2900 #define PERL_ARGS_ASSERT_SAVE_ARY \ 2901 assert(gv) 2902 2903 PERL_CALLCONV void Perl_save_bool(pTHX_ bool* boolp) 2904 __attribute__nonnull__(pTHX_1); 2905 #define PERL_ARGS_ASSERT_SAVE_BOOL \ 2906 assert(boolp) 2907 2908 PERL_CALLCONV void Perl_save_clearsv(pTHX_ SV** svp) 2909 __attribute__nonnull__(pTHX_1); 2910 #define PERL_ARGS_ASSERT_SAVE_CLEARSV \ 2911 assert(svp) 2912 2913 PERL_CALLCONV void Perl_save_delete(pTHX_ HV *hv, char *key, I32 klen) 2914 __attribute__nonnull__(pTHX_1) 2915 __attribute__nonnull__(pTHX_2); 2916 #define PERL_ARGS_ASSERT_SAVE_DELETE \ 2917 assert(hv); assert(key) 2918 2919 PERL_CALLCONV void Perl_save_hdelete(pTHX_ HV *hv, SV *keysv) 2920 __attribute__nonnull__(pTHX_1) 2921 __attribute__nonnull__(pTHX_2); 2922 #define PERL_ARGS_ASSERT_SAVE_HDELETE \ 2923 assert(hv); assert(keysv) 2924 2925 PERL_CALLCONV void Perl_save_adelete(pTHX_ AV *av, I32 key) 2926 __attribute__nonnull__(pTHX_1); 2927 #define PERL_ARGS_ASSERT_SAVE_ADELETE \ 2928 assert(av) 2929 2930 PERL_CALLCONV void Perl_save_destructor(pTHX_ DESTRUCTORFUNC_NOCONTEXT_t f, void* p) 2931 __attribute__nonnull__(pTHX_2); 2932 #define PERL_ARGS_ASSERT_SAVE_DESTRUCTOR \ 2933 assert(p) 2934 2935 PERL_CALLCONV void Perl_save_destructor_x(pTHX_ DESTRUCTORFUNC_t f, void* p); 2936 /* PERL_CALLCONV void Perl_save_freesv(pTHX_ SV* sv); */ 2937 /* PERL_CALLCONV void Perl_save_freeop(pTHX_ OP* o); */ 2938 /* PERL_CALLCONV void Perl_save_freepv(pTHX_ char* pv); */ 2939 PERL_CALLCONV void Perl_save_generic_svref(pTHX_ SV** sptr) 2940 __attribute__nonnull__(pTHX_1); 2941 #define PERL_ARGS_ASSERT_SAVE_GENERIC_SVREF \ 2942 assert(sptr) 2943 2944 PERL_CALLCONV void Perl_save_generic_pvref(pTHX_ char** str) 2945 __attribute__nonnull__(pTHX_1); 2946 #define PERL_ARGS_ASSERT_SAVE_GENERIC_PVREF \ 2947 assert(str) 2948 2949 PERL_CALLCONV void Perl_save_shared_pvref(pTHX_ char** str) 2950 __attribute__nonnull__(pTHX_1); 2951 #define PERL_ARGS_ASSERT_SAVE_SHARED_PVREF \ 2952 assert(str) 2953 2954 PERL_CALLCONV void Perl_save_gp(pTHX_ GV* gv, I32 empty) 2955 __attribute__nonnull__(pTHX_1); 2956 #define PERL_ARGS_ASSERT_SAVE_GP \ 2957 assert(gv) 2958 2959 PERL_CALLCONV HV* Perl_save_hash(pTHX_ GV* gv) 2960 __attribute__nonnull__(pTHX_1); 2961 #define PERL_ARGS_ASSERT_SAVE_HASH \ 2962 assert(gv) 2963 2964 PERL_CALLCONV void Perl_save_hints(pTHX); 2965 /* PERL_CALLCONV void Perl_save_helem(pTHX_ HV *hv, SV *key, SV **sptr) 2966 __attribute__nonnull__(pTHX_1) 2967 __attribute__nonnull__(pTHX_2) 2968 __attribute__nonnull__(pTHX_3); */ 2969 2970 PERL_CALLCONV void Perl_save_helem_flags(pTHX_ HV *hv, SV *key, SV **sptr, const U32 flags) 2971 __attribute__nonnull__(pTHX_1) 2972 __attribute__nonnull__(pTHX_2) 2973 __attribute__nonnull__(pTHX_3); 2974 #define PERL_ARGS_ASSERT_SAVE_HELEM_FLAGS \ 2975 assert(hv); assert(key); assert(sptr) 2976 2977 PERL_CALLCONV void Perl_save_hptr(pTHX_ HV** hptr) 2978 __attribute__nonnull__(pTHX_1); 2979 #define PERL_ARGS_ASSERT_SAVE_HPTR \ 2980 assert(hptr) 2981 2982 PERL_CALLCONV void Perl_save_I16(pTHX_ I16* intp) 2983 __attribute__nonnull__(pTHX_1); 2984 #define PERL_ARGS_ASSERT_SAVE_I16 \ 2985 assert(intp) 2986 2987 PERL_CALLCONV void Perl_save_I32(pTHX_ I32* intp) 2988 __attribute__nonnull__(pTHX_1); 2989 #define PERL_ARGS_ASSERT_SAVE_I32 \ 2990 assert(intp) 2991 2992 PERL_CALLCONV void Perl_save_I8(pTHX_ I8* bytep) 2993 __attribute__nonnull__(pTHX_1); 2994 #define PERL_ARGS_ASSERT_SAVE_I8 \ 2995 assert(bytep) 2996 2997 PERL_CALLCONV void Perl_save_int(pTHX_ int* intp) 2998 __attribute__nonnull__(pTHX_1); 2999 #define PERL_ARGS_ASSERT_SAVE_INT \ 3000 assert(intp) 3001 3002 PERL_CALLCONV void Perl_save_item(pTHX_ SV* item) 3003 __attribute__nonnull__(pTHX_1); 3004 #define PERL_ARGS_ASSERT_SAVE_ITEM \ 3005 assert(item) 3006 3007 PERL_CALLCONV void Perl_save_iv(pTHX_ IV *ivp) 3008 __attribute__nonnull__(pTHX_1); 3009 #define PERL_ARGS_ASSERT_SAVE_IV \ 3010 assert(ivp) 3011 3012 PERL_CALLCONV void Perl_save_list(pTHX_ SV** sarg, I32 maxsarg) 3013 __attribute__nonnull__(pTHX_1); 3014 #define PERL_ARGS_ASSERT_SAVE_LIST \ 3015 assert(sarg) 3016 3017 PERL_CALLCONV void Perl_save_long(pTHX_ long* longp) 3018 __attribute__nonnull__(pTHX_1); 3019 #define PERL_ARGS_ASSERT_SAVE_LONG \ 3020 assert(longp) 3021 3022 /* PERL_CALLCONV void Perl_save_mortalizesv(pTHX_ SV* sv) 3023 __attribute__nonnull__(pTHX_1); */ 3024 #define PERL_ARGS_ASSERT_SAVE_MORTALIZESV \ 3025 assert(sv) 3026 3027 PERL_CALLCONV void Perl_save_nogv(pTHX_ GV* gv) 3028 __attribute__nonnull__(pTHX_1); 3029 #define PERL_ARGS_ASSERT_SAVE_NOGV \ 3030 assert(gv) 3031 3032 /* PERL_CALLCONV void Perl_save_op(pTHX); */ 3033 PERL_CALLCONV SV* Perl_save_scalar(pTHX_ GV* gv) 3034 __attribute__nonnull__(pTHX_1); 3035 #define PERL_ARGS_ASSERT_SAVE_SCALAR \ 3036 assert(gv) 3037 3038 PERL_CALLCONV void Perl_save_pptr(pTHX_ char** pptr) 3039 __attribute__nonnull__(pTHX_1); 3040 #define PERL_ARGS_ASSERT_SAVE_PPTR \ 3041 assert(pptr) 3042 3043 PERL_CALLCONV void Perl_save_vptr(pTHX_ void *ptr) 3044 __attribute__nonnull__(pTHX_1); 3045 #define PERL_ARGS_ASSERT_SAVE_VPTR \ 3046 assert(ptr) 3047 3048 PERL_CALLCONV void Perl_save_re_context(pTHX); 3049 PERL_CALLCONV void Perl_save_padsv_and_mortalize(pTHX_ PADOFFSET off); 3050 PERL_CALLCONV void Perl_save_sptr(pTHX_ SV** sptr) 3051 __attribute__nonnull__(pTHX_1); 3052 #define PERL_ARGS_ASSERT_SAVE_SPTR \ 3053 assert(sptr) 3054 3055 PERL_CALLCONV SV* Perl_save_svref(pTHX_ SV** sptr) 3056 __attribute__nonnull__(pTHX_1); 3057 #define PERL_ARGS_ASSERT_SAVE_SVREF \ 3058 assert(sptr) 3059 3060 PERL_CALLCONV void Perl_save_pushptr(pTHX_ void *const ptr, const int type); 3061 PERL_CALLCONV void Perl_save_pushi32ptr(pTHX_ const I32 i, void *const ptr, const int type); 3062 PERL_CALLCONV void Perl_save_pushptrptr(pTHX_ void *const ptr1, void *const ptr2, const int type); 3063 #if defined(PERL_IN_SCOPE_C) || defined(PERL_DECL_PROT) 3064 STATIC void S_save_pushptri32ptr(pTHX_ void *const ptr1, const I32 i, void *const ptr2, const int type); 3065 #endif 3066 PERL_CALLCONV OP* Perl_sawparens(pTHX_ OP* o); 3067 PERL_CALLCONV OP* Perl_scalar(pTHX_ OP* o); 3068 #if defined(PERL_IN_OP_C) || defined(PERL_DECL_PROT) 3069 STATIC OP* S_scalarkids(pTHX_ OP* o); 3070 STATIC OP* S_scalarseq(pTHX_ OP* o); 3071 #endif 3072 PERL_CALLCONV OP* Perl_scalarvoid(pTHX_ OP* o) 3073 __attribute__nonnull__(pTHX_1); 3074 #define PERL_ARGS_ASSERT_SCALARVOID \ 3075 assert(o) 3076 3077 PERL_CALLCONV NV Perl_scan_bin(pTHX_ const char* start, STRLEN len, STRLEN* retlen) 3078 __attribute__nonnull__(pTHX_1) 3079 __attribute__nonnull__(pTHX_3); 3080 #define PERL_ARGS_ASSERT_SCAN_BIN \ 3081 assert(start); assert(retlen) 3082 3083 PERL_CALLCONV NV Perl_scan_hex(pTHX_ const char* start, STRLEN len, STRLEN* retlen) 3084 __attribute__nonnull__(pTHX_1) 3085 __attribute__nonnull__(pTHX_3); 3086 #define PERL_ARGS_ASSERT_SCAN_HEX \ 3087 assert(start); assert(retlen) 3088 3089 PERL_CALLCONV char* Perl_scan_num(pTHX_ const char* s, YYSTYPE *lvalp) 3090 __attribute__nonnull__(pTHX_1) 3091 __attribute__nonnull__(pTHX_2); 3092 #define PERL_ARGS_ASSERT_SCAN_NUM \ 3093 assert(s); assert(lvalp) 3094 3095 PERL_CALLCONV NV Perl_scan_oct(pTHX_ const char* start, STRLEN len, STRLEN* retlen) 3096 __attribute__nonnull__(pTHX_1) 3097 __attribute__nonnull__(pTHX_3); 3098 #define PERL_ARGS_ASSERT_SCAN_OCT \ 3099 assert(start); assert(retlen) 3100 3101 PERL_CALLCONV OP* Perl_scope(pTHX_ OP* o); 3102 PERL_CALLCONV char* Perl_screaminstr(pTHX_ SV *bigstr, SV *littlestr, I32 start_shift, I32 end_shift, I32 *old_posp, I32 last) 3103 __attribute__nonnull__(pTHX_1) 3104 __attribute__nonnull__(pTHX_2) 3105 __attribute__nonnull__(pTHX_5); 3106 #define PERL_ARGS_ASSERT_SCREAMINSTR \ 3107 assert(bigstr); assert(littlestr); assert(old_posp) 3108 3109 PERL_CALLCONV void Perl_setdefout(pTHX_ GV* gv); 3110 PERL_CALLCONV HEK* Perl_share_hek(pTHX_ const char* str, I32 len, U32 hash) 3111 __attribute__nonnull__(pTHX_1); 3112 #define PERL_ARGS_ASSERT_SHARE_HEK \ 3113 assert(str) 3114 3115 #if defined(HAS_SIGACTION) && defined(SA_SIGINFO) 3116 PERL_CALLCONV Signal_t Perl_sighandler(int sig, siginfo_t *info, void *uap); 3117 PERL_CALLCONV Signal_t Perl_csighandler(int sig, siginfo_t *info, void *uap); 3118 #else 3119 PERL_CALLCONV Signal_t Perl_sighandler(int sig); 3120 PERL_CALLCONV Signal_t Perl_csighandler(int sig); 3121 #endif 3122 PERL_CALLCONV SV** Perl_stack_grow(pTHX_ SV** sp, SV** p, int n) 3123 __attribute__nonnull__(pTHX_1) 3124 __attribute__nonnull__(pTHX_2); 3125 #define PERL_ARGS_ASSERT_STACK_GROW \ 3126 assert(sp); assert(p) 3127 3128 PERL_CALLCONV I32 Perl_start_subparse(pTHX_ I32 is_format, U32 flags); 3129 PERL_CALLCONV void Perl_sub_crush_depth(pTHX_ CV* cv) 3130 __attribute__nonnull__(pTHX_1); 3131 #define PERL_ARGS_ASSERT_SUB_CRUSH_DEPTH \ 3132 assert(cv) 3133 3134 PERL_CALLCONV bool Perl_sv_2bool(pTHX_ SV *const sv) 3135 __attribute__nonnull__(pTHX_1); 3136 #define PERL_ARGS_ASSERT_SV_2BOOL \ 3137 assert(sv) 3138 3139 PERL_CALLCONV CV* Perl_sv_2cv(pTHX_ SV* sv, HV **const st, GV **const gvp, const I32 lref) 3140 __attribute__nonnull__(pTHX_2) 3141 __attribute__nonnull__(pTHX_3); 3142 #define PERL_ARGS_ASSERT_SV_2CV \ 3143 assert(st); assert(gvp) 3144 3145 PERL_CALLCONV IO* Perl_sv_2io(pTHX_ SV *const sv) 3146 __attribute__nonnull__(pTHX_1); 3147 #define PERL_ARGS_ASSERT_SV_2IO \ 3148 assert(sv) 3149 3150 #if defined(PERL_IN_SV_C) || defined(PERL_DECL_PROT) 3151 STATIC bool S_glob_2number(pTHX_ GV* const gv) 3152 __attribute__nonnull__(pTHX_1); 3153 #define PERL_ARGS_ASSERT_GLOB_2NUMBER \ 3154 assert(gv) 3155 3156 #endif 3157 /* PERL_CALLCONV IV Perl_sv_2iv(pTHX_ SV *sv); */ 3158 PERL_CALLCONV IV Perl_sv_2iv_flags(pTHX_ SV *const sv, const I32 flags); 3159 PERL_CALLCONV SV* Perl_sv_2mortal(pTHX_ SV *const sv); 3160 PERL_CALLCONV NV Perl_sv_2nv(pTHX_ SV *const sv); 3161 PERL_CALLCONV SV* Perl_sv_2num(pTHX_ SV *const sv) 3162 __attribute__nonnull__(pTHX_1); 3163 #define PERL_ARGS_ASSERT_SV_2NUM \ 3164 assert(sv) 3165 3166 /* PERL_CALLCONV char* Perl_sv_2pv(pTHX_ SV *sv, STRLEN *lp); */ 3167 PERL_CALLCONV char* Perl_sv_2pv_flags(pTHX_ SV *const sv, STRLEN *const lp, const I32 flags); 3168 PERL_CALLCONV char* Perl_sv_2pvutf8(pTHX_ SV *const sv, STRLEN *const lp) 3169 __attribute__nonnull__(pTHX_1); 3170 #define PERL_ARGS_ASSERT_SV_2PVUTF8 \ 3171 assert(sv) 3172 3173 PERL_CALLCONV char* Perl_sv_2pvbyte(pTHX_ SV *const sv, STRLEN *const lp) 3174 __attribute__nonnull__(pTHX_1); 3175 #define PERL_ARGS_ASSERT_SV_2PVBYTE \ 3176 assert(sv) 3177 3178 PERL_CALLCONV char* Perl_sv_pvn_nomg(pTHX_ SV* sv, STRLEN* lp) 3179 __attribute__nonnull__(pTHX_1); 3180 #define PERL_ARGS_ASSERT_SV_PVN_NOMG \ 3181 assert(sv) 3182 3183 /* PERL_CALLCONV UV Perl_sv_2uv(pTHX_ SV *sv); */ 3184 PERL_CALLCONV UV Perl_sv_2uv_flags(pTHX_ SV *const sv, const I32 flags); 3185 PERL_CALLCONV IV Perl_sv_iv(pTHX_ SV* sv) 3186 __attribute__nonnull__(pTHX_1); 3187 #define PERL_ARGS_ASSERT_SV_IV \ 3188 assert(sv) 3189 3190 PERL_CALLCONV UV Perl_sv_uv(pTHX_ SV* sv) 3191 __attribute__nonnull__(pTHX_1); 3192 #define PERL_ARGS_ASSERT_SV_UV \ 3193 assert(sv) 3194 3195 PERL_CALLCONV NV Perl_sv_nv(pTHX_ SV* sv) 3196 __attribute__nonnull__(pTHX_1); 3197 #define PERL_ARGS_ASSERT_SV_NV \ 3198 assert(sv) 3199 3200 PERL_CALLCONV char* Perl_sv_pvn(pTHX_ SV *sv, STRLEN *lp) 3201 __attribute__nonnull__(pTHX_1) 3202 __attribute__nonnull__(pTHX_2); 3203 #define PERL_ARGS_ASSERT_SV_PVN \ 3204 assert(sv); assert(lp) 3205 3206 PERL_CALLCONV char* Perl_sv_pvutf8n(pTHX_ SV *sv, STRLEN *lp) 3207 __attribute__nonnull__(pTHX_1) 3208 __attribute__nonnull__(pTHX_2); 3209 #define PERL_ARGS_ASSERT_SV_PVUTF8N \ 3210 assert(sv); assert(lp) 3211 3212 PERL_CALLCONV char* Perl_sv_pvbyten(pTHX_ SV *sv, STRLEN *lp) 3213 __attribute__nonnull__(pTHX_1) 3214 __attribute__nonnull__(pTHX_2); 3215 #define PERL_ARGS_ASSERT_SV_PVBYTEN \ 3216 assert(sv); assert(lp) 3217 3218 PERL_CALLCONV I32 Perl_sv_true(pTHX_ SV *const sv); 3219 #if defined(PERL_IN_SV_C) || defined(PERL_DECL_PROT) 3220 STATIC void S_sv_add_arena(pTHX_ char *const ptr, const U32 size, const U32 flags) 3221 __attribute__nonnull__(pTHX_1); 3222 #define PERL_ARGS_ASSERT_SV_ADD_ARENA \ 3223 assert(ptr) 3224 3225 #endif 3226 PERL_CALLCONV int Perl_sv_backoff(pTHX_ SV *const sv) 3227 __attribute__nonnull__(pTHX_1); 3228 #define PERL_ARGS_ASSERT_SV_BACKOFF \ 3229 assert(sv) 3230 3231 PERL_CALLCONV SV* Perl_sv_bless(pTHX_ SV *const sv, HV *const stash) 3232 __attribute__nonnull__(pTHX_1) 3233 __attribute__nonnull__(pTHX_2); 3234 #define PERL_ARGS_ASSERT_SV_BLESS \ 3235 assert(sv); assert(stash) 3236 3237 PERL_CALLCONV void Perl_sv_catpvf(pTHX_ SV *const sv, const char *const pat, ...) 3238 __attribute__format__(__printf__,pTHX_2,pTHX_3) 3239 __attribute__nonnull__(pTHX_1) 3240 __attribute__nonnull__(pTHX_2); 3241 #define PERL_ARGS_ASSERT_SV_CATPVF \ 3242 assert(sv); assert(pat) 3243 3244 PERL_CALLCONV void Perl_sv_vcatpvf(pTHX_ SV *const sv, const char *const pat, va_list *const args) 3245 __attribute__nonnull__(pTHX_1) 3246 __attribute__nonnull__(pTHX_2); 3247 #define PERL_ARGS_ASSERT_SV_VCATPVF \ 3248 assert(sv); assert(pat) 3249 3250 PERL_CALLCONV void Perl_sv_catpv(pTHX_ SV *const sv, const char* ptr) 3251 __attribute__nonnull__(pTHX_1); 3252 #define PERL_ARGS_ASSERT_SV_CATPV \ 3253 assert(sv) 3254 3255 /* PERL_CALLCONV void Perl_sv_catpvn(pTHX_ SV *dsv, const char *sstr, STRLEN len) 3256 __attribute__nonnull__(pTHX_1) 3257 __attribute__nonnull__(pTHX_2); */ 3258 #define PERL_ARGS_ASSERT_SV_CATPVN \ 3259 assert(dsv); assert(sstr) 3260 3261 /* PERL_CALLCONV void Perl_sv_catsv(pTHX_ SV *dstr, SV *sstr) 3262 __attribute__nonnull__(pTHX_1); */ 3263 #define PERL_ARGS_ASSERT_SV_CATSV \ 3264 assert(dstr) 3265 3266 PERL_CALLCONV void Perl_sv_chop(pTHX_ SV *const sv, const char *const ptr) 3267 __attribute__nonnull__(pTHX_1); 3268 #define PERL_ARGS_ASSERT_SV_CHOP \ 3269 assert(sv) 3270 3271 PERL_CALLCONV I32 Perl_sv_clean_all(pTHX); 3272 PERL_CALLCONV void Perl_sv_clean_objs(pTHX); 3273 PERL_CALLCONV void Perl_sv_clear(pTHX_ SV *const sv) 3274 __attribute__nonnull__(pTHX_1); 3275 #define PERL_ARGS_ASSERT_SV_CLEAR \ 3276 assert(sv) 3277 3278 PERL_CALLCONV I32 Perl_sv_cmp(pTHX_ SV *const sv1, SV *const sv2); 3279 PERL_CALLCONV I32 Perl_sv_cmp_locale(pTHX_ SV *const sv1, SV *const sv2); 3280 #if defined(USE_LOCALE_COLLATE) 3281 PERL_CALLCONV char* Perl_sv_collxfrm(pTHX_ SV *const sv, STRLEN *const nxp) 3282 __attribute__nonnull__(pTHX_1) 3283 __attribute__nonnull__(pTHX_2); 3284 #define PERL_ARGS_ASSERT_SV_COLLXFRM \ 3285 assert(sv); assert(nxp) 3286 3287 #endif 3288 PERL_CALLCONV OP* Perl_sv_compile_2op(pTHX_ SV *sv, OP **startop, const char *code, PAD **padp) 3289 __attribute__nonnull__(pTHX_1) 3290 __attribute__nonnull__(pTHX_2) 3291 __attribute__nonnull__(pTHX_3) 3292 __attribute__nonnull__(pTHX_4); 3293 #define PERL_ARGS_ASSERT_SV_COMPILE_2OP \ 3294 assert(sv); assert(startop); assert(code); assert(padp) 3295 3296 PERL_CALLCONV int Perl_getcwd_sv(pTHX_ SV* sv) 3297 __attribute__nonnull__(pTHX_1); 3298 #define PERL_ARGS_ASSERT_GETCWD_SV \ 3299 assert(sv) 3300 3301 PERL_CALLCONV void Perl_sv_dec(pTHX_ SV *const sv); 3302 PERL_CALLCONV void Perl_sv_dump(pTHX_ SV* sv) 3303 __attribute__nonnull__(pTHX_1); 3304 #define PERL_ARGS_ASSERT_SV_DUMP \ 3305 assert(sv) 3306 3307 PERL_CALLCONV bool Perl_sv_derived_from(pTHX_ SV* sv, const char *const name) 3308 __attribute__warn_unused_result__ 3309 __attribute__nonnull__(pTHX_1) 3310 __attribute__nonnull__(pTHX_2); 3311 #define PERL_ARGS_ASSERT_SV_DERIVED_FROM \ 3312 assert(sv); assert(name) 3313 3314 PERL_CALLCONV bool Perl_sv_does(pTHX_ SV* sv, const char *const name) 3315 __attribute__warn_unused_result__ 3316 __attribute__nonnull__(pTHX_1) 3317 __attribute__nonnull__(pTHX_2); 3318 #define PERL_ARGS_ASSERT_SV_DOES \ 3319 assert(sv); assert(name) 3320 3321 PERL_CALLCONV I32 Perl_sv_eq(pTHX_ SV* sv1, SV* sv2); 3322 PERL_CALLCONV void Perl_sv_free(pTHX_ SV *const sv); 3323 PERL_CALLCONV void Perl_sv_free2(pTHX_ SV *const sv) 3324 __attribute__nonnull__(pTHX_1); 3325 #define PERL_ARGS_ASSERT_SV_FREE2 \ 3326 assert(sv) 3327 3328 PERL_CALLCONV void Perl_sv_free_arenas(pTHX); 3329 PERL_CALLCONV char* Perl_sv_gets(pTHX_ SV *const sv, PerlIO *const fp, I32 append) 3330 __attribute__nonnull__(pTHX_1) 3331 __attribute__nonnull__(pTHX_2); 3332 #define PERL_ARGS_ASSERT_SV_GETS \ 3333 assert(sv); assert(fp) 3334 3335 PERL_CALLCONV char* Perl_sv_grow(pTHX_ SV *const sv, STRLEN newlen) 3336 __attribute__nonnull__(pTHX_1); 3337 #define PERL_ARGS_ASSERT_SV_GROW \ 3338 assert(sv) 3339 3340 PERL_CALLCONV void Perl_sv_inc(pTHX_ SV *const sv); 3341 /* PERL_CALLCONV void Perl_sv_insert(pTHX_ SV *const bigstr, const STRLEN offset, const STRLEN len, const char *const little, const STRLEN littlelen) 3342 __attribute__nonnull__(pTHX_1) 3343 __attribute__nonnull__(pTHX_4); */ 3344 #define PERL_ARGS_ASSERT_SV_INSERT \ 3345 assert(bigstr); assert(little) 3346 3347 PERL_CALLCONV void Perl_sv_insert_flags(pTHX_ SV *const bigstr, const STRLEN offset, const STRLEN len, const char *const little, const STRLEN littlelen, const U32 flags) 3348 __attribute__nonnull__(pTHX_1) 3349 __attribute__nonnull__(pTHX_4); 3350 #define PERL_ARGS_ASSERT_SV_INSERT_FLAGS \ 3351 assert(bigstr); assert(little) 3352 3353 PERL_CALLCONV int Perl_sv_isa(pTHX_ SV* sv, const char *const name) 3354 __attribute__nonnull__(pTHX_2); 3355 #define PERL_ARGS_ASSERT_SV_ISA \ 3356 assert(name) 3357 3358 PERL_CALLCONV int Perl_sv_isobject(pTHX_ SV* sv); 3359 PERL_CALLCONV STRLEN Perl_sv_len(pTHX_ SV *const sv); 3360 PERL_CALLCONV STRLEN Perl_sv_len_utf8(pTHX_ SV *const sv); 3361 PERL_CALLCONV void Perl_sv_magic(pTHX_ SV *const sv, SV *const obj, const int how, const char *const name, const I32 namlen) 3362 __attribute__nonnull__(pTHX_1); 3363 #define PERL_ARGS_ASSERT_SV_MAGIC \ 3364 assert(sv) 3365 3366 PERL_CALLCONV MAGIC * Perl_sv_magicext(pTHX_ SV *const sv, SV *const obj, const int how, const MGVTBL *const vtbl, const char *const name, const I32 namlen) 3367 __attribute__nonnull__(pTHX_1); 3368 #define PERL_ARGS_ASSERT_SV_MAGICEXT \ 3369 assert(sv) 3370 3371 PERL_CALLCONV SV* Perl_sv_mortalcopy(pTHX_ SV *const oldsv) 3372 __attribute__malloc__ 3373 __attribute__warn_unused_result__; 3374 3375 PERL_CALLCONV SV* Perl_sv_newmortal(pTHX) 3376 __attribute__warn_unused_result__; 3377 3378 PERL_CALLCONV SV* Perl_sv_newref(pTHX_ SV *const sv); 3379 PERL_CALLCONV char* Perl_sv_peek(pTHX_ SV* sv); 3380 PERL_CALLCONV void Perl_sv_pos_u2b(pTHX_ SV *const sv, I32 *const offsetp, I32 *const lenp) 3381 __attribute__nonnull__(pTHX_2); 3382 #define PERL_ARGS_ASSERT_SV_POS_U2B \ 3383 assert(offsetp) 3384 3385 PERL_CALLCONV STRLEN Perl_sv_pos_u2b_flags(pTHX_ SV *const sv, STRLEN uoffset, STRLEN *const lenp, U32 flags) 3386 __attribute__nonnull__(pTHX_1); 3387 #define PERL_ARGS_ASSERT_SV_POS_U2B_FLAGS \ 3388 assert(sv) 3389 3390 PERL_CALLCONV void Perl_sv_pos_b2u(pTHX_ SV *const sv, I32 *const offsetp) 3391 __attribute__nonnull__(pTHX_2); 3392 #define PERL_ARGS_ASSERT_SV_POS_B2U \ 3393 assert(offsetp) 3394 3395 /* PERL_CALLCONV char* Perl_sv_pvn_force(pTHX_ SV* sv, STRLEN* lp) 3396 __attribute__nonnull__(pTHX_1); */ 3397 #define PERL_ARGS_ASSERT_SV_PVN_FORCE \ 3398 assert(sv) 3399 3400 PERL_CALLCONV char* Perl_sv_pvutf8n_force(pTHX_ SV *const sv, STRLEN *const lp) 3401 __attribute__nonnull__(pTHX_1); 3402 #define PERL_ARGS_ASSERT_SV_PVUTF8N_FORCE \ 3403 assert(sv) 3404 3405 PERL_CALLCONV char* Perl_sv_pvbyten_force(pTHX_ SV *const sv, STRLEN *const lp) 3406 __attribute__nonnull__(pTHX_1); 3407 #define PERL_ARGS_ASSERT_SV_PVBYTEN_FORCE \ 3408 assert(sv) 3409 3410 PERL_CALLCONV char* Perl_sv_recode_to_utf8(pTHX_ SV* sv, SV *encoding) 3411 __attribute__nonnull__(pTHX_1) 3412 __attribute__nonnull__(pTHX_2); 3413 #define PERL_ARGS_ASSERT_SV_RECODE_TO_UTF8 \ 3414 assert(sv); assert(encoding) 3415 3416 PERL_CALLCONV bool Perl_sv_cat_decode(pTHX_ SV* dsv, SV *encoding, SV *ssv, int *offset, char* tstr, int tlen) 3417 __attribute__nonnull__(pTHX_1) 3418 __attribute__nonnull__(pTHX_2) 3419 __attribute__nonnull__(pTHX_3) 3420 __attribute__nonnull__(pTHX_4) 3421 __attribute__nonnull__(pTHX_5); 3422 #define PERL_ARGS_ASSERT_SV_CAT_DECODE \ 3423 assert(dsv); assert(encoding); assert(ssv); assert(offset); assert(tstr) 3424 3425 PERL_CALLCONV const char* Perl_sv_reftype(pTHX_ const SV *const sv, const int ob) 3426 __attribute__warn_unused_result__ 3427 __attribute__nonnull__(pTHX_1); 3428 #define PERL_ARGS_ASSERT_SV_REFTYPE \ 3429 assert(sv) 3430 3431 PERL_CALLCONV void Perl_sv_replace(pTHX_ SV *const sv, SV *const nsv) 3432 __attribute__nonnull__(pTHX_1) 3433 __attribute__nonnull__(pTHX_2); 3434 #define PERL_ARGS_ASSERT_SV_REPLACE \ 3435 assert(sv); assert(nsv) 3436 3437 PERL_CALLCONV void Perl_sv_report_used(pTHX); 3438 PERL_CALLCONV void Perl_sv_reset(pTHX_ const char* s, HV *const stash) 3439 __attribute__nonnull__(pTHX_1); 3440 #define PERL_ARGS_ASSERT_SV_RESET \ 3441 assert(s) 3442 3443 PERL_CALLCONV void Perl_sv_setpvf(pTHX_ SV *const sv, const char *const pat, ...) 3444 __attribute__format__(__printf__,pTHX_2,pTHX_3) 3445 __attribute__nonnull__(pTHX_1) 3446 __attribute__nonnull__(pTHX_2); 3447 #define PERL_ARGS_ASSERT_SV_SETPVF \ 3448 assert(sv); assert(pat) 3449 3450 PERL_CALLCONV void Perl_sv_vsetpvf(pTHX_ SV *const sv, const char *const pat, va_list *const args) 3451 __attribute__nonnull__(pTHX_1) 3452 __attribute__nonnull__(pTHX_2); 3453 #define PERL_ARGS_ASSERT_SV_VSETPVF \ 3454 assert(sv); assert(pat) 3455 3456 PERL_CALLCONV void Perl_sv_setiv(pTHX_ SV *const sv, const IV num) 3457 __attribute__nonnull__(pTHX_1); 3458 #define PERL_ARGS_ASSERT_SV_SETIV \ 3459 assert(sv) 3460 3461 PERL_CALLCONV void Perl_sv_setpviv(pTHX_ SV *const sv, const IV num) 3462 __attribute__nonnull__(pTHX_1); 3463 #define PERL_ARGS_ASSERT_SV_SETPVIV \ 3464 assert(sv) 3465 3466 PERL_CALLCONV void Perl_sv_setuv(pTHX_ SV *const sv, const UV num) 3467 __attribute__nonnull__(pTHX_1); 3468 #define PERL_ARGS_ASSERT_SV_SETUV \ 3469 assert(sv) 3470 3471 PERL_CALLCONV void Perl_sv_setnv(pTHX_ SV *const sv, const NV num) 3472 __attribute__nonnull__(pTHX_1); 3473 #define PERL_ARGS_ASSERT_SV_SETNV \ 3474 assert(sv) 3475 3476 PERL_CALLCONV SV* Perl_sv_setref_iv(pTHX_ SV *const rv, const char *const classname, const IV iv) 3477 __attribute__nonnull__(pTHX_1); 3478 #define PERL_ARGS_ASSERT_SV_SETREF_IV \ 3479 assert(rv) 3480 3481 PERL_CALLCONV SV* Perl_sv_setref_uv(pTHX_ SV *const rv, const char *const classname, const UV uv) 3482 __attribute__nonnull__(pTHX_1); 3483 #define PERL_ARGS_ASSERT_SV_SETREF_UV \ 3484 assert(rv) 3485 3486 PERL_CALLCONV SV* Perl_sv_setref_nv(pTHX_ SV *const rv, const char *const classname, const NV nv) 3487 __attribute__nonnull__(pTHX_1); 3488 #define PERL_ARGS_ASSERT_SV_SETREF_NV \ 3489 assert(rv) 3490 3491 PERL_CALLCONV SV* Perl_sv_setref_pv(pTHX_ SV *const rv, const char *const classname, void *const pv) 3492 __attribute__nonnull__(pTHX_1); 3493 #define PERL_ARGS_ASSERT_SV_SETREF_PV \ 3494 assert(rv) 3495 3496 PERL_CALLCONV SV* Perl_sv_setref_pvn(pTHX_ SV *const rv, const char *const classname, const char *const pv, const STRLEN n) 3497 __attribute__nonnull__(pTHX_1) 3498 __attribute__nonnull__(pTHX_3); 3499 #define PERL_ARGS_ASSERT_SV_SETREF_PVN \ 3500 assert(rv); assert(pv) 3501 3502 PERL_CALLCONV void Perl_sv_setpv(pTHX_ SV *const sv, const char *const ptr) 3503 __attribute__nonnull__(pTHX_1); 3504 #define PERL_ARGS_ASSERT_SV_SETPV \ 3505 assert(sv) 3506 3507 PERL_CALLCONV void Perl_sv_setpvn(pTHX_ SV *const sv, const char *const ptr, const STRLEN len) 3508 __attribute__nonnull__(pTHX_1); 3509 #define PERL_ARGS_ASSERT_SV_SETPVN \ 3510 assert(sv) 3511 3512 /* PERL_CALLCONV void Perl_sv_setsv(pTHX_ SV *dstr, SV *sstr) 3513 __attribute__nonnull__(pTHX_1); */ 3514 #define PERL_ARGS_ASSERT_SV_SETSV \ 3515 assert(dstr) 3516 3517 /* PERL_CALLCONV void Perl_sv_taint(pTHX_ SV* sv) 3518 __attribute__nonnull__(pTHX_1); */ 3519 #define PERL_ARGS_ASSERT_SV_TAINT \ 3520 assert(sv) 3521 3522 PERL_CALLCONV bool Perl_sv_tainted(pTHX_ SV *const sv) 3523 __attribute__warn_unused_result__ 3524 __attribute__nonnull__(pTHX_1); 3525 #define PERL_ARGS_ASSERT_SV_TAINTED \ 3526 assert(sv) 3527 3528 PERL_CALLCONV int Perl_sv_unmagic(pTHX_ SV *const sv, const int type) 3529 __attribute__nonnull__(pTHX_1); 3530 #define PERL_ARGS_ASSERT_SV_UNMAGIC \ 3531 assert(sv) 3532 3533 /* PERL_CALLCONV void Perl_sv_unref(pTHX_ SV* sv) 3534 __attribute__nonnull__(pTHX_1); */ 3535 #define PERL_ARGS_ASSERT_SV_UNREF \ 3536 assert(sv) 3537 3538 PERL_CALLCONV void Perl_sv_unref_flags(pTHX_ SV *const ref, const U32 flags) 3539 __attribute__nonnull__(pTHX_1); 3540 #define PERL_ARGS_ASSERT_SV_UNREF_FLAGS \ 3541 assert(ref) 3542 3543 PERL_CALLCONV void Perl_sv_untaint(pTHX_ SV *const sv) 3544 __attribute__nonnull__(pTHX_1); 3545 #define PERL_ARGS_ASSERT_SV_UNTAINT \ 3546 assert(sv) 3547 3548 PERL_CALLCONV void Perl_sv_upgrade(pTHX_ SV *const sv, svtype new_type) 3549 __attribute__nonnull__(pTHX_1); 3550 #define PERL_ARGS_ASSERT_SV_UPGRADE \ 3551 assert(sv) 3552 3553 /* PERL_CALLCONV void Perl_sv_usepvn(pTHX_ SV* sv, char* ptr, STRLEN len) 3554 __attribute__nonnull__(pTHX_1); */ 3555 #define PERL_ARGS_ASSERT_SV_USEPVN \ 3556 assert(sv) 3557 3558 PERL_CALLCONV void Perl_sv_usepvn_flags(pTHX_ SV *const sv, char* ptr, const STRLEN len, const U32 flags) 3559 __attribute__nonnull__(pTHX_1); 3560 #define PERL_ARGS_ASSERT_SV_USEPVN_FLAGS \ 3561 assert(sv) 3562 3563 PERL_CALLCONV void Perl_sv_vcatpvfn(pTHX_ SV *const sv, const char *const pat, const STRLEN patlen, va_list *const args, SV **const svargs, const I32 svmax, bool *const maybe_tainted) 3564 __attribute__nonnull__(pTHX_1) 3565 __attribute__nonnull__(pTHX_2); 3566 #define PERL_ARGS_ASSERT_SV_VCATPVFN \ 3567 assert(sv); assert(pat) 3568 3569 PERL_CALLCONV void Perl_sv_vsetpvfn(pTHX_ SV *const sv, const char *const pat, const STRLEN patlen, va_list *const args, SV **const svargs, const I32 svmax, bool *const maybe_tainted) 3570 __attribute__nonnull__(pTHX_1) 3571 __attribute__nonnull__(pTHX_2); 3572 #define PERL_ARGS_ASSERT_SV_VSETPVFN \ 3573 assert(sv); assert(pat) 3574 3575 PERL_CALLCONV NV Perl_str_to_version(pTHX_ SV *sv) 3576 __attribute__warn_unused_result__ 3577 __attribute__nonnull__(pTHX_1); 3578 #define PERL_ARGS_ASSERT_STR_TO_VERSION \ 3579 assert(sv) 3580 3581 PERL_CALLCONV SV* Perl_swash_init(pTHX_ const char* pkg, const char* name, SV* listsv, I32 minbits, I32 none) 3582 __attribute__nonnull__(pTHX_1) 3583 __attribute__nonnull__(pTHX_2) 3584 __attribute__nonnull__(pTHX_3); 3585 #define PERL_ARGS_ASSERT_SWASH_INIT \ 3586 assert(pkg); assert(name); assert(listsv) 3587 3588 PERL_CALLCONV UV Perl_swash_fetch(pTHX_ SV *swash, const U8 *ptr, bool do_utf8) 3589 __attribute__nonnull__(pTHX_1) 3590 __attribute__nonnull__(pTHX_2); 3591 #define PERL_ARGS_ASSERT_SWASH_FETCH \ 3592 assert(swash); assert(ptr) 3593 3594 PERL_CALLCONV void Perl_taint_env(pTHX); 3595 PERL_CALLCONV void Perl_taint_proper(pTHX_ const char* f, const char *const s) 3596 __attribute__nonnull__(pTHX_2); 3597 #define PERL_ARGS_ASSERT_TAINT_PROPER \ 3598 assert(s) 3599 3600 PERL_CALLCONV UV Perl_to_utf8_case(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp, SV **swashp, const char *normal, const char *special) 3601 __attribute__nonnull__(pTHX_1) 3602 __attribute__nonnull__(pTHX_2) 3603 __attribute__nonnull__(pTHX_4) 3604 __attribute__nonnull__(pTHX_5) 3605 __attribute__nonnull__(pTHX_6); 3606 #define PERL_ARGS_ASSERT_TO_UTF8_CASE \ 3607 assert(p); assert(ustrp); assert(swashp); assert(normal); assert(special) 3608 3609 PERL_CALLCONV UV Perl_to_utf8_lower(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp) 3610 __attribute__nonnull__(pTHX_1) 3611 __attribute__nonnull__(pTHX_2); 3612 #define PERL_ARGS_ASSERT_TO_UTF8_LOWER \ 3613 assert(p); assert(ustrp) 3614 3615 PERL_CALLCONV UV Perl_to_utf8_upper(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp) 3616 __attribute__nonnull__(pTHX_1) 3617 __attribute__nonnull__(pTHX_2); 3618 #define PERL_ARGS_ASSERT_TO_UTF8_UPPER \ 3619 assert(p); assert(ustrp) 3620 3621 PERL_CALLCONV UV Perl_to_utf8_title(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp) 3622 __attribute__nonnull__(pTHX_1) 3623 __attribute__nonnull__(pTHX_2); 3624 #define PERL_ARGS_ASSERT_TO_UTF8_TITLE \ 3625 assert(p); assert(ustrp) 3626 3627 PERL_CALLCONV UV Perl_to_utf8_fold(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp) 3628 __attribute__nonnull__(pTHX_1) 3629 __attribute__nonnull__(pTHX_2); 3630 #define PERL_ARGS_ASSERT_TO_UTF8_FOLD \ 3631 assert(p); assert(ustrp) 3632 3633 #if defined(UNLINK_ALL_VERSIONS) 3634 PERL_CALLCONV I32 Perl_unlnk(pTHX_ const char* f) 3635 __attribute__nonnull__(pTHX_1); 3636 #define PERL_ARGS_ASSERT_UNLNK \ 3637 assert(f) 3638 3639 #endif 3640 PERL_CALLCONV I32 Perl_unpack_str(pTHX_ const char *pat, const char *patend, const char *s, const char *strbeg, const char *strend, char **new_s, I32 ocnt, U32 flags) 3641 __attribute__nonnull__(pTHX_1) 3642 __attribute__nonnull__(pTHX_2) 3643 __attribute__nonnull__(pTHX_3) 3644 __attribute__nonnull__(pTHX_5); 3645 #define PERL_ARGS_ASSERT_UNPACK_STR \ 3646 assert(pat); assert(patend); assert(s); assert(strend) 3647 3648 PERL_CALLCONV I32 Perl_unpackstring(pTHX_ const char *pat, const char *patend, const char *s, const char *strend, U32 flags) 3649 __attribute__nonnull__(pTHX_1) 3650 __attribute__nonnull__(pTHX_2) 3651 __attribute__nonnull__(pTHX_3) 3652 __attribute__nonnull__(pTHX_4); 3653 #define PERL_ARGS_ASSERT_UNPACKSTRING \ 3654 assert(pat); assert(patend); assert(s); assert(strend) 3655 3656 PERL_CALLCONV void Perl_unsharepvn(pTHX_ const char* sv, I32 len, U32 hash); 3657 PERL_CALLCONV void Perl_unshare_hek(pTHX_ HEK* hek); 3658 #ifdef PERL_MAD 3659 PERL_CALLCONV OP * Perl_utilize(pTHX_ int aver, I32 floor, OP* version, OP* idop, OP* arg) 3660 __attribute__nonnull__(pTHX_4); 3661 #define PERL_ARGS_ASSERT_UTILIZE \ 3662 assert(idop) 3663 3664 #else 3665 PERL_CALLCONV void Perl_utilize(pTHX_ int aver, I32 floor, OP* version, OP* idop, OP* arg) 3666 __attribute__nonnull__(pTHX_4); 3667 #define PERL_ARGS_ASSERT_UTILIZE \ 3668 assert(idop) 3669 3670 #endif 3671 PERL_CALLCONV U8* Perl_utf16_to_utf8(pTHX_ U8* p, U8 *d, I32 bytelen, I32 *newlen) 3672 __attribute__nonnull__(pTHX_1) 3673 __attribute__nonnull__(pTHX_2) 3674 __attribute__nonnull__(pTHX_4); 3675 #define PERL_ARGS_ASSERT_UTF16_TO_UTF8 \ 3676 assert(p); assert(d); assert(newlen) 3677 3678 PERL_CALLCONV U8* Perl_utf16_to_utf8_reversed(pTHX_ U8* p, U8 *d, I32 bytelen, I32 *newlen) 3679 __attribute__nonnull__(pTHX_1) 3680 __attribute__nonnull__(pTHX_2) 3681 __attribute__nonnull__(pTHX_4); 3682 #define PERL_ARGS_ASSERT_UTF16_TO_UTF8_REVERSED \ 3683 assert(p); assert(d); assert(newlen) 3684 3685 PERL_CALLCONV STRLEN Perl_utf8_length(pTHX_ const U8* s, const U8 *e) 3686 __attribute__warn_unused_result__ 3687 __attribute__pure__ 3688 __attribute__nonnull__(pTHX_1) 3689 __attribute__nonnull__(pTHX_2); 3690 #define PERL_ARGS_ASSERT_UTF8_LENGTH \ 3691 assert(s); assert(e) 3692 3693 PERL_CALLCONV IV Perl_utf8_distance(pTHX_ const U8 *a, const U8 *b) 3694 __attribute__warn_unused_result__ 3695 __attribute__pure__ 3696 __attribute__nonnull__(pTHX_1) 3697 __attribute__nonnull__(pTHX_2); 3698 #define PERL_ARGS_ASSERT_UTF8_DISTANCE \ 3699 assert(a); assert(b) 3700 3701 PERL_CALLCONV U8* Perl_utf8_hop(pTHX_ const U8 *s, I32 off) 3702 __attribute__warn_unused_result__ 3703 __attribute__pure__ 3704 __attribute__nonnull__(pTHX_1); 3705 #define PERL_ARGS_ASSERT_UTF8_HOP \ 3706 assert(s) 3707 3708 PERL_CALLCONV U8* Perl_utf8_to_bytes(pTHX_ U8 *s, STRLEN *len) 3709 __attribute__nonnull__(pTHX_1) 3710 __attribute__nonnull__(pTHX_2); 3711 #define PERL_ARGS_ASSERT_UTF8_TO_BYTES \ 3712 assert(s); assert(len) 3713 3714 PERL_CALLCONV U8* Perl_bytes_from_utf8(pTHX_ const U8 *s, STRLEN *len, bool *is_utf8) 3715 __attribute__nonnull__(pTHX_1) 3716 __attribute__nonnull__(pTHX_2); 3717 #define PERL_ARGS_ASSERT_BYTES_FROM_UTF8 \ 3718 assert(s); assert(len) 3719 3720 PERL_CALLCONV U8* Perl_bytes_to_utf8(pTHX_ const U8 *s, STRLEN *len) 3721 __attribute__nonnull__(pTHX_1) 3722 __attribute__nonnull__(pTHX_2); 3723 #define PERL_ARGS_ASSERT_BYTES_TO_UTF8 \ 3724 assert(s); assert(len) 3725 3726 PERL_CALLCONV UV Perl_utf8_to_uvchr(pTHX_ const U8 *s, STRLEN *retlen) 3727 __attribute__nonnull__(pTHX_1); 3728 #define PERL_ARGS_ASSERT_UTF8_TO_UVCHR \ 3729 assert(s) 3730 3731 PERL_CALLCONV UV Perl_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen) 3732 __attribute__nonnull__(pTHX_1); 3733 #define PERL_ARGS_ASSERT_UTF8_TO_UVUNI \ 3734 assert(s) 3735 3736 3737 #ifdef EBCDIC 3738 PERL_CALLCONV UV Perl_utf8n_to_uvchr(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags) 3739 __attribute__nonnull__(pTHX_1); 3740 #define PERL_ARGS_ASSERT_UTF8N_TO_UVCHR \ 3741 assert(s) 3742 3743 #else 3744 /* PERL_CALLCONV UV Perl_utf8n_to_uvchr(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags) 3745 __attribute__nonnull__(pTHX_1); */ 3746 #define PERL_ARGS_ASSERT_UTF8N_TO_UVCHR \ 3747 assert(s) 3748 3749 #endif 3750 3751 PERL_CALLCONV UV Perl_utf8n_to_uvuni(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags) 3752 __attribute__nonnull__(pTHX_1); 3753 #define PERL_ARGS_ASSERT_UTF8N_TO_UVUNI \ 3754 assert(s) 3755 3756 3757 #ifdef EBCDIC 3758 PERL_CALLCONV U8* Perl_uvchr_to_utf8(pTHX_ U8 *d, UV uv) 3759 __attribute__nonnull__(pTHX_1); 3760 #define PERL_ARGS_ASSERT_UVCHR_TO_UTF8 \ 3761 assert(d) 3762 3763 #else 3764 /* PERL_CALLCONV U8* Perl_uvchr_to_utf8(pTHX_ U8 *d, UV uv) 3765 __attribute__nonnull__(pTHX_1); */ 3766 #define PERL_ARGS_ASSERT_UVCHR_TO_UTF8 \ 3767 assert(d) 3768 3769 #endif 3770 3771 /* PERL_CALLCONV U8* Perl_uvuni_to_utf8(pTHX_ U8 *d, UV uv) 3772 __attribute__nonnull__(pTHX_1); */ 3773 #define PERL_ARGS_ASSERT_UVUNI_TO_UTF8 \ 3774 assert(d) 3775 3776 PERL_CALLCONV U8* Perl_uvchr_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags) 3777 __attribute__nonnull__(pTHX_1); 3778 #define PERL_ARGS_ASSERT_UVCHR_TO_UTF8_FLAGS \ 3779 assert(d) 3780 3781 PERL_CALLCONV U8* Perl_uvuni_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags) 3782 __attribute__nonnull__(pTHX_1); 3783 #define PERL_ARGS_ASSERT_UVUNI_TO_UTF8_FLAGS \ 3784 assert(d) 3785 3786 PERL_CALLCONV char* Perl_pv_uni_display(pTHX_ SV *dsv, const U8 *spv, STRLEN len, STRLEN pvlim, UV flags) 3787 __attribute__nonnull__(pTHX_1) 3788 __attribute__nonnull__(pTHX_2); 3789 #define PERL_ARGS_ASSERT_PV_UNI_DISPLAY \ 3790 assert(dsv); assert(spv) 3791 3792 PERL_CALLCONV char* Perl_sv_uni_display(pTHX_ SV *dsv, SV *ssv, STRLEN pvlim, UV flags) 3793 __attribute__warn_unused_result__ 3794 __attribute__nonnull__(pTHX_1) 3795 __attribute__nonnull__(pTHX_2); 3796 #define PERL_ARGS_ASSERT_SV_UNI_DISPLAY \ 3797 assert(dsv); assert(ssv) 3798 3799 PERL_CALLCONV void Perl_vivify_defelem(pTHX_ SV* sv) 3800 __attribute__nonnull__(pTHX_1); 3801 #define PERL_ARGS_ASSERT_VIVIFY_DEFELEM \ 3802 assert(sv) 3803 3804 PERL_CALLCONV void Perl_vivify_ref(pTHX_ SV* sv, U32 to_what) 3805 __attribute__nonnull__(pTHX_1); 3806 #define PERL_ARGS_ASSERT_VIVIFY_REF \ 3807 assert(sv) 3808 3809 PERL_CALLCONV I32 Perl_wait4pid(pTHX_ Pid_t pid, int* statusp, int flags) 3810 __attribute__nonnull__(pTHX_2); 3811 #define PERL_ARGS_ASSERT_WAIT4PID \ 3812 assert(statusp) 3813 3814 PERL_CALLCONV U32 Perl_parse_unicode_opts(pTHX_ const char **popt) 3815 __attribute__nonnull__(pTHX_1); 3816 #define PERL_ARGS_ASSERT_PARSE_UNICODE_OPTS \ 3817 assert(popt) 3818 3819 PERL_CALLCONV U32 Perl_seed(pTHX); 3820 PERL_CALLCONV UV Perl_get_hash_seed(pTHX) 3821 __attribute__warn_unused_result__; 3822 3823 PERL_CALLCONV void Perl_report_evil_fh(pTHX_ const GV *gv, const IO *io, I32 op); 3824 PERL_CALLCONV void Perl_report_uninit(pTHX_ const SV *uninit_sv); 3825 PERL_CALLCONV void Perl_warn(pTHX_ const char* pat, ...) 3826 __attribute__format__(__printf__,pTHX_1,pTHX_2) 3827 __attribute__nonnull__(pTHX_1); 3828 #define PERL_ARGS_ASSERT_WARN \ 3829 assert(pat) 3830 3831 PERL_CALLCONV void Perl_vwarn(pTHX_ const char* pat, va_list* args) 3832 __attribute__nonnull__(pTHX_1); 3833 #define PERL_ARGS_ASSERT_VWARN \ 3834 assert(pat) 3835 3836 PERL_CALLCONV void Perl_warner(pTHX_ U32 err, const char* pat, ...) 3837 __attribute__format__(__printf__,pTHX_2,pTHX_3) 3838 __attribute__nonnull__(pTHX_2); 3839 #define PERL_ARGS_ASSERT_WARNER \ 3840 assert(pat) 3841 3842 PERL_CALLCONV void Perl_ck_warner(pTHX_ U32 err, const char* pat, ...) 3843 __attribute__format__(__printf__,pTHX_2,pTHX_3) 3844 __attribute__nonnull__(pTHX_2); 3845 #define PERL_ARGS_ASSERT_CK_WARNER \ 3846 assert(pat) 3847 3848 PERL_CALLCONV void Perl_ck_warner_d(pTHX_ U32 err, const char* pat, ...) 3849 __attribute__format__(__printf__,pTHX_2,pTHX_3) 3850 __attribute__nonnull__(pTHX_2); 3851 #define PERL_ARGS_ASSERT_CK_WARNER_D \ 3852 assert(pat) 3853 3854 PERL_CALLCONV void Perl_vwarner(pTHX_ U32 err, const char* pat, va_list* args) 3855 __attribute__nonnull__(pTHX_2); 3856 #define PERL_ARGS_ASSERT_VWARNER \ 3857 assert(pat) 3858 3859 PERL_CALLCONV void Perl_watch(pTHX_ char** addr) 3860 __attribute__nonnull__(pTHX_1); 3861 #define PERL_ARGS_ASSERT_WATCH \ 3862 assert(addr) 3863 3864 PERL_CALLCONV I32 Perl_whichsig(pTHX_ const char* sig) 3865 __attribute__nonnull__(pTHX_1); 3866 #define PERL_ARGS_ASSERT_WHICHSIG \ 3867 assert(sig) 3868 3869 PERL_CALLCONV void Perl_write_to_stderr(pTHX_ SV* msv) 3870 __attribute__nonnull__(pTHX_1); 3871 #define PERL_ARGS_ASSERT_WRITE_TO_STDERR \ 3872 assert(msv) 3873 3874 PERL_CALLCONV int Perl_yyerror(pTHX_ const char *const s) 3875 __attribute__nonnull__(pTHX_1); 3876 #define PERL_ARGS_ASSERT_YYERROR \ 3877 assert(s) 3878 3879 PERL_CALLCONV int Perl_yylex(pTHX); 3880 PERL_CALLCONV int Perl_yyparse(pTHX); 3881 PERL_CALLCONV void Perl_parser_free(pTHX_ const yy_parser *parser) 3882 __attribute__nonnull__(pTHX_1); 3883 #define PERL_ARGS_ASSERT_PARSER_FREE \ 3884 assert(parser) 3885 3886 #if defined(PERL_IN_TOKE_C) || defined(PERL_DECL_PROT) 3887 STATIC int S_yywarn(pTHX_ const char *const s) 3888 __attribute__nonnull__(pTHX_1); 3889 #define PERL_ARGS_ASSERT_YYWARN \ 3890 assert(s) 3891 3892 #endif 3893 #if defined(MYMALLOC) 3894 PERL_CALLCONV void Perl_dump_mstats(pTHX_ const char* s) 3895 __attribute__nonnull__(pTHX_1); 3896 #define PERL_ARGS_ASSERT_DUMP_MSTATS \ 3897 assert(s) 3898 3899 PERL_CALLCONV int Perl_get_mstats(pTHX_ perl_mstats_t *buf, int buflen, int level) 3900 __attribute__nonnull__(pTHX_1); 3901 #define PERL_ARGS_ASSERT_GET_MSTATS \ 3902 assert(buf) 3903 3904 #endif 3905 PERL_CALLCONV Malloc_t Perl_safesysmalloc(MEM_SIZE nbytes) 3906 __attribute__malloc__ 3907 __attribute__warn_unused_result__; 3908 3909 PERL_CALLCONV Malloc_t Perl_safesyscalloc(MEM_SIZE elements, MEM_SIZE size) 3910 __attribute__malloc__ 3911 __attribute__warn_unused_result__; 3912 3913 PERL_CALLCONV Malloc_t Perl_safesysrealloc(Malloc_t where, MEM_SIZE nbytes) 3914 __attribute__malloc__ 3915 __attribute__warn_unused_result__; 3916 3917 PERL_CALLCONV Free_t Perl_safesysfree(Malloc_t where); 3918 #if defined(PERL_GLOBAL_STRUCT) 3919 PERL_CALLCONV struct perl_vars * Perl_GetVars(pTHX); 3920 PERL_CALLCONV struct perl_vars* Perl_init_global_struct(pTHX); 3921 PERL_CALLCONV void Perl_free_global_struct(pTHX_ struct perl_vars *plvarsp) 3922 __attribute__nonnull__(pTHX_1); 3923 #define PERL_ARGS_ASSERT_FREE_GLOBAL_STRUCT \ 3924 assert(plvarsp) 3925 3926 #endif 3927 PERL_CALLCONV int Perl_runops_standard(pTHX); 3928 PERL_CALLCONV int Perl_runops_debug(pTHX); 3929 PERL_CALLCONV void Perl_sv_catpvf_mg(pTHX_ SV *const sv, const char *const pat, ...) 3930 __attribute__format__(__printf__,pTHX_2,pTHX_3) 3931 __attribute__nonnull__(pTHX_1) 3932 __attribute__nonnull__(pTHX_2); 3933 #define PERL_ARGS_ASSERT_SV_CATPVF_MG \ 3934 assert(sv); assert(pat) 3935 3936 PERL_CALLCONV void Perl_sv_vcatpvf_mg(pTHX_ SV *const sv, const char *const pat, va_list *const args) 3937 __attribute__nonnull__(pTHX_1) 3938 __attribute__nonnull__(pTHX_2); 3939 #define PERL_ARGS_ASSERT_SV_VCATPVF_MG \ 3940 assert(sv); assert(pat) 3941 3942 PERL_CALLCONV void Perl_sv_catpv_mg(pTHX_ SV *const sv, const char *const ptr) 3943 __attribute__nonnull__(pTHX_1); 3944 #define PERL_ARGS_ASSERT_SV_CATPV_MG \ 3945 assert(sv) 3946 3947 /* PERL_CALLCONV void Perl_sv_catpvn_mg(pTHX_ SV *sv, const char *ptr, STRLEN len) 3948 __attribute__nonnull__(pTHX_1) 3949 __attribute__nonnull__(pTHX_2); */ 3950 #define PERL_ARGS_ASSERT_SV_CATPVN_MG \ 3951 assert(sv); assert(ptr) 3952 3953 /* PERL_CALLCONV void Perl_sv_catsv_mg(pTHX_ SV *dsv, SV *ssv) 3954 __attribute__nonnull__(pTHX_1); */ 3955 #define PERL_ARGS_ASSERT_SV_CATSV_MG \ 3956 assert(dsv) 3957 3958 PERL_CALLCONV void Perl_sv_setpvf_mg(pTHX_ SV *const sv, const char *const pat, ...) 3959 __attribute__format__(__printf__,pTHX_2,pTHX_3) 3960 __attribute__nonnull__(pTHX_1) 3961 __attribute__nonnull__(pTHX_2); 3962 #define PERL_ARGS_ASSERT_SV_SETPVF_MG \ 3963 assert(sv); assert(pat) 3964 3965 PERL_CALLCONV void Perl_sv_vsetpvf_mg(pTHX_ SV *const sv, const char *const pat, va_list *const args) 3966 __attribute__nonnull__(pTHX_1) 3967 __attribute__nonnull__(pTHX_2); 3968 #define PERL_ARGS_ASSERT_SV_VSETPVF_MG \ 3969 assert(sv); assert(pat) 3970 3971 PERL_CALLCONV void Perl_sv_setiv_mg(pTHX_ SV *const sv, const IV i) 3972 __attribute__nonnull__(pTHX_1); 3973 #define PERL_ARGS_ASSERT_SV_SETIV_MG \ 3974 assert(sv) 3975 3976 PERL_CALLCONV void Perl_sv_setpviv_mg(pTHX_ SV *const sv, const IV iv) 3977 __attribute__nonnull__(pTHX_1); 3978 #define PERL_ARGS_ASSERT_SV_SETPVIV_MG \ 3979 assert(sv) 3980 3981 PERL_CALLCONV void Perl_sv_setuv_mg(pTHX_ SV *const sv, const UV u) 3982 __attribute__nonnull__(pTHX_1); 3983 #define PERL_ARGS_ASSERT_SV_SETUV_MG \ 3984 assert(sv) 3985 3986 PERL_CALLCONV void Perl_sv_setnv_mg(pTHX_ SV *const sv, const NV num) 3987 __attribute__nonnull__(pTHX_1); 3988 #define PERL_ARGS_ASSERT_SV_SETNV_MG \ 3989 assert(sv) 3990 3991 PERL_CALLCONV void Perl_sv_setpv_mg(pTHX_ SV *const sv, const char *const ptr) 3992 __attribute__nonnull__(pTHX_1); 3993 #define PERL_ARGS_ASSERT_SV_SETPV_MG \ 3994 assert(sv) 3995 3996 PERL_CALLCONV void Perl_sv_setpvn_mg(pTHX_ SV *const sv, const char *const ptr, const STRLEN len) 3997 __attribute__nonnull__(pTHX_1) 3998 __attribute__nonnull__(pTHX_2); 3999 #define PERL_ARGS_ASSERT_SV_SETPVN_MG \ 4000 assert(sv); assert(ptr) 4001 4002 PERL_CALLCONV void Perl_sv_setsv_mg(pTHX_ SV *const dstr, SV *const sstr) 4003 __attribute__nonnull__(pTHX_1); 4004 #define PERL_ARGS_ASSERT_SV_SETSV_MG \ 4005 assert(dstr) 4006 4007 /* PERL_CALLCONV void Perl_sv_usepvn_mg(pTHX_ SV *sv, char *ptr, STRLEN len) 4008 __attribute__nonnull__(pTHX_1); */ 4009 #define PERL_ARGS_ASSERT_SV_USEPVN_MG \ 4010 assert(sv) 4011 4012 PERL_CALLCONV MGVTBL* Perl_get_vtbl(pTHX_ int vtbl_id) 4013 __attribute__warn_unused_result__; 4014 4015 PERL_CALLCONV char* Perl_pv_display(pTHX_ SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim) 4016 __attribute__nonnull__(pTHX_1) 4017 __attribute__nonnull__(pTHX_2); 4018 #define PERL_ARGS_ASSERT_PV_DISPLAY \ 4019 assert(dsv); assert(pv) 4020 4021 PERL_CALLCONV char* Perl_pv_escape(pTHX_ SV *dsv, char const * const str, const STRLEN count, const STRLEN max, STRLEN * const escaped, const U32 flags) 4022 __attribute__nonnull__(pTHX_1) 4023 __attribute__nonnull__(pTHX_2); 4024 #define PERL_ARGS_ASSERT_PV_ESCAPE \ 4025 assert(dsv); assert(str) 4026 4027 PERL_CALLCONV char* Perl_pv_pretty(pTHX_ SV *dsv, char const * const str, const STRLEN count, const STRLEN max, char const * const start_color, char const * const end_color, const U32 flags) 4028 __attribute__nonnull__(pTHX_1) 4029 __attribute__nonnull__(pTHX_2); 4030 #define PERL_ARGS_ASSERT_PV_PRETTY \ 4031 assert(dsv); assert(str) 4032 4033 PERL_CALLCONV void Perl_dump_indent(pTHX_ I32 level, PerlIO *file, const char* pat, ...) 4034 __attribute__format__(__printf__,pTHX_3,pTHX_4) 4035 __attribute__nonnull__(pTHX_2) 4036 __attribute__nonnull__(pTHX_3); 4037 #define PERL_ARGS_ASSERT_DUMP_INDENT \ 4038 assert(file); assert(pat) 4039 4040 PERL_CALLCONV void Perl_dump_vindent(pTHX_ I32 level, PerlIO *file, const char* pat, va_list *args) 4041 __attribute__nonnull__(pTHX_2) 4042 __attribute__nonnull__(pTHX_3); 4043 #define PERL_ARGS_ASSERT_DUMP_VINDENT \ 4044 assert(file); assert(pat) 4045 4046 PERL_CALLCONV void Perl_do_gv_dump(pTHX_ I32 level, PerlIO *file, const char *name, GV *sv) 4047 __attribute__nonnull__(pTHX_2) 4048 __attribute__nonnull__(pTHX_3); 4049 #define PERL_ARGS_ASSERT_DO_GV_DUMP \ 4050 assert(file); assert(name) 4051 4052 PERL_CALLCONV void Perl_do_gvgv_dump(pTHX_ I32 level, PerlIO *file, const char *name, GV *sv) 4053 __attribute__nonnull__(pTHX_2) 4054 __attribute__nonnull__(pTHX_3); 4055 #define PERL_ARGS_ASSERT_DO_GVGV_DUMP \ 4056 assert(file); assert(name) 4057 4058 PERL_CALLCONV void Perl_do_hv_dump(pTHX_ I32 level, PerlIO *file, const char *name, HV *sv) 4059 __attribute__nonnull__(pTHX_2) 4060 __attribute__nonnull__(pTHX_3); 4061 #define PERL_ARGS_ASSERT_DO_HV_DUMP \ 4062 assert(file); assert(name) 4063 4064 PERL_CALLCONV void Perl_do_magic_dump(pTHX_ I32 level, PerlIO *file, const MAGIC *mg, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim) 4065 __attribute__nonnull__(pTHX_2) 4066 __attribute__nonnull__(pTHX_3); 4067 #define PERL_ARGS_ASSERT_DO_MAGIC_DUMP \ 4068 assert(file); assert(mg) 4069 4070 PERL_CALLCONV void Perl_do_op_dump(pTHX_ I32 level, PerlIO *file, const OP *o) 4071 __attribute__nonnull__(pTHX_2); 4072 #define PERL_ARGS_ASSERT_DO_OP_DUMP \ 4073 assert(file) 4074 4075 PERL_CALLCONV void Perl_do_pmop_dump(pTHX_ I32 level, PerlIO *file, const PMOP *pm) 4076 __attribute__nonnull__(pTHX_2); 4077 #define PERL_ARGS_ASSERT_DO_PMOP_DUMP \ 4078 assert(file) 4079 4080 PERL_CALLCONV void Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim) 4081 __attribute__nonnull__(pTHX_2); 4082 #define PERL_ARGS_ASSERT_DO_SV_DUMP \ 4083 assert(file) 4084 4085 PERL_CALLCONV void Perl_magic_dump(pTHX_ const MAGIC *mg); 4086 PERL_CALLCONV void Perl_reginitcolors(pTHX); 4087 /* PERL_CALLCONV char* Perl_sv_2pv_nolen(pTHX_ SV* sv) 4088 __attribute__warn_unused_result__ 4089 __attribute__nonnull__(pTHX_1); */ 4090 #define PERL_ARGS_ASSERT_SV_2PV_NOLEN \ 4091 assert(sv) 4092 4093 /* PERL_CALLCONV char* Perl_sv_2pvutf8_nolen(pTHX_ SV* sv) 4094 __attribute__warn_unused_result__ 4095 __attribute__nonnull__(pTHX_1); */ 4096 #define PERL_ARGS_ASSERT_SV_2PVUTF8_NOLEN \ 4097 assert(sv) 4098 4099 /* PERL_CALLCONV char* Perl_sv_2pvbyte_nolen(pTHX_ SV* sv) 4100 __attribute__warn_unused_result__ 4101 __attribute__nonnull__(pTHX_1); */ 4102 #define PERL_ARGS_ASSERT_SV_2PVBYTE_NOLEN \ 4103 assert(sv) 4104 4105 /* PERL_CALLCONV char* Perl_sv_pv(pTHX_ SV *sv) 4106 __attribute__warn_unused_result__ 4107 __attribute__nonnull__(pTHX_1); */ 4108 #define PERL_ARGS_ASSERT_SV_PV \ 4109 assert(sv) 4110 4111 /* PERL_CALLCONV char* Perl_sv_pvutf8(pTHX_ SV *sv) 4112 __attribute__warn_unused_result__ 4113 __attribute__nonnull__(pTHX_1); */ 4114 #define PERL_ARGS_ASSERT_SV_PVUTF8 \ 4115 assert(sv) 4116 4117 /* PERL_CALLCONV char* Perl_sv_pvbyte(pTHX_ SV *sv) 4118 __attribute__warn_unused_result__ 4119 __attribute__nonnull__(pTHX_1); */ 4120 #define PERL_ARGS_ASSERT_SV_PVBYTE \ 4121 assert(sv) 4122 4123 /* PERL_CALLCONV STRLEN Perl_sv_utf8_upgrade(pTHX_ SV *sv) 4124 __attribute__nonnull__(pTHX_1); */ 4125 #define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE \ 4126 assert(sv) 4127 4128 /* PERL_CALLCONV STRLEN sv_utf8_upgrade_nomg(pTHX_ SV *sv) 4129 __attribute__nonnull__(pTHX_1); */ 4130 4131 PERL_CALLCONV bool Perl_sv_utf8_downgrade(pTHX_ SV *const sv, const bool fail_ok) 4132 __attribute__nonnull__(pTHX_1); 4133 #define PERL_ARGS_ASSERT_SV_UTF8_DOWNGRADE \ 4134 assert(sv) 4135 4136 PERL_CALLCONV void Perl_sv_utf8_encode(pTHX_ SV *const sv) 4137 __attribute__nonnull__(pTHX_1); 4138 #define PERL_ARGS_ASSERT_SV_UTF8_ENCODE \ 4139 assert(sv) 4140 4141 PERL_CALLCONV bool Perl_sv_utf8_decode(pTHX_ SV *const sv) 4142 __attribute__nonnull__(pTHX_1); 4143 #define PERL_ARGS_ASSERT_SV_UTF8_DECODE \ 4144 assert(sv) 4145 4146 /* PERL_CALLCONV void Perl_sv_force_normal(pTHX_ SV *sv) 4147 __attribute__nonnull__(pTHX_1); */ 4148 #define PERL_ARGS_ASSERT_SV_FORCE_NORMAL \ 4149 assert(sv) 4150 4151 PERL_CALLCONV void Perl_sv_force_normal_flags(pTHX_ SV *const sv, const U32 flags) 4152 __attribute__nonnull__(pTHX_1); 4153 #define PERL_ARGS_ASSERT_SV_FORCE_NORMAL_FLAGS \ 4154 assert(sv) 4155 4156 PERL_CALLCONV void Perl_tmps_grow(pTHX_ I32 n); 4157 PERL_CALLCONV SV* Perl_sv_rvweaken(pTHX_ SV *const sv) 4158 __attribute__nonnull__(pTHX_1); 4159 #define PERL_ARGS_ASSERT_SV_RVWEAKEN \ 4160 assert(sv) 4161 4162 PERL_CALLCONV int Perl_magic_killbackrefs(pTHX_ SV *sv, MAGIC *mg) 4163 __attribute__nonnull__(pTHX_1) 4164 __attribute__nonnull__(pTHX_2); 4165 #define PERL_ARGS_ASSERT_MAGIC_KILLBACKREFS \ 4166 assert(sv); assert(mg) 4167 4168 PERL_CALLCONV OP* Perl_newANONATTRSUB(pTHX_ I32 floor, OP *proto, OP *attrs, OP *block); 4169 PERL_CALLCONV CV* Perl_newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block); 4170 #ifdef PERL_MAD 4171 PERL_CALLCONV OP * Perl_newMYSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block) 4172 __attribute__noreturn__; 4173 4174 #else 4175 PERL_CALLCONV void Perl_newMYSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block) 4176 __attribute__noreturn__; 4177 4178 #endif 4179 PERL_CALLCONV OP * Perl_my_attrs(pTHX_ OP *o, OP *attrs) 4180 __attribute__nonnull__(pTHX_1); 4181 #define PERL_ARGS_ASSERT_MY_ATTRS \ 4182 assert(o) 4183 4184 #if defined(USE_ITHREADS) 4185 PERL_CALLCONV PERL_CONTEXT* Perl_cx_dup(pTHX_ PERL_CONTEXT* cx, I32 ix, I32 max, CLONE_PARAMS* param) 4186 __attribute__warn_unused_result__ 4187 __attribute__nonnull__(pTHX_4); 4188 #define PERL_ARGS_ASSERT_CX_DUP \ 4189 assert(param) 4190 4191 PERL_CALLCONV PERL_SI* Perl_si_dup(pTHX_ PERL_SI* si, CLONE_PARAMS* param) 4192 __attribute__warn_unused_result__ 4193 __attribute__nonnull__(pTHX_2); 4194 #define PERL_ARGS_ASSERT_SI_DUP \ 4195 assert(param) 4196 4197 PERL_CALLCONV ANY* Perl_ss_dup(pTHX_ PerlInterpreter* proto_perl, CLONE_PARAMS* param) 4198 __attribute__malloc__ 4199 __attribute__warn_unused_result__ 4200 __attribute__nonnull__(pTHX_1) 4201 __attribute__nonnull__(pTHX_2); 4202 #define PERL_ARGS_ASSERT_SS_DUP \ 4203 assert(proto_perl); assert(param) 4204 4205 PERL_CALLCONV void* Perl_any_dup(pTHX_ void* v, const PerlInterpreter* proto_perl) 4206 __attribute__warn_unused_result__ 4207 __attribute__nonnull__(pTHX_2); 4208 #define PERL_ARGS_ASSERT_ANY_DUP \ 4209 assert(proto_perl) 4210 4211 PERL_CALLCONV HE* Perl_he_dup(pTHX_ const HE* e, bool shared, CLONE_PARAMS* param) 4212 __attribute__warn_unused_result__ 4213 __attribute__nonnull__(pTHX_3); 4214 #define PERL_ARGS_ASSERT_HE_DUP \ 4215 assert(param) 4216 4217 PERL_CALLCONV HEK* Perl_hek_dup(pTHX_ HEK* e, CLONE_PARAMS* param) 4218 __attribute__warn_unused_result__ 4219 __attribute__nonnull__(pTHX_2); 4220 #define PERL_ARGS_ASSERT_HEK_DUP \ 4221 assert(param) 4222 4223 PERL_CALLCONV void Perl_re_dup_guts(pTHX_ const REGEXP *sstr, REGEXP *dstr, CLONE_PARAMS* param) 4224 __attribute__nonnull__(pTHX_1) 4225 __attribute__nonnull__(pTHX_2) 4226 __attribute__nonnull__(pTHX_3); 4227 #define PERL_ARGS_ASSERT_RE_DUP_GUTS \ 4228 assert(sstr); assert(dstr); assert(param) 4229 4230 PERL_CALLCONV PerlIO* Perl_fp_dup(pTHX_ PerlIO *const fp, const char type, CLONE_PARAMS *const param) 4231 __attribute__nonnull__(pTHX_3); 4232 #define PERL_ARGS_ASSERT_FP_DUP \ 4233 assert(param) 4234 4235 PERL_CALLCONV DIR* Perl_dirp_dup(pTHX_ DIR *const dp) 4236 __attribute__warn_unused_result__; 4237 4238 PERL_CALLCONV GP* Perl_gp_dup(pTHX_ GP *const gp, CLONE_PARAMS *const param) 4239 __attribute__warn_unused_result__ 4240 __attribute__nonnull__(pTHX_2); 4241 #define PERL_ARGS_ASSERT_GP_DUP \ 4242 assert(param) 4243 4244 PERL_CALLCONV MAGIC* Perl_mg_dup(pTHX_ MAGIC *mg, CLONE_PARAMS *const param) 4245 __attribute__warn_unused_result__ 4246 __attribute__nonnull__(pTHX_2); 4247 #define PERL_ARGS_ASSERT_MG_DUP \ 4248 assert(param) 4249 4250 #if defined(PERL_IN_SV_C) || defined(PERL_DECL_PROT) 4251 STATIC SV ** S_sv_dup_inc_multiple(pTHX_ SV *const *source, SV **dest, SSize_t items, CLONE_PARAMS *const param) 4252 __attribute__nonnull__(pTHX_1) 4253 __attribute__nonnull__(pTHX_2) 4254 __attribute__nonnull__(pTHX_4); 4255 #define PERL_ARGS_ASSERT_SV_DUP_INC_MULTIPLE \ 4256 assert(source); assert(dest); assert(param) 4257 4258 #endif 4259 PERL_CALLCONV SV* Perl_sv_dup(pTHX_ const SV *const sstr, CLONE_PARAMS *const param) 4260 __attribute__warn_unused_result__ 4261 __attribute__nonnull__(pTHX_2); 4262 #define PERL_ARGS_ASSERT_SV_DUP \ 4263 assert(param) 4264 4265 PERL_CALLCONV void Perl_rvpv_dup(pTHX_ SV *const dstr, const SV *const sstr, CLONE_PARAMS *const param) 4266 __attribute__nonnull__(pTHX_1) 4267 __attribute__nonnull__(pTHX_2) 4268 __attribute__nonnull__(pTHX_3); 4269 #define PERL_ARGS_ASSERT_RVPV_DUP \ 4270 assert(dstr); assert(sstr); assert(param) 4271 4272 PERL_CALLCONV yy_parser* Perl_parser_dup(pTHX_ const yy_parser *const proto, CLONE_PARAMS *const param) 4273 __attribute__nonnull__(pTHX_2); 4274 #define PERL_ARGS_ASSERT_PARSER_DUP \ 4275 assert(param) 4276 4277 #endif 4278 PERL_CALLCONV PTR_TBL_t* Perl_ptr_table_new(pTHX) 4279 __attribute__malloc__ 4280 __attribute__warn_unused_result__; 4281 4282 PERL_CALLCONV void* Perl_ptr_table_fetch(pTHX_ PTR_TBL_t *const tbl, const void *const sv) 4283 __attribute__warn_unused_result__ 4284 __attribute__nonnull__(pTHX_1); 4285 #define PERL_ARGS_ASSERT_PTR_TABLE_FETCH \ 4286 assert(tbl) 4287 4288 PERL_CALLCONV void Perl_ptr_table_store(pTHX_ PTR_TBL_t *const tbl, const void *const oldsv, void *const newsv) 4289 __attribute__nonnull__(pTHX_1) 4290 __attribute__nonnull__(pTHX_3); 4291 #define PERL_ARGS_ASSERT_PTR_TABLE_STORE \ 4292 assert(tbl); assert(newsv) 4293 4294 PERL_CALLCONV void Perl_ptr_table_split(pTHX_ PTR_TBL_t *const tbl) 4295 __attribute__nonnull__(pTHX_1); 4296 #define PERL_ARGS_ASSERT_PTR_TABLE_SPLIT \ 4297 assert(tbl) 4298 4299 PERL_CALLCONV void Perl_ptr_table_clear(pTHX_ PTR_TBL_t *const tbl); 4300 PERL_CALLCONV void Perl_ptr_table_free(pTHX_ PTR_TBL_t *const tbl); 4301 #if defined(USE_ITHREADS) 4302 # if defined(HAVE_INTERP_INTERN) 4303 PERL_CALLCONV void Perl_sys_intern_dup(pTHX_ struct interp_intern* src, struct interp_intern* dst) 4304 __attribute__nonnull__(pTHX_1) 4305 __attribute__nonnull__(pTHX_2); 4306 #define PERL_ARGS_ASSERT_SYS_INTERN_DUP \ 4307 assert(src); assert(dst) 4308 4309 # endif 4310 #endif 4311 #if defined(HAVE_INTERP_INTERN) 4312 PERL_CALLCONV void Perl_sys_intern_clear(pTHX); 4313 PERL_CALLCONV void Perl_sys_intern_init(pTHX); 4314 #endif 4315 4316 PERL_CALLCONV const char * Perl_custom_op_name(pTHX_ const OP *o) 4317 __attribute__warn_unused_result__ 4318 __attribute__nonnull__(pTHX_1); 4319 #define PERL_ARGS_ASSERT_CUSTOM_OP_NAME \ 4320 assert(o) 4321 4322 PERL_CALLCONV const char * Perl_custom_op_desc(pTHX_ const OP *o) 4323 __attribute__warn_unused_result__ 4324 __attribute__nonnull__(pTHX_1); 4325 #define PERL_ARGS_ASSERT_CUSTOM_OP_DESC \ 4326 assert(o) 4327 4328 4329 PERL_CALLCONV void Perl_sv_nosharing(pTHX_ SV *sv); 4330 /* PERL_CALLCONV void Perl_sv_nolocking(pTHX_ SV *sv); */ 4331 PERL_CALLCONV bool Perl_sv_destroyable(pTHX_ SV *sv); 4332 #ifdef NO_MATHOMS 4333 /* PERL_CALLCONV void Perl_sv_nounlocking(pTHX_ SV *sv); */ 4334 #else 4335 PERL_CALLCONV void Perl_sv_nounlocking(pTHX_ SV *sv); 4336 #endif 4337 PERL_CALLCONV int Perl_nothreadhook(pTHX); 4338 4339 END_EXTERN_C 4340 4341 #if defined(PERL_IN_DOOP_C) || defined(PERL_DECL_PROT) 4342 STATIC I32 S_do_trans_simple(pTHX_ SV * const sv) 4343 __attribute__warn_unused_result__ 4344 __attribute__nonnull__(pTHX_1); 4345 #define PERL_ARGS_ASSERT_DO_TRANS_SIMPLE \ 4346 assert(sv) 4347 4348 STATIC I32 S_do_trans_count(pTHX_ SV * const sv) 4349 __attribute__warn_unused_result__ 4350 __attribute__nonnull__(pTHX_1); 4351 #define PERL_ARGS_ASSERT_DO_TRANS_COUNT \ 4352 assert(sv) 4353 4354 STATIC I32 S_do_trans_complex(pTHX_ SV * const sv) 4355 __attribute__warn_unused_result__ 4356 __attribute__nonnull__(pTHX_1); 4357 #define PERL_ARGS_ASSERT_DO_TRANS_COMPLEX \ 4358 assert(sv) 4359 4360 STATIC I32 S_do_trans_simple_utf8(pTHX_ SV * const sv) 4361 __attribute__warn_unused_result__ 4362 __attribute__nonnull__(pTHX_1); 4363 #define PERL_ARGS_ASSERT_DO_TRANS_SIMPLE_UTF8 \ 4364 assert(sv) 4365 4366 STATIC I32 S_do_trans_count_utf8(pTHX_ SV * const sv) 4367 __attribute__warn_unused_result__ 4368 __attribute__nonnull__(pTHX_1); 4369 #define PERL_ARGS_ASSERT_DO_TRANS_COUNT_UTF8 \ 4370 assert(sv) 4371 4372 STATIC I32 S_do_trans_complex_utf8(pTHX_ SV * const sv) 4373 __attribute__warn_unused_result__ 4374 __attribute__nonnull__(pTHX_1); 4375 #define PERL_ARGS_ASSERT_DO_TRANS_COMPLEX_UTF8 \ 4376 assert(sv) 4377 4378 #endif 4379 4380 #if defined(PERL_IN_GV_C) || defined(PERL_DECL_PROT) 4381 STATIC void S_gv_init_sv(pTHX_ GV *gv, const svtype sv_type) 4382 __attribute__nonnull__(pTHX_1); 4383 #define PERL_ARGS_ASSERT_GV_INIT_SV \ 4384 assert(gv) 4385 4386 STATIC HV* S_gv_get_super_pkg(pTHX_ const char* name, I32 namelen) 4387 __attribute__nonnull__(pTHX_1); 4388 #define PERL_ARGS_ASSERT_GV_GET_SUPER_PKG \ 4389 assert(name) 4390 4391 STATIC HV* S_require_tie_mod(pTHX_ GV *gv, const char *varpv, SV* namesv, const char *methpv, const U32 flags) 4392 __attribute__nonnull__(pTHX_1) 4393 __attribute__nonnull__(pTHX_2) 4394 __attribute__nonnull__(pTHX_3) 4395 __attribute__nonnull__(pTHX_4); 4396 #define PERL_ARGS_ASSERT_REQUIRE_TIE_MOD \ 4397 assert(gv); assert(varpv); assert(namesv); assert(methpv) 4398 4399 #endif 4400 4401 PERL_CALLCONV void* Perl_get_arena(pTHX_ const size_t arenasize, const svtype bodytype) 4402 __attribute__malloc__ 4403 __attribute__warn_unused_result__; 4404 4405 4406 #if defined(PERL_IN_HV_C) || defined(PERL_DECL_PROT) 4407 STATIC void S_hsplit(pTHX_ HV *hv) 4408 __attribute__nonnull__(pTHX_1); 4409 #define PERL_ARGS_ASSERT_HSPLIT \ 4410 assert(hv) 4411 4412 STATIC void S_hfreeentries(pTHX_ HV *hv) 4413 __attribute__nonnull__(pTHX_1); 4414 #define PERL_ARGS_ASSERT_HFREEENTRIES \ 4415 assert(hv) 4416 4417 STATIC I32 S_anonymise_cv(pTHX_ HEK *stash, SV *val) 4418 __attribute__nonnull__(pTHX_2); 4419 #define PERL_ARGS_ASSERT_ANONYMISE_CV \ 4420 assert(val) 4421 4422 STATIC HE* S_new_he(pTHX) 4423 __attribute__malloc__ 4424 __attribute__warn_unused_result__; 4425 4426 STATIC HEK* S_save_hek_flags(const char *str, I32 len, U32 hash, int flags) 4427 __attribute__malloc__ 4428 __attribute__warn_unused_result__ 4429 __attribute__nonnull__(1); 4430 #define PERL_ARGS_ASSERT_SAVE_HEK_FLAGS \ 4431 assert(str) 4432 4433 STATIC void S_hv_magic_check(HV *hv, bool *needs_copy, bool *needs_store) 4434 __attribute__nonnull__(1) 4435 __attribute__nonnull__(2) 4436 __attribute__nonnull__(3); 4437 #define PERL_ARGS_ASSERT_HV_MAGIC_CHECK \ 4438 assert(hv); assert(needs_copy); assert(needs_store) 4439 4440 STATIC void S_unshare_hek_or_pvn(pTHX_ const HEK* hek, const char* str, I32 len, U32 hash); 4441 STATIC HEK* S_share_hek_flags(pTHX_ const char *str, I32 len, U32 hash, int flags) 4442 __attribute__warn_unused_result__ 4443 __attribute__nonnull__(pTHX_1); 4444 #define PERL_ARGS_ASSERT_SHARE_HEK_FLAGS \ 4445 assert(str) 4446 4447 STATIC void S_hv_notallowed(pTHX_ int flags, const char *key, I32 klen, const char *msg) 4448 __attribute__noreturn__ 4449 __attribute__nonnull__(pTHX_2) 4450 __attribute__nonnull__(pTHX_4); 4451 #define PERL_ARGS_ASSERT_HV_NOTALLOWED \ 4452 assert(key); assert(msg) 4453 4454 STATIC struct xpvhv_aux* S_hv_auxinit(HV *hv) 4455 __attribute__nonnull__(1); 4456 #define PERL_ARGS_ASSERT_HV_AUXINIT \ 4457 assert(hv) 4458 4459 STATIC SV* S_hv_delete_common(pTHX_ HV *hv, SV *keysv, const char *key, STRLEN klen, int k_flags, I32 d_flags, U32 hash); 4460 STATIC void S_clear_placeholders(pTHX_ HV *hv, U32 items) 4461 __attribute__nonnull__(pTHX_1); 4462 #define PERL_ARGS_ASSERT_CLEAR_PLACEHOLDERS \ 4463 assert(hv) 4464 4465 STATIC SV * S_refcounted_he_value(pTHX_ const struct refcounted_he *he) 4466 __attribute__nonnull__(pTHX_1); 4467 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_VALUE \ 4468 assert(he) 4469 4470 #endif 4471 4472 #if defined(PERL_IN_MG_C) || defined(PERL_DECL_PROT) 4473 STATIC void S_save_magic(pTHX_ I32 mgs_ix, SV *sv) 4474 __attribute__nonnull__(pTHX_2); 4475 #define PERL_ARGS_ASSERT_SAVE_MAGIC \ 4476 assert(sv) 4477 4478 STATIC int S_magic_methpack(pTHX_ SV *sv, const MAGIC *mg, const char *meth) 4479 __attribute__nonnull__(pTHX_1) 4480 __attribute__nonnull__(pTHX_2) 4481 __attribute__nonnull__(pTHX_3); 4482 #define PERL_ARGS_ASSERT_MAGIC_METHPACK \ 4483 assert(sv); assert(mg); assert(meth) 4484 4485 STATIC int S_magic_methcall(pTHX_ SV *sv, const MAGIC *mg, const char *meth, I32 f, int n, SV *val) 4486 __attribute__nonnull__(pTHX_1) 4487 __attribute__nonnull__(pTHX_2) 4488 __attribute__nonnull__(pTHX_3); 4489 #define PERL_ARGS_ASSERT_MAGIC_METHCALL \ 4490 assert(sv); assert(mg); assert(meth) 4491 4492 STATIC void S_restore_magic(pTHX_ const void *p); 4493 STATIC void S_unwind_handler_stack(pTHX_ const void *p) 4494 __attribute__nonnull__(pTHX_1); 4495 #define PERL_ARGS_ASSERT_UNWIND_HANDLER_STACK \ 4496 assert(p) 4497 4498 4499 #endif 4500 4501 #if defined(PERL_IN_OP_C) || defined(PERL_DECL_PROT) 4502 PERL_CALLCONV OP* Perl_ck_anoncode(pTHX_ OP *o) 4503 __attribute__warn_unused_result__ 4504 __attribute__nonnull__(pTHX_1); 4505 #define PERL_ARGS_ASSERT_CK_ANONCODE \ 4506 assert(o) 4507 4508 PERL_CALLCONV OP* Perl_ck_bitop(pTHX_ OP *o) 4509 __attribute__warn_unused_result__ 4510 __attribute__nonnull__(pTHX_1); 4511 #define PERL_ARGS_ASSERT_CK_BITOP \ 4512 assert(o) 4513 4514 PERL_CALLCONV OP* Perl_ck_concat(pTHX_ OP *o) 4515 __attribute__warn_unused_result__ 4516 __attribute__nonnull__(pTHX_1); 4517 #define PERL_ARGS_ASSERT_CK_CONCAT \ 4518 assert(o) 4519 4520 PERL_CALLCONV OP* Perl_ck_defined(pTHX_ OP *o) 4521 __attribute__warn_unused_result__ 4522 __attribute__nonnull__(pTHX_1); 4523 #define PERL_ARGS_ASSERT_CK_DEFINED \ 4524 assert(o) 4525 4526 PERL_CALLCONV OP* Perl_ck_delete(pTHX_ OP *o) 4527 __attribute__warn_unused_result__ 4528 __attribute__nonnull__(pTHX_1); 4529 #define PERL_ARGS_ASSERT_CK_DELETE \ 4530 assert(o) 4531 4532 PERL_CALLCONV OP* Perl_ck_die(pTHX_ OP *o) 4533 __attribute__warn_unused_result__ 4534 __attribute__nonnull__(pTHX_1); 4535 #define PERL_ARGS_ASSERT_CK_DIE \ 4536 assert(o) 4537 4538 PERL_CALLCONV OP* Perl_ck_eof(pTHX_ OP *o) 4539 __attribute__warn_unused_result__ 4540 __attribute__nonnull__(pTHX_1); 4541 #define PERL_ARGS_ASSERT_CK_EOF \ 4542 assert(o) 4543 4544 PERL_CALLCONV OP* Perl_ck_eval(pTHX_ OP *o) 4545 __attribute__warn_unused_result__ 4546 __attribute__nonnull__(pTHX_1); 4547 #define PERL_ARGS_ASSERT_CK_EVAL \ 4548 assert(o) 4549 4550 PERL_CALLCONV OP* Perl_ck_exec(pTHX_ OP *o) 4551 __attribute__warn_unused_result__ 4552 __attribute__nonnull__(pTHX_1); 4553 #define PERL_ARGS_ASSERT_CK_EXEC \ 4554 assert(o) 4555 4556 PERL_CALLCONV OP* Perl_ck_exists(pTHX_ OP *o) 4557 __attribute__warn_unused_result__ 4558 __attribute__nonnull__(pTHX_1); 4559 #define PERL_ARGS_ASSERT_CK_EXISTS \ 4560 assert(o) 4561 4562 PERL_CALLCONV OP* Perl_ck_exit(pTHX_ OP *o) 4563 __attribute__warn_unused_result__ 4564 __attribute__nonnull__(pTHX_1); 4565 #define PERL_ARGS_ASSERT_CK_EXIT \ 4566 assert(o) 4567 4568 PERL_CALLCONV OP* Perl_ck_ftst(pTHX_ OP *o) 4569 __attribute__warn_unused_result__ 4570 __attribute__nonnull__(pTHX_1); 4571 #define PERL_ARGS_ASSERT_CK_FTST \ 4572 assert(o) 4573 4574 PERL_CALLCONV OP* Perl_ck_fun(pTHX_ OP *o) 4575 __attribute__warn_unused_result__ 4576 __attribute__nonnull__(pTHX_1); 4577 #define PERL_ARGS_ASSERT_CK_FUN \ 4578 assert(o) 4579 4580 PERL_CALLCONV OP* Perl_ck_glob(pTHX_ OP *o) 4581 __attribute__warn_unused_result__ 4582 __attribute__nonnull__(pTHX_1); 4583 #define PERL_ARGS_ASSERT_CK_GLOB \ 4584 assert(o) 4585 4586 PERL_CALLCONV OP* Perl_ck_grep(pTHX_ OP *o) 4587 __attribute__warn_unused_result__ 4588 __attribute__nonnull__(pTHX_1); 4589 #define PERL_ARGS_ASSERT_CK_GREP \ 4590 assert(o) 4591 4592 PERL_CALLCONV OP* Perl_ck_index(pTHX_ OP *o) 4593 __attribute__warn_unused_result__ 4594 __attribute__nonnull__(pTHX_1); 4595 #define PERL_ARGS_ASSERT_CK_INDEX \ 4596 assert(o) 4597 4598 PERL_CALLCONV OP* Perl_ck_join(pTHX_ OP *o) 4599 __attribute__warn_unused_result__ 4600 __attribute__nonnull__(pTHX_1); 4601 #define PERL_ARGS_ASSERT_CK_JOIN \ 4602 assert(o) 4603 4604 PERL_CALLCONV OP* Perl_ck_lfun(pTHX_ OP *o) 4605 __attribute__warn_unused_result__ 4606 __attribute__nonnull__(pTHX_1); 4607 #define PERL_ARGS_ASSERT_CK_LFUN \ 4608 assert(o) 4609 4610 PERL_CALLCONV OP* Perl_ck_listiob(pTHX_ OP *o) 4611 __attribute__warn_unused_result__ 4612 __attribute__nonnull__(pTHX_1); 4613 #define PERL_ARGS_ASSERT_CK_LISTIOB \ 4614 assert(o) 4615 4616 PERL_CALLCONV OP* Perl_ck_match(pTHX_ OP *o) 4617 __attribute__warn_unused_result__ 4618 __attribute__nonnull__(pTHX_1); 4619 #define PERL_ARGS_ASSERT_CK_MATCH \ 4620 assert(o) 4621 4622 PERL_CALLCONV OP* Perl_ck_method(pTHX_ OP *o) 4623 __attribute__warn_unused_result__ 4624 __attribute__nonnull__(pTHX_1); 4625 #define PERL_ARGS_ASSERT_CK_METHOD \ 4626 assert(o) 4627 4628 PERL_CALLCONV OP* Perl_ck_null(pTHX_ OP *o) 4629 __attribute__warn_unused_result__ 4630 __attribute__nonnull__(pTHX_1); 4631 #define PERL_ARGS_ASSERT_CK_NULL \ 4632 assert(o) 4633 4634 PERL_CALLCONV OP* Perl_ck_open(pTHX_ OP *o) 4635 __attribute__warn_unused_result__ 4636 __attribute__nonnull__(pTHX_1); 4637 #define PERL_ARGS_ASSERT_CK_OPEN \ 4638 assert(o) 4639 4640 PERL_CALLCONV OP* Perl_ck_readline(pTHX_ OP *o) 4641 __attribute__warn_unused_result__ 4642 __attribute__nonnull__(pTHX_1); 4643 #define PERL_ARGS_ASSERT_CK_READLINE \ 4644 assert(o) 4645 4646 PERL_CALLCONV OP* Perl_ck_repeat(pTHX_ OP *o) 4647 __attribute__warn_unused_result__ 4648 __attribute__nonnull__(pTHX_1); 4649 #define PERL_ARGS_ASSERT_CK_REPEAT \ 4650 assert(o) 4651 4652 PERL_CALLCONV OP* Perl_ck_require(pTHX_ OP *o) 4653 __attribute__warn_unused_result__ 4654 __attribute__nonnull__(pTHX_1); 4655 #define PERL_ARGS_ASSERT_CK_REQUIRE \ 4656 assert(o) 4657 4658 PERL_CALLCONV OP* Perl_ck_return(pTHX_ OP *o) 4659 __attribute__warn_unused_result__ 4660 __attribute__nonnull__(pTHX_1); 4661 #define PERL_ARGS_ASSERT_CK_RETURN \ 4662 assert(o) 4663 4664 PERL_CALLCONV OP* Perl_ck_rfun(pTHX_ OP *o) 4665 __attribute__warn_unused_result__ 4666 __attribute__nonnull__(pTHX_1); 4667 #define PERL_ARGS_ASSERT_CK_RFUN \ 4668 assert(o) 4669 4670 PERL_CALLCONV OP* Perl_ck_rvconst(pTHX_ OP *o) 4671 __attribute__warn_unused_result__ 4672 __attribute__nonnull__(pTHX_1); 4673 #define PERL_ARGS_ASSERT_CK_RVCONST \ 4674 assert(o) 4675 4676 PERL_CALLCONV OP* Perl_ck_sassign(pTHX_ OP *o) 4677 __attribute__warn_unused_result__ 4678 __attribute__nonnull__(pTHX_1); 4679 #define PERL_ARGS_ASSERT_CK_SASSIGN \ 4680 assert(o) 4681 4682 PERL_CALLCONV OP* Perl_ck_select(pTHX_ OP *o) 4683 __attribute__warn_unused_result__ 4684 __attribute__nonnull__(pTHX_1); 4685 #define PERL_ARGS_ASSERT_CK_SELECT \ 4686 assert(o) 4687 4688 PERL_CALLCONV OP* Perl_ck_shift(pTHX_ OP *o) 4689 __attribute__warn_unused_result__ 4690 __attribute__nonnull__(pTHX_1); 4691 #define PERL_ARGS_ASSERT_CK_SHIFT \ 4692 assert(o) 4693 4694 PERL_CALLCONV OP* Perl_ck_sort(pTHX_ OP *o) 4695 __attribute__warn_unused_result__ 4696 __attribute__nonnull__(pTHX_1); 4697 #define PERL_ARGS_ASSERT_CK_SORT \ 4698 assert(o) 4699 4700 PERL_CALLCONV OP* Perl_ck_spair(pTHX_ OP *o) 4701 __attribute__warn_unused_result__ 4702 __attribute__nonnull__(pTHX_1); 4703 #define PERL_ARGS_ASSERT_CK_SPAIR \ 4704 assert(o) 4705 4706 PERL_CALLCONV OP* Perl_ck_split(pTHX_ OP *o) 4707 __attribute__warn_unused_result__ 4708 __attribute__nonnull__(pTHX_1); 4709 #define PERL_ARGS_ASSERT_CK_SPLIT \ 4710 assert(o) 4711 4712 PERL_CALLCONV OP* Perl_ck_subr(pTHX_ OP *o) 4713 __attribute__warn_unused_result__ 4714 __attribute__nonnull__(pTHX_1); 4715 #define PERL_ARGS_ASSERT_CK_SUBR \ 4716 assert(o) 4717 4718 PERL_CALLCONV OP* Perl_ck_substr(pTHX_ OP *o) 4719 __attribute__warn_unused_result__ 4720 __attribute__nonnull__(pTHX_1); 4721 #define PERL_ARGS_ASSERT_CK_SUBSTR \ 4722 assert(o) 4723 4724 PERL_CALLCONV OP* Perl_ck_svconst(pTHX_ OP *o) 4725 __attribute__warn_unused_result__ 4726 __attribute__nonnull__(pTHX_1); 4727 #define PERL_ARGS_ASSERT_CK_SVCONST \ 4728 assert(o) 4729 4730 PERL_CALLCONV OP* Perl_ck_trunc(pTHX_ OP *o) 4731 __attribute__warn_unused_result__ 4732 __attribute__nonnull__(pTHX_1); 4733 #define PERL_ARGS_ASSERT_CK_TRUNC \ 4734 assert(o) 4735 4736 PERL_CALLCONV OP* Perl_ck_unpack(pTHX_ OP *o) 4737 __attribute__warn_unused_result__ 4738 __attribute__nonnull__(pTHX_1); 4739 #define PERL_ARGS_ASSERT_CK_UNPACK \ 4740 assert(o) 4741 4742 PERL_CALLCONV OP* Perl_ck_each(pTHX_ OP *o) 4743 __attribute__warn_unused_result__ 4744 __attribute__nonnull__(pTHX_1); 4745 #define PERL_ARGS_ASSERT_CK_EACH \ 4746 assert(o) 4747 4748 STATIC bool S_is_handle_constructor(const OP *o, I32 numargs) 4749 __attribute__warn_unused_result__ 4750 __attribute__nonnull__(1); 4751 #define PERL_ARGS_ASSERT_IS_HANDLE_CONSTRUCTOR \ 4752 assert(o) 4753 4754 STATIC I32 S_is_list_assignment(pTHX_ const OP *o) 4755 __attribute__warn_unused_result__; 4756 4757 # ifdef USE_ITHREADS 4758 STATIC void S_forget_pmop(pTHX_ PMOP *const o, U32 flags) 4759 __attribute__nonnull__(pTHX_1); 4760 #define PERL_ARGS_ASSERT_FORGET_PMOP \ 4761 assert(o) 4762 4763 # else 4764 STATIC void S_forget_pmop(pTHX_ PMOP *const o) 4765 __attribute__nonnull__(pTHX_1); 4766 #define PERL_ARGS_ASSERT_FORGET_PMOP \ 4767 assert(o) 4768 4769 # endif 4770 STATIC void S_find_and_forget_pmops(pTHX_ OP *o) 4771 __attribute__nonnull__(pTHX_1); 4772 #define PERL_ARGS_ASSERT_FIND_AND_FORGET_PMOPS \ 4773 assert(o) 4774 4775 STATIC void S_cop_free(pTHX_ COP *cop) 4776 __attribute__nonnull__(pTHX_1); 4777 #define PERL_ARGS_ASSERT_COP_FREE \ 4778 assert(cop) 4779 4780 STATIC OP* S_modkids(pTHX_ OP *o, I32 type); 4781 STATIC OP* S_scalarboolean(pTHX_ OP *o) 4782 __attribute__nonnull__(pTHX_1); 4783 #define PERL_ARGS_ASSERT_SCALARBOOLEAN \ 4784 assert(o) 4785 4786 STATIC OP* S_newDEFSVOP(pTHX) 4787 __attribute__warn_unused_result__; 4788 4789 STATIC OP* S_search_const(pTHX_ OP *o) 4790 __attribute__warn_unused_result__ 4791 __attribute__nonnull__(pTHX_1); 4792 #define PERL_ARGS_ASSERT_SEARCH_CONST \ 4793 assert(o) 4794 4795 STATIC OP* S_new_logop(pTHX_ I32 type, I32 flags, OP **firstp, OP **otherp) 4796 __attribute__warn_unused_result__ 4797 __attribute__nonnull__(pTHX_3) 4798 __attribute__nonnull__(pTHX_4); 4799 #define PERL_ARGS_ASSERT_NEW_LOGOP \ 4800 assert(firstp); assert(otherp) 4801 4802 STATIC void S_simplify_sort(pTHX_ OP *o) 4803 __attribute__nonnull__(pTHX_1); 4804 #define PERL_ARGS_ASSERT_SIMPLIFY_SORT \ 4805 assert(o) 4806 4807 STATIC const char* S_gv_ename(pTHX_ GV *gv) 4808 __attribute__nonnull__(pTHX_1); 4809 #define PERL_ARGS_ASSERT_GV_ENAME \ 4810 assert(gv) 4811 4812 STATIC bool S_scalar_mod_type(const OP *o, I32 type) 4813 __attribute__warn_unused_result__ 4814 __attribute__nonnull__(1); 4815 #define PERL_ARGS_ASSERT_SCALAR_MOD_TYPE \ 4816 assert(o) 4817 4818 STATIC OP * S_my_kid(pTHX_ OP *o, OP *attrs, OP **imopsp) 4819 __attribute__nonnull__(pTHX_3); 4820 #define PERL_ARGS_ASSERT_MY_KID \ 4821 assert(imopsp) 4822 4823 STATIC OP * S_dup_attrlist(pTHX_ OP *o) 4824 __attribute__nonnull__(pTHX_1); 4825 #define PERL_ARGS_ASSERT_DUP_ATTRLIST \ 4826 assert(o) 4827 4828 STATIC void S_apply_attrs(pTHX_ HV *stash, SV *target, OP *attrs, bool for_my) 4829 __attribute__nonnull__(pTHX_1) 4830 __attribute__nonnull__(pTHX_2); 4831 #define PERL_ARGS_ASSERT_APPLY_ATTRS \ 4832 assert(stash); assert(target) 4833 4834 STATIC void S_apply_attrs_my(pTHX_ HV *stash, OP *target, OP *attrs, OP **imopsp) 4835 __attribute__nonnull__(pTHX_1) 4836 __attribute__nonnull__(pTHX_2) 4837 __attribute__nonnull__(pTHX_4); 4838 #define PERL_ARGS_ASSERT_APPLY_ATTRS_MY \ 4839 assert(stash); assert(target); assert(imopsp) 4840 4841 STATIC void S_bad_type(pTHX_ I32 n, const char *t, const char *name, const OP *kid) 4842 __attribute__nonnull__(pTHX_2) 4843 __attribute__nonnull__(pTHX_3) 4844 __attribute__nonnull__(pTHX_4); 4845 #define PERL_ARGS_ASSERT_BAD_TYPE \ 4846 assert(t); assert(name); assert(kid) 4847 4848 STATIC void S_no_bareword_allowed(pTHX_ const OP *o) 4849 __attribute__nonnull__(pTHX_1); 4850 #define PERL_ARGS_ASSERT_NO_BAREWORD_ALLOWED \ 4851 assert(o) 4852 4853 STATIC OP* S_no_fh_allowed(pTHX_ OP *o) 4854 __attribute__warn_unused_result__ 4855 __attribute__nonnull__(pTHX_1); 4856 #define PERL_ARGS_ASSERT_NO_FH_ALLOWED \ 4857 assert(o) 4858 4859 STATIC OP* S_too_few_arguments(pTHX_ OP *o, const char* name) 4860 __attribute__warn_unused_result__ 4861 __attribute__nonnull__(pTHX_1) 4862 __attribute__nonnull__(pTHX_2); 4863 #define PERL_ARGS_ASSERT_TOO_FEW_ARGUMENTS \ 4864 assert(o); assert(name) 4865 4866 STATIC OP* S_too_many_arguments(pTHX_ OP *o, const char* name) 4867 __attribute__warn_unused_result__ 4868 __attribute__nonnull__(pTHX_1) 4869 __attribute__nonnull__(pTHX_2); 4870 #define PERL_ARGS_ASSERT_TOO_MANY_ARGUMENTS \ 4871 assert(o); assert(name) 4872 4873 STATIC bool S_looks_like_bool(pTHX_ const OP* o) 4874 __attribute__nonnull__(pTHX_1); 4875 #define PERL_ARGS_ASSERT_LOOKS_LIKE_BOOL \ 4876 assert(o) 4877 4878 STATIC OP* S_newGIVWHENOP(pTHX_ OP* cond, OP *block, I32 enter_opcode, I32 leave_opcode, PADOFFSET entertarg) 4879 __attribute__nonnull__(pTHX_2); 4880 #define PERL_ARGS_ASSERT_NEWGIVWHENOP \ 4881 assert(block) 4882 4883 STATIC OP* S_ref_array_or_hash(pTHX_ OP* cond); 4884 STATIC void S_process_special_blocks(pTHX_ const char *const fullname, GV *const gv, CV *const cv) 4885 __attribute__nonnull__(pTHX_1) 4886 __attribute__nonnull__(pTHX_2) 4887 __attribute__nonnull__(pTHX_3); 4888 #define PERL_ARGS_ASSERT_PROCESS_SPECIAL_BLOCKS \ 4889 assert(fullname); assert(gv); assert(cv) 4890 4891 #endif 4892 #if defined(PL_OP_SLAB_ALLOC) 4893 PERL_CALLCONV void* Perl_Slab_Alloc(pTHX_ size_t sz) 4894 __attribute__malloc__ 4895 __attribute__warn_unused_result__; 4896 4897 PERL_CALLCONV void Perl_Slab_Free(pTHX_ void *op) 4898 __attribute__nonnull__(pTHX_1); 4899 #define PERL_ARGS_ASSERT_SLAB_FREE \ 4900 assert(op) 4901 4902 # if defined(PERL_DEBUG_READONLY_OPS) 4903 PERL_CALLCONV void Perl_pending_Slabs_to_ro(pTHX); 4904 PERL_CALLCONV OP * Perl_op_refcnt_inc(pTHX_ OP *o); 4905 PERL_CALLCONV PADOFFSET Perl_op_refcnt_dec(pTHX_ OP *o) 4906 __attribute__nonnull__(pTHX_1); 4907 #define PERL_ARGS_ASSERT_OP_REFCNT_DEC \ 4908 assert(o) 4909 4910 # if defined(PERL_IN_OP_C) 4911 STATIC void S_Slab_to_rw(pTHX_ void *op) 4912 __attribute__nonnull__(pTHX_1); 4913 #define PERL_ARGS_ASSERT_SLAB_TO_RW \ 4914 assert(op) 4915 4916 # endif 4917 # endif 4918 #endif 4919 4920 #if defined(PERL_IN_PERL_C) || defined(PERL_DECL_PROT) 4921 STATIC void S_find_beginning(pTHX_ SV* linestr_sv, PerlIO *rsfp) 4922 __attribute__nonnull__(pTHX_1) 4923 __attribute__nonnull__(pTHX_2); 4924 #define PERL_ARGS_ASSERT_FIND_BEGINNING \ 4925 assert(linestr_sv); assert(rsfp) 4926 4927 STATIC void S_forbid_setid(pTHX_ const char flag, const bool suidscript); 4928 STATIC void S_incpush(pTHX_ const char *const dir, STRLEN len, U32 flags) 4929 __attribute__nonnull__(pTHX_1); 4930 #define PERL_ARGS_ASSERT_INCPUSH \ 4931 assert(dir) 4932 4933 STATIC void S_incpush_use_sep(pTHX_ const char *p, STRLEN len, U32 flags) 4934 __attribute__nonnull__(pTHX_1); 4935 #define PERL_ARGS_ASSERT_INCPUSH_USE_SEP \ 4936 assert(p) 4937 4938 STATIC void S_init_interp(pTHX); 4939 STATIC void S_init_ids(pTHX); 4940 STATIC void S_init_main_stash(pTHX); 4941 STATIC void S_init_perllib(pTHX); 4942 STATIC void S_init_postdump_symbols(pTHX_ int argc, char **argv, char **env) 4943 __attribute__nonnull__(pTHX_2); 4944 #define PERL_ARGS_ASSERT_INIT_POSTDUMP_SYMBOLS \ 4945 assert(argv) 4946 4947 STATIC void S_init_predump_symbols(pTHX); 4948 STATIC void S_my_exit_jump(pTHX) 4949 __attribute__noreturn__; 4950 4951 STATIC void S_nuke_stacks(pTHX); 4952 STATIC int S_open_script(pTHX_ const char *scriptname, bool dosearch, bool *suidscript, PerlIO **rsfpp) 4953 __attribute__nonnull__(pTHX_1) 4954 __attribute__nonnull__(pTHX_3) 4955 __attribute__nonnull__(pTHX_4); 4956 #define PERL_ARGS_ASSERT_OPEN_SCRIPT \ 4957 assert(scriptname); assert(suidscript); assert(rsfpp) 4958 4959 STATIC void S_usage(pTHX_ const char *name) 4960 __attribute__nonnull__(pTHX_1); 4961 #define PERL_ARGS_ASSERT_USAGE \ 4962 assert(name) 4963 4964 #ifndef SETUID_SCRIPTS_ARE_SECURE_NOW 4965 STATIC void S_validate_suid(pTHX_ PerlIO *rsfp) 4966 __attribute__nonnull__(pTHX_1); 4967 #define PERL_ARGS_ASSERT_VALIDATE_SUID \ 4968 assert(rsfp) 4969 4970 #endif 4971 4972 STATIC void* S_parse_body(pTHX_ char **env, XSINIT_t xsinit); 4973 STATIC void S_run_body(pTHX_ I32 oldscope) 4974 __attribute__noreturn__; 4975 4976 STATIC SV * S_incpush_if_exists(pTHX_ AV *const av, SV *dir, SV *const stem) 4977 __attribute__nonnull__(pTHX_1) 4978 __attribute__nonnull__(pTHX_2) 4979 __attribute__nonnull__(pTHX_3); 4980 #define PERL_ARGS_ASSERT_INCPUSH_IF_EXISTS \ 4981 assert(av); assert(dir); assert(stem) 4982 4983 #endif 4984 4985 #if defined(PERL_IN_PP_C) || defined(PERL_DECL_PROT) 4986 STATIC OP* S_do_delete_local(pTHX); 4987 STATIC SV* S_refto(pTHX_ SV* sv) 4988 __attribute__warn_unused_result__ 4989 __attribute__nonnull__(pTHX_1); 4990 #define PERL_ARGS_ASSERT_REFTO \ 4991 assert(sv) 4992 4993 #endif 4994 #if defined(PERL_IN_PP_C) || defined(PERL_IN_PP_HOT_C) || defined(PERL_DECL_PROT) 4995 PERL_CALLCONV GV* Perl_softref2xv(pTHX_ SV *const sv, const char *const what, const svtype type, SV ***spp) 4996 __attribute__warn_unused_result__ 4997 __attribute__nonnull__(pTHX_1) 4998 __attribute__nonnull__(pTHX_2) 4999 __attribute__nonnull__(pTHX_4); 5000 #define PERL_ARGS_ASSERT_SOFTREF2XV \ 5001 assert(sv); assert(what); assert(spp) 5002 5003 #endif 5004 5005 #if defined(PERL_IN_PP_PACK_C) || defined(PERL_DECL_PROT) 5006 STATIC I32 S_unpack_rec(pTHX_ struct tempsym* symptr, const char *s, const char *strbeg, const char *strend, const char **new_s) 5007 __attribute__nonnull__(pTHX_1) 5008 __attribute__nonnull__(pTHX_2) 5009 __attribute__nonnull__(pTHX_3) 5010 __attribute__nonnull__(pTHX_4); 5011 #define PERL_ARGS_ASSERT_UNPACK_REC \ 5012 assert(symptr); assert(s); assert(strbeg); assert(strend) 5013 5014 STATIC SV ** S_pack_rec(pTHX_ SV *cat, struct tempsym* symptr, SV **beglist, SV **endlist) 5015 __attribute__nonnull__(pTHX_1) 5016 __attribute__nonnull__(pTHX_2) 5017 __attribute__nonnull__(pTHX_3) 5018 __attribute__nonnull__(pTHX_4); 5019 #define PERL_ARGS_ASSERT_PACK_REC \ 5020 assert(cat); assert(symptr); assert(beglist); assert(endlist) 5021 5022 STATIC SV* S_mul128(pTHX_ SV *sv, U8 m) 5023 __attribute__nonnull__(pTHX_1); 5024 #define PERL_ARGS_ASSERT_MUL128 \ 5025 assert(sv) 5026 5027 STATIC I32 S_measure_struct(pTHX_ struct tempsym* symptr) 5028 __attribute__nonnull__(pTHX_1); 5029 #define PERL_ARGS_ASSERT_MEASURE_STRUCT \ 5030 assert(symptr) 5031 5032 STATIC bool S_next_symbol(pTHX_ struct tempsym* symptr) 5033 __attribute__nonnull__(pTHX_1); 5034 #define PERL_ARGS_ASSERT_NEXT_SYMBOL \ 5035 assert(symptr) 5036 5037 STATIC SV* S_is_an_int(pTHX_ const char *s, STRLEN l) 5038 __attribute__warn_unused_result__ 5039 __attribute__nonnull__(pTHX_1); 5040 #define PERL_ARGS_ASSERT_IS_AN_INT \ 5041 assert(s) 5042 5043 STATIC int S_div128(pTHX_ SV *pnum, bool *done) 5044 __attribute__nonnull__(pTHX_1) 5045 __attribute__nonnull__(pTHX_2); 5046 #define PERL_ARGS_ASSERT_DIV128 \ 5047 assert(pnum); assert(done) 5048 5049 STATIC const char * S_group_end(pTHX_ const char *patptr, const char *patend, char ender) 5050 __attribute__nonnull__(pTHX_1) 5051 __attribute__nonnull__(pTHX_2); 5052 #define PERL_ARGS_ASSERT_GROUP_END \ 5053 assert(patptr); assert(patend) 5054 5055 STATIC const char * S_get_num(pTHX_ const char *patptr, I32 *lenptr) 5056 __attribute__warn_unused_result__ 5057 __attribute__nonnull__(pTHX_1) 5058 __attribute__nonnull__(pTHX_2); 5059 #define PERL_ARGS_ASSERT_GET_NUM \ 5060 assert(patptr); assert(lenptr) 5061 5062 STATIC bool S_need_utf8(const char *pat, const char *patend) 5063 __attribute__nonnull__(1) 5064 __attribute__nonnull__(2); 5065 #define PERL_ARGS_ASSERT_NEED_UTF8 \ 5066 assert(pat); assert(patend) 5067 5068 STATIC char S_first_symbol(const char *pat, const char *patend) 5069 __attribute__nonnull__(1) 5070 __attribute__nonnull__(2); 5071 #define PERL_ARGS_ASSERT_FIRST_SYMBOL \ 5072 assert(pat); assert(patend) 5073 5074 STATIC char * S_sv_exp_grow(pTHX_ SV *sv, STRLEN needed) 5075 __attribute__warn_unused_result__ 5076 __attribute__nonnull__(pTHX_1); 5077 #define PERL_ARGS_ASSERT_SV_EXP_GROW \ 5078 assert(sv) 5079 5080 STATIC char * S_bytes_to_uni(const U8 *start, STRLEN len, char *dest) 5081 __attribute__warn_unused_result__ 5082 __attribute__nonnull__(1) 5083 __attribute__nonnull__(3); 5084 #define PERL_ARGS_ASSERT_BYTES_TO_UNI \ 5085 assert(start); assert(dest) 5086 5087 #endif 5088 5089 #if defined(PERL_IN_PP_CTL_C) || defined(PERL_DECL_PROT) 5090 STATIC OP* S_docatch(pTHX_ OP *o) 5091 __attribute__warn_unused_result__; 5092 5093 STATIC OP* S_dofindlabel(pTHX_ OP *o, const char *label, OP **opstack, OP **oplimit) 5094 __attribute__warn_unused_result__ 5095 __attribute__nonnull__(pTHX_1) 5096 __attribute__nonnull__(pTHX_2) 5097 __attribute__nonnull__(pTHX_3) 5098 __attribute__nonnull__(pTHX_4); 5099 #define PERL_ARGS_ASSERT_DOFINDLABEL \ 5100 assert(o); assert(label); assert(opstack); assert(oplimit) 5101 5102 STATIC OP* S_doparseform(pTHX_ SV *sv) 5103 __attribute__warn_unused_result__ 5104 __attribute__nonnull__(pTHX_1); 5105 #define PERL_ARGS_ASSERT_DOPARSEFORM \ 5106 assert(sv) 5107 5108 STATIC bool S_num_overflow(NV value, I32 fldsize, I32 frcsize) 5109 __attribute__warn_unused_result__; 5110 5111 STATIC I32 S_dopoptoeval(pTHX_ I32 startingblock) 5112 __attribute__warn_unused_result__; 5113 5114 STATIC I32 S_dopoptogiven(pTHX_ I32 startingblock) 5115 __attribute__warn_unused_result__; 5116 5117 STATIC I32 S_dopoptolabel(pTHX_ const char *label) 5118 __attribute__warn_unused_result__ 5119 __attribute__nonnull__(pTHX_1); 5120 #define PERL_ARGS_ASSERT_DOPOPTOLABEL \ 5121 assert(label) 5122 5123 STATIC I32 S_dopoptoloop(pTHX_ I32 startingblock) 5124 __attribute__warn_unused_result__; 5125 5126 STATIC I32 S_dopoptosub_at(pTHX_ const PERL_CONTEXT* cxstk, I32 startingblock) 5127 __attribute__warn_unused_result__ 5128 __attribute__nonnull__(pTHX_1); 5129 #define PERL_ARGS_ASSERT_DOPOPTOSUB_AT \ 5130 assert(cxstk) 5131 5132 STATIC I32 S_dopoptowhen(pTHX_ I32 startingblock) 5133 __attribute__warn_unused_result__; 5134 5135 STATIC void S_save_lines(pTHX_ AV *array, SV *sv) 5136 __attribute__nonnull__(pTHX_2); 5137 #define PERL_ARGS_ASSERT_SAVE_LINES \ 5138 assert(sv) 5139 5140 STATIC bool S_doeval(pTHX_ int gimme, OP** startop, CV* outside, U32 seq); 5141 STATIC PerlIO * S_check_type_and_open(pTHX_ const char *name) 5142 __attribute__warn_unused_result__ 5143 __attribute__nonnull__(pTHX_1); 5144 #define PERL_ARGS_ASSERT_CHECK_TYPE_AND_OPEN \ 5145 assert(name) 5146 5147 #ifndef PERL_DISABLE_PMC 5148 STATIC PerlIO * S_doopen_pm(pTHX_ const char *name, const STRLEN namelen) 5149 __attribute__warn_unused_result__ 5150 __attribute__nonnull__(pTHX_1); 5151 #define PERL_ARGS_ASSERT_DOOPEN_PM \ 5152 assert(name) 5153 5154 #endif 5155 STATIC bool S_path_is_absolute(const char *name) 5156 __attribute__warn_unused_result__ 5157 __attribute__nonnull__(1); 5158 #define PERL_ARGS_ASSERT_PATH_IS_ABSOLUTE \ 5159 assert(name) 5160 5161 STATIC I32 S_run_user_filter(pTHX_ int idx, SV *buf_sv, int maxlen) 5162 __attribute__warn_unused_result__ 5163 __attribute__nonnull__(pTHX_2); 5164 #define PERL_ARGS_ASSERT_RUN_USER_FILTER \ 5165 assert(buf_sv) 5166 5167 STATIC PMOP* S_make_matcher(pTHX_ REGEXP* re) 5168 __attribute__warn_unused_result__ 5169 __attribute__nonnull__(pTHX_1); 5170 #define PERL_ARGS_ASSERT_MAKE_MATCHER \ 5171 assert(re) 5172 5173 STATIC bool S_matcher_matches_sv(pTHX_ PMOP* matcher, SV* sv) 5174 __attribute__warn_unused_result__ 5175 __attribute__nonnull__(pTHX_1) 5176 __attribute__nonnull__(pTHX_2); 5177 #define PERL_ARGS_ASSERT_MATCHER_MATCHES_SV \ 5178 assert(matcher); assert(sv) 5179 5180 STATIC void S_destroy_matcher(pTHX_ PMOP* matcher) 5181 __attribute__nonnull__(pTHX_1); 5182 #define PERL_ARGS_ASSERT_DESTROY_MATCHER \ 5183 assert(matcher) 5184 5185 STATIC OP* S_do_smartmatch(pTHX_ HV* seen_this, HV* seen_other); 5186 #endif 5187 5188 #if defined(PERL_IN_PP_HOT_C) || defined(PERL_DECL_PROT) 5189 STATIC void S_do_oddball(pTHX_ HV *hash, SV **relem, SV **firstrelem) 5190 __attribute__nonnull__(pTHX_1) 5191 __attribute__nonnull__(pTHX_2) 5192 __attribute__nonnull__(pTHX_3); 5193 #define PERL_ARGS_ASSERT_DO_ODDBALL \ 5194 assert(hash); assert(relem); assert(firstrelem) 5195 5196 STATIC SV* S_method_common(pTHX_ SV* meth, U32* hashp) 5197 __attribute__warn_unused_result__ 5198 __attribute__nonnull__(pTHX_1); 5199 #define PERL_ARGS_ASSERT_METHOD_COMMON \ 5200 assert(meth) 5201 5202 #endif 5203 5204 #if defined(PERL_IN_PP_SORT_C) || defined(PERL_DECL_PROT) 5205 STATIC I32 S_sv_ncmp(pTHX_ SV *const a, SV *const b) 5206 __attribute__nonnull__(pTHX_1) 5207 __attribute__nonnull__(pTHX_2); 5208 #define PERL_ARGS_ASSERT_SV_NCMP \ 5209 assert(a); assert(b) 5210 5211 STATIC I32 S_sv_i_ncmp(pTHX_ SV *const a, SV *const b) 5212 __attribute__nonnull__(pTHX_1) 5213 __attribute__nonnull__(pTHX_2); 5214 #define PERL_ARGS_ASSERT_SV_I_NCMP \ 5215 assert(a); assert(b) 5216 5217 STATIC I32 S_amagic_ncmp(pTHX_ SV *const a, SV *const b) 5218 __attribute__nonnull__(pTHX_1) 5219 __attribute__nonnull__(pTHX_2); 5220 #define PERL_ARGS_ASSERT_AMAGIC_NCMP \ 5221 assert(a); assert(b) 5222 5223 STATIC I32 S_amagic_i_ncmp(pTHX_ SV *const a, SV *const b) 5224 __attribute__nonnull__(pTHX_1) 5225 __attribute__nonnull__(pTHX_2); 5226 #define PERL_ARGS_ASSERT_AMAGIC_I_NCMP \ 5227 assert(a); assert(b) 5228 5229 STATIC I32 S_amagic_cmp(pTHX_ SV *const str1, SV *const str2) 5230 __attribute__nonnull__(pTHX_1) 5231 __attribute__nonnull__(pTHX_2); 5232 #define PERL_ARGS_ASSERT_AMAGIC_CMP \ 5233 assert(str1); assert(str2) 5234 5235 STATIC I32 S_amagic_cmp_locale(pTHX_ SV *const str1, SV *const str2) 5236 __attribute__nonnull__(pTHX_1) 5237 __attribute__nonnull__(pTHX_2); 5238 #define PERL_ARGS_ASSERT_AMAGIC_CMP_LOCALE \ 5239 assert(str1); assert(str2) 5240 5241 STATIC I32 S_sortcv(pTHX_ SV *const a, SV *const b) 5242 __attribute__nonnull__(pTHX_1) 5243 __attribute__nonnull__(pTHX_2); 5244 #define PERL_ARGS_ASSERT_SORTCV \ 5245 assert(a); assert(b) 5246 5247 STATIC I32 S_sortcv_xsub(pTHX_ SV *const a, SV *const b) 5248 __attribute__nonnull__(pTHX_1) 5249 __attribute__nonnull__(pTHX_2); 5250 #define PERL_ARGS_ASSERT_SORTCV_XSUB \ 5251 assert(a); assert(b) 5252 5253 STATIC I32 S_sortcv_stacked(pTHX_ SV *const a, SV *const b) 5254 __attribute__nonnull__(pTHX_1) 5255 __attribute__nonnull__(pTHX_2); 5256 #define PERL_ARGS_ASSERT_SORTCV_STACKED \ 5257 assert(a); assert(b) 5258 5259 STATIC void S_qsortsvu(pTHX_ SV** array, size_t num_elts, SVCOMPARE_t compare) 5260 __attribute__nonnull__(pTHX_3); 5261 #define PERL_ARGS_ASSERT_QSORTSVU \ 5262 assert(compare) 5263 5264 #endif 5265 5266 #if defined(PERL_IN_PP_SYS_C) || defined(PERL_DECL_PROT) 5267 STATIC OP* S_doform(pTHX_ CV *cv, GV *gv, OP *retop) 5268 __attribute__nonnull__(pTHX_1) 5269 __attribute__nonnull__(pTHX_2) 5270 __attribute__nonnull__(pTHX_3); 5271 #define PERL_ARGS_ASSERT_DOFORM \ 5272 assert(cv); assert(gv); assert(retop) 5273 5274 # if !defined(HAS_MKDIR) || !defined(HAS_RMDIR) 5275 STATIC int S_dooneliner(pTHX_ const char *cmd, const char *filename) 5276 __attribute__warn_unused_result__ 5277 __attribute__nonnull__(pTHX_1) 5278 __attribute__nonnull__(pTHX_2); 5279 #define PERL_ARGS_ASSERT_DOONELINER \ 5280 assert(cmd); assert(filename) 5281 5282 # endif 5283 STATIC SV * S_space_join_names_mortal(pTHX_ char *const *array) 5284 __attribute__nonnull__(pTHX_1); 5285 #define PERL_ARGS_ASSERT_SPACE_JOIN_NAMES_MORTAL \ 5286 assert(array) 5287 5288 #endif 5289 5290 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_DECL_PROT) 5291 STATIC regnode* S_reg(pTHX_ struct RExC_state_t *pRExC_state, I32 paren, I32 *flagp, U32 depth) 5292 __attribute__nonnull__(pTHX_1) 5293 __attribute__nonnull__(pTHX_3); 5294 #define PERL_ARGS_ASSERT_REG \ 5295 assert(pRExC_state); assert(flagp) 5296 5297 STATIC regnode* S_reganode(pTHX_ struct RExC_state_t *pRExC_state, U8 op, U32 arg) 5298 __attribute__nonnull__(pTHX_1); 5299 #define PERL_ARGS_ASSERT_REGANODE \ 5300 assert(pRExC_state) 5301 5302 STATIC regnode* S_regatom(pTHX_ struct RExC_state_t *pRExC_state, I32 *flagp, U32 depth) 5303 __attribute__nonnull__(pTHX_1) 5304 __attribute__nonnull__(pTHX_2); 5305 #define PERL_ARGS_ASSERT_REGATOM \ 5306 assert(pRExC_state); assert(flagp) 5307 5308 STATIC regnode* S_regbranch(pTHX_ struct RExC_state_t *pRExC_state, I32 *flagp, I32 first, U32 depth) 5309 __attribute__nonnull__(pTHX_1) 5310 __attribute__nonnull__(pTHX_2); 5311 #define PERL_ARGS_ASSERT_REGBRANCH \ 5312 assert(pRExC_state); assert(flagp) 5313 5314 STATIC STRLEN S_reguni(pTHX_ const struct RExC_state_t *pRExC_state, UV uv, char *s) 5315 __attribute__nonnull__(pTHX_1) 5316 __attribute__nonnull__(pTHX_3); 5317 #define PERL_ARGS_ASSERT_REGUNI \ 5318 assert(pRExC_state); assert(s) 5319 5320 STATIC regnode* S_regclass(pTHX_ struct RExC_state_t *pRExC_state, U32 depth) 5321 __attribute__nonnull__(pTHX_1); 5322 #define PERL_ARGS_ASSERT_REGCLASS \ 5323 assert(pRExC_state) 5324 5325 STATIC regnode* S_reg_node(pTHX_ struct RExC_state_t *pRExC_state, U8 op) 5326 __attribute__nonnull__(pTHX_1); 5327 #define PERL_ARGS_ASSERT_REG_NODE \ 5328 assert(pRExC_state) 5329 5330 STATIC UV S_reg_recode(pTHX_ const char value, SV **encp) 5331 __attribute__nonnull__(pTHX_2); 5332 #define PERL_ARGS_ASSERT_REG_RECODE \ 5333 assert(encp) 5334 5335 STATIC regnode* S_regpiece(pTHX_ struct RExC_state_t *pRExC_state, I32 *flagp, U32 depth) 5336 __attribute__nonnull__(pTHX_1) 5337 __attribute__nonnull__(pTHX_2); 5338 #define PERL_ARGS_ASSERT_REGPIECE \ 5339 assert(pRExC_state); assert(flagp) 5340 5341 STATIC regnode* S_reg_namedseq(pTHX_ struct RExC_state_t *pRExC_state, UV *valuep, I32 *flagp) 5342 __attribute__nonnull__(pTHX_1); 5343 #define PERL_ARGS_ASSERT_REG_NAMEDSEQ \ 5344 assert(pRExC_state) 5345 5346 STATIC void S_reginsert(pTHX_ struct RExC_state_t *pRExC_state, U8 op, regnode *opnd, U32 depth) 5347 __attribute__nonnull__(pTHX_1) 5348 __attribute__nonnull__(pTHX_3); 5349 #define PERL_ARGS_ASSERT_REGINSERT \ 5350 assert(pRExC_state); assert(opnd) 5351 5352 STATIC void S_regtail(pTHX_ struct RExC_state_t *pRExC_state, regnode *p, const regnode *val, U32 depth) 5353 __attribute__nonnull__(pTHX_1) 5354 __attribute__nonnull__(pTHX_2) 5355 __attribute__nonnull__(pTHX_3); 5356 #define PERL_ARGS_ASSERT_REGTAIL \ 5357 assert(pRExC_state); assert(p); assert(val) 5358 5359 STATIC SV * S_reg_scan_name(pTHX_ struct RExC_state_t *pRExC_state, U32 flags) 5360 __attribute__nonnull__(pTHX_1); 5361 #define PERL_ARGS_ASSERT_REG_SCAN_NAME \ 5362 assert(pRExC_state) 5363 5364 STATIC U32 S_join_exact(pTHX_ struct RExC_state_t *pRExC_state, regnode *scan, I32 *min, U32 flags, regnode *val, U32 depth) 5365 __attribute__nonnull__(pTHX_1) 5366 __attribute__nonnull__(pTHX_2) 5367 __attribute__nonnull__(pTHX_3); 5368 #define PERL_ARGS_ASSERT_JOIN_EXACT \ 5369 assert(pRExC_state); assert(scan); assert(min) 5370 5371 STATIC char * S_regwhite(struct RExC_state_t *pRExC_state, char *p) 5372 __attribute__warn_unused_result__ 5373 __attribute__nonnull__(1) 5374 __attribute__nonnull__(2); 5375 #define PERL_ARGS_ASSERT_REGWHITE \ 5376 assert(pRExC_state); assert(p) 5377 5378 STATIC char * S_nextchar(pTHX_ struct RExC_state_t *pRExC_state) 5379 __attribute__nonnull__(pTHX_1); 5380 #define PERL_ARGS_ASSERT_NEXTCHAR \ 5381 assert(pRExC_state) 5382 5383 STATIC bool S_reg_skipcomment(pTHX_ struct RExC_state_t *pRExC_state) 5384 __attribute__nonnull__(pTHX_1); 5385 #define PERL_ARGS_ASSERT_REG_SKIPCOMMENT \ 5386 assert(pRExC_state) 5387 5388 STATIC void S_scan_commit(pTHX_ const struct RExC_state_t *pRExC_state, struct scan_data_t *data, I32 *minlenp, int is_inf) 5389 __attribute__nonnull__(pTHX_1) 5390 __attribute__nonnull__(pTHX_2) 5391 __attribute__nonnull__(pTHX_3); 5392 #define PERL_ARGS_ASSERT_SCAN_COMMIT \ 5393 assert(pRExC_state); assert(data); assert(minlenp) 5394 5395 STATIC void S_cl_anything(const struct RExC_state_t *pRExC_state, struct regnode_charclass_class *cl) 5396 __attribute__nonnull__(1) 5397 __attribute__nonnull__(2); 5398 #define PERL_ARGS_ASSERT_CL_ANYTHING \ 5399 assert(pRExC_state); assert(cl) 5400 5401 STATIC int S_cl_is_anything(const struct regnode_charclass_class *cl) 5402 __attribute__warn_unused_result__ 5403 __attribute__nonnull__(1); 5404 #define PERL_ARGS_ASSERT_CL_IS_ANYTHING \ 5405 assert(cl) 5406 5407 STATIC void S_cl_init(const struct RExC_state_t *pRExC_state, struct regnode_charclass_class *cl) 5408 __attribute__nonnull__(1) 5409 __attribute__nonnull__(2); 5410 #define PERL_ARGS_ASSERT_CL_INIT \ 5411 assert(pRExC_state); assert(cl) 5412 5413 STATIC void S_cl_init_zero(const struct RExC_state_t *pRExC_state, struct regnode_charclass_class *cl) 5414 __attribute__nonnull__(1) 5415 __attribute__nonnull__(2); 5416 #define PERL_ARGS_ASSERT_CL_INIT_ZERO \ 5417 assert(pRExC_state); assert(cl) 5418 5419 STATIC void S_cl_and(struct regnode_charclass_class *cl, const struct regnode_charclass_class *and_with) 5420 __attribute__nonnull__(1) 5421 __attribute__nonnull__(2); 5422 #define PERL_ARGS_ASSERT_CL_AND \ 5423 assert(cl); assert(and_with) 5424 5425 STATIC void S_cl_or(const struct RExC_state_t *pRExC_state, struct regnode_charclass_class *cl, const struct regnode_charclass_class *or_with) 5426 __attribute__nonnull__(1) 5427 __attribute__nonnull__(2) 5428 __attribute__nonnull__(3); 5429 #define PERL_ARGS_ASSERT_CL_OR \ 5430 assert(pRExC_state); assert(cl); assert(or_with) 5431 5432 STATIC I32 S_study_chunk(pTHX_ struct RExC_state_t *pRExC_state, regnode **scanp, I32 *minlenp, I32 *deltap, regnode *last, struct scan_data_t *data, I32 stopparen, U8* recursed, struct regnode_charclass_class *and_withp, U32 flags, U32 depth) 5433 __attribute__nonnull__(pTHX_1) 5434 __attribute__nonnull__(pTHX_2) 5435 __attribute__nonnull__(pTHX_3) 5436 __attribute__nonnull__(pTHX_4) 5437 __attribute__nonnull__(pTHX_5); 5438 #define PERL_ARGS_ASSERT_STUDY_CHUNK \ 5439 assert(pRExC_state); assert(scanp); assert(minlenp); assert(deltap); assert(last) 5440 5441 STATIC U32 S_add_data(struct RExC_state_t *pRExC_state, U32 n, const char *s) 5442 __attribute__warn_unused_result__ 5443 __attribute__nonnull__(1) 5444 __attribute__nonnull__(3); 5445 #define PERL_ARGS_ASSERT_ADD_DATA \ 5446 assert(pRExC_state); assert(s) 5447 5448 STATIC void S_re_croak2(pTHX_ const char* pat1, const char* pat2, ...) 5449 __attribute__noreturn__ 5450 __attribute__nonnull__(pTHX_1) 5451 __attribute__nonnull__(pTHX_2); 5452 #define PERL_ARGS_ASSERT_RE_CROAK2 \ 5453 assert(pat1); assert(pat2) 5454 5455 STATIC I32 S_regpposixcc(pTHX_ struct RExC_state_t *pRExC_state, I32 value) 5456 __attribute__nonnull__(pTHX_1); 5457 #define PERL_ARGS_ASSERT_REGPPOSIXCC \ 5458 assert(pRExC_state) 5459 5460 STATIC void S_checkposixcc(pTHX_ struct RExC_state_t *pRExC_state) 5461 __attribute__nonnull__(pTHX_1); 5462 #define PERL_ARGS_ASSERT_CHECKPOSIXCC \ 5463 assert(pRExC_state) 5464 5465 STATIC I32 S_make_trie(pTHX_ struct RExC_state_t *pRExC_state, regnode *startbranch, regnode *first, regnode *last, regnode *tail, U32 word_count, U32 flags, U32 depth) 5466 __attribute__nonnull__(pTHX_1) 5467 __attribute__nonnull__(pTHX_2) 5468 __attribute__nonnull__(pTHX_3) 5469 __attribute__nonnull__(pTHX_4) 5470 __attribute__nonnull__(pTHX_5); 5471 #define PERL_ARGS_ASSERT_MAKE_TRIE \ 5472 assert(pRExC_state); assert(startbranch); assert(first); assert(last); assert(tail) 5473 5474 STATIC void S_make_trie_failtable(pTHX_ struct RExC_state_t *pRExC_state, regnode *source, regnode *stclass, U32 depth) 5475 __attribute__nonnull__(pTHX_1) 5476 __attribute__nonnull__(pTHX_2) 5477 __attribute__nonnull__(pTHX_3); 5478 #define PERL_ARGS_ASSERT_MAKE_TRIE_FAILTABLE \ 5479 assert(pRExC_state); assert(source); assert(stclass) 5480 5481 # ifdef DEBUGGING 5482 STATIC void S_regdump_extflags(pTHX_ const char *lead, const U32 flags); 5483 STATIC const regnode* S_dumpuntil(pTHX_ const regexp *r, const regnode *start, const regnode *node, const regnode *last, const regnode *plast, SV* sv, I32 indent, U32 depth) 5484 __attribute__nonnull__(pTHX_1) 5485 __attribute__nonnull__(pTHX_2) 5486 __attribute__nonnull__(pTHX_3) 5487 __attribute__nonnull__(pTHX_6); 5488 #define PERL_ARGS_ASSERT_DUMPUNTIL \ 5489 assert(r); assert(start); assert(node); assert(sv) 5490 5491 STATIC void S_put_byte(pTHX_ SV* sv, int c) 5492 __attribute__nonnull__(pTHX_1); 5493 #define PERL_ARGS_ASSERT_PUT_BYTE \ 5494 assert(sv) 5495 5496 STATIC void S_dump_trie(pTHX_ const struct _reg_trie_data *trie, HV* widecharmap, AV *revcharmap, U32 depth) 5497 __attribute__nonnull__(pTHX_1) 5498 __attribute__nonnull__(pTHX_3); 5499 #define PERL_ARGS_ASSERT_DUMP_TRIE \ 5500 assert(trie); assert(revcharmap) 5501 5502 STATIC void S_dump_trie_interim_list(pTHX_ const struct _reg_trie_data *trie, HV* widecharmap, AV *revcharmap, U32 next_alloc, U32 depth) 5503 __attribute__nonnull__(pTHX_1) 5504 __attribute__nonnull__(pTHX_3); 5505 #define PERL_ARGS_ASSERT_DUMP_TRIE_INTERIM_LIST \ 5506 assert(trie); assert(revcharmap) 5507 5508 STATIC void S_dump_trie_interim_table(pTHX_ const struct _reg_trie_data *trie, HV* widecharmap, AV *revcharmap, U32 next_alloc, U32 depth) 5509 __attribute__nonnull__(pTHX_1) 5510 __attribute__nonnull__(pTHX_3); 5511 #define PERL_ARGS_ASSERT_DUMP_TRIE_INTERIM_TABLE \ 5512 assert(trie); assert(revcharmap) 5513 5514 STATIC U8 S_regtail_study(pTHX_ struct RExC_state_t *pRExC_state, regnode *p, const regnode *val, U32 depth) 5515 __attribute__nonnull__(pTHX_1) 5516 __attribute__nonnull__(pTHX_2) 5517 __attribute__nonnull__(pTHX_3); 5518 #define PERL_ARGS_ASSERT_REGTAIL_STUDY \ 5519 assert(pRExC_state); assert(p); assert(val) 5520 5521 # endif 5522 #endif 5523 5524 #if defined(PERL_IN_REGEXEC_C) || defined(PERL_DECL_PROT) 5525 STATIC I32 S_regmatch(pTHX_ regmatch_info *reginfo, regnode *prog) 5526 __attribute__warn_unused_result__ 5527 __attribute__nonnull__(pTHX_1) 5528 __attribute__nonnull__(pTHX_2); 5529 #define PERL_ARGS_ASSERT_REGMATCH \ 5530 assert(reginfo); assert(prog) 5531 5532 STATIC I32 S_regrepeat(pTHX_ const regexp *prog, const regnode *p, I32 max, int depth) 5533 __attribute__warn_unused_result__ 5534 __attribute__nonnull__(pTHX_1) 5535 __attribute__nonnull__(pTHX_2); 5536 #define PERL_ARGS_ASSERT_REGREPEAT \ 5537 assert(prog); assert(p) 5538 5539 STATIC I32 S_regtry(pTHX_ regmatch_info *reginfo, char **startpos) 5540 __attribute__warn_unused_result__ 5541 __attribute__nonnull__(pTHX_1) 5542 __attribute__nonnull__(pTHX_2); 5543 #define PERL_ARGS_ASSERT_REGTRY \ 5544 assert(reginfo); assert(startpos) 5545 5546 STATIC bool S_reginclass(pTHX_ const regexp *prog, const regnode *n, const U8 *p, STRLEN *lenp, bool do_utf8sv_is_utf8) 5547 __attribute__warn_unused_result__ 5548 __attribute__nonnull__(pTHX_2) 5549 __attribute__nonnull__(pTHX_3); 5550 #define PERL_ARGS_ASSERT_REGINCLASS \ 5551 assert(n); assert(p) 5552 5553 STATIC CHECKPOINT S_regcppush(pTHX_ I32 parenfloor); 5554 STATIC char* S_regcppop(pTHX_ const regexp *rex) 5555 __attribute__nonnull__(pTHX_1); 5556 #define PERL_ARGS_ASSERT_REGCPPOP \ 5557 assert(rex) 5558 5559 STATIC U8* S_reghop3(U8 *s, I32 off, const U8 *lim) 5560 __attribute__warn_unused_result__ 5561 __attribute__nonnull__(1) 5562 __attribute__nonnull__(3); 5563 #define PERL_ARGS_ASSERT_REGHOP3 \ 5564 assert(s); assert(lim) 5565 5566 #ifdef XXX_dmq 5567 STATIC U8* S_reghop4(U8 *s, I32 off, const U8 *llim, const U8 *rlim) 5568 __attribute__warn_unused_result__ 5569 __attribute__nonnull__(1) 5570 __attribute__nonnull__(3) 5571 __attribute__nonnull__(4); 5572 #define PERL_ARGS_ASSERT_REGHOP4 \ 5573 assert(s); assert(llim); assert(rlim) 5574 5575 #endif 5576 STATIC U8* S_reghopmaybe3(U8 *s, I32 off, const U8 *lim) 5577 __attribute__warn_unused_result__ 5578 __attribute__nonnull__(1) 5579 __attribute__nonnull__(3); 5580 #define PERL_ARGS_ASSERT_REGHOPMAYBE3 \ 5581 assert(s); assert(lim) 5582 5583 STATIC char* S_find_byclass(pTHX_ regexp * prog, const regnode *c, char *s, const char *strend, regmatch_info *reginfo) 5584 __attribute__warn_unused_result__ 5585 __attribute__nonnull__(pTHX_1) 5586 __attribute__nonnull__(pTHX_2) 5587 __attribute__nonnull__(pTHX_3) 5588 __attribute__nonnull__(pTHX_4); 5589 #define PERL_ARGS_ASSERT_FIND_BYCLASS \ 5590 assert(prog); assert(c); assert(s); assert(strend) 5591 5592 STATIC void S_to_utf8_substr(pTHX_ regexp * prog) 5593 __attribute__nonnull__(pTHX_1); 5594 #define PERL_ARGS_ASSERT_TO_UTF8_SUBSTR \ 5595 assert(prog) 5596 5597 STATIC void S_to_byte_substr(pTHX_ regexp * prog) 5598 __attribute__nonnull__(pTHX_1); 5599 #define PERL_ARGS_ASSERT_TO_BYTE_SUBSTR \ 5600 assert(prog) 5601 5602 STATIC I32 S_reg_check_named_buff_matched(pTHX_ const regexp *rex, const regnode *scan) 5603 __attribute__warn_unused_result__ 5604 __attribute__nonnull__(pTHX_1) 5605 __attribute__nonnull__(pTHX_2); 5606 #define PERL_ARGS_ASSERT_REG_CHECK_NAMED_BUFF_MATCHED \ 5607 assert(rex); assert(scan) 5608 5609 # ifdef DEBUGGING 5610 STATIC void S_dump_exec_pos(pTHX_ const char *locinput, const regnode *scan, const char *loc_regeol, const char *loc_bostr, const char *loc_reg_starttry, const bool do_utf8) 5611 __attribute__nonnull__(pTHX_1) 5612 __attribute__nonnull__(pTHX_2) 5613 __attribute__nonnull__(pTHX_3) 5614 __attribute__nonnull__(pTHX_4) 5615 __attribute__nonnull__(pTHX_5); 5616 #define PERL_ARGS_ASSERT_DUMP_EXEC_POS \ 5617 assert(locinput); assert(scan); assert(loc_regeol); assert(loc_bostr); assert(loc_reg_starttry) 5618 5619 STATIC void S_debug_start_match(pTHX_ const REGEXP *prog, const bool do_utf8, const char *start, const char *end, const char *blurb) 5620 __attribute__nonnull__(pTHX_1) 5621 __attribute__nonnull__(pTHX_3) 5622 __attribute__nonnull__(pTHX_4) 5623 __attribute__nonnull__(pTHX_5); 5624 #define PERL_ARGS_ASSERT_DEBUG_START_MATCH \ 5625 assert(prog); assert(start); assert(end); assert(blurb) 5626 5627 # endif 5628 #endif 5629 5630 #if defined(PERL_IN_DUMP_C) || defined(PERL_DECL_PROT) 5631 STATIC CV* S_deb_curcv(pTHX_ const I32 ix); 5632 STATIC void S_debprof(pTHX_ const OP *o) 5633 __attribute__nonnull__(pTHX_1); 5634 #define PERL_ARGS_ASSERT_DEBPROF \ 5635 assert(o) 5636 5637 STATIC void S_sequence(pTHX_ const OP *o); 5638 STATIC void S_sequence_tail(pTHX_ const OP *o); 5639 STATIC UV S_sequence_num(pTHX_ const OP *o); 5640 STATIC SV* S_pm_description(pTHX_ const PMOP *pm) 5641 __attribute__nonnull__(pTHX_1); 5642 #define PERL_ARGS_ASSERT_PM_DESCRIPTION \ 5643 assert(pm) 5644 5645 #endif 5646 5647 #if defined(PERL_IN_SCOPE_C) || defined(PERL_DECL_PROT) 5648 STATIC SV* S_save_scalar_at(pTHX_ SV **sptr, const U32 flags) 5649 __attribute__nonnull__(pTHX_1); 5650 #define PERL_ARGS_ASSERT_SAVE_SCALAR_AT \ 5651 assert(sptr) 5652 5653 #endif 5654 5655 #if defined(PERL_IN_GV_C) || defined(PERL_IN_SV_C) || defined(PERL_IN_PAD_C) || defined(PERL_DECL_PROT) 5656 PERL_CALLCONV void Perl_sv_add_backref(pTHX_ SV *const tsv, SV *const sv) 5657 __attribute__nonnull__(pTHX_1) 5658 __attribute__nonnull__(pTHX_2); 5659 #define PERL_ARGS_ASSERT_SV_ADD_BACKREF \ 5660 assert(tsv); assert(sv) 5661 5662 #endif 5663 5664 #if defined(PERL_IN_HV_C) || defined(PERL_IN_MG_C) || defined(PERL_IN_SV_C) || defined(PERL_DECL_PROT) 5665 PERL_CALLCONV int Perl_sv_kill_backrefs(pTHX_ SV *const sv, AV *const av) 5666 __attribute__nonnull__(pTHX_1) 5667 __attribute__nonnull__(pTHX_2); 5668 #define PERL_ARGS_ASSERT_SV_KILL_BACKREFS \ 5669 assert(sv); assert(av) 5670 5671 #endif 5672 5673 #if defined(PERL_IN_SV_C) || defined(PERL_DECL_PROT) 5674 STATIC char * S_uiv_2buf(char *const buf, const IV iv, UV uv, const int is_uv, char **const peob) 5675 __attribute__warn_unused_result__ 5676 __attribute__nonnull__(1) 5677 __attribute__nonnull__(5); 5678 #define PERL_ARGS_ASSERT_UIV_2BUF \ 5679 assert(buf); assert(peob) 5680 5681 STATIC void S_sv_unglob(pTHX_ SV *const sv) 5682 __attribute__nonnull__(pTHX_1); 5683 #define PERL_ARGS_ASSERT_SV_UNGLOB \ 5684 assert(sv) 5685 5686 STATIC void S_not_a_number(pTHX_ SV *const sv) 5687 __attribute__nonnull__(pTHX_1); 5688 #define PERL_ARGS_ASSERT_NOT_A_NUMBER \ 5689 assert(sv) 5690 5691 STATIC I32 S_visit(pTHX_ SVFUNC_t f, const U32 flags, const U32 mask) 5692 __attribute__nonnull__(pTHX_1); 5693 #define PERL_ARGS_ASSERT_VISIT \ 5694 assert(f) 5695 5696 STATIC void S_sv_del_backref(pTHX_ SV *const tsv, SV *const sv) 5697 __attribute__nonnull__(pTHX_1) 5698 __attribute__nonnull__(pTHX_2); 5699 #define PERL_ARGS_ASSERT_SV_DEL_BACKREF \ 5700 assert(tsv); assert(sv) 5701 5702 STATIC SV * S_varname(pTHX_ const GV *const gv, const char gvtype, PADOFFSET targ, const SV *const keyname, I32 aindex, int subscript_type) 5703 __attribute__warn_unused_result__; 5704 5705 # ifdef DEBUGGING 5706 STATIC void S_del_sv(pTHX_ SV *p) 5707 __attribute__nonnull__(pTHX_1); 5708 #define PERL_ARGS_ASSERT_DEL_SV \ 5709 assert(p) 5710 5711 # endif 5712 # if !defined(NV_PRESERVES_UV) 5713 # ifdef DEBUGGING 5714 STATIC int S_sv_2iuv_non_preserve(pTHX_ SV *const sv, I32 numtype) 5715 __attribute__nonnull__(pTHX_1); 5716 #define PERL_ARGS_ASSERT_SV_2IUV_NON_PRESERVE \ 5717 assert(sv) 5718 5719 # else 5720 STATIC int S_sv_2iuv_non_preserve(pTHX_ SV *const sv) 5721 __attribute__nonnull__(pTHX_1); 5722 #define PERL_ARGS_ASSERT_SV_2IUV_NON_PRESERVE \ 5723 assert(sv) 5724 5725 # endif 5726 # endif 5727 STATIC I32 S_expect_number(pTHX_ char **const pattern) 5728 __attribute__warn_unused_result__ 5729 __attribute__nonnull__(pTHX_1); 5730 #define PERL_ARGS_ASSERT_EXPECT_NUMBER \ 5731 assert(pattern) 5732 5733 # 5734 STATIC STRLEN S_sv_pos_u2b_forwards(const U8 *const start, const U8 *const send, STRLEN uoffset) 5735 __attribute__nonnull__(1) 5736 __attribute__nonnull__(2); 5737 #define PERL_ARGS_ASSERT_SV_POS_U2B_FORWARDS \ 5738 assert(start); assert(send) 5739 5740 STATIC STRLEN S_sv_pos_u2b_midway(const U8 *const start, const U8 *send, const STRLEN uoffset, const STRLEN uend) 5741 __attribute__nonnull__(1) 5742 __attribute__nonnull__(2); 5743 #define PERL_ARGS_ASSERT_SV_POS_U2B_MIDWAY \ 5744 assert(start); assert(send) 5745 5746 STATIC STRLEN S_sv_pos_u2b_cached(pTHX_ SV *const sv, MAGIC **const mgp, const U8 *const start, const U8 *const send, const STRLEN uoffset, STRLEN uoffset0, STRLEN boffset0) 5747 __attribute__nonnull__(pTHX_1) 5748 __attribute__nonnull__(pTHX_2) 5749 __attribute__nonnull__(pTHX_3) 5750 __attribute__nonnull__(pTHX_4); 5751 #define PERL_ARGS_ASSERT_SV_POS_U2B_CACHED \ 5752 assert(sv); assert(mgp); assert(start); assert(send) 5753 5754 STATIC void S_utf8_mg_pos_cache_update(pTHX_ SV *const sv, MAGIC **const mgp, const STRLEN byte, const STRLEN utf8, const STRLEN blen) 5755 __attribute__nonnull__(pTHX_1) 5756 __attribute__nonnull__(pTHX_2); 5757 #define PERL_ARGS_ASSERT_UTF8_MG_POS_CACHE_UPDATE \ 5758 assert(sv); assert(mgp) 5759 5760 STATIC STRLEN S_sv_pos_b2u_midway(pTHX_ const U8 *const s, const U8 *const target, const U8 *end, STRLEN endu) 5761 __attribute__nonnull__(pTHX_1) 5762 __attribute__nonnull__(pTHX_2) 5763 __attribute__nonnull__(pTHX_3); 5764 #define PERL_ARGS_ASSERT_SV_POS_B2U_MIDWAY \ 5765 assert(s); assert(target); assert(end) 5766 5767 STATIC char * S_F0convert(NV nv, char *const endbuf, STRLEN *const len) 5768 __attribute__nonnull__(2) 5769 __attribute__nonnull__(3); 5770 #define PERL_ARGS_ASSERT_F0CONVERT \ 5771 assert(endbuf); assert(len) 5772 5773 # if defined(PERL_OLD_COPY_ON_WRITE) 5774 STATIC void S_sv_release_COW(pTHX_ SV *sv, const char *pvx, SV *after) 5775 __attribute__nonnull__(pTHX_1) 5776 __attribute__nonnull__(pTHX_2) 5777 __attribute__nonnull__(pTHX_3); 5778 #define PERL_ARGS_ASSERT_SV_RELEASE_COW \ 5779 assert(sv); assert(pvx); assert(after) 5780 5781 # endif 5782 STATIC SV * S_more_sv(pTHX); 5783 STATIC void * S_more_bodies(pTHX_ const svtype sv_type); 5784 STATIC bool S_sv_2iuv_common(pTHX_ SV *const sv) 5785 __attribute__nonnull__(pTHX_1); 5786 #define PERL_ARGS_ASSERT_SV_2IUV_COMMON \ 5787 assert(sv) 5788 5789 STATIC void S_glob_assign_glob(pTHX_ SV *const dstr, SV *const sstr, const int dtype) 5790 __attribute__nonnull__(pTHX_1) 5791 __attribute__nonnull__(pTHX_2); 5792 #define PERL_ARGS_ASSERT_GLOB_ASSIGN_GLOB \ 5793 assert(dstr); assert(sstr) 5794 5795 STATIC void S_glob_assign_ref(pTHX_ SV *const dstr, SV *const sstr) 5796 __attribute__nonnull__(pTHX_1) 5797 __attribute__nonnull__(pTHX_2); 5798 #define PERL_ARGS_ASSERT_GLOB_ASSIGN_REF \ 5799 assert(dstr); assert(sstr) 5800 5801 STATIC PTR_TBL_ENT_t * S_ptr_table_find(PTR_TBL_t *const tbl, const void *const sv) 5802 __attribute__warn_unused_result__ 5803 __attribute__nonnull__(1); 5804 #define PERL_ARGS_ASSERT_PTR_TABLE_FIND \ 5805 assert(tbl) 5806 5807 #endif 5808 5809 #if defined(PERL_IN_TOKE_C) || defined(PERL_DECL_PROT) 5810 STATIC void S_check_uni(pTHX); 5811 STATIC void S_force_next(pTHX_ I32 type); 5812 STATIC char* S_force_version(pTHX_ char *s, int guessing) 5813 __attribute__nonnull__(pTHX_1); 5814 #define PERL_ARGS_ASSERT_FORCE_VERSION \ 5815 assert(s) 5816 5817 STATIC char* S_force_strict_version(pTHX_ char *s) 5818 __attribute__nonnull__(pTHX_1); 5819 #define PERL_ARGS_ASSERT_FORCE_STRICT_VERSION \ 5820 assert(s) 5821 5822 STATIC char* S_force_word(pTHX_ char *start, int token, int check_keyword, int allow_pack, int allow_tick) 5823 __attribute__nonnull__(pTHX_1); 5824 #define PERL_ARGS_ASSERT_FORCE_WORD \ 5825 assert(start) 5826 5827 STATIC SV* S_tokeq(pTHX_ SV *sv) 5828 __attribute__nonnull__(pTHX_1); 5829 #define PERL_ARGS_ASSERT_TOKEQ \ 5830 assert(sv) 5831 5832 STATIC void S_readpipe_override(pTHX); 5833 STATIC char* S_scan_const(pTHX_ char *start) 5834 __attribute__warn_unused_result__ 5835 __attribute__nonnull__(pTHX_1); 5836 #define PERL_ARGS_ASSERT_SCAN_CONST \ 5837 assert(start) 5838 5839 STATIC char* S_scan_formline(pTHX_ char *s) 5840 __attribute__warn_unused_result__ 5841 __attribute__nonnull__(pTHX_1); 5842 #define PERL_ARGS_ASSERT_SCAN_FORMLINE \ 5843 assert(s) 5844 5845 STATIC char* S_scan_heredoc(pTHX_ char *s) 5846 __attribute__warn_unused_result__ 5847 __attribute__nonnull__(pTHX_1); 5848 #define PERL_ARGS_ASSERT_SCAN_HEREDOC \ 5849 assert(s) 5850 5851 STATIC char* S_scan_ident(pTHX_ char *s, const char *send, char *dest, STRLEN destlen, I32 ck_uni) 5852 __attribute__nonnull__(pTHX_1) 5853 __attribute__nonnull__(pTHX_2) 5854 __attribute__nonnull__(pTHX_3); 5855 #define PERL_ARGS_ASSERT_SCAN_IDENT \ 5856 assert(s); assert(send); assert(dest) 5857 5858 STATIC char* S_scan_inputsymbol(pTHX_ char *start) 5859 __attribute__warn_unused_result__ 5860 __attribute__nonnull__(pTHX_1); 5861 #define PERL_ARGS_ASSERT_SCAN_INPUTSYMBOL \ 5862 assert(start) 5863 5864 STATIC char* S_scan_pat(pTHX_ char *start, I32 type) 5865 __attribute__warn_unused_result__ 5866 __attribute__nonnull__(pTHX_1); 5867 #define PERL_ARGS_ASSERT_SCAN_PAT \ 5868 assert(start) 5869 5870 STATIC char* S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims) 5871 __attribute__warn_unused_result__ 5872 __attribute__nonnull__(pTHX_1); 5873 #define PERL_ARGS_ASSERT_SCAN_STR \ 5874 assert(start) 5875 5876 STATIC char* S_scan_subst(pTHX_ char *start) 5877 __attribute__warn_unused_result__ 5878 __attribute__nonnull__(pTHX_1); 5879 #define PERL_ARGS_ASSERT_SCAN_SUBST \ 5880 assert(start) 5881 5882 STATIC char* S_scan_trans(pTHX_ char *start) 5883 __attribute__warn_unused_result__ 5884 __attribute__nonnull__(pTHX_1); 5885 #define PERL_ARGS_ASSERT_SCAN_TRANS \ 5886 assert(start) 5887 5888 STATIC char* S_scan_word(pTHX_ char *s, char *dest, STRLEN destlen, int allow_package, STRLEN *slp) 5889 __attribute__nonnull__(pTHX_1) 5890 __attribute__nonnull__(pTHX_2) 5891 __attribute__nonnull__(pTHX_5); 5892 #define PERL_ARGS_ASSERT_SCAN_WORD \ 5893 assert(s); assert(dest); assert(slp) 5894 5895 STATIC void S_update_debugger_info(pTHX_ SV *orig_sv, const char *const buf, STRLEN len); 5896 STATIC char* S_skipspace(pTHX_ char *s) 5897 __attribute__warn_unused_result__ 5898 __attribute__nonnull__(pTHX_1); 5899 #define PERL_ARGS_ASSERT_SKIPSPACE \ 5900 assert(s) 5901 5902 STATIC char* S_swallow_bom(pTHX_ U8 *s) 5903 __attribute__warn_unused_result__ 5904 __attribute__nonnull__(pTHX_1); 5905 #define PERL_ARGS_ASSERT_SWALLOW_BOM \ 5906 assert(s) 5907 5908 #ifndef PERL_NO_UTF16_FILTER 5909 STATIC I32 S_utf16_textfilter(pTHX_ int idx, SV *sv, int maxlen) 5910 __attribute__nonnull__(pTHX_2); 5911 #define PERL_ARGS_ASSERT_UTF16_TEXTFILTER \ 5912 assert(sv) 5913 5914 STATIC U8* S_add_utf16_textfilter(pTHX_ U8 *const s, bool reversed) 5915 __attribute__nonnull__(pTHX_1); 5916 #define PERL_ARGS_ASSERT_ADD_UTF16_TEXTFILTER \ 5917 assert(s) 5918 5919 #endif 5920 STATIC void S_checkcomma(pTHX_ const char *s, const char *name, const char *what) 5921 __attribute__nonnull__(pTHX_1) 5922 __attribute__nonnull__(pTHX_2) 5923 __attribute__nonnull__(pTHX_3); 5924 #define PERL_ARGS_ASSERT_CHECKCOMMA \ 5925 assert(s); assert(name); assert(what) 5926 5927 STATIC bool S_feature_is_enabled(pTHX_ const char *const name, STRLEN namelen) 5928 __attribute__nonnull__(pTHX_1); 5929 #define PERL_ARGS_ASSERT_FEATURE_IS_ENABLED \ 5930 assert(name) 5931 5932 STATIC void S_force_ident(pTHX_ const char *s, int kind) 5933 __attribute__nonnull__(pTHX_1); 5934 #define PERL_ARGS_ASSERT_FORCE_IDENT \ 5935 assert(s) 5936 5937 STATIC void S_incline(pTHX_ const char *s) 5938 __attribute__nonnull__(pTHX_1); 5939 #define PERL_ARGS_ASSERT_INCLINE \ 5940 assert(s) 5941 5942 STATIC int S_intuit_method(pTHX_ char *s, GV *gv, CV *cv) 5943 __attribute__nonnull__(pTHX_1); 5944 #define PERL_ARGS_ASSERT_INTUIT_METHOD \ 5945 assert(s) 5946 5947 STATIC int S_intuit_more(pTHX_ char *s) 5948 __attribute__nonnull__(pTHX_1); 5949 #define PERL_ARGS_ASSERT_INTUIT_MORE \ 5950 assert(s) 5951 5952 STATIC I32 S_lop(pTHX_ I32 f, int x, char *s) 5953 __attribute__nonnull__(pTHX_3); 5954 #define PERL_ARGS_ASSERT_LOP \ 5955 assert(s) 5956 5957 STATIC void S_missingterm(pTHX_ char *s) 5958 __attribute__noreturn__; 5959 5960 STATIC void S_no_op(pTHX_ const char *const what, char *s) 5961 __attribute__nonnull__(pTHX_1); 5962 #define PERL_ARGS_ASSERT_NO_OP \ 5963 assert(what) 5964 5965 STATIC I32 S_sublex_done(pTHX) 5966 __attribute__warn_unused_result__; 5967 5968 STATIC I32 S_sublex_push(pTHX) 5969 __attribute__warn_unused_result__; 5970 5971 STATIC I32 S_sublex_start(pTHX) 5972 __attribute__warn_unused_result__; 5973 5974 STATIC char * S_filter_gets(pTHX_ SV *sv, STRLEN append) 5975 __attribute__warn_unused_result__ 5976 __attribute__nonnull__(pTHX_1); 5977 #define PERL_ARGS_ASSERT_FILTER_GETS \ 5978 assert(sv) 5979 5980 STATIC HV * S_find_in_my_stash(pTHX_ const char *pkgname, STRLEN len) 5981 __attribute__warn_unused_result__ 5982 __attribute__nonnull__(pTHX_1); 5983 #define PERL_ARGS_ASSERT_FIND_IN_MY_STASH \ 5984 assert(pkgname) 5985 5986 STATIC char * S_tokenize_use(pTHX_ int is_use, char *s) 5987 __attribute__warn_unused_result__ 5988 __attribute__nonnull__(pTHX_2); 5989 #define PERL_ARGS_ASSERT_TOKENIZE_USE \ 5990 assert(s) 5991 5992 STATIC SV* S_new_constant(pTHX_ const char *s, STRLEN len, const char *key, STRLEN keylen, SV *sv, SV *pv, const char *type, STRLEN typelen) 5993 __attribute__nonnull__(pTHX_3) 5994 __attribute__nonnull__(pTHX_5); 5995 #define PERL_ARGS_ASSERT_NEW_CONSTANT \ 5996 assert(key); assert(sv) 5997 5998 STATIC int S_deprecate_commaless_var_list(pTHX); 5999 STATIC int S_ao(pTHX_ int toketype); 6000 # if defined(PERL_CR_FILTER) 6001 STATIC I32 S_cr_textfilter(pTHX_ int idx, SV *sv, int maxlen); 6002 STATIC void S_strip_return(pTHX_ SV *sv) 6003 __attribute__nonnull__(pTHX_1); 6004 #define PERL_ARGS_ASSERT_STRIP_RETURN \ 6005 assert(sv) 6006 6007 # endif 6008 # if defined(DEBUGGING) 6009 STATIC int S_tokereport(pTHX_ I32 rv, const YYSTYPE* lvalp) 6010 __attribute__nonnull__(pTHX_2); 6011 #define PERL_ARGS_ASSERT_TOKEREPORT \ 6012 assert(lvalp) 6013 6014 STATIC void S_printbuf(pTHX_ const char *const fmt, const char *const s) 6015 __attribute__nonnull__(pTHX_1) 6016 __attribute__nonnull__(pTHX_2); 6017 #define PERL_ARGS_ASSERT_PRINTBUF \ 6018 assert(fmt); assert(s) 6019 6020 # endif 6021 #endif 6022 6023 #if defined(PERL_IN_UNIVERSAL_C) || defined(PERL_DECL_PROT) 6024 STATIC bool S_isa_lookup(pTHX_ HV *stash, const char * const name) 6025 __attribute__nonnull__(pTHX_1) 6026 __attribute__nonnull__(pTHX_2); 6027 #define PERL_ARGS_ASSERT_ISA_LOOKUP \ 6028 assert(stash); assert(name) 6029 6030 STATIC HV * S_get_isa_hash(pTHX_ HV *const stash) 6031 __attribute__nonnull__(pTHX_1); 6032 #define PERL_ARGS_ASSERT_GET_ISA_HASH \ 6033 assert(stash) 6034 6035 #endif 6036 6037 #if defined(PERL_IN_LOCALE_C) || defined(PERL_DECL_PROT) 6038 #if defined(USE_LOCALE_NUMERIC) || defined(USE_LOCALE_COLLATE) 6039 STATIC char* S_stdize_locale(pTHX_ char* locs) 6040 __attribute__nonnull__(pTHX_1); 6041 #define PERL_ARGS_ASSERT_STDIZE_LOCALE \ 6042 assert(locs) 6043 6044 #endif 6045 #endif 6046 6047 #if defined(PERL_IN_UTIL_C) || defined(PERL_DECL_PROT) 6048 STATIC const COP* S_closest_cop(pTHX_ const COP *cop, const OP *o) 6049 __attribute__nonnull__(pTHX_1); 6050 #define PERL_ARGS_ASSERT_CLOSEST_COP \ 6051 assert(cop) 6052 6053 STATIC SV* S_mess_alloc(pTHX); 6054 STATIC SV * S_vdie_croak_common(pTHX_ const char *pat, va_list *args); 6055 STATIC bool S_vdie_common(pTHX_ SV *message, bool warn); 6056 STATIC char * S_write_no_mem(pTHX) 6057 __attribute__noreturn__; 6058 6059 #if defined(PERL_MEM_LOG) && !defined(PERL_MEM_LOG_NOIMPL) 6060 STATIC void S_mem_log_common(enum mem_log_type mlt, const UV n, const UV typesize, const char *type_name, const SV *sv, Malloc_t oldalloc, Malloc_t newalloc, const char *filename, const int linenumber, const char *funcname) 6061 __attribute__nonnull__(4) 6062 __attribute__nonnull__(8) 6063 __attribute__nonnull__(10); 6064 #define PERL_ARGS_ASSERT_MEM_LOG_COMMON \ 6065 assert(type_name); assert(filename); assert(funcname) 6066 6067 #endif 6068 #endif 6069 6070 #if defined(PERL_IN_NUMERIC_C) || defined(PERL_DECL_PROT) 6071 STATIC NV S_mulexp10(NV value, I32 exponent); 6072 #endif 6073 6074 #if defined(PERL_IN_UTF8_C) || defined(PERL_DECL_PROT) 6075 STATIC STRLEN S_is_utf8_char_slow(const U8 *s, const STRLEN len) 6076 __attribute__warn_unused_result__ 6077 __attribute__nonnull__(1); 6078 #define PERL_ARGS_ASSERT_IS_UTF8_CHAR_SLOW \ 6079 assert(s) 6080 6081 STATIC bool S_is_utf8_common(pTHX_ const U8 *const p, SV **swash, const char * const swashname) 6082 __attribute__warn_unused_result__ 6083 __attribute__nonnull__(pTHX_1) 6084 __attribute__nonnull__(pTHX_2) 6085 __attribute__nonnull__(pTHX_3); 6086 #define PERL_ARGS_ASSERT_IS_UTF8_COMMON \ 6087 assert(p); assert(swash); assert(swashname) 6088 6089 STATIC SV* S_swash_get(pTHX_ SV* swash, UV start, UV span) 6090 __attribute__warn_unused_result__ 6091 __attribute__nonnull__(pTHX_1); 6092 #define PERL_ARGS_ASSERT_SWASH_GET \ 6093 assert(swash) 6094 6095 #endif 6096 6097 START_EXTERN_C 6098 6099 PERL_CALLCONV void Perl_sv_setsv_flags(pTHX_ SV *dstr, SV *sstr, const I32 flags) 6100 __attribute__nonnull__(pTHX_1); 6101 #define PERL_ARGS_ASSERT_SV_SETSV_FLAGS \ 6102 assert(dstr) 6103 6104 PERL_CALLCONV void Perl_sv_catpvn_flags(pTHX_ SV *const dstr, const char *sstr, const STRLEN len, const I32 flags) 6105 __attribute__nonnull__(pTHX_1) 6106 __attribute__nonnull__(pTHX_2); 6107 #define PERL_ARGS_ASSERT_SV_CATPVN_FLAGS \ 6108 assert(dstr); assert(sstr) 6109 6110 PERL_CALLCONV void Perl_sv_catsv_flags(pTHX_ SV *const dsv, SV *const ssv, const I32 flags) 6111 __attribute__nonnull__(pTHX_1); 6112 #define PERL_ARGS_ASSERT_SV_CATSV_FLAGS \ 6113 assert(dsv) 6114 6115 /* PERL_CALLCONV STRLEN Perl_sv_utf8_upgrade_flags(pTHX_ SV *const sv, const I32 flags) 6116 __attribute__nonnull__(pTHX_1); */ 6117 6118 PERL_CALLCONV STRLEN Perl_sv_utf8_upgrade_flags_grow(pTHX_ SV *const sv, const I32 flags, STRLEN extra) 6119 __attribute__nonnull__(pTHX_1); 6120 #define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE_FLAGS_GROW \ 6121 assert(sv) 6122 6123 PERL_CALLCONV char* Perl_sv_pvn_force_flags(pTHX_ SV *const sv, STRLEN *const lp, const I32 flags) 6124 __attribute__nonnull__(pTHX_1); 6125 #define PERL_ARGS_ASSERT_SV_PVN_FORCE_FLAGS \ 6126 assert(sv) 6127 6128 PERL_CALLCONV void Perl_sv_copypv(pTHX_ SV *const dsv, SV *const ssv) 6129 __attribute__nonnull__(pTHX_1) 6130 __attribute__nonnull__(pTHX_2); 6131 #define PERL_ARGS_ASSERT_SV_COPYPV \ 6132 assert(dsv); assert(ssv) 6133 6134 PERL_CALLCONV char* Perl_my_atof2(pTHX_ const char *s, NV* value) 6135 __attribute__nonnull__(pTHX_1) 6136 __attribute__nonnull__(pTHX_2); 6137 #define PERL_ARGS_ASSERT_MY_ATOF2 \ 6138 assert(s); assert(value) 6139 6140 PERL_CALLCONV int Perl_my_socketpair(int family, int type, int protocol, int fd[2]); 6141 PERL_CALLCONV int Perl_my_dirfd(pTHX_ DIR* dir); 6142 #ifdef PERL_OLD_COPY_ON_WRITE 6143 PERL_CALLCONV SV* Perl_sv_setsv_cow(pTHX_ SV* dstr, SV* sstr) 6144 __attribute__nonnull__(pTHX_2); 6145 #define PERL_ARGS_ASSERT_SV_SETSV_COW \ 6146 assert(sstr) 6147 6148 #endif 6149 6150 PERL_CALLCONV const char * Perl_PerlIO_context_layers(pTHX_ const char *mode); 6151 6152 #if defined(USE_PERLIO) && !defined(USE_SFIO) 6153 PERL_CALLCONV int Perl_PerlIO_close(pTHX_ PerlIO *f); 6154 PERL_CALLCONV int Perl_PerlIO_fill(pTHX_ PerlIO *f); 6155 PERL_CALLCONV int Perl_PerlIO_fileno(pTHX_ PerlIO *f); 6156 PERL_CALLCONV int Perl_PerlIO_eof(pTHX_ PerlIO *f); 6157 PERL_CALLCONV int Perl_PerlIO_error(pTHX_ PerlIO *f); 6158 PERL_CALLCONV int Perl_PerlIO_flush(pTHX_ PerlIO *f); 6159 PERL_CALLCONV void Perl_PerlIO_clearerr(pTHX_ PerlIO *f); 6160 PERL_CALLCONV void Perl_PerlIO_set_cnt(pTHX_ PerlIO *f, int cnt); 6161 PERL_CALLCONV void Perl_PerlIO_set_ptrcnt(pTHX_ PerlIO *f, STDCHAR *ptr, int cnt); 6162 PERL_CALLCONV void Perl_PerlIO_setlinebuf(pTHX_ PerlIO *f); 6163 PERL_CALLCONV SSize_t Perl_PerlIO_read(pTHX_ PerlIO *f, void *vbuf, Size_t count) 6164 __attribute__nonnull__(pTHX_2); 6165 #define PERL_ARGS_ASSERT_PERLIO_READ \ 6166 assert(vbuf) 6167 6168 PERL_CALLCONV SSize_t Perl_PerlIO_write(pTHX_ PerlIO *f, const void *vbuf, Size_t count) 6169 __attribute__nonnull__(pTHX_2); 6170 #define PERL_ARGS_ASSERT_PERLIO_WRITE \ 6171 assert(vbuf) 6172 6173 PERL_CALLCONV SSize_t Perl_PerlIO_unread(pTHX_ PerlIO *f, const void *vbuf, Size_t count) 6174 __attribute__nonnull__(pTHX_2); 6175 #define PERL_ARGS_ASSERT_PERLIO_UNREAD \ 6176 assert(vbuf) 6177 6178 PERL_CALLCONV Off_t Perl_PerlIO_tell(pTHX_ PerlIO *f); 6179 PERL_CALLCONV int Perl_PerlIO_seek(pTHX_ PerlIO *f, Off_t offset, int whence); 6180 6181 PERL_CALLCONV STDCHAR * Perl_PerlIO_get_base(pTHX_ PerlIO *f); 6182 PERL_CALLCONV STDCHAR * Perl_PerlIO_get_ptr(pTHX_ PerlIO *f); 6183 PERL_CALLCONV int Perl_PerlIO_get_bufsiz(pTHX_ PerlIO *f) 6184 __attribute__warn_unused_result__; 6185 6186 PERL_CALLCONV int Perl_PerlIO_get_cnt(pTHX_ PerlIO *f) 6187 __attribute__warn_unused_result__; 6188 6189 6190 PERL_CALLCONV PerlIO * Perl_PerlIO_stdin(pTHX) 6191 __attribute__warn_unused_result__; 6192 6193 PERL_CALLCONV PerlIO * Perl_PerlIO_stdout(pTHX) 6194 __attribute__warn_unused_result__; 6195 6196 PERL_CALLCONV PerlIO * Perl_PerlIO_stderr(pTHX) 6197 __attribute__warn_unused_result__; 6198 6199 #endif /* PERLIO_LAYERS */ 6200 6201 PERL_CALLCONV void Perl_deb_stack_all(pTHX); 6202 #if defined(PERL_IN_DEB_C) || defined(PERL_DECL_PROT) 6203 STATIC void S_deb_stack_n(pTHX_ SV** stack_base, I32 stack_min, I32 stack_max, I32 mark_min, I32 mark_max) 6204 __attribute__nonnull__(pTHX_1); 6205 #define PERL_ARGS_ASSERT_DEB_STACK_N \ 6206 assert(stack_base) 6207 6208 #endif 6209 6210 PERL_CALLCONV PADLIST* Perl_pad_new(pTHX_ int flags) 6211 __attribute__malloc__ 6212 __attribute__warn_unused_result__; 6213 6214 PERL_CALLCONV void Perl_pad_undef(pTHX_ CV* cv) 6215 __attribute__nonnull__(pTHX_1); 6216 #define PERL_ARGS_ASSERT_PAD_UNDEF \ 6217 assert(cv) 6218 6219 PERL_CALLCONV PADOFFSET Perl_pad_add_name(pTHX_ const char *name, const STRLEN len, const U32 flags, HV *typestash, HV *ourstash) 6220 __attribute__nonnull__(pTHX_1); 6221 #define PERL_ARGS_ASSERT_PAD_ADD_NAME \ 6222 assert(name) 6223 6224 PERL_CALLCONV PADOFFSET Perl_pad_add_anon(pTHX_ SV* sv, OPCODE op_type) 6225 __attribute__nonnull__(pTHX_1); 6226 #define PERL_ARGS_ASSERT_PAD_ADD_ANON \ 6227 assert(sv) 6228 6229 #if defined(PERL_IN_PAD_C) || defined(PERL_DECL_PROT) 6230 STATIC void S_pad_check_dup(pTHX_ SV *name, const U32 flags, const HV *ourstash) 6231 __attribute__nonnull__(pTHX_1); 6232 #define PERL_ARGS_ASSERT_PAD_CHECK_DUP \ 6233 assert(name) 6234 6235 #endif 6236 #ifdef DEBUGGING 6237 PERL_CALLCONV void Perl_pad_setsv(pTHX_ PADOFFSET po, SV* sv) 6238 __attribute__nonnull__(pTHX_2); 6239 #define PERL_ARGS_ASSERT_PAD_SETSV \ 6240 assert(sv) 6241 6242 #endif 6243 PERL_CALLCONV void Perl_pad_block_start(pTHX_ int full); 6244 PERL_CALLCONV void Perl_pad_tidy(pTHX_ padtidy_type type); 6245 PERL_CALLCONV void Perl_do_dump_pad(pTHX_ I32 level, PerlIO *file, PADLIST *padlist, int full) 6246 __attribute__nonnull__(pTHX_2); 6247 #define PERL_ARGS_ASSERT_DO_DUMP_PAD \ 6248 assert(file) 6249 6250 PERL_CALLCONV void Perl_pad_fixup_inner_anons(pTHX_ PADLIST *padlist, CV *old_cv, CV *new_cv) 6251 __attribute__nonnull__(pTHX_1) 6252 __attribute__nonnull__(pTHX_2) 6253 __attribute__nonnull__(pTHX_3); 6254 #define PERL_ARGS_ASSERT_PAD_FIXUP_INNER_ANONS \ 6255 assert(padlist); assert(old_cv); assert(new_cv) 6256 6257 6258 PERL_CALLCONV void Perl_pad_push(pTHX_ PADLIST *padlist, int depth) 6259 __attribute__nonnull__(pTHX_1); 6260 #define PERL_ARGS_ASSERT_PAD_PUSH \ 6261 assert(padlist) 6262 6263 PERL_CALLCONV HV* Perl_pad_compname_type(pTHX_ const PADOFFSET po) 6264 __attribute__warn_unused_result__; 6265 6266 6267 #if defined(PERL_IN_PAD_C) || defined(PERL_DECL_PROT) 6268 STATIC PADOFFSET S_pad_findlex(pTHX_ const char *name, const CV* cv, U32 seq, int warn, SV** out_capture, SV** out_name_sv, int *out_flags) 6269 __attribute__nonnull__(pTHX_1) 6270 __attribute__nonnull__(pTHX_2) 6271 __attribute__nonnull__(pTHX_6) 6272 __attribute__nonnull__(pTHX_7); 6273 #define PERL_ARGS_ASSERT_PAD_FINDLEX \ 6274 assert(name); assert(cv); assert(out_name_sv); assert(out_flags) 6275 6276 STATIC PADOFFSET S_pad_add_name_sv(pTHX_ SV *namesv, const U32 flags, HV *typestash, HV *ourstash) 6277 __attribute__nonnull__(pTHX_1); 6278 #define PERL_ARGS_ASSERT_PAD_ADD_NAME_SV \ 6279 assert(namesv) 6280 6281 # if defined(DEBUGGING) 6282 STATIC void S_cv_dump(pTHX_ const CV *cv, const char *title) 6283 __attribute__nonnull__(pTHX_1) 6284 __attribute__nonnull__(pTHX_2); 6285 #define PERL_ARGS_ASSERT_CV_DUMP \ 6286 assert(cv); assert(title) 6287 6288 # endif 6289 #endif 6290 PERL_CALLCONV CV* Perl_find_runcv(pTHX_ U32 *db_seqp) 6291 __attribute__warn_unused_result__; 6292 6293 PERL_CALLCONV void Perl_free_tied_hv_pool(pTHX); 6294 #if defined(DEBUGGING) 6295 PERL_CALLCONV int Perl_get_debug_opts(pTHX_ const char **s, bool givehelp) 6296 __attribute__warn_unused_result__ 6297 __attribute__nonnull__(pTHX_1); 6298 #define PERL_ARGS_ASSERT_GET_DEBUG_OPTS \ 6299 assert(s) 6300 6301 #endif 6302 PERL_CALLCONV void Perl_save_set_svflags(pTHX_ SV *sv, U32 mask, U32 val) 6303 __attribute__nonnull__(pTHX_1); 6304 #define PERL_ARGS_ASSERT_SAVE_SET_SVFLAGS \ 6305 assert(sv) 6306 6307 #ifdef DEBUGGING 6308 PERL_CALLCONV void Perl_hv_assert(pTHX_ HV *hv) 6309 __attribute__nonnull__(pTHX_1); 6310 #define PERL_ARGS_ASSERT_HV_ASSERT \ 6311 assert(hv) 6312 6313 #endif 6314 6315 PERL_CALLCONV SV* Perl_hv_scalar(pTHX_ HV *hv) 6316 __attribute__warn_unused_result__ 6317 __attribute__nonnull__(pTHX_1); 6318 #define PERL_ARGS_ASSERT_HV_SCALAR \ 6319 assert(hv) 6320 6321 PERL_CALLCONV I32* Perl_hv_riter_p(pTHX_ HV *hv) 6322 __attribute__warn_unused_result__ 6323 __attribute__nonnull__(pTHX_1); 6324 #define PERL_ARGS_ASSERT_HV_RITER_P \ 6325 assert(hv) 6326 6327 PERL_CALLCONV HE** Perl_hv_eiter_p(pTHX_ HV *hv) 6328 __attribute__warn_unused_result__ 6329 __attribute__nonnull__(pTHX_1); 6330 #define PERL_ARGS_ASSERT_HV_EITER_P \ 6331 assert(hv) 6332 6333 PERL_CALLCONV void Perl_hv_riter_set(pTHX_ HV *hv, I32 riter) 6334 __attribute__nonnull__(pTHX_1); 6335 #define PERL_ARGS_ASSERT_HV_RITER_SET \ 6336 assert(hv) 6337 6338 PERL_CALLCONV void Perl_hv_eiter_set(pTHX_ HV *hv, HE *eiter) 6339 __attribute__nonnull__(pTHX_1); 6340 #define PERL_ARGS_ASSERT_HV_EITER_SET \ 6341 assert(hv) 6342 6343 PERL_CALLCONV void Perl_hv_name_set(pTHX_ HV *hv, const char *name, U32 len, U32 flags) 6344 __attribute__nonnull__(pTHX_1); 6345 #define PERL_ARGS_ASSERT_HV_NAME_SET \ 6346 assert(hv) 6347 6348 PERL_CALLCONV AV** Perl_hv_backreferences_p(pTHX_ HV *hv) 6349 __attribute__nonnull__(pTHX_1); 6350 #define PERL_ARGS_ASSERT_HV_BACKREFERENCES_P \ 6351 assert(hv) 6352 6353 #if defined(PERL_IN_DUMP_C) || defined(PERL_IN_HV_C) || defined(PERL_IN_SV_C) || defined(PERL_DECL_PROT) 6354 PERL_CALLCONV void Perl_hv_kill_backrefs(pTHX_ HV *hv) 6355 __attribute__nonnull__(pTHX_1); 6356 #define PERL_ARGS_ASSERT_HV_KILL_BACKREFS \ 6357 assert(hv) 6358 6359 #endif 6360 PERL_CALLCONV void Perl_hv_clear_placeholders(pTHX_ HV *hv) 6361 __attribute__nonnull__(pTHX_1); 6362 #define PERL_ARGS_ASSERT_HV_CLEAR_PLACEHOLDERS \ 6363 assert(hv) 6364 6365 PERL_CALLCONV I32* Perl_hv_placeholders_p(pTHX_ HV *hv) 6366 __attribute__warn_unused_result__ 6367 __attribute__nonnull__(pTHX_1); 6368 #define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_P \ 6369 assert(hv) 6370 6371 PERL_CALLCONV I32 Perl_hv_placeholders_get(pTHX_ const HV *hv) 6372 __attribute__warn_unused_result__ 6373 __attribute__nonnull__(pTHX_1); 6374 #define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_GET \ 6375 assert(hv) 6376 6377 PERL_CALLCONV void Perl_hv_placeholders_set(pTHX_ HV *hv, I32 ph) 6378 __attribute__nonnull__(pTHX_1); 6379 #define PERL_ARGS_ASSERT_HV_PLACEHOLDERS_SET \ 6380 assert(hv) 6381 6382 6383 PERL_CALLCONV SV* Perl_magic_scalarpack(pTHX_ HV *hv, MAGIC *mg) 6384 __attribute__nonnull__(pTHX_1) 6385 __attribute__nonnull__(pTHX_2); 6386 #define PERL_ARGS_ASSERT_MAGIC_SCALARPACK \ 6387 assert(hv); assert(mg) 6388 6389 6390 #if defined(PERL_IN_SV_C) || defined(PERL_DECL_PROT) 6391 STATIC SV * S_find_hash_subscript(pTHX_ const HV *const hv, const SV *const val) 6392 __attribute__nonnull__(pTHX_2); 6393 #define PERL_ARGS_ASSERT_FIND_HASH_SUBSCRIPT \ 6394 assert(val) 6395 6396 STATIC I32 S_find_array_subscript(pTHX_ const AV *const av, const SV *const val) 6397 __attribute__nonnull__(pTHX_2); 6398 #define PERL_ARGS_ASSERT_FIND_ARRAY_SUBSCRIPT \ 6399 assert(val) 6400 6401 STATIC SV* S_find_uninit_var(pTHX_ const OP *const obase, const SV *const uninit_sv, bool top); 6402 #endif 6403 6404 #ifdef PERL_NEED_MY_HTOLE16 6405 PERL_CALLCONV U16 Perl_my_htole16(U16 n); 6406 #endif 6407 #ifdef PERL_NEED_MY_LETOH16 6408 PERL_CALLCONV U16 Perl_my_letoh16(U16 n); 6409 #endif 6410 #ifdef PERL_NEED_MY_HTOBE16 6411 PERL_CALLCONV U16 Perl_my_htobe16(U16 n); 6412 #endif 6413 #ifdef PERL_NEED_MY_BETOH16 6414 PERL_CALLCONV U16 Perl_my_betoh16(U16 n); 6415 #endif 6416 #ifdef PERL_NEED_MY_HTOLE32 6417 PERL_CALLCONV U32 Perl_my_htole32(U32 n); 6418 #endif 6419 #ifdef PERL_NEED_MY_LETOH32 6420 PERL_CALLCONV U32 Perl_my_letoh32(U32 n); 6421 #endif 6422 #ifdef PERL_NEED_MY_HTOBE32 6423 PERL_CALLCONV U32 Perl_my_htobe32(U32 n); 6424 #endif 6425 #ifdef PERL_NEED_MY_BETOH32 6426 PERL_CALLCONV U32 Perl_my_betoh32(U32 n); 6427 #endif 6428 #ifdef PERL_NEED_MY_HTOLE64 6429 PERL_CALLCONV U64 Perl_my_htole64(U64 n); 6430 #endif 6431 #ifdef PERL_NEED_MY_LETOH64 6432 PERL_CALLCONV U64 Perl_my_letoh64(U64 n); 6433 #endif 6434 #ifdef PERL_NEED_MY_HTOBE64 6435 PERL_CALLCONV U64 Perl_my_htobe64(U64 n); 6436 #endif 6437 #ifdef PERL_NEED_MY_BETOH64 6438 PERL_CALLCONV U64 Perl_my_betoh64(U64 n); 6439 #endif 6440 6441 #ifdef PERL_NEED_MY_HTOLES 6442 PERL_CALLCONV short Perl_my_htoles(short n); 6443 #endif 6444 #ifdef PERL_NEED_MY_LETOHS 6445 PERL_CALLCONV short Perl_my_letohs(short n); 6446 #endif 6447 #ifdef PERL_NEED_MY_HTOBES 6448 PERL_CALLCONV short Perl_my_htobes(short n); 6449 #endif 6450 #ifdef PERL_NEED_MY_BETOHS 6451 PERL_CALLCONV short Perl_my_betohs(short n); 6452 #endif 6453 #ifdef PERL_NEED_MY_HTOLEI 6454 PERL_CALLCONV int Perl_my_htolei(int n); 6455 #endif 6456 #ifdef PERL_NEED_MY_LETOHI 6457 PERL_CALLCONV int Perl_my_letohi(int n); 6458 #endif 6459 #ifdef PERL_NEED_MY_HTOBEI 6460 PERL_CALLCONV int Perl_my_htobei(int n); 6461 #endif 6462 #ifdef PERL_NEED_MY_BETOHI 6463 PERL_CALLCONV int Perl_my_betohi(int n); 6464 #endif 6465 #ifdef PERL_NEED_MY_HTOLEL 6466 PERL_CALLCONV long Perl_my_htolel(long n); 6467 #endif 6468 #ifdef PERL_NEED_MY_LETOHL 6469 PERL_CALLCONV long Perl_my_letohl(long n); 6470 #endif 6471 #ifdef PERL_NEED_MY_HTOBEL 6472 PERL_CALLCONV long Perl_my_htobel(long n); 6473 #endif 6474 #ifdef PERL_NEED_MY_BETOHL 6475 PERL_CALLCONV long Perl_my_betohl(long n); 6476 #endif 6477 6478 PERL_CALLCONV void Perl_my_swabn(void* ptr, int n) 6479 __attribute__nonnull__(1); 6480 #define PERL_ARGS_ASSERT_MY_SWABN \ 6481 assert(ptr) 6482 6483 6484 PERL_CALLCONV GV* Perl_gv_fetchpvn_flags(pTHX_ const char* name, STRLEN len, I32 flags, const svtype sv_type) 6485 __attribute__nonnull__(pTHX_1); 6486 #define PERL_ARGS_ASSERT_GV_FETCHPVN_FLAGS \ 6487 assert(name) 6488 6489 PERL_CALLCONV GV* Perl_gv_fetchsv(pTHX_ SV *name, I32 flags, const svtype sv_type) 6490 __attribute__nonnull__(pTHX_1); 6491 #define PERL_ARGS_ASSERT_GV_FETCHSV \ 6492 assert(name) 6493 6494 PERL_CALLCONV bool Perl_is_gv_magical_sv(pTHX_ SV *const name_sv, U32 flags) 6495 __attribute__warn_unused_result__ 6496 __attribute__nonnull__(pTHX_1); 6497 #define PERL_ARGS_ASSERT_IS_GV_MAGICAL_SV \ 6498 assert(name_sv) 6499 6500 6501 PERL_CALLCONV bool Perl_stashpv_hvname_match(pTHX_ const COP *c, const HV *hv) 6502 __attribute__warn_unused_result__ 6503 __attribute__nonnull__(pTHX_1) 6504 __attribute__nonnull__(pTHX_2); 6505 #define PERL_ARGS_ASSERT_STASHPV_HVNAME_MATCH \ 6506 assert(c); assert(hv) 6507 6508 6509 #ifdef DEBUG_LEAKING_SCALARS_FORK_DUMP 6510 PERL_CALLCONV void Perl_dump_sv_child(pTHX_ SV *sv) 6511 __attribute__nonnull__(pTHX_1); 6512 #define PERL_ARGS_ASSERT_DUMP_SV_CHILD \ 6513 assert(sv) 6514 6515 #endif 6516 6517 #ifdef PERL_DONT_CREATE_GVSV 6518 /* PERL_CALLCONV GV* Perl_gv_SVadd(pTHX_ GV *gv); */ 6519 #endif 6520 #if defined(PERL_IN_UTIL_C) || defined(PERL_DECL_PROT) 6521 STATIC bool S_ckwarn_common(pTHX_ U32 w); 6522 #endif 6523 PERL_CALLCONV bool Perl_ckwarn(pTHX_ U32 w); 6524 PERL_CALLCONV bool Perl_ckwarn_d(pTHX_ U32 w); 6525 PERL_CALLCONV STRLEN * Perl_new_warnings_bitfield(pTHX_ STRLEN *buffer, const char *const bits, STRLEN size) 6526 __attribute__malloc__ 6527 __attribute__warn_unused_result__ 6528 __attribute__nonnull__(pTHX_2); 6529 #define PERL_ARGS_ASSERT_NEW_WARNINGS_BITFIELD \ 6530 assert(bits) 6531 6532 6533 PERL_CALLCONV void Perl_offer_nice_chunk(pTHX_ void *const chunk, const U32 chunk_size) 6534 __attribute__nonnull__(pTHX_1); 6535 #define PERL_ARGS_ASSERT_OFFER_NICE_CHUNK \ 6536 assert(chunk) 6537 6538 6539 #ifndef SPRINTF_RETURNS_STRLEN 6540 PERL_CALLCONV int Perl_my_sprintf(char *buffer, const char *pat, ...) 6541 __attribute__nonnull__(1) 6542 __attribute__nonnull__(2); 6543 #define PERL_ARGS_ASSERT_MY_SPRINTF \ 6544 assert(buffer); assert(pat) 6545 6546 #endif 6547 6548 PERL_CALLCONV int Perl_my_snprintf(char *buffer, const Size_t len, const char *format, ...) 6549 __attribute__format__(__printf__,3,4) 6550 __attribute__nonnull__(1) 6551 __attribute__nonnull__(3); 6552 #define PERL_ARGS_ASSERT_MY_SNPRINTF \ 6553 assert(buffer); assert(format) 6554 6555 PERL_CALLCONV int Perl_my_vsnprintf(char *buffer, const Size_t len, const char *format, va_list ap) 6556 __attribute__nonnull__(1) 6557 __attribute__nonnull__(3); 6558 #define PERL_ARGS_ASSERT_MY_VSNPRINTF \ 6559 assert(buffer); assert(format) 6560 6561 6562 PERL_CALLCONV void Perl_my_clearenv(pTHX); 6563 6564 #ifdef PERL_IMPLICIT_CONTEXT 6565 #ifdef PERL_GLOBAL_STRUCT_PRIVATE 6566 PERL_CALLCONV void* Perl_my_cxt_init(pTHX_ const char *my_cxt_key, size_t size) 6567 __attribute__nonnull__(pTHX_1); 6568 #define PERL_ARGS_ASSERT_MY_CXT_INIT \ 6569 assert(my_cxt_key) 6570 6571 PERL_CALLCONV int Perl_my_cxt_index(pTHX_ const char *my_cxt_key) 6572 __attribute__nonnull__(pTHX_1); 6573 #define PERL_ARGS_ASSERT_MY_CXT_INDEX \ 6574 assert(my_cxt_key) 6575 6576 #else 6577 PERL_CALLCONV void* Perl_my_cxt_init(pTHX_ int *index, size_t size) 6578 __attribute__nonnull__(pTHX_1); 6579 #define PERL_ARGS_ASSERT_MY_CXT_INIT \ 6580 assert(index) 6581 6582 #endif 6583 #endif 6584 6585 #ifndef HAS_STRLCAT 6586 PERL_CALLCONV Size_t Perl_my_strlcat(char *dst, const char *src, Size_t size); 6587 #endif 6588 6589 #ifndef HAS_STRLCPY 6590 PERL_CALLCONV Size_t Perl_my_strlcpy(char *dst, const char *src, Size_t size); 6591 #endif 6592 6593 #ifdef PERL_MAD 6594 PERL_CALLCONV void Perl_pad_peg(const char* s) 6595 __attribute__nonnull__(1); 6596 #define PERL_ARGS_ASSERT_PAD_PEG \ 6597 assert(s) 6598 6599 #if defined(PERL_IN_DUMP_C) || defined(PERL_DECL_PROT) 6600 STATIC void S_xmldump_attr(pTHX_ I32 level, PerlIO *file, const char* pat, ...) 6601 __attribute__format__(__printf__,pTHX_3,pTHX_4) 6602 __attribute__nonnull__(pTHX_2) 6603 __attribute__nonnull__(pTHX_3); 6604 #define PERL_ARGS_ASSERT_XMLDUMP_ATTR \ 6605 assert(file); assert(pat) 6606 6607 #endif 6608 PERL_CALLCONV void Perl_xmldump_indent(pTHX_ I32 level, PerlIO *file, const char* pat, ...) 6609 __attribute__format__(__printf__,pTHX_3,pTHX_4) 6610 __attribute__nonnull__(pTHX_2) 6611 __attribute__nonnull__(pTHX_3); 6612 #define PERL_ARGS_ASSERT_XMLDUMP_INDENT \ 6613 assert(file); assert(pat) 6614 6615 PERL_CALLCONV void Perl_xmldump_vindent(pTHX_ I32 level, PerlIO *file, const char* pat, va_list *args) 6616 __attribute__nonnull__(pTHX_2) 6617 __attribute__nonnull__(pTHX_3); 6618 #define PERL_ARGS_ASSERT_XMLDUMP_VINDENT \ 6619 assert(file); assert(pat) 6620 6621 PERL_CALLCONV void Perl_xmldump_all(pTHX); 6622 PERL_CALLCONV void Perl_xmldump_all_perl(pTHX_ bool justperl); 6623 PERL_CALLCONV void Perl_xmldump_packsubs(pTHX_ const HV* stash) 6624 __attribute__nonnull__(pTHX_1); 6625 #define PERL_ARGS_ASSERT_XMLDUMP_PACKSUBS \ 6626 assert(stash) 6627 6628 PERL_CALLCONV void Perl_xmldump_packsubs_perl(pTHX_ const HV* stash, bool justperl) 6629 __attribute__nonnull__(pTHX_1); 6630 #define PERL_ARGS_ASSERT_XMLDUMP_PACKSUBS_PERL \ 6631 assert(stash) 6632 6633 PERL_CALLCONV void Perl_xmldump_sub(pTHX_ const GV* gv) 6634 __attribute__nonnull__(pTHX_1); 6635 #define PERL_ARGS_ASSERT_XMLDUMP_SUB \ 6636 assert(gv) 6637 6638 PERL_CALLCONV void Perl_xmldump_sub_perl(pTHX_ const GV* gv, bool justperl) 6639 __attribute__nonnull__(pTHX_1); 6640 #define PERL_ARGS_ASSERT_XMLDUMP_SUB_PERL \ 6641 assert(gv) 6642 6643 PERL_CALLCONV void Perl_xmldump_form(pTHX_ const GV* gv) 6644 __attribute__nonnull__(pTHX_1); 6645 #define PERL_ARGS_ASSERT_XMLDUMP_FORM \ 6646 assert(gv) 6647 6648 PERL_CALLCONV void Perl_xmldump_eval(pTHX); 6649 PERL_CALLCONV char* Perl_sv_catxmlsv(pTHX_ SV *dsv, SV *ssv) 6650 __attribute__nonnull__(pTHX_1) 6651 __attribute__nonnull__(pTHX_2); 6652 #define PERL_ARGS_ASSERT_SV_CATXMLSV \ 6653 assert(dsv); assert(ssv) 6654 6655 PERL_CALLCONV char* Perl_sv_catxmlpvn(pTHX_ SV *dsv, const char *pv, STRLEN len, int utf8) 6656 __attribute__nonnull__(pTHX_1) 6657 __attribute__nonnull__(pTHX_2); 6658 #define PERL_ARGS_ASSERT_SV_CATXMLPVN \ 6659 assert(dsv); assert(pv) 6660 6661 PERL_CALLCONV char* Perl_sv_xmlpeek(pTHX_ SV* sv) 6662 __attribute__nonnull__(pTHX_1); 6663 #define PERL_ARGS_ASSERT_SV_XMLPEEK \ 6664 assert(sv) 6665 6666 PERL_CALLCONV void Perl_do_pmop_xmldump(pTHX_ I32 level, PerlIO *file, const PMOP *pm) 6667 __attribute__nonnull__(pTHX_2); 6668 #define PERL_ARGS_ASSERT_DO_PMOP_XMLDUMP \ 6669 assert(file) 6670 6671 PERL_CALLCONV void Perl_pmop_xmldump(pTHX_ const PMOP* pm); 6672 PERL_CALLCONV void Perl_do_op_xmldump(pTHX_ I32 level, PerlIO *file, const OP *o) 6673 __attribute__nonnull__(pTHX_2); 6674 #define PERL_ARGS_ASSERT_DO_OP_XMLDUMP \ 6675 assert(file) 6676 6677 PERL_CALLCONV void Perl_op_xmldump(pTHX_ const OP *o) 6678 __attribute__nonnull__(pTHX_1); 6679 #define PERL_ARGS_ASSERT_OP_XMLDUMP \ 6680 assert(o) 6681 6682 6683 PERL_CALLCONV TOKEN* Perl_newTOKEN(pTHX_ I32 optype, YYSTYPE lval, MADPROP* madprop); 6684 PERL_CALLCONV void Perl_token_free(pTHX_ TOKEN *tk) 6685 __attribute__nonnull__(pTHX_1); 6686 #define PERL_ARGS_ASSERT_TOKEN_FREE \ 6687 assert(tk) 6688 6689 PERL_CALLCONV void Perl_token_getmad(pTHX_ TOKEN *tk, OP *o, char slot) 6690 __attribute__nonnull__(pTHX_1); 6691 #define PERL_ARGS_ASSERT_TOKEN_GETMAD \ 6692 assert(tk) 6693 6694 PERL_CALLCONV void Perl_op_getmad_weak(pTHX_ OP* from, OP* o, char slot); 6695 PERL_CALLCONV void Perl_op_getmad(pTHX_ OP* from, OP* o, char slot); 6696 PERL_CALLCONV void Perl_prepend_madprops(pTHX_ MADPROP* mp, OP* o, char slot); 6697 PERL_CALLCONV void Perl_append_madprops(pTHX_ MADPROP* tm, OP* o, char slot); 6698 PERL_CALLCONV void Perl_addmad(pTHX_ MADPROP* tm, MADPROP** root, char slot); 6699 PERL_CALLCONV MADPROP* Perl_newMADsv(pTHX_ char key, SV* sv) 6700 __attribute__nonnull__(pTHX_2); 6701 #define PERL_ARGS_ASSERT_NEWMADSV \ 6702 assert(sv) 6703 6704 PERL_CALLCONV MADPROP* Perl_newMADPROP(pTHX_ char key, char type, void* val, I32 vlen); 6705 PERL_CALLCONV void Perl_mad_free(pTHX_ MADPROP* mp); 6706 6707 # if defined(PERL_IN_TOKE_C) || defined(PERL_DECL_PROT) 6708 STATIC char* S_skipspace0(pTHX_ char *s) 6709 __attribute__nonnull__(pTHX_1); 6710 #define PERL_ARGS_ASSERT_SKIPSPACE0 \ 6711 assert(s) 6712 6713 STATIC char* S_skipspace1(pTHX_ char *s) 6714 __attribute__nonnull__(pTHX_1); 6715 #define PERL_ARGS_ASSERT_SKIPSPACE1 \ 6716 assert(s) 6717 6718 STATIC char* S_skipspace2(pTHX_ char *s, SV **sv) 6719 __attribute__nonnull__(pTHX_1); 6720 #define PERL_ARGS_ASSERT_SKIPSPACE2 \ 6721 assert(s) 6722 6723 STATIC void S_start_force(pTHX_ int where); 6724 STATIC void S_curmad(pTHX_ char slot, SV *sv); 6725 # endif 6726 PERL_CALLCONV int Perl_madlex(pTHX); 6727 PERL_CALLCONV int Perl_madparse(pTHX); 6728 #endif 6729 #if !defined(HAS_SIGNBIT) 6730 PERL_CALLCONV int Perl_signbit(NV f) 6731 __attribute__pure__; 6732 6733 #endif 6734 6735 PERL_CALLCONV void Perl_emulate_cop_io(pTHX_ const COP *const c, SV *const sv) 6736 __attribute__nonnull__(pTHX_1) 6737 __attribute__nonnull__(pTHX_2); 6738 #define PERL_ARGS_ASSERT_EMULATE_COP_IO \ 6739 assert(c); assert(sv) 6740 6741 PERL_CALLCONV REGEXP * Perl_get_re_arg(pTHX_ SV *sv); 6742 6743 PERL_CALLCONV SV* Perl_mro_get_private_data(pTHX_ struct mro_meta *const smeta, const struct mro_alg *const which) 6744 __attribute__nonnull__(pTHX_1) 6745 __attribute__nonnull__(pTHX_2); 6746 #define PERL_ARGS_ASSERT_MRO_GET_PRIVATE_DATA \ 6747 assert(smeta); assert(which) 6748 6749 PERL_CALLCONV SV* Perl_mro_set_private_data(pTHX_ struct mro_meta *const smeta, const struct mro_alg *const which, SV *const data) 6750 __attribute__nonnull__(pTHX_1) 6751 __attribute__nonnull__(pTHX_2) 6752 __attribute__nonnull__(pTHX_3); 6753 #define PERL_ARGS_ASSERT_MRO_SET_PRIVATE_DATA \ 6754 assert(smeta); assert(which); assert(data) 6755 6756 PERL_CALLCONV const struct mro_alg * Perl_mro_get_from_name(pTHX_ SV *name) 6757 __attribute__nonnull__(pTHX_1); 6758 #define PERL_ARGS_ASSERT_MRO_GET_FROM_NAME \ 6759 assert(name) 6760 6761 PERL_CALLCONV void Perl_mro_register(pTHX_ const struct mro_alg *mro) 6762 __attribute__nonnull__(pTHX_1); 6763 #define PERL_ARGS_ASSERT_MRO_REGISTER \ 6764 assert(mro) 6765 6766 PERL_CALLCONV void Perl_mro_set_mro(pTHX_ struct mro_meta *const meta, SV *const name) 6767 __attribute__nonnull__(pTHX_1) 6768 __attribute__nonnull__(pTHX_2); 6769 #define PERL_ARGS_ASSERT_MRO_SET_MRO \ 6770 assert(meta); assert(name) 6771 6772 PERL_CALLCONV struct mro_meta* Perl_mro_meta_init(pTHX_ HV* stash) 6773 __attribute__nonnull__(pTHX_1); 6774 #define PERL_ARGS_ASSERT_MRO_META_INIT \ 6775 assert(stash) 6776 6777 #if defined(USE_ITHREADS) 6778 PERL_CALLCONV struct mro_meta* Perl_mro_meta_dup(pTHX_ struct mro_meta* smeta, CLONE_PARAMS* param) 6779 __attribute__nonnull__(pTHX_1) 6780 __attribute__nonnull__(pTHX_2); 6781 #define PERL_ARGS_ASSERT_MRO_META_DUP \ 6782 assert(smeta); assert(param) 6783 6784 #endif 6785 PERL_CALLCONV AV* Perl_mro_get_linear_isa(pTHX_ HV* stash) 6786 __attribute__nonnull__(pTHX_1); 6787 #define PERL_ARGS_ASSERT_MRO_GET_LINEAR_ISA \ 6788 assert(stash) 6789 6790 #if defined(PERL_IN_MRO_C) || defined(PERL_DECL_PROT) 6791 STATIC AV* S_mro_get_linear_isa_dfs(pTHX_ HV* stash, U32 level) 6792 __attribute__nonnull__(pTHX_1); 6793 #define PERL_ARGS_ASSERT_MRO_GET_LINEAR_ISA_DFS \ 6794 assert(stash) 6795 6796 #endif 6797 PERL_CALLCONV void Perl_mro_isa_changed_in(pTHX_ HV* stash) 6798 __attribute__nonnull__(pTHX_1); 6799 #define PERL_ARGS_ASSERT_MRO_ISA_CHANGED_IN \ 6800 assert(stash) 6801 6802 PERL_CALLCONV void Perl_mro_method_changed_in(pTHX_ HV* stash) 6803 __attribute__nonnull__(pTHX_1); 6804 #define PERL_ARGS_ASSERT_MRO_METHOD_CHANGED_IN \ 6805 assert(stash) 6806 6807 PERL_CALLCONV void Perl_boot_core_mro(pTHX); 6808 PERL_CALLCONV void Perl_sys_init(int* argc, char*** argv) 6809 __attribute__nonnull__(1) 6810 __attribute__nonnull__(2); 6811 #define PERL_ARGS_ASSERT_SYS_INIT \ 6812 assert(argc); assert(argv) 6813 6814 PERL_CALLCONV void Perl_sys_init3(int* argc, char*** argv, char*** env) 6815 __attribute__nonnull__(1) 6816 __attribute__nonnull__(2) 6817 __attribute__nonnull__(3); 6818 #define PERL_ARGS_ASSERT_SYS_INIT3 \ 6819 assert(argc); assert(argv); assert(env) 6820 6821 PERL_CALLCONV void Perl_sys_term(void); 6822 PERL_CALLCONV const char * Perl_fetch_cop_label(pTHX_ struct refcounted_he *const chain, STRLEN *len, U32 *flags); 6823 PERL_CALLCONV struct refcounted_he * Perl_store_cop_label(pTHX_ struct refcounted_he *const chain, const char *label) 6824 __attribute__nonnull__(pTHX_2); 6825 #define PERL_ARGS_ASSERT_STORE_COP_LABEL \ 6826 assert(label) 6827 6828 6829 PERL_CALLCONV int Perl_keyword_plugin_standard(pTHX_ char* keyword_ptr, STRLEN keyword_len, OP** op_ptr) 6830 __attribute__nonnull__(pTHX_1) 6831 __attribute__nonnull__(pTHX_3); 6832 #define PERL_ARGS_ASSERT_KEYWORD_PLUGIN_STANDARD \ 6833 assert(keyword_ptr); assert(op_ptr) 6834 6835 6836 END_EXTERN_C 6837 /* 6838 * ex: set ts=8 sts=4 sw=4 noet: 6839 */ 6840 /* ex: set ro: */ 6841