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
Various updates and fixes to some of the SysV IPC ops and their tests
[perl5.git] / proto.h
diff --git a/proto.h b/proto.h
index eb985d9..e886261 100644 (file)
--- a/proto.h
+++ b/proto.h
@@ -219,6 +219,13 @@ PERL_CALLCONV SV** Perl_av_arylen_p(pTHX_ AV *av);
 PERL_CALLCONV void     Perl_av_clear(pTHX_ AV *av);
 #define PERL_ARGS_ASSERT_AV_CLEAR      \
        assert(av)
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_INLINE Size_t      Perl_av_count(pTHX_ AV *av)
+                       __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_AV_COUNT      \
+       assert(av)
+#endif
+
 PERL_CALLCONV void     Perl_av_create_and_push(pTHX_ AV **const avp, SV *const val);
 #define PERL_ARGS_ASSERT_AV_CREATE_AND_PUSH    \
        assert(avp); assert(val)
@@ -284,12 +291,9 @@ PERL_CALLCONV SV** Perl_av_store(pTHX_ AV *av, SSize_t key, SV *val);
                        __attribute__warn_unused_result__; */
 #define PERL_ARGS_ASSERT_AV_TINDEX
 
-#ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE SSize_t     Perl_av_top_index(pTHX_ AV *av)
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_AV_TOP_INDEX  \
-       assert(av)
-#endif
+/* PERL_CALLCONV SSize_t       av_top_index(pTHX_ AV *av)
+                       __attribute__warn_unused_result__; */
+#define PERL_ARGS_ASSERT_AV_TOP_INDEX
 
 PERL_CALLCONV void     Perl_av_undef(pTHX_ AV *av);
 #define PERL_ARGS_ASSERT_AV_UNDEF      \
@@ -656,6 +660,20 @@ PERL_CALLCONV void Perl_clear_defarray(pTHX_ AV* av, bool abandon);
 PERL_CALLCONV const COP*       Perl_closest_cop(pTHX_ const COP *cop, const OP *o, const OP *curop, bool opnext);
 #define PERL_ARGS_ASSERT_CLOSEST_COP   \
        assert(cop)
+PERL_CALLCONV OP*      Perl_cmpchain_extend(pTHX_ I32 type, OP* ch, OP* right)
+                       __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_CMPCHAIN_EXTEND       \
+       assert(ch)
+
+PERL_CALLCONV OP*      Perl_cmpchain_finish(pTHX_ OP* ch)
+                       __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_CMPCHAIN_FINISH       \
+       assert(ch)
+
+PERL_CALLCONV OP*      Perl_cmpchain_start(pTHX_ I32 type, OP* left, OP* right)
+                       __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_CMPCHAIN_START
+
 PERL_CALLCONV const char *     Perl_cntrl_to_mnemonic(const U8 c)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_CNTRL_TO_MNEMONIC
@@ -684,7 +702,7 @@ PERL_CALLCONV_NO_RET void   Perl_croak_caller(const char* pat, ...)
                        __attribute__format__null_ok__(__printf__,1,2);
 #define PERL_ARGS_ASSERT_CROAK_CALLER
 
-PERL_STATIC_INLINE_NO_RET void Perl_croak_memory_wrap(void)
+PERL_CALLCONV_NO_RET void      Perl_croak_memory_wrap(void)
                        __attribute__noreturn__;
 #define PERL_ARGS_ASSERT_CROAK_MEMORY_WRAP
 
@@ -819,12 +837,12 @@ PERL_CALLCONV SV *        Perl_defelem_target(pTHX_ SV *sv, MAGIC *mg)
 
 PERL_CALLCONV void     Perl_delete_eval_scope(pTHX);
 #define PERL_ARGS_ASSERT_DELETE_EVAL_SCOPE
-PERL_CALLCONV char*    Perl_delimcpy(char* to, const char* toend, const char* from, const char* fromend, int delim, I32* retlen);
+PERL_CALLCONV char*    Perl_delimcpy(char* to, const char* to_end, const char* from, const char* from_end, const int delim, I32* retlen);
 #define PERL_ARGS_ASSERT_DELIMCPY      \
-       assert(to); assert(toend); assert(from); assert(fromend); assert(retlen)
-PERL_CALLCONV char*    Perl_delimcpy_no_escape(char* to, const char* toend, const char* from, const char* fromend, int delim, I32* retlen);
+       assert(to); assert(to_end); assert(from); assert(from_end); assert(retlen)
+PERL_CALLCONV char*    Perl_delimcpy_no_escape(char* to, const char* to_end, const char* from, const char* from_end, const int delim, I32* retlen);
 #define PERL_ARGS_ASSERT_DELIMCPY_NO_ESCAPE    \
-       assert(to); assert(toend); assert(from); assert(fromend); assert(retlen)
+       assert(to); assert(to_end); assert(from); assert(from_end); assert(retlen)
 PERL_CALLCONV void     Perl_despatch_signals(pTHX);
 #define PERL_ARGS_ASSERT_DESPATCH_SIGNALS
 PERL_CALLCONV_NO_RET OP*       Perl_die(pTHX_ const char* pat, ...)
@@ -1295,7 +1313,7 @@ PERL_CALLCONV GV* Perl_gv_fetchmethod_pvn_flags(pTHX_ HV* stash, const char* nam
 PERL_CALLCONV GV*      Perl_gv_fetchmethod_sv_flags(pTHX_ HV* stash, SV* namesv, U32 flags);
 #define PERL_ARGS_ASSERT_GV_FETCHMETHOD_SV_FLAGS       \
        assert(stash); assert(namesv)
-PERL_CALLCONV GV*      Perl_gv_fetchpv(pTHX_ const char *nambeg, I32 add, const svtype sv_type);
+PERL_CALLCONV GV*      Perl_gv_fetchpv(pTHX_ const char *nambeg, I32 flags, const svtype sv_type);
 #define PERL_ARGS_ASSERT_GV_FETCHPV    \
        assert(nambeg)
 PERL_CALLCONV GV*      Perl_gv_fetchpvn_flags(pTHX_ const char* name, STRLEN len, I32 flags, const svtype sv_type);
@@ -1340,9 +1358,9 @@ PERL_CALLCONV void        Perl_gv_name_set(pTHX_ GV* gv, const char *name, U32 len, U32
 PERL_CALLCONV GV *     Perl_gv_override(pTHX_ const char * const name, const STRLEN len);
 #define PERL_ARGS_ASSERT_GV_OVERRIDE   \
        assert(name)
-PERL_CALLCONV void     Perl_gv_setref(pTHX_ SV *const dstr, SV *const sstr);
+PERL_CALLCONV void     Perl_gv_setref(pTHX_ SV *const dsv, SV *const ssv);
 #define PERL_ARGS_ASSERT_GV_SETREF     \
-       assert(dstr); assert(sstr)
+       assert(dsv); assert(ssv)
 PERL_CALLCONV HV*      Perl_gv_stashpv(pTHX_ const char* name, I32 flags);
 #define PERL_ARGS_ASSERT_GV_STASHPV    \
        assert(name)
@@ -1839,9 +1857,15 @@ PERL_CALLCONV int        Perl_magic_existspack(pTHX_ SV* sv, const MAGIC* mg);
 PERL_CALLCONV int      Perl_magic_freearylen_p(pTHX_ SV* sv, MAGIC* mg);
 #define PERL_ARGS_ASSERT_MAGIC_FREEARYLEN_P    \
        assert(sv); assert(mg)
+PERL_CALLCONV int      Perl_magic_freemglob(pTHX_ SV* sv, MAGIC* mg);
+#define PERL_ARGS_ASSERT_MAGIC_FREEMGLOB       \
+       assert(sv); assert(mg)
 PERL_CALLCONV int      Perl_magic_freeovrld(pTHX_ SV* sv, MAGIC* mg);
 #define PERL_ARGS_ASSERT_MAGIC_FREEOVRLD       \
        assert(sv); assert(mg)
+PERL_CALLCONV int      Perl_magic_freeutf8(pTHX_ SV* sv, MAGIC* mg);
+#define PERL_ARGS_ASSERT_MAGIC_FREEUTF8        \
+       assert(sv); assert(mg)
 PERL_CALLCONV int      Perl_magic_get(pTHX_ SV* sv, MAGIC* mg);
 #define PERL_ARGS_ASSERT_MAGIC_GET     \
        assert(sv); assert(mg)
@@ -2043,6 +2067,13 @@ PERL_CALLCONV void *     Perl_more_bodies(pTHX_ const svtype sv_type, const size_t b
 PERL_CALLCONV const char*      Perl_moreswitches(pTHX_ const char* s);
 #define PERL_ARGS_ASSERT_MORESWITCHES  \
        assert(s)
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_INLINE char *      Perl_mortal_getenv(const char * str)
+                       __attribute__warn_unused_result__;
+#define PERL_ARGS_ASSERT_MORTAL_GETENV \
+       assert(str)
+#endif
+
 PERL_CALLCONV const struct mro_alg *   Perl_mro_get_from_name(pTHX_ SV *name);
 #define PERL_ARGS_ASSERT_MRO_GET_FROM_NAME     \
        assert(name)
@@ -2558,10 +2589,12 @@ PERL_CALLCONV void      Perl_optimize_optree(pTHX_ OP* o);
 #define PERL_ARGS_ASSERT_OPTIMIZE_OPTREE       \
        assert(o)
 #ifndef NO_MATHOMS
-PERL_CALLCONV void     Perl_pack_cat(pTHX_ SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist, SV ***next_in_list, U32 flags);
+PERL_CALLCONV void     Perl_pack_cat(pTHX_ SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist, SV ***next_in_list, U32 flags)
+                       __attribute__deprecated__;
 #define PERL_ARGS_ASSERT_PACK_CAT      \
        assert(cat); assert(pat); assert(patend); assert(beglist); assert(endlist); assert(next_in_list)
 #endif
+
 PERL_CALLCONV void     Perl_package(pTHX_ OP* o);
 #define PERL_ARGS_ASSERT_PACKAGE       \
        assert(o)
@@ -2592,6 +2625,7 @@ PERL_CALLCONV void        Perl_pad_block_start(pTHX_ int full);
 #define PERL_ARGS_ASSERT_PAD_BLOCK_START
 #ifndef NO_MATHOMS
 PERL_CALLCONV HV*      Perl_pad_compname_type(pTHX_ const PADOFFSET po)
+                       __attribute__deprecated__
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_PAD_COMPNAME_TYPE
 #endif
@@ -3220,7 +3254,7 @@ 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);
+PERL_CALLCONV char*    Perl_sv_2pv_flags(pTHX_ SV *const sv, STRLEN *const lp, const U32 flags);
 #define PERL_ARGS_ASSERT_SV_2PV_FLAGS  \
        assert(sv)
 #ifndef NO_MATHOMS
@@ -3277,15 +3311,15 @@ PERL_CALLCONV SV*       Perl_sv_bless(pTHX_ SV *const sv, HV *const stash);
 PERL_CALLCONV bool     Perl_sv_cat_decode(pTHX_ SV* dsv, SV *encoding, SV *ssv, int *offset, char* tstr, int tlen);
 #define PERL_ARGS_ASSERT_SV_CAT_DECODE \
        assert(dsv); assert(encoding); assert(ssv); assert(offset); assert(tstr)
-PERL_CALLCONV void     Perl_sv_catpv(pTHX_ SV *const sv, const char* ptr);
+PERL_CALLCONV void     Perl_sv_catpv(pTHX_ SV *const dsv, const char* sstr);
 #define PERL_ARGS_ASSERT_SV_CATPV      \
-       assert(sv)
-PERL_CALLCONV void     Perl_sv_catpv_flags(pTHX_ SV *dstr, const char *sstr, const I32 flags);
+       assert(dsv)
+PERL_CALLCONV void     Perl_sv_catpv_flags(pTHX_ SV *dsv, const char *sstr, const I32 flags);
 #define PERL_ARGS_ASSERT_SV_CATPV_FLAGS        \
-       assert(dstr); assert(sstr)
-PERL_CALLCONV void     Perl_sv_catpv_mg(pTHX_ SV *const sv, const char *const ptr);
+       assert(dsv); assert(sstr)
+PERL_CALLCONV void     Perl_sv_catpv_mg(pTHX_ SV *const dsv, const char *const sstr);
 #define PERL_ARGS_ASSERT_SV_CATPV_MG   \
-       assert(sv)
+       assert(dsv)
 PERL_CALLCONV void     Perl_sv_catpvf(pTHX_ SV *const sv, const char *const pat, ...)
                        __attribute__format__(__printf__,pTHX_2,pTHX_3);
 #define PERL_ARGS_ASSERT_SV_CATPVF     \
@@ -3301,24 +3335,24 @@ 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);
+PERL_CALLCONV void     Perl_sv_catpvn_flags(pTHX_ SV *const dsv, const char *sstr, const STRLEN len, const I32 flags);
 #define PERL_ARGS_ASSERT_SV_CATPVN_FLAGS       \
-       assert(dstr); assert(sstr)
+       assert(dsv); assert(sstr)
 #ifndef NO_MATHOMS
-PERL_CALLCONV void     Perl_sv_catpvn_mg(pTHX_ SV *sv, const char *ptr, STRLEN len);
+PERL_CALLCONV void     Perl_sv_catpvn_mg(pTHX_ SV *dsv, const char *sstr, STRLEN len);
 #define PERL_ARGS_ASSERT_SV_CATPVN_MG  \
-       assert(sv); assert(ptr)
+       assert(dsv); assert(sstr)
 #endif
 #ifndef NO_MATHOMS
-PERL_CALLCONV void     Perl_sv_catsv(pTHX_ SV *dstr, SV *sstr);
+PERL_CALLCONV void     Perl_sv_catsv(pTHX_ SV *dsv, SV *sstr);
 #define PERL_ARGS_ASSERT_SV_CATSV      \
-       assert(dstr)
+       assert(dsv)
 #endif
-PERL_CALLCONV void     Perl_sv_catsv_flags(pTHX_ SV *const dsv, SV *const ssv, const I32 flags);
+PERL_CALLCONV void     Perl_sv_catsv_flags(pTHX_ SV *const dsv, SV *const sstr, const I32 flags);
 #define PERL_ARGS_ASSERT_SV_CATSV_FLAGS        \
        assert(dsv)
 #ifndef NO_MATHOMS
-PERL_CALLCONV void     Perl_sv_catsv_mg(pTHX_ SV *dsv, SV *ssv);
+PERL_CALLCONV void     Perl_sv_catsv_mg(pTHX_ SV *dsv, SV *sstr);
 #define PERL_ARGS_ASSERT_SV_CATSV_MG   \
        assert(dsv)
 #endif
@@ -3568,7 +3602,7 @@ 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);
+PERL_CALLCONV char*    Perl_sv_pvn_force_flags(pTHX_ SV *const sv, STRLEN *const lp, const U32 flags);
 #define PERL_ARGS_ASSERT_SV_PVN_FORCE_FLAGS    \
        assert(sv)
 #ifndef NO_MATHOMS
@@ -3695,16 +3729,16 @@ PERL_CALLCONV SV*       Perl_sv_setref_uv(pTHX_ SV *const rv, const char *const classn
 #define PERL_ARGS_ASSERT_SV_SETREF_UV  \
        assert(rv)
 #ifndef NO_MATHOMS
-PERL_CALLCONV void     Perl_sv_setsv(pTHX_ SV *dstr, SV *sstr);
+PERL_CALLCONV void     Perl_sv_setsv(pTHX_ SV *dsv, SV *ssv);
 #define PERL_ARGS_ASSERT_SV_SETSV      \
-       assert(dstr)
+       assert(dsv)
 #endif
-PERL_CALLCONV void     Perl_sv_setsv_flags(pTHX_ SV *dstr, SV *sstr, const I32 flags);
+PERL_CALLCONV void     Perl_sv_setsv_flags(pTHX_ SV *dsv, SV *ssv, const I32 flags);
 #define PERL_ARGS_ASSERT_SV_SETSV_FLAGS        \
-       assert(dstr)
-PERL_CALLCONV void     Perl_sv_setsv_mg(pTHX_ SV *const dstr, SV *const sstr);
+       assert(dsv)
+PERL_CALLCONV void     Perl_sv_setsv_mg(pTHX_ SV *const dsv, SV *const ssv);
 #define PERL_ARGS_ASSERT_SV_SETSV_MG   \
-       assert(dstr)
+       assert(dsv)
 PERL_CALLCONV void     Perl_sv_setuv(pTHX_ SV *const sv, const UV num);
 #define PERL_ARGS_ASSERT_SV_SETUV      \
        assert(sv)
@@ -4134,6 +4168,13 @@ PERL_STATIC_INLINE void *        S_my_memrchr(const char * s, const char c, const STRLE
        assert(s)
 #endif
 #endif
+#if !(!defined(PERL_EXT_RE_BUILD))
+#  if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C)
+PERL_CALLCONV SV*      Perl_get_re_gclass_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_RE_GCLASS_NONBITMAP_DATA  \
+       assert(node)
+#  endif
+#endif
 #if !(defined(DEBUGGING))
 #  if !defined(NV_PRESERVES_UV)
 #    if defined(PERL_IN_SV_C)
@@ -4158,13 +4199,6 @@ PERL_CALLCONV bool       Perl_do_exec(pTHX_ const char* cmd);
 #define PERL_ARGS_ASSERT_DO_EXEC       \
        assert(cmd)
 #endif
-#if !(defined(PERL_GLOBAL_STRUCT_PRIVATE))
-#  if defined(PERL_IMPLICIT_CONTEXT)
-PERL_CALLCONV void*    Perl_my_cxt_init(pTHX_ int *indexp, size_t size);
-#define PERL_ARGS_ASSERT_MY_CXT_INIT   \
-       assert(indexp)
-#  endif
-#endif
 #if !(defined(PERL_USE_3ARG_SIGHANDLER))
 PERL_CALLCONV Signal_t Perl_csighandler(int sig);
 #define PERL_ARGS_ASSERT_CSIGHANDLER
@@ -4316,6 +4350,11 @@ PERL_STATIC_INLINE void  S_invlist_trim(SV* invlist);
        assert(invlist)
 #endif
 #  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 **output_invlist);
+#define PERL_ARGS_ASSERT_GET_REGCLASS_NONBITMAP_DATA   \
+       assert(node)
+#  endif
 #endif
 #if !defined(PERL_IMPLICIT_SYS)
 PERL_CALLCONV I32      Perl_my_pclose(pTHX_ PerlIO* ptr);
@@ -4664,9 +4703,9 @@ PERL_CALLCONV MEM_SIZE    Perl_malloced_size(void *p)
 
 #endif
 #if defined(PERL_ANY_COW)
-PERL_CALLCONV SV*      Perl_sv_setsv_cow(pTHX_ SV* dstr, SV* sstr);
+PERL_CALLCONV SV*      Perl_sv_setsv_cow(pTHX_ SV* dsv, SV* ssv);
 #define PERL_ARGS_ASSERT_SV_SETSV_COW  \
-       assert(sstr)
+       assert(ssv)
 #endif
 #if defined(PERL_CORE)
 PERL_CALLCONV void     Perl_opslab_force_free(pTHX_ OPSLAB *slab);
@@ -4762,25 +4801,6 @@ PERL_CALLCONV GV*        Perl_gv_SVadd(pTHX_ GV *gv);
 #define PERL_ARGS_ASSERT_GV_SVADD
 #endif
 #endif
-#if defined(PERL_GLOBAL_STRUCT)
-PERL_CALLCONV struct perl_vars *       Perl_GetVars(pTHX);
-#define PERL_ARGS_ASSERT_GETVARS
-PERL_CALLCONV void     Perl_free_global_struct(pTHX_ struct perl_vars *plvarsp);
-#define PERL_ARGS_ASSERT_FREE_GLOBAL_STRUCT    \
-       assert(plvarsp)
-PERL_CALLCONV struct perl_vars*        Perl_init_global_struct(pTHX);
-#define PERL_ARGS_ASSERT_INIT_GLOBAL_STRUCT
-#endif
-#if defined(PERL_GLOBAL_STRUCT_PRIVATE)
-#  if defined(PERL_IMPLICIT_CONTEXT)
-PERL_CALLCONV int      Perl_my_cxt_index(pTHX_ const char *my_cxt_key);
-#define PERL_ARGS_ASSERT_MY_CXT_INDEX  \
-       assert(my_cxt_key)
-PERL_CALLCONV void*    Perl_my_cxt_init(pTHX_ const char *my_cxt_key, size_t size);
-#define PERL_ARGS_ASSERT_MY_CXT_INIT   \
-       assert(my_cxt_key)
-#  endif
-#endif
 #if defined(PERL_IMPLICIT_CONTEXT)
 PERL_CALLCONV_NO_RET void      Perl_croak_nocontext(const char* pat, ...)
                        __attribute__noreturn__
@@ -4818,6 +4838,9 @@ PERL_CALLCONV SV* Perl_mess_nocontext(const char* pat, ...)
 #define PERL_ARGS_ASSERT_MESS_NOCONTEXT        \
        assert(pat)
 
+PERL_CALLCONV void*    Perl_my_cxt_init(pTHX_ int *indexp, size_t size);
+#define PERL_ARGS_ASSERT_MY_CXT_INIT   \
+       assert(indexp)
 PERL_CALLCONV SV*      Perl_newSVpvf_nocontext(const char *const pat, ...)
                        __attribute__format__(__printf__,1,2);
 #define PERL_ARGS_ASSERT_NEWSVPVF_NOCONTEXT    \
@@ -5487,6 +5510,14 @@ PERL_STATIC_INLINE HV*   S_opmethod_stash(pTHX_ SV* meth);
 #define PERL_ARGS_ASSERT_OPMETHOD_STASH        \
        assert(meth)
 #endif
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_FORCE_INLINE bool  S_should_we_output_Debug_r(pTHX_ regexp * prog)
+                       __attribute__warn_unused_result__
+                       __attribute__always_inline__;
+#define PERL_ARGS_ASSERT_SHOULD_WE_OUTPUT_DEBUG_R      \
+       assert(prog)
+#endif
+
 #endif
 #if defined(PERL_IN_PP_PACK_C)
 STATIC int     S_div128(pTHX_ SV *pnum, bool *done);
@@ -5538,15 +5569,55 @@ STATIC SSize_t  S_unpack_rec(pTHX_ struct tempsym* symptr, const char *s, const c
        assert(symptr); assert(s); assert(strbeg); assert(strend)
 #endif
 #if defined(PERL_IN_PP_SORT_C)
-STATIC I32     S_amagic_cmp(pTHX_ SV *const str1, SV *const str2);
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_FORCE_INLINE I32   S_amagic_cmp(pTHX_ SV *const str1, SV *const str2)
+                       __attribute__always_inline__;
 #define PERL_ARGS_ASSERT_AMAGIC_CMP    \
        assert(str1); assert(str2)
-STATIC I32     S_amagic_i_ncmp(pTHX_ SV *const a, SV *const b);
+#endif
+
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_FORCE_INLINE I32   S_amagic_cmp_desc(pTHX_ SV *const str1, SV *const str2)
+                       __attribute__always_inline__;
+#define PERL_ARGS_ASSERT_AMAGIC_CMP_DESC       \
+       assert(str1); assert(str2)
+#endif
+
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_FORCE_INLINE I32   S_amagic_i_ncmp(pTHX_ SV *const a, SV *const b)
+                       __attribute__always_inline__;
 #define PERL_ARGS_ASSERT_AMAGIC_I_NCMP \
        assert(a); assert(b)
-STATIC I32     S_amagic_ncmp(pTHX_ SV *const a, SV *const b);
+#endif
+
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_FORCE_INLINE I32   S_amagic_i_ncmp_desc(pTHX_ SV *const a, SV *const b)
+                       __attribute__always_inline__;
+#define PERL_ARGS_ASSERT_AMAGIC_I_NCMP_DESC    \
+       assert(a); assert(b)
+#endif
+
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_FORCE_INLINE I32   S_amagic_ncmp(pTHX_ SV *const a, SV *const b)
+                       __attribute__always_inline__;
 #define PERL_ARGS_ASSERT_AMAGIC_NCMP   \
        assert(a); assert(b)
+#endif
+
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_FORCE_INLINE I32   S_amagic_ncmp_desc(pTHX_ SV *const a, SV *const b)
+                       __attribute__always_inline__;
+#define PERL_ARGS_ASSERT_AMAGIC_NCMP_DESC      \
+       assert(a); assert(b)
+#endif
+
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_FORCE_INLINE I32   S_cmp_desc(pTHX_ SV *const str1, SV *const str2)
+                       __attribute__always_inline__;
+#define PERL_ARGS_ASSERT_CMP_DESC      \
+       assert(str1); assert(str2)
+#endif
+
 STATIC I32     S_sortcv(pTHX_ SV *const a, SV *const b);
 #define PERL_ARGS_ASSERT_SORTCV        \
        assert(a); assert(b)
@@ -5556,16 +5627,63 @@ STATIC I32      S_sortcv_stacked(pTHX_ SV *const a, SV *const b);
 STATIC I32     S_sortcv_xsub(pTHX_ SV *const a, SV *const b);
 #define PERL_ARGS_ASSERT_SORTCV_XSUB   \
        assert(a); assert(b)
-STATIC I32     S_sv_i_ncmp(pTHX_ SV *const a, SV *const b);
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_FORCE_INLINE void  S_sortsv_flags_impl(pTHX_ SV** array, size_t num_elts, SVCOMPARE_t cmp, U32 flags)
+                       __attribute__always_inline__;
+#define PERL_ARGS_ASSERT_SORTSV_FLAGS_IMPL     \
+       assert(cmp)
+#endif
+
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_FORCE_INLINE I32   S_sv_i_ncmp(pTHX_ SV *const a, SV *const b)
+                       __attribute__always_inline__;
 #define PERL_ARGS_ASSERT_SV_I_NCMP     \
        assert(a); assert(b)
-STATIC I32     S_sv_ncmp(pTHX_ SV *const a, SV *const b);
+#endif
+
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_FORCE_INLINE I32   S_sv_i_ncmp_desc(pTHX_ SV *const a, SV *const b)
+                       __attribute__always_inline__;
+#define PERL_ARGS_ASSERT_SV_I_NCMP_DESC        \
+       assert(a); assert(b)
+#endif
+
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_FORCE_INLINE I32   S_sv_ncmp(pTHX_ SV *const a, SV *const b)
+                       __attribute__always_inline__;
 #define PERL_ARGS_ASSERT_SV_NCMP       \
        assert(a); assert(b)
+#endif
+
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_FORCE_INLINE I32   S_sv_ncmp_desc(pTHX_ SV *const a, SV *const b)
+                       __attribute__always_inline__;
+#define PERL_ARGS_ASSERT_SV_NCMP_DESC  \
+       assert(a); assert(b)
+#endif
+
 #  if defined(USE_LOCALE_COLLATE)
-STATIC I32     S_amagic_cmp_locale(pTHX_ SV *const str1, SV *const str2);
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_FORCE_INLINE I32   S_amagic_cmp_locale(pTHX_ SV *const str1, SV *const str2)
+                       __attribute__always_inline__;
 #define PERL_ARGS_ASSERT_AMAGIC_CMP_LOCALE     \
        assert(str1); assert(str2)
+#endif
+
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_FORCE_INLINE I32   S_amagic_cmp_locale_desc(pTHX_ SV *const str1, SV *const str2)
+                       __attribute__always_inline__;
+#define PERL_ARGS_ASSERT_AMAGIC_CMP_LOCALE_DESC        \
+       assert(str1); assert(str2)
+#endif
+
+#ifndef PERL_NO_INLINE_FUNCTIONS
+PERL_STATIC_FORCE_INLINE I32   S_cmp_locale_desc(pTHX_ SV *const str1, SV *const str2)
+                       __attribute__always_inline__;
+#define PERL_ARGS_ASSERT_CMP_LOCALE_DESC       \
+       assert(str1); assert(str2)
+#endif
+
 #  endif
 #endif
 #if defined(PERL_IN_PP_SYS_C)
@@ -5595,11 +5713,9 @@ STATIC REGEXP*   S_compile_wildcard(pTHX_ const char * subpattern, const STRLEN le
 #define PERL_ARGS_ASSERT_COMPILE_WILDCARD      \
        assert(subpattern)
 
-#ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE U8  S_compute_EXACTish(RExC_state_t *pRExC_state);
+STATIC U8      S_compute_EXACTish(RExC_state_t *pRExC_state);
 #define PERL_ARGS_ASSERT_COMPUTE_EXACTISH      \
        assert(pRExC_state)
-#endif
 STATIC regnode *       S_construct_ahocorasick_from_trie(pTHX_ RExC_state_t *pRExC_state, regnode *source, U32 depth);
 #define PERL_ARGS_ASSERT_CONSTRUCT_AHOCORASICK_FROM_TRIE       \
        assert(pRExC_state); assert(source)
@@ -5627,11 +5743,12 @@ STATIC SV*      S_get_ANYOF_cp_list_for_ssc(pTHX_ const RExC_state_t *pRExC_state, co
 STATIC bool    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);
 #define PERL_ARGS_ASSERT_GROK_BSLASH_N \
        assert(pRExC_state); assert(flagp)
-#ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE regnode_offset      S_handle_named_backref(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, char * parse_start, char ch);
+STATIC regnode_offset  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)
-#endif
+STATIC bool    S_handle_names_wildcard(pTHX_ const char * wname, const STRLEN wname_len, SV ** prop_definition, AV ** strings);
+#define PERL_ARGS_ASSERT_HANDLE_NAMES_WILDCARD \
+       assert(wname); assert(prop_definition); assert(strings)
 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)
@@ -5690,23 +5807,21 @@ STATIC void     S_output_posix_warnings(pTHX_ RExC_state_t *pRExC_state, AV* posix_w
 STATIC void    S_parse_lparen_question_flags(pTHX_ RExC_state_t *pRExC_state);
 #define PERL_ARGS_ASSERT_PARSE_LPAREN_QUESTION_FLAGS   \
        assert(pRExC_state)
-STATIC SV *    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, bool * user_defined_ptr, SV * msg, const STRLEN level);
+STATIC SV *    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);
 #define PERL_ARGS_ASSERT_PARSE_UNIPROP_STRING  \
        assert(name); assert(user_defined_ptr); assert(msg)
 STATIC void    S_populate_ANYOF_from_invlist(pTHX_ regnode *node, SV** invlist_ptr);
 #define PERL_ARGS_ASSERT_POPULATE_ANYOF_FROM_INVLIST   \
        assert(node); assert(invlist_ptr)
+STATIC void    S_rck_elide_nothing(pTHX_ regnode *node);
+#define PERL_ARGS_ASSERT_RCK_ELIDE_NOTHING     \
+       assert(node)
 PERL_STATIC_NO_RET void        S_re_croak(pTHX_ bool utf8, const char* pat, ...)
                        __attribute__noreturn__
                        __attribute__format__(__printf__,pTHX_2,pTHX_3);
 #define PERL_ARGS_ASSERT_RE_CROAK      \
        assert(pat)
 
-STATIC REGEXP* S_re_op_compile_wrapper(pTHX_ SV * const pattern, U32 orig_rx_flags, const U32 pm_flags)
-                       __attribute__warn_unused_result__;
-#define PERL_ARGS_ASSERT_RE_OP_COMPILE_WRAPPER \
-       assert(pattern)
-
 STATIC regnode_offset  S_reg(pTHX_ RExC_state_t *pRExC_state, I32 paren, I32 *flagp, U32 depth);
 #define PERL_ARGS_ASSERT_REG   \
        assert(pRExC_state); assert(flagp)
@@ -5749,7 +5864,7 @@ STATIC regnode_offset     S_regnode_guts(pTHX_ RExC_state_t *pRExC_state, const U8 o
 STATIC regnode_offset  S_regpiece(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth);
 #define PERL_ARGS_ASSERT_REGPIECE      \
        assert(pRExC_state); assert(flagp)
-STATIC regnode_offset  S_regpnode(pTHX_ RExC_state_t *pRExC_state, U8 op, void * arg);
+STATIC regnode_offset  S_regpnode(pTHX_ RExC_state_t *pRExC_state, U8 op, SV * arg);
 #define PERL_ARGS_ASSERT_REGPNODE      \
        assert(pRExC_state); assert(arg)
 STATIC bool    S_regtail(pTHX_ RExC_state_t * pRExC_state, const regnode_offset p, const regnode_offset val, const U32 depth)
@@ -5769,38 +5884,30 @@ STATIC void     S_set_regex_pv(pTHX_ RExC_state_t *pRExC_state, REGEXP *Rx);
 STATIC void    S_skip_to_be_ignored_text(pTHX_ RExC_state_t *pRExC_state, char ** p, const bool force_to_xmod);
 #define PERL_ARGS_ASSERT_SKIP_TO_BE_IGNORED_TEXT       \
        assert(pRExC_state); assert(p)
-#ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE void        S_ssc_add_range(pTHX_ regnode_ssc *ssc, UV const start, UV const end);
+STATIC void    S_ssc_add_range(pTHX_ regnode_ssc *ssc, UV const start, UV const end);
 #define PERL_ARGS_ASSERT_SSC_ADD_RANGE \
        assert(ssc)
-#endif
 STATIC void    S_ssc_and(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode_charclass *and_with);
 #define PERL_ARGS_ASSERT_SSC_AND       \
        assert(pRExC_state); assert(ssc); assert(and_with)
 STATIC void    S_ssc_anything(pTHX_ regnode_ssc *ssc);
 #define PERL_ARGS_ASSERT_SSC_ANYTHING  \
        assert(ssc)
-#ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE void        S_ssc_clear_locale(regnode_ssc *ssc);
+STATIC void    S_ssc_clear_locale(regnode_ssc *ssc);
 #define PERL_ARGS_ASSERT_SSC_CLEAR_LOCALE      \
        assert(ssc)
-#endif
-#ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE void        S_ssc_cp_and(pTHX_ regnode_ssc *ssc, UV const cp);
+STATIC void    S_ssc_cp_and(pTHX_ regnode_ssc *ssc, UV const cp);
 #define PERL_ARGS_ASSERT_SSC_CP_AND    \
        assert(ssc)
-#endif
 STATIC void    S_ssc_finalize(pTHX_ RExC_state_t *pRExC_state, regnode_ssc *ssc);
 #define PERL_ARGS_ASSERT_SSC_FINALIZE  \
        assert(pRExC_state); assert(ssc)
 STATIC void    S_ssc_init(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc);
 #define PERL_ARGS_ASSERT_SSC_INIT      \
        assert(pRExC_state); assert(ssc)
-#ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE void        S_ssc_intersection(pTHX_ regnode_ssc *ssc, SV* const invlist, const bool invert_2nd);
+STATIC void    S_ssc_intersection(pTHX_ regnode_ssc *ssc, SV* const invlist, const bool invert_2nd);
 #define PERL_ARGS_ASSERT_SSC_INTERSECTION      \
        assert(ssc); assert(invlist)
-#endif
 STATIC int     S_ssc_is_anything(const regnode_ssc *ssc)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_SSC_IS_ANYTHING       \
@@ -5814,12 +5921,10 @@ STATIC int      S_ssc_is_cp_posixl_init(const RExC_state_t *pRExC_state, const regnod
 STATIC void    S_ssc_or(pTHX_ const RExC_state_t *pRExC_state, regnode_ssc *ssc, const regnode_charclass *or_with);
 #define PERL_ARGS_ASSERT_SSC_OR        \
        assert(pRExC_state); assert(ssc); assert(or_with)
-#ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE void        S_ssc_union(pTHX_ regnode_ssc *ssc, SV* const invlist, const bool invert_2nd);
+STATIC void    S_ssc_union(pTHX_ regnode_ssc *ssc, SV* const invlist, const bool invert_2nd);
 #define PERL_ARGS_ASSERT_SSC_UNION     \
        assert(ssc); assert(invlist)
-#endif
-STATIC SSize_t S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, SSize_t *minlenp, SSize_t *deltap, regnode *last, struct scan_data_t *data, I32 stopparen, U32 recursed_depth, regnode_ssc *and_withp, U32 flags, U32 depth);
+STATIC SSize_t S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, SSize_t *minlenp, SSize_t *deltap, regnode *last, struct scan_data_t *data, I32 stopparen, U32 recursed_depth, regnode_ssc *and_withp, U32 flags, U32 depth, bool was_mutate_ok);
 #define PERL_ARGS_ASSERT_STUDY_CHUNK   \
        assert(pRExC_state); assert(scanp); assert(minlenp); assert(deltap); assert(last)
 #endif
@@ -5955,9 +6060,6 @@ PERL_STATIC_INLINE const char *   S_get_regex_charset_name(const U32 flags, STRLEN
 #endif
 #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 **output_invlist);
-#define PERL_ARGS_ASSERT__GET_REGCLASS_NONBITMAP_DATA  \
-       assert(node)
 PERL_CALLCONV int      Perl_re_printf(pTHX_ const char *fmt, ...)
                        __attribute__format__(__printf__,pTHX_1,pTHX_2);
 #define PERL_ARGS_ASSERT_RE_PRINTF     \
@@ -6026,12 +6128,10 @@ PERL_CALLCONV SV*       Perl_invlist_clone(pTHX_ SV* const invlist, SV* newlist);
        assert(invlist)
 #endif
 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_TOKE_C)
-#ifndef PERL_NO_INLINE_FUNCTIONS
-PERL_STATIC_INLINE bool        S_regcurly(const char *s)
+PERL_CALLCONV bool     Perl_regcurly(const char *s)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_REGCURLY      \
        assert(s)
-#endif
 
 #endif
 #if defined(PERL_IN_REGEXEC_C)
@@ -6219,9 +6319,9 @@ STATIC SV*        S_find_uninit_var(pTHX_ const OP *const obase, const SV *const uninit
 STATIC bool    S_glob_2number(pTHX_ GV* const gv);
 #define PERL_ARGS_ASSERT_GLOB_2NUMBER  \
        assert(gv)
-STATIC void    S_glob_assign_glob(pTHX_ SV *const dstr, SV *const sstr, const int dtype);
+STATIC void    S_glob_assign_glob(pTHX_ SV *const dsv, SV *const ssv, const int dtype);
 #define PERL_ARGS_ASSERT_GLOB_ASSIGN_GLOB      \
-       assert(dstr); assert(sstr)
+       assert(dsv); assert(ssv)
 STATIC SV *    S_more_sv(pTHX);
 #define PERL_ARGS_ASSERT_MORE_SV
 STATIC void    S_not_a_number(pTHX_ SV *const sv);
@@ -6278,10 +6378,10 @@ STATIC I32      S_visit(pTHX_ SVFUNC_t f, const U32 flags, const U32 mask);
 #define PERL_ARGS_ASSERT_VISIT \
        assert(f)
 #  if defined(USE_ITHREADS)
-STATIC SV*     S_sv_dup_common(pTHX_ const SV *const sstr, CLONE_PARAMS *const param)
+STATIC SV*     S_sv_dup_common(pTHX_ const SV *const ssv, CLONE_PARAMS *const param)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_SV_DUP_COMMON \
-       assert(sstr); assert(param)
+       assert(ssv); assert(param)
 
 STATIC SV **   S_sv_dup_inc_multiple(pTHX_ SV *const *source, SV **dest, SSize_t items, CLONE_PARAMS *const param);
 #define PERL_ARGS_ASSERT_SV_DUP_INC_MULTIPLE   \
@@ -6656,9 +6756,9 @@ PERL_CALLCONV void        Perl_re_dup_guts(pTHX_ const REGEXP *sstr, REGEXP *dstr, CLON
 PERL_CALLCONV void*    Perl_regdupe_internal(pTHX_ REGEXP * const r, CLONE_PARAMS* param);
 #define PERL_ARGS_ASSERT_REGDUPE_INTERNAL      \
        assert(r); assert(param)
-PERL_CALLCONV void     Perl_rvpv_dup(pTHX_ SV *const dstr, const SV *const sstr, CLONE_PARAMS *const param);
+PERL_CALLCONV void     Perl_rvpv_dup(pTHX_ SV *const dsv, const SV *const ssv, CLONE_PARAMS *const param);
 #define PERL_ARGS_ASSERT_RVPV_DUP      \
-       assert(dstr); assert(sstr); assert(param)
+       assert(dsv); assert(ssv); assert(param)
 PERL_CALLCONV PERL_SI* Perl_si_dup(pTHX_ PERL_SI* si, CLONE_PARAMS* param)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_SI_DUP        \
@@ -6669,12 +6769,12 @@ PERL_CALLCONV ANY*      Perl_ss_dup(pTHX_ PerlInterpreter* proto_perl, CLONE_PARAMS*
 #define PERL_ARGS_ASSERT_SS_DUP        \
        assert(proto_perl); assert(param)
 
-PERL_CALLCONV SV*      Perl_sv_dup(pTHX_ const SV *const sstr, CLONE_PARAMS *const param)
+PERL_CALLCONV SV*      Perl_sv_dup(pTHX_ const SV *const ssv, CLONE_PARAMS *const param)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_SV_DUP        \
        assert(param)
 
-PERL_CALLCONV SV*      Perl_sv_dup_inc(pTHX_ const SV *const sstr, CLONE_PARAMS *const param)
+PERL_CALLCONV SV*      Perl_sv_dup_inc(pTHX_ const SV *const ssv, CLONE_PARAMS *const param)
                        __attribute__warn_unused_result__;
 #define PERL_ARGS_ASSERT_SV_DUP_INC    \
        assert(param)
@@ -6685,6 +6785,9 @@ PERL_CALLCONV bool        Perl__is_cur_LC_category_utf8(pTHX_ int category);
 #define PERL_ARGS_ASSERT__IS_CUR_LC_CATEGORY_UTF8
 #endif
 #if defined(USE_LOCALE_COLLATE)
+PERL_CALLCONV int      Perl_magic_freecollxfrm(pTHX_ SV* sv, MAGIC* mg);
+#define PERL_ARGS_ASSERT_MAGIC_FREECOLLXFRM    \
+       assert(sv); assert(mg)
 PERL_CALLCONV int      Perl_magic_setcollxfrm(pTHX_ SV* sv, MAGIC* mg);
 #define PERL_ARGS_ASSERT_MAGIC_SETCOLLXFRM     \
        assert(sv); assert(mg)
@@ -6782,7 +6885,7 @@ PERL_CALLCONV_NO_RET void win32_croak_not_implemented(const char * fname)
        assert(fname)
 
 #endif
-#if defined(WIN32) || defined(__SYMBIAN32__) || defined(VMS)
+#if defined(WIN32) || defined(VMS)
 PERL_CALLCONV int      Perl_do_aspawn(pTHX_ SV* really, SV** mark, SV** sp);
 #define PERL_ARGS_ASSERT_DO_ASPAWN     \
        assert(mark); assert(sp)
Unnamed repository; edit this file 'description' to name the repository.