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