This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
https://perl5.git.perl.org / perl5.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Do better locale collation in UTF-8 locales
[perl5.git] / proto.h
diff --git a/proto.h b/proto.h
index 232086d..fabb4e0 100644 (file)
--- a/proto.h
+++ b/proto.h
@@ -17,18 +17,22 @@
  */
 
 START_EXTERN_C
+#ifndef NO_MATHOMS
 PERL_CALLCONV UV       ASCII_TO_NEED(const UV enc, const UV ch)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
+#endif
 
 PERL_CALLCONV int      Perl_Gv_AMupdate(pTHX_ HV* stash, bool destructing);
 #define PERL_ARGS_ASSERT_GV_AMUPDATE   \
        assert(stash)
+#ifndef NO_MATHOMS
 PERL_CALLCONV UV       NATIVE_TO_NEED(const UV enc, const UV ch)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__
                        __attribute__pure__;
+#endif
 
 PERL_CALLCONV const char *     Perl_PerlIO_context_layers(pTHX_ const char *mode);
 PERL_CALLCONV void*    Perl_Slab_Alloc(pTHX_ size_t sz)
@@ -674,9 +678,11 @@ PERL_CALLCONV_NO_RET void  Perl_die_unwind(pTHX_ SV* msv)
 #define PERL_ARGS_ASSERT_DIE_UNWIND    \
        assert(msv)
 
-/* PERL_CALLCONV bool  Perl_do_aexec(pTHX_ SV* really, SV** mark, SV** sp); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV bool     Perl_do_aexec(pTHX_ SV* really, SV** mark, SV** sp);
 #define PERL_ARGS_ASSERT_DO_AEXEC      \
        assert(mark); assert(sp)
+#endif
 PERL_CALLCONV bool     Perl_do_aexec5(pTHX_ SV* really, SV** mark, SV** sp, int fd, int do_report);
 #define PERL_ARGS_ASSERT_DO_AEXEC5     \
        assert(mark); assert(sp)
@@ -714,9 +720,11 @@ PERL_CALLCONV I32  Perl_do_ncmp(pTHX_ SV *const left, SV *const right)
 PERL_CALLCONV void     Perl_do_op_dump(pTHX_ I32 level, PerlIO *file, const OP *o);
 #define PERL_ARGS_ASSERT_DO_OP_DUMP    \
        assert(file)
-/* PERL_CALLCONV bool  Perl_do_open(pTHX_ GV* gv, const char* name, I32 len, int as_raw, int rawmode, int rawperm, PerlIO* supplied_fp); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV bool     Perl_do_open(pTHX_ GV* gv, const char* name, I32 len, int as_raw, int rawmode, int rawperm, PerlIO* supplied_fp);
 #define PERL_ARGS_ASSERT_DO_OPEN       \
        assert(gv); assert(name)
+#endif
 PERL_CALLCONV bool     Perl_do_open6(pTHX_ GV *gv, const char *oname, STRLEN len, PerlIO *supplied_fp, SV **svp, U32 num);
 #define PERL_ARGS_ASSERT_DO_OPEN6      \
        assert(gv); assert(oname)
@@ -961,9 +969,15 @@ PERL_CALLCONV bool Perl_grok_numeric_radix(pTHX_ const char **sp, const char *se
 PERL_CALLCONV UV       Perl_grok_oct(pTHX_ const char* start, STRLEN* len_p, I32* flags, NV *result);
 #define PERL_ARGS_ASSERT_GROK_OCT      \
        assert(start); assert(len_p); assert(flags)
-/* PERL_CALLCONV GV*   Perl_gv_AVadd(pTHX_ GV *gv); */
-/* PERL_CALLCONV GV*   Perl_gv_HVadd(pTHX_ GV *gv); */
-/* PERL_CALLCONV GV*   Perl_gv_IOadd(pTHX_ GV* gv); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV GV*      Perl_gv_AVadd(pTHX_ GV *gv);
+#endif
+#ifndef NO_MATHOMS
+PERL_CALLCONV GV*      Perl_gv_HVadd(pTHX_ GV *gv);
+#endif
+#ifndef NO_MATHOMS
+PERL_CALLCONV GV*      Perl_gv_IOadd(pTHX_ GV* gv);
+#endif
 PERL_CALLCONV GV*      Perl_gv_add_by_type(pTHX_ GV *gv, svtype type);
 /* PERL_CALLCONV GV*   gv_autoload4(pTHX_ HV* stash, const char* name, STRLEN len, I32 method)
                        __attribute__warn_unused_result__; */
@@ -995,9 +1009,11 @@ PERL_CALLCONV void        Perl_gv_dump(pTHX_ GV* gv);
 PERL_CALLCONV void     Perl_gv_efullname(pTHX_ SV* sv, const GV* gv);
 #define PERL_ARGS_ASSERT_GV_EFULLNAME  \
        assert(sv); assert(gv)
-/* PERL_CALLCONV void  Perl_gv_efullname3(pTHX_ SV* sv, const GV* gv, const char* prefix); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV void     Perl_gv_efullname3(pTHX_ SV* sv, const GV* gv, const char* prefix);
 #define PERL_ARGS_ASSERT_GV_EFULLNAME3 \
        assert(sv); assert(gv)
+#endif
 PERL_CALLCONV void     Perl_gv_efullname4(pTHX_ SV* sv, const GV* gv, const char* prefix, bool keepmain);
 #define PERL_ARGS_ASSERT_GV_EFULLNAME4 \
        assert(sv); assert(gv)
@@ -1027,9 +1043,11 @@ PERL_CALLCONV GV*        Perl_gv_fetchmeth_sv(pTHX_ HV* stash, SV* namesv, I32 level, U
 PERL_CALLCONV GV*      Perl_gv_fetchmeth_sv_autoload(pTHX_ HV* stash, SV* namesv, I32 level, U32 flags);
 #define PERL_ARGS_ASSERT_GV_FETCHMETH_SV_AUTOLOAD      \
        assert(namesv)
-/* PERL_CALLCONV GV*   Perl_gv_fetchmethod(pTHX_ HV* stash, const char* name); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV GV*      Perl_gv_fetchmethod(pTHX_ HV* stash, const char* name);
 #define PERL_ARGS_ASSERT_GV_FETCHMETHOD        \
        assert(stash); assert(name)
+#endif
 PERL_CALLCONV GV*      Perl_gv_fetchmethod_autoload(pTHX_ HV* stash, const char* name, I32 autoload);
 #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_AUTOLOAD       \
        assert(stash); assert(name)
@@ -1054,9 +1072,11 @@ PERL_CALLCONV GV*        Perl_gv_fetchsv(pTHX_ SV *name, I32 flags, const svtype sv_typ
 PERL_CALLCONV void     Perl_gv_fullname(pTHX_ SV* sv, const GV* gv);
 #define PERL_ARGS_ASSERT_GV_FULLNAME   \
        assert(sv); assert(gv)
-/* PERL_CALLCONV void  Perl_gv_fullname3(pTHX_ SV* sv, const GV* gv, const char* prefix); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV void     Perl_gv_fullname3(pTHX_ SV* sv, const GV* gv, const char* prefix);
 #define PERL_ARGS_ASSERT_GV_FULLNAME3  \
        assert(sv); assert(gv)
+#endif
 PERL_CALLCONV void     Perl_gv_fullname4(pTHX_ SV* sv, const GV* gv, const char* prefix, bool keepmain);
 #define PERL_ARGS_ASSERT_GV_FULLNAME4  \
        assert(sv); assert(gv)
@@ -1111,12 +1131,16 @@ PERL_CALLCONV HV *      Perl_hv_copy_hints_hv(pTHX_ HV *const ohv)
 PERL_CALLCONV void     Perl_hv_delayfree_ent(pTHX_ HV *hv, HE *entry);
 #define PERL_ARGS_ASSERT_HV_DELAYFREE_ENT      \
        assert(hv)
-/* PERL_CALLCONV SV*   Perl_hv_delete(pTHX_ HV *hv, const char *key, I32 klen, I32 flags); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV SV*      Perl_hv_delete(pTHX_ HV *hv, const char *key, I32 klen, I32 flags);
 #define PERL_ARGS_ASSERT_HV_DELETE     \
        assert(key)
-/* PERL_CALLCONV SV*   Perl_hv_delete_ent(pTHX_ HV *hv, SV *keysv, I32 flags, U32 hash); */
+#endif
+#ifndef NO_MATHOMS
+PERL_CALLCONV SV*      Perl_hv_delete_ent(pTHX_ HV *hv, SV *keysv, I32 flags, U32 hash);
 #define PERL_ARGS_ASSERT_HV_DELETE_ENT \
        assert(keysv)
+#endif
 PERL_CALLCONV HE**     Perl_hv_eiter_p(pTHX_ HV *hv)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_HV_EITER_P    \
@@ -1131,22 +1155,30 @@ PERL_CALLCONV void      Perl_hv_ename_add(pTHX_ HV *hv, const char *name, U32 len, U3
 PERL_CALLCONV void     Perl_hv_ename_delete(pTHX_ HV *hv, const char *name, U32 len, U32 flags);
 #define PERL_ARGS_ASSERT_HV_ENAME_DELETE       \
        assert(hv); assert(name)
-/* PERL_CALLCONV bool  Perl_hv_exists(pTHX_ HV *hv, const char *key, I32 klen)
-                       __attribute__warn_unused_result__; */
+#ifndef NO_MATHOMS
+PERL_CALLCONV bool     Perl_hv_exists(pTHX_ HV *hv, const char *key, I32 klen)
+                       __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_HV_EXISTS     \
        assert(key)
+#endif
 
-/* PERL_CALLCONV bool  Perl_hv_exists_ent(pTHX_ HV *hv, SV *keysv, U32 hash)
-                       __attribute__warn_unused_result__; */
+#ifndef NO_MATHOMS
+PERL_CALLCONV bool     Perl_hv_exists_ent(pTHX_ HV *hv, SV *keysv, U32 hash)
+                       __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_HV_EXISTS_ENT \
        assert(keysv)
+#endif
 
-/* PERL_CALLCONV SV**  Perl_hv_fetch(pTHX_ HV *hv, const char *key, I32 klen, I32 lval); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV SV**     Perl_hv_fetch(pTHX_ HV *hv, const char *key, I32 klen, I32 lval);
 #define PERL_ARGS_ASSERT_HV_FETCH      \
        assert(key)
-/* PERL_CALLCONV HE*   Perl_hv_fetch_ent(pTHX_ HV *hv, SV *keysv, I32 lval, U32 hash); */
+#endif
+#ifndef NO_MATHOMS
+PERL_CALLCONV HE*      Perl_hv_fetch_ent(pTHX_ HV *hv, SV *keysv, I32 lval, U32 hash);
 #define PERL_ARGS_ASSERT_HV_FETCH_ENT  \
        assert(keysv)
+#endif
 PERL_CALLCONV STRLEN   Perl_hv_fill(pTHX_ HV *const hv);
 #define PERL_ARGS_ASSERT_HV_FILL       \
        assert(hv)
@@ -1166,10 +1198,12 @@ PERL_CALLCONV SV*       Perl_hv_iterkeysv(pTHX_ HE* entry)
 #define PERL_ARGS_ASSERT_HV_ITERKEYSV  \
        assert(entry)
 
-/* PERL_CALLCONV HE*   Perl_hv_iternext(pTHX_ HV *hv)
-                       __attribute__warn_unused_result__; */
+#ifndef NO_MATHOMS
+PERL_CALLCONV HE*      Perl_hv_iternext(pTHX_ HV *hv)
+                       __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_HV_ITERNEXT   \
        assert(hv)
+#endif
 
 PERL_CALLCONV HE*      Perl_hv_iternext_flags(pTHX_ HV *hv, I32 flags)
                        __attribute__warn_unused_result__;
@@ -1189,9 +1223,11 @@ PERL_CALLCONV SV*        Perl_hv_iterval(pTHX_ HV *hv, HE *entry)
 PERL_CALLCONV void     Perl_hv_ksplit(pTHX_ HV *hv, IV newmax);
 #define PERL_ARGS_ASSERT_HV_KSPLIT     \
        assert(hv)
-/* PERL_CALLCONV void  Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV void     Perl_hv_magic(pTHX_ HV *hv, GV *gv, int how);
 #define PERL_ARGS_ASSERT_HV_MAGIC      \
        assert(hv)
+#endif
 PERL_CALLCONV void     Perl_hv_name_set(pTHX_ HV *hv, const char *name, U32 len, U32 flags);
 #define PERL_ARGS_ASSERT_HV_NAME_SET   \
        assert(hv)
@@ -1224,9 +1260,15 @@ PERL_CALLCONV SV*        Perl_hv_scalar(pTHX_ HV *hv)
 #define PERL_ARGS_ASSERT_HV_SCALAR     \
        assert(hv)
 
-/* PERL_CALLCONV SV**  Perl_hv_store(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash); */
-/* PERL_CALLCONV HE*   Perl_hv_store_ent(pTHX_ HV *hv, SV *key, SV *val, U32 hash); */
-/* PERL_CALLCONV SV**  Perl_hv_store_flags(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash, int flags); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV SV**     Perl_hv_store(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash);
+#endif
+#ifndef NO_MATHOMS
+PERL_CALLCONV HE*      Perl_hv_store_ent(pTHX_ HV *hv, SV *key, SV *val, U32 hash);
+#endif
+#ifndef NO_MATHOMS
+PERL_CALLCONV SV**     Perl_hv_store_flags(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash, int flags);
+#endif
 /* PERL_CALLCONV void  hv_undef(pTHX_ HV *hv); */
 PERL_CALLCONV void     Perl_hv_undef_flags(pTHX_ HV *hv, U32 flags);
 /* PERL_CALLCONV I32   ibcmp(pTHX_ const char* a, const char* b, I32 len); */
@@ -1244,11 +1286,13 @@ PERL_CALLCONV void      Perl_init_stacks(pTHX);
 PERL_CALLCONV void     Perl_init_tm(pTHX_ struct tm *ptm);
 #define PERL_ARGS_ASSERT_INIT_TM       \
        assert(ptm)
+#ifndef NO_MATHOMS
 PERL_CALLCONV char*    Perl_instr(const char* big, const char* little)
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 #define PERL_ARGS_ASSERT_INSTR \
        assert(big); assert(little)
+#endif
 
 PERL_CALLCONV U32      Perl_intro_my(pTHX);
 PERL_CALLCONV OP*      Perl_invert(pTHX_ OP* cmd)
@@ -1467,9 +1511,11 @@ PERL_CALLCONV STRLEN     Perl_is_utf8_char(const U8 *s)
 #define PERL_ARGS_ASSERT_IS_UTF8_CHAR  \
        assert(s)
 
-/* PERL_CALLCONV STRLEN        Perl_is_utf8_char_buf(const U8 *buf, const U8 *buf_end); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV STRLEN   Perl_is_utf8_char_buf(const U8 *buf, const U8 *buf_end);
 #define PERL_ARGS_ASSERT_IS_UTF8_CHAR_BUF      \
        assert(buf); assert(buf_end)
+#endif
 PERL_CALLCONV bool     Perl_is_utf8_cntrl(pTHX_ const U8 *p)
                        __attribute__deprecated__
                        __attribute__warn_unused_result__;
@@ -1551,9 +1597,11 @@ PERL_CALLCONV bool       Perl_is_utf8_space(pTHX_ const U8 *p)
 PERL_CALLCONV bool     Perl_is_utf8_string(const U8 *s, STRLEN len);
 #define PERL_ARGS_ASSERT_IS_UTF8_STRING        \
        assert(s)
-/* PERL_CALLCONV bool  Perl_is_utf8_string_loc(const U8 *s, STRLEN len, const U8 **ep); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV bool     Perl_is_utf8_string_loc(const U8 *s, STRLEN len, const U8 **ep);
 #define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOC    \
        assert(s)
+#endif
 PERL_CALLCONV bool     Perl_is_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el);
 #define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOCLEN \
        assert(s)
@@ -1914,7 +1962,9 @@ PERL_CALLCONV_NO_RET void Perl_my_failure_exit(pTHX)
 
 PERL_CALLCONV I32      Perl_my_fflush_all(pTHX);
 PERL_CALLCONV Pid_t    Perl_my_fork(void);
-/* PERL_CALLCONV I32   Perl_my_lstat(pTHX); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV I32      Perl_my_lstat(pTHX);
+#endif
 PERL_CALLCONV I32      Perl_my_lstat_flags(pTHX_ const U32 flags);
 PERL_CALLCONV PerlIO*  Perl_my_popen_list(pTHX_ const char* mode, int n, SV ** args);
 #define PERL_ARGS_ASSERT_MY_POPEN_LIST \
@@ -1926,7 +1976,9 @@ PERL_CALLCONV int Perl_my_snprintf(char *buffer, const Size_t len, const char *f
        assert(buffer); assert(format)
 
 PERL_CALLCONV int      Perl_my_socketpair(int family, int type, int protocol, int fd[2]);
-/* PERL_CALLCONV I32   Perl_my_stat(pTHX); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV I32      Perl_my_stat(pTHX);
+#endif
 PERL_CALLCONV I32      Perl_my_stat_flags(pTHX_ const U32 flags);
 PERL_CALLCONV char*    Perl_my_strerror(pTHX_ const int errnum);
 PERL_CALLCONV char *   Perl_my_strftime(pTHX_ const char *fmt, int sec, int min, int hour, int mday, int mon, int year, int wday, int yday, int isdst)
@@ -1954,8 +2006,10 @@ PERL_CALLCONV OP*        Perl_newASSIGNOP(pTHX_ I32 flags, OP* left, I32 optype, OP* ri
 
 /* PERL_CALLCONV CV*   newATTRSUB(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block); */
 PERL_CALLCONV CV*      Perl_newATTRSUB_x(pTHX_ I32 floor, OP *o, OP *proto, OP *attrs, OP *block, bool o_is_gv);
-/* PERL_CALLCONV AV*   Perl_newAV(pTHX)
-                       __attribute__warn_unused_result__; */
+#ifndef NO_MATHOMS
+PERL_CALLCONV AV*      Perl_newAV(pTHX)
+                       __attribute__warn_unused_result__;
+#endif
 
 PERL_CALLCONV OP*      Perl_newAVREF(pTHX_ OP* o)
                        __attribute__malloc__
@@ -2015,8 +2069,10 @@ PERL_CALLCONV GV*        Perl_newGVgen_flags(pTHX_ const char* pack, U32 flags)
 #define PERL_ARGS_ASSERT_NEWGVGEN_FLAGS        \
        assert(pack)
 
-/* PERL_CALLCONV HV*   Perl_newHV(pTHX)
-                       __attribute__warn_unused_result__; */
+#ifndef NO_MATHOMS
+PERL_CALLCONV HV*      Perl_newHV(pTHX)
+                       __attribute__warn_unused_result__;
+#endif
 
 PERL_CALLCONV OP*      Perl_newHVREF(pTHX_ OP* o)
                        __attribute__malloc__
@@ -2028,9 +2084,11 @@ PERL_CALLCONV HV*        Perl_newHVhv(pTHX_ HV *hv)
                        __attribute__malloc__
                        __attribute__warn_unused_result__;
 
-/* PERL_CALLCONV IO*   Perl_newIO(pTHX)
+#ifndef NO_MATHOMS
+PERL_CALLCONV IO*      Perl_newIO(pTHX)
                        __attribute__malloc__
-                       __attribute__warn_unused_result__; */
+                       __attribute__warn_unused_result__;
+#endif
 
 PERL_CALLCONV OP*      Perl_newLISTOP(pTHX_ I32 type, I32 flags, OP* first, OP* last)
                        __attribute__malloc__
@@ -2131,7 +2189,9 @@ PERL_CALLCONV OP* Perl_newSTATEOP(pTHX_ I32 flags, char* label, OP* o)
 PERL_CALLCONV CV*      Perl_newSTUB(pTHX_ GV *gv, bool fake);
 #define PERL_ARGS_ASSERT_NEWSTUB       \
        assert(gv)
-/* PERL_CALLCONV CV*   Perl_newSUB(pTHX_ I32 floor, OP* o, OP* proto, OP* block); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV CV*      Perl_newSUB(pTHX_ I32 floor, OP* o, OP* proto, OP* block);
+#endif
 PERL_CALLCONV SV*      Perl_newSV(pTHX_ const STRLEN len)
                        __attribute__malloc__
                        __attribute__warn_unused_result__;
@@ -2259,11 +2319,6 @@ PERL_CALLCONV STRLEN *   Perl_new_warnings_bitfield(pTHX_ STRLEN *buffer, const ch
 PERL_CALLCONV PerlIO*  Perl_nextargv(pTHX_ GV* gv, bool nomagicopen);
 #define PERL_ARGS_ASSERT_NEXTARGV      \
        assert(gv)
-PERL_CALLCONV char*    Perl_ninstr(const char* big, const char* bigend, const char* little, const char* lend)
-                       __attribute__pure__;
-#define PERL_ARGS_ASSERT_NINSTR        \
-       assert(big); assert(bigend); assert(little); assert(lend)
-
 PERL_CALLCONV_NO_RET void      Perl_noperl_die(const char* pat, ...)
                        __attribute__noreturn__
                        __attribute__format__(__printf__,1,2);
@@ -2339,8 +2394,10 @@ PERL_CALLCONV void       Perl_pad_add_weakref(pTHX_ CV* func);
        assert(func)
 PERL_CALLCONV PADOFFSET        Perl_pad_alloc(pTHX_ I32 optype, U32 tmptype);
 PERL_CALLCONV void     Perl_pad_block_start(pTHX_ int full);
+#ifndef NO_MATHOMS
 PERL_CALLCONV HV*      Perl_pad_compname_type(pTHX_ const PADOFFSET po)
                        __attribute__warn_unused_result__;
+#endif
 
 PERL_CALLCONV PADOFFSET        Perl_pad_findmy_pv(pTHX_ const char* name, U32 flags);
 #define PERL_ARGS_ASSERT_PAD_FINDMY_PV \
@@ -2495,7 +2552,9 @@ PERL_CALLCONV void*       Perl_reentrant_retry(const char *f, ...);
 #define PERL_ARGS_ASSERT_REENTRANT_RETRY       \
        assert(f)
 PERL_CALLCONV void     Perl_reentrant_size(pTHX);
-/* PERL_CALLCONV OP*   Perl_ref(pTHX_ OP* o, I32 type); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV OP*      Perl_ref(pTHX_ OP* o, I32 type);
+#endif
 PERL_CALLCONV HV *     Perl_refcounted_he_chain_2hv(pTHX_ const struct refcounted_he *c, U32 flags);
 PERL_CALLCONV SV *     Perl_refcounted_he_fetch_pv(pTHX_ const struct refcounted_he *chain, const char *key, U32 hash, U32 flags);
 #define PERL_ARGS_ASSERT_REFCOUNTED_HE_FETCH_PV        \
@@ -2650,9 +2709,15 @@ PERL_CALLCONV void       Perl_save_destructor(pTHX_ DESTRUCTORFUNC_NOCONTEXT_t f, void
 #define PERL_ARGS_ASSERT_SAVE_DESTRUCTOR       \
        assert(p)
 PERL_CALLCONV void     Perl_save_destructor_x(pTHX_ DESTRUCTORFUNC_t f, void* p);
-/* PERL_CALLCONV void  Perl_save_freeop(pTHX_ OP* o); */
-/* PERL_CALLCONV void  Perl_save_freepv(pTHX_ char* pv); */
-/* PERL_CALLCONV void  Perl_save_freesv(pTHX_ SV* sv); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV void     Perl_save_freeop(pTHX_ OP* o);
+#endif
+#ifndef NO_MATHOMS
+PERL_CALLCONV void     Perl_save_freepv(pTHX_ char* pv);
+#endif
+#ifndef NO_MATHOMS
+PERL_CALLCONV void     Perl_save_freesv(pTHX_ SV* sv);
+#endif
 PERL_CALLCONV void     Perl_save_generic_pvref(pTHX_ char** str);
 #define PERL_ARGS_ASSERT_SAVE_GENERIC_PVREF    \
        assert(str)
@@ -2691,13 +2756,17 @@ PERL_CALLCONV void      Perl_save_list(pTHX_ SV** sarg, I32 maxsarg);
 PERL_CALLCONV void     Perl_save_long(pTHX_ long* longp);
 #define PERL_ARGS_ASSERT_SAVE_LONG     \
        assert(longp)
-/* PERL_CALLCONV void  Perl_save_mortalizesv(pTHX_ SV* sv); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV void     Perl_save_mortalizesv(pTHX_ SV* sv);
 #define PERL_ARGS_ASSERT_SAVE_MORTALIZESV      \
        assert(sv)
+#endif
 PERL_CALLCONV void     Perl_save_nogv(pTHX_ GV* gv);
 #define PERL_ARGS_ASSERT_SAVE_NOGV     \
        assert(gv)
-/* PERL_CALLCONV void  Perl_save_op(pTHX); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV void     Perl_save_op(pTHX);
+#endif
 PERL_CALLCONV void     Perl_save_padsv_and_mortalize(pTHX_ PADOFFSET off);
 PERL_CALLCONV void     Perl_save_pptr(pTHX_ char** pptr);
 #define PERL_ARGS_ASSERT_SAVE_PPTR     \
@@ -2826,9 +2895,11 @@ PERL_CALLCONV CV*        Perl_sv_2cv(pTHX_ SV* sv, HV **const st, GV **const gvp, const
 PERL_CALLCONV IO*      Perl_sv_2io(pTHX_ SV *const sv);
 #define PERL_ARGS_ASSERT_SV_2IO        \
        assert(sv)
-/* PERL_CALLCONV IV    Perl_sv_2iv(pTHX_ SV *sv); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV IV       Perl_sv_2iv(pTHX_ SV *sv);
 #define PERL_ARGS_ASSERT_SV_2IV        \
        assert(sv)
+#endif
 PERL_CALLCONV IV       Perl_sv_2iv_flags(pTHX_ SV *const sv, const I32 flags);
 #define PERL_ARGS_ASSERT_SV_2IV_FLAGS  \
        assert(sv)
@@ -2839,36 +2910,46 @@ PERL_CALLCONV SV*       Perl_sv_2num(pTHX_ SV *const sv);
 PERL_CALLCONV NV       Perl_sv_2nv_flags(pTHX_ SV *const sv, const I32 flags);
 #define PERL_ARGS_ASSERT_SV_2NV_FLAGS  \
        assert(sv)
-/* PERL_CALLCONV char* Perl_sv_2pv(pTHX_ SV *sv, STRLEN *lp); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV char*    Perl_sv_2pv(pTHX_ SV *sv, STRLEN *lp);
 #define PERL_ARGS_ASSERT_SV_2PV        \
        assert(sv)
+#endif
 PERL_CALLCONV char*    Perl_sv_2pv_flags(pTHX_ SV *const sv, STRLEN *const lp, const I32 flags);
 #define PERL_ARGS_ASSERT_SV_2PV_FLAGS  \
        assert(sv)
-/* PERL_CALLCONV char* Perl_sv_2pv_nolen(pTHX_ SV* sv)
-                       __attribute__warn_unused_result__; */
+#ifndef NO_MATHOMS
+PERL_CALLCONV char*    Perl_sv_2pv_nolen(pTHX_ SV* sv)
+                       __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_SV_2PV_NOLEN  \
        assert(sv)
+#endif
 
 PERL_CALLCONV char*    Perl_sv_2pvbyte(pTHX_ SV *sv, STRLEN *const lp);
 #define PERL_ARGS_ASSERT_SV_2PVBYTE    \
        assert(sv)
-/* PERL_CALLCONV char* Perl_sv_2pvbyte_nolen(pTHX_ SV* sv)
-                       __attribute__warn_unused_result__; */
+#ifndef NO_MATHOMS
+PERL_CALLCONV char*    Perl_sv_2pvbyte_nolen(pTHX_ SV* sv)
+                       __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_SV_2PVBYTE_NOLEN      \
        assert(sv)
+#endif
 
 PERL_CALLCONV char*    Perl_sv_2pvutf8(pTHX_ SV *sv, STRLEN *const lp);
 #define PERL_ARGS_ASSERT_SV_2PVUTF8    \
        assert(sv)
-/* PERL_CALLCONV char* Perl_sv_2pvutf8_nolen(pTHX_ SV* sv)
-                       __attribute__warn_unused_result__; */
+#ifndef NO_MATHOMS
+PERL_CALLCONV char*    Perl_sv_2pvutf8_nolen(pTHX_ SV* sv)
+                       __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_SV_2PVUTF8_NOLEN      \
        assert(sv)
+#endif
 
-/* PERL_CALLCONV UV    Perl_sv_2uv(pTHX_ SV *sv); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV UV       Perl_sv_2uv(pTHX_ SV *sv);
 #define PERL_ARGS_ASSERT_SV_2UV        \
        assert(sv)
+#endif
 PERL_CALLCONV UV       Perl_sv_2uv_flags(pTHX_ SV *const sv, const I32 flags);
 #define PERL_ARGS_ASSERT_SV_2UV_FLAGS  \
        assert(sv)
@@ -2900,24 +2981,32 @@ PERL_CALLCONV void      Perl_sv_catpvf_mg(pTHX_ SV *const sv, const char *const pat,
 #define PERL_ARGS_ASSERT_SV_CATPVF_MG  \
        assert(sv); assert(pat)
 
-/* PERL_CALLCONV void  Perl_sv_catpvn(pTHX_ SV *dsv, const char *sstr, STRLEN len); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV void     Perl_sv_catpvn(pTHX_ SV *dsv, const char *sstr, STRLEN len);
 #define PERL_ARGS_ASSERT_SV_CATPVN     \
        assert(dsv); assert(sstr)
+#endif
 PERL_CALLCONV void     Perl_sv_catpvn_flags(pTHX_ SV *const dstr, const char *sstr, const STRLEN len, const I32 flags);
 #define PERL_ARGS_ASSERT_SV_CATPVN_FLAGS       \
        assert(dstr); assert(sstr)
-/* PERL_CALLCONV void  Perl_sv_catpvn_mg(pTHX_ SV *sv, const char *ptr, STRLEN len); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV void     Perl_sv_catpvn_mg(pTHX_ SV *sv, const char *ptr, STRLEN len);
 #define PERL_ARGS_ASSERT_SV_CATPVN_MG  \
        assert(sv); assert(ptr)
-/* PERL_CALLCONV void  Perl_sv_catsv(pTHX_ SV *dstr, SV *sstr); */
+#endif
+#ifndef NO_MATHOMS
+PERL_CALLCONV void     Perl_sv_catsv(pTHX_ SV *dstr, SV *sstr);
 #define PERL_ARGS_ASSERT_SV_CATSV      \
        assert(dstr)
+#endif
 PERL_CALLCONV void     Perl_sv_catsv_flags(pTHX_ SV *const dsv, SV *const ssv, const I32 flags);
 #define PERL_ARGS_ASSERT_SV_CATSV_FLAGS        \
        assert(dsv)
-/* PERL_CALLCONV void  Perl_sv_catsv_mg(pTHX_ SV *dsv, SV *ssv); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV void     Perl_sv_catsv_mg(pTHX_ SV *dsv, SV *ssv);
 #define PERL_ARGS_ASSERT_SV_CATSV_MG   \
        assert(dsv)
+#endif
 PERL_CALLCONV void     Perl_sv_chop(pTHX_ SV *const sv, const char *const ptr);
 #define PERL_ARGS_ASSERT_SV_CHOP       \
        assert(sv)
@@ -2930,9 +3019,11 @@ PERL_CALLCONV I32        Perl_sv_cmp(pTHX_ SV *const sv1, SV *const sv2);
 PERL_CALLCONV I32      Perl_sv_cmp_flags(pTHX_ SV *const sv1, SV *const sv2, const U32 flags);
 PERL_CALLCONV I32      Perl_sv_cmp_locale(pTHX_ SV *const sv1, SV *const sv2);
 PERL_CALLCONV I32      Perl_sv_cmp_locale_flags(pTHX_ SV *const sv1, SV *const sv2, const U32 flags);
-/* PERL_CALLCONV void  Perl_sv_copypv(pTHX_ SV *const dsv, SV *const ssv); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV void     Perl_sv_copypv(pTHX_ SV *const dsv, SV *const ssv);
 #define PERL_ARGS_ASSERT_SV_COPYPV     \
        assert(dsv); assert(ssv)
+#endif
 PERL_CALLCONV void     Perl_sv_copypv_flags(pTHX_ SV *const dsv, SV *const ssv, const I32 flags);
 #define PERL_ARGS_ASSERT_SV_COPYPV_FLAGS       \
        assert(dsv); assert(ssv)
@@ -2988,9 +3079,11 @@ PERL_CALLCONV void       Perl_sv_dump(pTHX_ SV* sv);
        assert(sv)
 /* PERL_CALLCONV I32   sv_eq(pTHX_ SV* sv1, SV* sv2); */
 PERL_CALLCONV I32      Perl_sv_eq_flags(pTHX_ SV* sv1, SV* sv2, const U32 flags);
-/* PERL_CALLCONV void  Perl_sv_force_normal(pTHX_ SV *sv); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV void     Perl_sv_force_normal(pTHX_ SV *sv);
 #define PERL_ARGS_ASSERT_SV_FORCE_NORMAL       \
        assert(sv)
+#endif
 PERL_CALLCONV void     Perl_sv_force_normal_flags(pTHX_ SV *const sv, const U32 flags);
 #define PERL_ARGS_ASSERT_SV_FORCE_NORMAL_FLAGS \
        assert(sv)
@@ -3012,9 +3105,11 @@ PERL_CALLCONV char*      Perl_sv_grow(pTHX_ SV *const sv, STRLEN newlen);
        assert(sv)
 PERL_CALLCONV void     Perl_sv_inc(pTHX_ SV *const sv);
 PERL_CALLCONV void     Perl_sv_inc_nomg(pTHX_ SV *const sv);
-/* PERL_CALLCONV void  Perl_sv_insert(pTHX_ SV *const bigstr, const STRLEN offset, const STRLEN len, const char *const little, const STRLEN littlelen); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV void     Perl_sv_insert(pTHX_ SV *const bigstr, const STRLEN offset, const STRLEN len, const char *const little, const STRLEN littlelen);
 #define PERL_ARGS_ASSERT_SV_INSERT     \
        assert(bigstr); assert(little)
+#endif
 PERL_CALLCONV void     Perl_sv_insert_flags(pTHX_ SV *const bigstr, const STRLEN offset, const STRLEN len, const char *const little, const STRLEN littlelen, const U32 flags);
 #define PERL_ARGS_ASSERT_SV_INSERT_FLAGS       \
        assert(bigstr); assert(little)
@@ -3039,9 +3134,11 @@ PERL_CALLCONV MAGIC *    Perl_sv_magicext(pTHX_ SV *const sv, SV *const obj, const
 PERL_CALLCONV MAGIC *  Perl_sv_magicext_mglob(pTHX_ SV *sv);
 #define PERL_ARGS_ASSERT_SV_MAGICEXT_MGLOB     \
        assert(sv)
-/* PERL_CALLCONV SV*   Perl_sv_mortalcopy(pTHX_ SV *const oldsv)
+#ifndef NO_MATHOMS
+PERL_CALLCONV SV*      Perl_sv_mortalcopy(pTHX_ SV *const oldsv)
                        __attribute__malloc__
-                       __attribute__warn_unused_result__; */
+                       __attribute__warn_unused_result__;
+#endif
 
 PERL_CALLCONV SV*      Perl_sv_mortalcopy_flags(pTHX_ SV *const oldsv, U32 flags)
                        __attribute__malloc__
@@ -3051,8 +3148,13 @@ PERL_CALLCONV SV*        Perl_sv_newmortal(pTHX)
                        __attribute__warn_unused_result__;
 
 PERL_CALLCONV SV*      Perl_sv_newref(pTHX_ SV *const sv);
-/* PERL_CALLCONV void  Perl_sv_nolocking(pTHX_ SV *sv); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV void     Perl_sv_nolocking(pTHX_ SV *sv);
+#endif
 PERL_CALLCONV void     Perl_sv_nosharing(pTHX_ SV *sv);
+#ifndef NO_MATHOMS
+PERL_CALLCONV void     Perl_sv_nounlocking(pTHX_ SV *sv);
+#endif
 PERL_CALLCONV NV       Perl_sv_nv(pTHX_ SV* sv);
 #define PERL_ARGS_ASSERT_SV_NV \
        assert(sv)
@@ -3069,15 +3171,19 @@ PERL_CALLCONV void      Perl_sv_pos_u2b(pTHX_ SV *const sv, I32 *const offsetp, I32 *
 PERL_CALLCONV STRLEN   Perl_sv_pos_u2b_flags(pTHX_ SV *const sv, STRLEN uoffset, STRLEN *const lenp, U32 flags);
 #define PERL_ARGS_ASSERT_SV_POS_U2B_FLAGS      \
        assert(sv)
-/* PERL_CALLCONV char* Perl_sv_pv(pTHX_ SV *sv)
-                       __attribute__warn_unused_result__; */
+#ifndef NO_MATHOMS
+PERL_CALLCONV char*    Perl_sv_pv(pTHX_ SV *sv)
+                       __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_SV_PV \
        assert(sv)
+#endif
 
-/* PERL_CALLCONV char* Perl_sv_pvbyte(pTHX_ SV *sv)
-                       __attribute__warn_unused_result__; */
+#ifndef NO_MATHOMS
+PERL_CALLCONV char*    Perl_sv_pvbyte(pTHX_ SV *sv)
+                       __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_SV_PVBYTE     \
        assert(sv)
+#endif
 
 PERL_CALLCONV char*    Perl_sv_pvbyten(pTHX_ SV *sv, STRLEN *lp);
 #define PERL_ARGS_ASSERT_SV_PVBYTEN    \
@@ -3088,19 +3194,23 @@ PERL_CALLCONV char*     Perl_sv_pvbyten_force(pTHX_ SV *const sv, STRLEN *const lp);
 PERL_CALLCONV char*    Perl_sv_pvn(pTHX_ SV *sv, STRLEN *lp);
 #define PERL_ARGS_ASSERT_SV_PVN        \
        assert(sv); assert(lp)
-/* PERL_CALLCONV char* Perl_sv_pvn_force(pTHX_ SV* sv, STRLEN* lp); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV char*    Perl_sv_pvn_force(pTHX_ SV* sv, STRLEN* lp);
 #define PERL_ARGS_ASSERT_SV_PVN_FORCE  \
        assert(sv)
+#endif
 PERL_CALLCONV char*    Perl_sv_pvn_force_flags(pTHX_ SV *const sv, STRLEN *const lp, const I32 flags);
 #define PERL_ARGS_ASSERT_SV_PVN_FORCE_FLAGS    \
        assert(sv)
 PERL_CALLCONV char*    Perl_sv_pvn_nomg(pTHX_ SV* sv, STRLEN* lp);
 #define PERL_ARGS_ASSERT_SV_PVN_NOMG   \
        assert(sv)
-/* PERL_CALLCONV char* Perl_sv_pvutf8(pTHX_ SV *sv)
-                       __attribute__warn_unused_result__; */
+#ifndef NO_MATHOMS
+PERL_CALLCONV char*    Perl_sv_pvutf8(pTHX_ SV *sv)
+                       __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_SV_PVUTF8     \
        assert(sv)
+#endif
 
 PERL_CALLCONV char*    Perl_sv_pvutf8n(pTHX_ SV *sv, STRLEN *lp);
 #define PERL_ARGS_ASSERT_SV_PVUTF8N    \
@@ -3161,12 +3271,16 @@ PERL_CALLCONV void      Perl_sv_setpvf_mg(pTHX_ SV *const sv, const char *const pat,
 #define PERL_ARGS_ASSERT_SV_SETPVF_MG  \
        assert(sv); assert(pat)
 
+#ifndef NO_MATHOMS
 PERL_CALLCONV void     Perl_sv_setpviv(pTHX_ SV *const sv, const IV num);
 #define PERL_ARGS_ASSERT_SV_SETPVIV    \
        assert(sv)
+#endif
+#ifndef NO_MATHOMS
 PERL_CALLCONV void     Perl_sv_setpviv_mg(pTHX_ SV *const sv, const IV iv);
 #define PERL_ARGS_ASSERT_SV_SETPVIV_MG \
        assert(sv)
+#endif
 PERL_CALLCONV void     Perl_sv_setpvn(pTHX_ SV *const sv, const char *const ptr, const STRLEN len);
 #define PERL_ARGS_ASSERT_SV_SETPVN     \
        assert(sv)
@@ -3188,9 +3302,11 @@ PERL_CALLCONV SV*        Perl_sv_setref_pvn(pTHX_ SV *const rv, const char *const class
 PERL_CALLCONV SV*      Perl_sv_setref_uv(pTHX_ SV *const rv, const char *const classname, const UV uv);
 #define PERL_ARGS_ASSERT_SV_SETREF_UV  \
        assert(rv)
-/* PERL_CALLCONV void  Perl_sv_setsv(pTHX_ SV *dstr, SV *sstr); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV void     Perl_sv_setsv(pTHX_ SV *dstr, SV *sstr);
 #define PERL_ARGS_ASSERT_SV_SETSV      \
        assert(dstr)
+#endif
 PERL_CALLCONV void     Perl_sv_setsv_flags(pTHX_ SV *dstr, SV *sstr, const I32 flags);
 #define PERL_ARGS_ASSERT_SV_SETSV_FLAGS        \
        assert(dstr)
@@ -3203,9 +3319,11 @@ PERL_CALLCONV void       Perl_sv_setuv(pTHX_ SV *const sv, const UV num);
 PERL_CALLCONV void     Perl_sv_setuv_mg(pTHX_ SV *const sv, const UV u);
 #define PERL_ARGS_ASSERT_SV_SETUV_MG   \
        assert(sv)
-/* PERL_CALLCONV void  Perl_sv_taint(pTHX_ SV* sv); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV void     Perl_sv_taint(pTHX_ SV* sv);
 #define PERL_ARGS_ASSERT_SV_TAINT      \
        assert(sv)
+#endif
 PERL_CALLCONV bool     Perl_sv_tainted(pTHX_ SV *const sv)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_SV_TAINTED    \
@@ -3223,9 +3341,11 @@ PERL_CALLCONV int        Perl_sv_unmagic(pTHX_ SV *const sv, const int type);
 PERL_CALLCONV int      Perl_sv_unmagicext(pTHX_ SV *const sv, const int type, MGVTBL *vtbl);
 #define PERL_ARGS_ASSERT_SV_UNMAGICEXT \
        assert(sv)
-/* PERL_CALLCONV void  Perl_sv_unref(pTHX_ SV* sv); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV void     Perl_sv_unref(pTHX_ SV* sv);
 #define PERL_ARGS_ASSERT_SV_UNREF      \
        assert(sv)
+#endif
 PERL_CALLCONV void     Perl_sv_unref_flags(pTHX_ SV *const ref, const U32 flags);
 #define PERL_ARGS_ASSERT_SV_UNREF_FLAGS        \
        assert(ref)
@@ -3235,15 +3355,19 @@ PERL_CALLCONV void      Perl_sv_untaint(pTHX_ SV *const sv);
 PERL_CALLCONV void     Perl_sv_upgrade(pTHX_ SV *const sv, svtype new_type);
 #define PERL_ARGS_ASSERT_SV_UPGRADE    \
        assert(sv)
-/* PERL_CALLCONV void  Perl_sv_usepvn(pTHX_ SV* sv, char* ptr, STRLEN len); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV void     Perl_sv_usepvn(pTHX_ SV* sv, char* ptr, STRLEN len);
 #define PERL_ARGS_ASSERT_SV_USEPVN     \
        assert(sv)
+#endif
 PERL_CALLCONV void     Perl_sv_usepvn_flags(pTHX_ SV *const sv, char* ptr, const STRLEN len, const U32 flags);
 #define PERL_ARGS_ASSERT_SV_USEPVN_FLAGS       \
        assert(sv)
-/* PERL_CALLCONV void  Perl_sv_usepvn_mg(pTHX_ SV *sv, char *ptr, STRLEN len); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV void     Perl_sv_usepvn_mg(pTHX_ SV *sv, char *ptr, STRLEN len);
 #define PERL_ARGS_ASSERT_SV_USEPVN_MG  \
        assert(sv)
+#endif
 PERL_CALLCONV bool     Perl_sv_utf8_decode(pTHX_ SV *const sv);
 #define PERL_ARGS_ASSERT_SV_UTF8_DECODE        \
        assert(sv)
@@ -3253,9 +3377,11 @@ PERL_CALLCONV bool       Perl_sv_utf8_downgrade(pTHX_ SV *const sv, const bool fail_ok
 PERL_CALLCONV void     Perl_sv_utf8_encode(pTHX_ SV *const sv);
 #define PERL_ARGS_ASSERT_SV_UTF8_ENCODE        \
        assert(sv)
-/* PERL_CALLCONV STRLEN        Perl_sv_utf8_upgrade(pTHX_ SV *sv); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV STRLEN   Perl_sv_utf8_upgrade(pTHX_ SV *sv);
 #define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE       \
        assert(sv)
+#endif
 /* PERL_CALLCONV STRLEN        Perl_sv_utf8_upgrade_flags(pTHX_ SV *const sv, const I32 flags); */
 PERL_CALLCONV STRLEN   Perl_sv_utf8_upgrade_flags_grow(pTHX_ SV *const sv, const I32 flags, STRLEN extra);
 #define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE_FLAGS_GROW    \
@@ -3339,18 +3465,26 @@ PERL_CALLCONV UV        Perl_to_utf8_case(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp, S
 #define PERL_ARGS_ASSERT_TO_UTF8_CASE  \
        assert(p); assert(ustrp); assert(swashp); assert(normal)
 
-/* PERL_CALLCONV UV    Perl_to_utf8_fold(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV UV       Perl_to_utf8_fold(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp);
 #define PERL_ARGS_ASSERT_TO_UTF8_FOLD  \
        assert(p); assert(ustrp)
-/* PERL_CALLCONV UV    Perl_to_utf8_lower(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp); */
+#endif
+#ifndef NO_MATHOMS
+PERL_CALLCONV UV       Perl_to_utf8_lower(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp);
 #define PERL_ARGS_ASSERT_TO_UTF8_LOWER \
        assert(p); assert(ustrp)
-/* PERL_CALLCONV UV    Perl_to_utf8_title(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp); */
+#endif
+#ifndef NO_MATHOMS
+PERL_CALLCONV UV       Perl_to_utf8_title(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp);
 #define PERL_ARGS_ASSERT_TO_UTF8_TITLE \
        assert(p); assert(ustrp)
-/* PERL_CALLCONV UV    Perl_to_utf8_upper(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp); */
+#endif
+#ifndef NO_MATHOMS
+PERL_CALLCONV UV       Perl_to_utf8_upper(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp);
 #define PERL_ARGS_ASSERT_TO_UTF8_UPPER \
        assert(p); assert(ustrp)
+#endif
 PERL_CALLCONV bool     Perl_try_amagic_bin(pTHX_ int method, int flags);
 PERL_CALLCONV bool     Perl_try_amagic_un(pTHX_ int method, int flags);
 PERL_CALLCONV I32      Perl_unpack_str(pTHX_ const char *pat, const char *patend, const char *s, const char *strbeg, const char *strend, char **new_s, I32 ocnt, U32 flags);
@@ -3376,7 +3510,7 @@ PERL_CALLCONV IV  Perl_utf8_distance(pTHX_ const U8 *a, const U8 *b)
 #define PERL_ARGS_ASSERT_UTF8_DISTANCE \
        assert(a); assert(b)
 
-PERL_CALLCONV U8*      Perl_utf8_hop(const U8 *s, I32 off)
+PERL_CALLCONV U8*      Perl_utf8_hop(const U8 *s, SSize_t off)
                        __attribute__warn_unused_result__
                        __attribute__pure__;
 #define PERL_ARGS_ASSERT_UTF8_HOP      \
@@ -3551,13 +3685,17 @@ STATIC int      S_sv_2iuv_non_preserve(pTHX_ SV *const sv);
 #    endif
 #  endif
 #endif
+#if !(defined(HAS_MEMMEM))
+PERL_CALLCONV char*    Perl_ninstr(const char* big, const char* bigend, const char* little, const char* lend)
+                       __attribute__pure__;
+#define PERL_ARGS_ASSERT_NINSTR        \
+       assert(big); assert(bigend); assert(little); assert(lend)
+
+#endif
 #if !(defined(HAS_SIGACTION) && defined(SA_SIGINFO))
 PERL_CALLCONV Signal_t Perl_csighandler(int sig);
 PERL_CALLCONV Signal_t Perl_sighandler(int sig);
 #endif
-#if !(defined(NO_MATHOMS))
-PERL_CALLCONV void     Perl_sv_nounlocking(pTHX_ SV *sv);
-#endif
 #if !(defined(PERL_DEFAULT_DO_EXEC3_IMPLEMENTATION))
 PERL_CALLCONV bool     Perl_do_exec(pTHX_ const char* cmd);
 #define PERL_ARGS_ASSERT_DO_EXEC       \
@@ -3583,9 +3721,9 @@ PERL_CALLCONV_NO_RET int  Perl_magic_regdatum_set(pTHX_ SV* sv, MAGIC* mg)
 
 #endif
 #if !defined(HAS_BZERO) && !defined(HAS_MEMSET)
-PERL_CALLCONV char*    Perl_my_bzero(char* loc, I32 len);
+PERL_CALLCONV void*    Perl_my_bzero(void* vloc, size_t len);
 #define PERL_ARGS_ASSERT_MY_BZERO      \
-       assert(loc)
+       assert(vloc)
 #endif
 #if !defined(HAS_GETENV_LEN)
 PERL_CALLCONV char*    Perl_getenv_len(pTHX_ const char *env_elem, unsigned long *len);
@@ -3593,16 +3731,21 @@ PERL_CALLCONV char*     Perl_getenv_len(pTHX_ const char *env_elem, unsigned long *l
        assert(env_elem); assert(len)
 #endif
 #if !defined(HAS_MEMCMP) || !defined(HAS_SANE_MEMCMP)
-PERL_CALLCONV I32      Perl_my_memcmp(const char* s1, const char* s2, I32 len)
+PERL_CALLCONV int      Perl_my_memcmp(const void* vs1, const void* vs2, size_t len)
                        __attribute__pure__;
 #define PERL_ARGS_ASSERT_MY_MEMCMP     \
-       assert(s1); assert(s2)
+       assert(vs1); assert(vs2)
 
 #endif
+#if !defined(HAS_MEMCPY) || (!defined(HAS_MEMMOVE) && !defined(HAS_SAFE_MEMCPY))
+PERL_CALLCONV void*    Perl_my_bcopy(const void* vfrom, void* vto, size_t len);
+#define PERL_ARGS_ASSERT_MY_BCOPY      \
+       assert(vfrom); assert(vto)
+#endif
 #if !defined(HAS_MEMSET)
-PERL_CALLCONV void*    Perl_my_memset(char* loc, I32 ch, I32 len);
+PERL_CALLCONV void*    Perl_my_memset(void* vloc, int ch, size_t len);
 #define PERL_ARGS_ASSERT_MY_MEMSET     \
-       assert(loc)
+       assert(vloc)
 #endif
 #if !defined(HAS_MKDIR) || !defined(HAS_RMDIR)
 #  if defined(PERL_IN_PP_SYS_C)
@@ -3659,15 +3802,21 @@ PERL_STATIC_INLINE IV*  S_get_invlist_previous_index_addr(SV* invlist)
 #define PERL_ARGS_ASSERT_GET_INVLIST_PREVIOUS_INDEX_ADDR       \
        assert(invlist)
 
+PERL_STATIC_INLINE void        S_invlist_clear(pTHX_ SV* invlist);
+#define PERL_ARGS_ASSERT_INVLIST_CLEAR \
+       assert(invlist)
 PERL_STATIC_INLINE IV  S_invlist_previous_index(SV* const invlist)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_INVLIST_PREVIOUS_INDEX        \
        assert(invlist)
 
+STATIC void    S_invlist_replace_list_destroys_src(pTHX_ SV *dest, SV *src);
+#define PERL_ARGS_ASSERT_INVLIST_REPLACE_LIST_DESTROYS_SRC     \
+       assert(dest); assert(src)
 PERL_STATIC_INLINE void        S_invlist_set_previous_index(SV* const invlist, const IV index);
 #define PERL_ARGS_ASSERT_INVLIST_SET_PREVIOUS_INDEX    \
        assert(invlist)
-PERL_STATIC_INLINE void        S_invlist_trim(SV* const invlist);
+PERL_STATIC_INLINE void        S_invlist_trim(SV* invlist);
 #define PERL_ARGS_ASSERT_INVLIST_TRIM  \
        assert(invlist)
 #  endif
@@ -3794,11 +3943,6 @@ PERL_CALLCONV bool       Perl_do_exec3(pTHX_ const char *incmd, int fd, int do_report)
 #define PERL_ARGS_ASSERT_DO_EXEC3      \
        assert(incmd)
 #endif
-#if (!defined(HAS_MEMCPY) && !defined(HAS_BCOPY)) || (!defined(HAS_MEMMOVE) && !defined(HAS_SAFE_MEMCPY) && !defined(HAS_SAFE_BCOPY))
-PERL_CALLCONV char*    Perl_my_bcopy(const char* from, char* to, I32 len);
-#define PERL_ARGS_ASSERT_MY_BCOPY      \
-       assert(from); assert(to)
-#endif
 #if defined(DEBUGGING)
 PERL_CALLCONV int      Perl_get_debug_opts(pTHX_ const char **s, bool givehelp)
                        __attribute__warn_unused_result__;
@@ -3833,15 +3977,24 @@ STATIC void     S_dump_trie_interim_table(pTHX_ const struct _reg_trie_data *trie, H
 STATIC const regnode*  S_dumpuntil(pTHX_ const regexp *r, const regnode *start, const regnode *node, const regnode *last, const regnode *plast, SV* sv, I32 indent, U32 depth);
 #define PERL_ARGS_ASSERT_DUMPUNTIL     \
        assert(r); assert(start); assert(node); assert(sv)
-STATIC bool    S_put_charclass_bitmap_innards(pTHX_ SV* sv, char* bitmap, SV** bitmap_invlist);
+STATIC bool    S_put_charclass_bitmap_innards(pTHX_ SV* sv, char* bitmap, SV* nonbitmap_invlist, SV* only_utf8_locale_invlist, const regnode * const node);
 #define PERL_ARGS_ASSERT_PUT_CHARCLASS_BITMAP_INNARDS  \
        assert(sv); assert(bitmap)
+STATIC SV*     S_put_charclass_bitmap_innards_common(pTHX_ SV* invlist, SV* posixes, SV* only_utf8, SV* not_utf8, SV* only_utf8_locale, const bool invert);
+#define PERL_ARGS_ASSERT_PUT_CHARCLASS_BITMAP_INNARDS_COMMON   \
+       assert(invlist)
+STATIC void    S_put_charclass_bitmap_innards_invlist(pTHX_ SV *sv, SV* invlist);
+#define PERL_ARGS_ASSERT_PUT_CHARCLASS_BITMAP_INNARDS_INVLIST  \
+       assert(sv); assert(invlist)
 STATIC void    S_put_code_point(pTHX_ SV* sv, UV c);
 #define PERL_ARGS_ASSERT_PUT_CODE_POINT        \
        assert(sv)
 STATIC void    S_put_range(pTHX_ SV* sv, UV start, const UV end, const bool allow_literals);
 #define PERL_ARGS_ASSERT_PUT_RANGE     \
        assert(sv)
+PERL_CALLCONV int      Perl_re_indentf(pTHX_ const char *fmt, U32 depth, ...);
+#define PERL_ARGS_ASSERT_RE_INDENTF    \
+       assert(fmt)
 STATIC void    S_regdump_extflags(pTHX_ const char *lead, const U32 flags);
 STATIC void    S_regdump_intflags(pTHX_ const char *lead, const U32 flags);
 STATIC U8      S_regtail_study(pTHX_ RExC_state_t *pRExC_state, regnode *p, const regnode *val, U32 depth);
@@ -3852,9 +4005,12 @@ STATIC U8        S_regtail_study(pTHX_ RExC_state_t *pRExC_state, regnode *p, const reg
 STATIC void    S_debug_start_match(pTHX_ const REGEXP *prog, const bool do_utf8, const char *start, const char *end, const char *blurb);
 #define PERL_ARGS_ASSERT_DEBUG_START_MATCH     \
        assert(prog); assert(start); assert(end); assert(blurb)
-STATIC void    S_dump_exec_pos(pTHX_ const char *locinput, const regnode *scan, const char *loc_regeol, const char *loc_bostr, const char *loc_reg_starttry, const bool do_utf8);
+STATIC void    S_dump_exec_pos(pTHX_ const char *locinput, const regnode *scan, const char *loc_regeol, const char *loc_bostr, const char *loc_reg_starttry, const bool do_utf8, const U32 depth);
 #define PERL_ARGS_ASSERT_DUMP_EXEC_POS \
        assert(locinput); assert(scan); assert(loc_regeol); assert(loc_bostr); assert(loc_reg_starttry)
+PERL_CALLCONV int      Perl_re_exec_indentf(pTHX_ const char *fmt, U32 depth, ...);
+#define PERL_ARGS_ASSERT_RE_EXEC_INDENTF       \
+       assert(fmt)
 #  endif
 #  if defined(PERL_IN_SV_C)
 STATIC void    S_del_sv(pTHX_ SV *p);
@@ -3883,6 +4039,13 @@ PERL_CALLCONV void       Perl_dump_sv_child(pTHX_ SV *sv);
 #define PERL_ARGS_ASSERT_DUMP_SV_CHILD \
        assert(sv)
 #endif
+#if defined(HAS_MEMMEM)
+PERL_CALLCONV char*    Perl_ninstr(const char* big, const char* bigend, const char* little, const char* lend)
+                       __attribute__pure__;
+#define PERL_ARGS_ASSERT_NINSTR        \
+       assert(big); assert(bigend); assert(little); assert(lend)
+
+#endif
 #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
 PERL_CALLCONV I32      Perl_do_ipcctl(pTHX_ I32 optype, SV** mark, SV** sp);
 #define PERL_ARGS_ASSERT_DO_IPCCTL     \
@@ -3932,9 +4095,6 @@ PERL_CALLCONV MEM_SIZE    Perl_malloced_size(void *p)
        assert(p)
 
 #endif
-#if defined(NO_MATHOMS)
-/* PERL_CALLCONV void  Perl_sv_nounlocking(pTHX_ SV *sv); */
-#endif
 #if defined(PERL_ANY_COW)
 PERL_CALLCONV SV*      Perl_sv_setsv_cow(pTHX_ SV* dstr, SV* sstr);
 #define PERL_ARGS_ASSERT_SV_SETSV_COW  \
@@ -4000,7 +4160,9 @@ PERL_CALLCONV OP *        Perl_op_refcnt_inc(pTHX_ OP *o);
 /* PERL_CALLCONV bool  Perl_do_exec(pTHX_ const char* cmd); */
 #endif
 #if defined(PERL_DONT_CREATE_GVSV)
-/* PERL_CALLCONV GV*   Perl_gv_SVadd(pTHX_ GV *gv); */
+#ifndef NO_MATHOMS
+PERL_CALLCONV GV*      Perl_gv_SVadd(pTHX_ GV *gv);
+#endif
 #endif
 #if defined(PERL_GLOBAL_STRUCT)
 PERL_CALLCONV struct perl_vars *       Perl_GetVars(pTHX);
@@ -4268,6 +4430,13 @@ PERL_CALLCONV SV*        Perl_hfree_next_entry(pTHX_ HV *hv, STRLEN *indexp);
 #define PERL_ARGS_ASSERT_HFREE_NEXT_ENTRY      \
        assert(hv); assert(indexp)
 #endif
+#if defined(PERL_IN_LOCALE_C) || defined(PERL_IN_SV_C)
+#  if defined(USE_LOCALE_COLLATE)
+PERL_CALLCONV char*    Perl__mem_collxfrm(pTHX_ const char* input_string, STRLEN len, STRLEN* xlen, bool utf8);
+#define PERL_ARGS_ASSERT__MEM_COLLXFRM \
+       assert(input_string); assert(xlen)
+#  endif
+#endif
 #if defined(PERL_IN_MALLOC_C)
 STATIC int     S_adjust_size_and_find_bucket(size_t *nbytes_p);
 #define PERL_ARGS_ASSERT_ADJUST_SIZE_AND_FIND_BUCKET   \
@@ -4734,7 +4903,7 @@ STATIC bool       S_grok_bslash_N(pTHX_ RExC_state_t *pRExC_state, regnode** nodep, UV
 PERL_STATIC_INLINE regnode*    S_handle_named_backref(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, char * parse_start, char ch);
 #define PERL_ARGS_ASSERT_HANDLE_NAMED_BACKREF  \
        assert(pRExC_state); assert(flagp); assert(parse_start)
-STATIC int     S_handle_possible_posix(pTHX_ RExC_state_t *pRExC_state, const char* const s, char ** updated_parse_ptr, AV** posix_warnings);
+STATIC int     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);
 #define PERL_ARGS_ASSERT_HANDLE_POSSIBLE_POSIX \
        assert(pRExC_state); assert(s)
 STATIC regnode*        S_handle_regex_sets(pTHX_ RExC_state_t *pRExC_state, SV ** return_invlist, I32 *flagp, U32 depth, char * const oregcomp_parse);
@@ -4794,6 +4963,9 @@ STATIC I32        S_make_trie(pTHX_ RExC_state_t *pRExC_state, regnode *startbranch, re
 STATIC void    S_nextchar(pTHX_ RExC_state_t *pRExC_state);
 #define PERL_ARGS_ASSERT_NEXTCHAR      \
        assert(pRExC_state)
+STATIC void    S_output_or_return_posix_warnings(pTHX_ RExC_state_t *pRExC_state, AV* posix_warnings, AV** return_posix_warnings);
+#define PERL_ARGS_ASSERT_OUTPUT_OR_RETURN_POSIX_WARNINGS       \
+       assert(pRExC_state); assert(posix_warnings)
 STATIC void    S_parse_lparen_question_flags(pTHX_ RExC_state_t *pRExC_state);
 #define PERL_ARGS_ASSERT_PARSE_LPAREN_QUESTION_FLAGS   \
        assert(pRExC_state)
@@ -4832,7 +5004,7 @@ STATIC regnode*   S_regatom(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth
 STATIC regnode*        S_regbranch(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, I32 first, U32 depth);
 #define PERL_ARGS_ASSERT_REGBRANCH     \
        assert(pRExC_state); assert(flagp)
-STATIC regnode*        S_regclass(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth, const bool stop_at_1, bool allow_multi_fold, const bool silence_non_portable, const bool strict, bool optimizable, SV** ret_invlist, AV** posix_warnings);
+STATIC regnode*        S_regclass(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth, const bool stop_at_1, bool allow_multi_fold, const bool silence_non_portable, const bool strict, bool optimizable, SV** ret_invlist, AV** return_posix_warnings);
 #define PERL_ARGS_ASSERT_REGCLASS      \
        assert(pRExC_state); assert(flagp)
 STATIC unsigned int    S_regex_set_precedence(const U8 my_operator)
@@ -4919,10 +5091,13 @@ PERL_CALLCONV SV*       Perl__new_invlist_C_array(pTHX_ const UV* const list)
 
 #endif
 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C)
-PERL_CALLCONV SV*      Perl__get_regclass_nonbitmap_data(pTHX_ const regexp *prog, const struct regnode *node, bool doinit, SV **listsvp, SV **lonly_utf8_locale, SV *exclude_list);
+PERL_CALLCONV SV*      Perl__get_regclass_nonbitmap_data(pTHX_ const regexp *prog, const struct regnode *node, bool doinit, SV **listsvp, SV **lonly_utf8_locale, SV **output_invlist);
 #define PERL_ARGS_ASSERT__GET_REGCLASS_NONBITMAP_DATA  \
        assert(node)
 PERL_CALLCONV void     Perl__load_PL_utf8_foldclosures(pTHX);
+PERL_CALLCONV int      Perl_re_printf(pTHX_ const char *fmt, ...);
+#define PERL_ARGS_ASSERT_RE_PRINTF     \
+       assert(fmt)
 PERL_CALLCONV void     Perl_regprop(pTHX_ const regexp *prog, SV* sv, const regnode* o, const regmatch_info *reginfo, const RExC_state_t *pRExC_state);
 #define PERL_ARGS_ASSERT_REGPROP       \
        assert(sv); assert(o)
@@ -5449,6 +5624,17 @@ STATIC void      S_mem_log_common(enum mem_log_type mlt, const UV n, const UV typesiz
        assert(type_name); assert(filename); assert(funcname)
 #  endif
 #endif
+#if defined(PERL_MEM_LOG)
+PERL_CALLCONV Malloc_t 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);
+#define PERL_ARGS_ASSERT_MEM_LOG_ALLOC \
+       assert(type_name); assert(filename); assert(funcname)
+PERL_CALLCONV Malloc_t Perl_mem_log_free(Malloc_t oldalloc, const char *filename, const int linenumber, const char *funcname);
+#define PERL_ARGS_ASSERT_MEM_LOG_FREE  \
+       assert(filename); assert(funcname)
+PERL_CALLCONV Malloc_t 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);
+#define PERL_ARGS_ASSERT_MEM_LOG_REALLOC       \
+       assert(type_name); assert(filename); assert(funcname)
+#endif
 #if defined(PERL_OP_PARENT)
 PERL_CALLCONV OP*      Perl_op_parent(OP *o);
 #define PERL_ARGS_ASSERT_OP_PARENT     \
@@ -5470,6 +5656,18 @@ PERL_CALLCONV bool       Perl_dump_c_backtrace(pTHX_ PerlIO* fp, int max_depth, int sk
 PERL_CALLCONV Perl_c_backtrace*        Perl_get_c_backtrace(pTHX_ int max_depth, int skip);
 PERL_CALLCONV SV*      Perl_get_c_backtrace_dump(pTHX_ int max_depth, int skip);
 #endif
+#if defined(USE_DTRACE)
+PERL_CALLCONV void     Perl_dtrace_probe_call(pTHX_ CV *cv, bool is_call);
+#define PERL_ARGS_ASSERT_DTRACE_PROBE_CALL     \
+       assert(cv)
+PERL_CALLCONV void     Perl_dtrace_probe_load(pTHX_ const char *name, bool is_loading);
+#define PERL_ARGS_ASSERT_DTRACE_PROBE_LOAD     \
+       assert(name)
+PERL_CALLCONV void     Perl_dtrace_probe_op(pTHX_ const OP *op);
+#define PERL_ARGS_ASSERT_DTRACE_PROBE_OP       \
+       assert(op)
+PERL_CALLCONV void     Perl_dtrace_probe_phase(pTHX_ enum perl_phase phase);
+#endif
 #if defined(USE_ITHREADS)
 PERL_CALLCONV PADOFFSET        Perl_alloccopstash(pTHX_ HV *hv);
 #define PERL_ARGS_ASSERT_ALLOCCOPSTASH \
@@ -5594,9 +5792,9 @@ STATIC char*      S_stdize_locale(pTHX_ char* locs);
 PERL_CALLCONV int      Perl_magic_setcollxfrm(pTHX_ SV* sv, MAGIC* mg);
 #define PERL_ARGS_ASSERT_MAGIC_SETCOLLXFRM     \
        assert(sv); assert(mg)
-PERL_CALLCONV char*    Perl_mem_collxfrm(pTHX_ const char* s, STRLEN len, STRLEN* xlen);
+PERL_CALLCONV char*    Perl_mem_collxfrm(pTHX_ const char* input_string, STRLEN len, STRLEN* xlen);
 #define PERL_ARGS_ASSERT_MEM_COLLXFRM  \
-       assert(s); assert(xlen)
+       assert(input_string); assert(xlen)
 /* PERL_CALLCONV char* sv_collxfrm(pTHX_ SV *const sv, STRLEN *const nxp); */
 PERL_CALLCONV char*    Perl_sv_collxfrm_flags(pTHX_ SV *const sv, STRLEN *const nxp, I32 const flags);
 #define PERL_ARGS_ASSERT_SV_COLLXFRM_FLAGS     \
Unnamed repository; edit this file 'description' to name the repository.