X-Git-Url: https://perl5.git.perl.org/perl5.git/blobdiff_plain/d8d1dede53afc4f33cf63203b0992459fe964dc3..36f453d19563f9476d4310b8310ce4080209b04f:/proto.h diff --git a/proto.h b/proto.h index 266ba598..e886261 100644 --- 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, ...) @@ -938,6 +956,11 @@ PERL_CALLCONV Off_t Perl_do_tell(pTHX_ GV* gv) PERL_CALLCONV Size_t Perl_do_trans(pTHX_ SV* sv); #define PERL_ARGS_ASSERT_DO_TRANS \ assert(sv) +PERL_CALLCONV I16 Perl_do_uniprop_match(const char * const key, const U16 key_len) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_DO_UNIPROP_MATCH \ + assert(key) + PERL_CALLCONV UV Perl_do_vecget(pTHX_ SV* sv, STRLEN offset, int size); #define PERL_ARGS_ASSERT_DO_VECGET \ assert(sv) @@ -1099,6 +1122,10 @@ PERL_CALLCONV CV* Perl_get_cvn_flags(pTHX_ const char* name, STRLEN len, I32 fla PERL_CALLCONV void Perl_get_db_sub(pTHX_ SV **svp, CV *cv); #define PERL_ARGS_ASSERT_GET_DB_SUB \ assert(cv) +PERL_CALLCONV const char * Perl_get_deprecated_property_msg(const Size_t warning_offset) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_GET_DEPRECATED_PROPERTY_MSG + PERL_CALLCONV void Perl_get_hash_seed(pTHX_ unsigned char * const seed_buffer); #define PERL_ARGS_ASSERT_GET_HASH_SEED \ assert(seed_buffer) @@ -1130,6 +1157,14 @@ PERL_CALLCONV PPADDR_t* Perl_get_ppaddr(pTHX) __attribute__pure__; #define PERL_ARGS_ASSERT_GET_PPADDR +PERL_CALLCONV SV * Perl_get_prop_definition(pTHX_ const int table_index) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_GET_PROP_DEFINITION + +PERL_CALLCONV const char * const * Perl_get_prop_values(const int table_index) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_GET_PROP_VALUES + PERL_CALLCONV REGEXP * Perl_get_re_arg(pTHX_ SV *sv); #define PERL_ARGS_ASSERT_GET_RE_ARG PERL_CALLCONV SV* Perl_get_sv(pTHX_ const char *name, I32 flags); @@ -1278,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); @@ -1323,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) @@ -1822,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) @@ -2026,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) @@ -2541,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) @@ -2575,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 @@ -3203,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 @@ -3260,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 \ @@ -3284,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 @@ -3551,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 @@ -3678,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) @@ -3909,10 +3960,12 @@ PERL_CALLCONV STRLEN Perl_utf8_length(pTHX_ const U8* s, const U8 *e) PERL_CALLCONV U8* Perl_utf8_to_bytes(pTHX_ U8 *s, STRLEN *lenp); #define PERL_ARGS_ASSERT_UTF8_TO_BYTES \ assert(s); assert(lenp) +#ifndef NO_MATHOMS PERL_CALLCONV UV Perl_utf8_to_uvchr(pTHX_ const U8 *s, STRLEN *retlen) __attribute__deprecated__; #define PERL_ARGS_ASSERT_UTF8_TO_UVCHR \ assert(s) +#endif PERL_CALLCONV UV Perl_utf8_to_uvchr_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen); #define PERL_ARGS_ASSERT_UTF8_TO_UVCHR_BUF \ @@ -3945,9 +3998,13 @@ PERL_STATIC_INLINE UV Perl_utf8n_to_uvchr_msgs(const U8 *s, STRLEN curlen, STRLE #define PERL_ARGS_ASSERT_UTF8N_TO_UVCHR_MSGS \ assert(s) #endif -PERL_CALLCONV UV Perl_utf8n_to_uvuni(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags); +#ifndef NO_MATHOMS +PERL_CALLCONV UV Perl_utf8n_to_uvuni(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags) + __attribute__deprecated__; #define PERL_ARGS_ASSERT_UTF8N_TO_UVUNI \ assert(s) +#endif + PERL_CALLCONV void Perl_utilize(pTHX_ int aver, I32 floor, OP* version, OP* idop, OP* arg); #define PERL_ARGS_ASSERT_UTILIZE \ assert(idop) @@ -3966,9 +4023,13 @@ PERL_CALLCONV U8* Perl_uvoffuni_to_utf8_flags_msgs(pTHX_ U8 *d, UV uv, const UV PERL_CALLCONV U8* Perl_uvuni_to_utf8(pTHX_ U8 *d, UV uv); #define PERL_ARGS_ASSERT_UVUNI_TO_UTF8 \ assert(d) -PERL_CALLCONV U8* Perl_uvuni_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags); +#ifndef NO_MATHOMS +PERL_CALLCONV U8* Perl_uvuni_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags) + __attribute__deprecated__; #define PERL_ARGS_ASSERT_UVUNI_TO_UTF8_FLAGS \ assert(d) +#endif + #ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE UV Perl_valid_utf8_to_uvchr(const U8 *s, STRLEN *retlen) __attribute__warn_unused_result__; @@ -4107,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) @@ -4131,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 @@ -4289,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); @@ -4637,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); @@ -4735,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__ @@ -4791,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 \ @@ -5364,13 +5414,6 @@ PERL_CALLCONV GV* Perl_softref2xv(pTHX_ SV *const sv, const char *const what, co assert(sv); assert(what); assert(spp) #endif -#if defined(PERL_IN_PP_C) || defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_TOKE_C) || defined(PERL_IN_UNIVERSAL_C) -#ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE const char * S_get_regex_charset_name(const U32 flags, STRLEN* const lenp); -#define PERL_ARGS_ASSERT_GET_REGEX_CHARSET_NAME \ - assert(lenp) -#endif -#endif #if defined(PERL_IN_PP_CTL_C) STATIC PerlIO * S_check_type_and_open(pTHX_ SV *name) __attribute__warn_unused_result__; @@ -5467,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); @@ -5518,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) @@ -5536,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) @@ -5570,11 +5708,14 @@ STATIC AV* S_add_multi_match(pTHX_ AV* multi_char_matches, SV* multi_string, con STATIC void S_change_engine_size(pTHX_ RExC_state_t *pRExC_state, const Ptrdiff_t size); #define PERL_ARGS_ASSERT_CHANGE_ENGINE_SIZE \ assert(pRExC_state) -#ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE U8 S_compute_EXACTish(RExC_state_t *pRExC_state); +STATIC REGEXP* S_compile_wildcard(pTHX_ const char * subpattern, const STRLEN len, const bool ignore_case) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_COMPILE_WILDCARD \ + assert(subpattern) + +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) @@ -5583,6 +5724,9 @@ STATIC int S_edit_distance(const UV *src, const UV *tgt, const STRLEN x, const S #define PERL_ARGS_ASSERT_EDIT_DISTANCE \ assert(src); assert(tgt) +STATIC I32 S_execute_wildcard(pTHX_ REGEXP * const prog, char* stringarg, char* strend, char* strbeg, SSize_t minend, SV* screamer, U32 nosave); +#define PERL_ARGS_ASSERT_EXECUTE_WILDCARD \ + assert(prog); assert(stringarg); assert(strend); assert(strbeg); assert(screamer) #ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE Size_t S_find_first_differing_byte_pos(const U8 * s1, const U8 * s2, const Size_t max); #define PERL_ARGS_ASSERT_FIND_FIRST_DIFFERING_BYTE_POS \ @@ -5599,18 +5743,19 @@ 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) STATIC regnode_offset S_handle_regex_sets(pTHX_ RExC_state_t *pRExC_state, SV ** return_invlist, I32 *flagp, U32 depth, char * const oregcomp_parse); #define PERL_ARGS_ASSERT_HANDLE_REGEX_SETS \ assert(pRExC_state); assert(flagp); assert(oregcomp_parse) -PERL_CALLCONV SV * Perl_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); +STATIC SV * 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); #define PERL_ARGS_ASSERT_HANDLE_USER_DEFINED_PROPERTY \ assert(name); assert(contents); assert(user_defined_ptr); assert(msg) #ifndef PERL_NO_INLINE_FUNCTIONS @@ -5662,16 +5807,20 @@ 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) -PERL_CALLCONV SV * Perl_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) -PERL_STATIC_NO_RET void S_re_croak2(pTHX_ bool utf8, const char* pat1, const char* pat2, ...) - __attribute__noreturn__; -#define PERL_ARGS_ASSERT_RE_CROAK2 \ - assert(pat1); assert(pat2) +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 regnode_offset S_reg(pTHX_ RExC_state_t *pRExC_state, I32 paren, I32 *flagp, U32 depth); #define PERL_ARGS_ASSERT_REG \ @@ -5715,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) @@ -5735,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 \ @@ -5780,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 @@ -5794,56 +5933,114 @@ PERL_CALLCONV void Perl__invlist_dump(pTHX_ PerlIO *file, I32 level, const char* #define PERL_ARGS_ASSERT__INVLIST_DUMP \ assert(file); assert(indent); assert(invlist) #endif -#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_OP_C) +#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_DOOP_C) || defined(PERL_IN_OP_C) #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE STRLEN* S_get_invlist_iter_addr(SV* invlist) +PERL_STATIC_INLINE SV* S_add_cp_to_invlist(pTHX_ SV* invlist, const UV cp) __attribute__warn_unused_result__; -#define PERL_ARGS_ASSERT_GET_INVLIST_ITER_ADDR \ - assert(invlist) +#define PERL_ARGS_ASSERT_ADD_CP_TO_INVLIST #endif #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE void S_invlist_iterfinish(SV* invlist); -#define PERL_ARGS_ASSERT_INVLIST_ITERFINISH \ +PERL_STATIC_INLINE void S_invlist_extend(pTHX_ SV* const invlist, const UV len); +#define PERL_ARGS_ASSERT_INVLIST_EXTEND \ assert(invlist) #endif #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE void S_invlist_iterinit(SV* invlist); -#define PERL_ARGS_ASSERT_INVLIST_ITERINIT \ +PERL_STATIC_INLINE UV S_invlist_highest(SV* const invlist) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_INVLIST_HIGHEST \ assert(invlist) #endif + #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE bool S_invlist_iternext(SV* invlist, UV* start, UV* end) +PERL_STATIC_INLINE void S_invlist_set_len(pTHX_ SV* const invlist, const UV len, const bool offset); +#define PERL_ARGS_ASSERT_INVLIST_SET_LEN \ + assert(invlist) +#endif +#endif +#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_DOOP_C) || defined(PERL_IN_OP_C) || defined(PERL_IN_UTF8_C) +PERL_CALLCONV SV* Perl__add_range_to_invlist(pTHX_ SV* invlist, UV start, UV end) __attribute__warn_unused_result__; -#define PERL_ARGS_ASSERT_INVLIST_ITERNEXT \ - assert(invlist); assert(start); assert(end) +#define PERL_ARGS_ASSERT__ADD_RANGE_TO_INVLIST + +/* PERL_CALLCONV void _invlist_intersection(pTHX_ SV* const a, SV* const b, SV** i); */ +#define PERL_ARGS_ASSERT__INVLIST_INTERSECTION +PERL_CALLCONV void Perl__invlist_intersection_maybe_complement_2nd(pTHX_ SV* const a, SV* const b, const bool complement_b, SV** i); +#define PERL_ARGS_ASSERT__INVLIST_INTERSECTION_MAYBE_COMPLEMENT_2ND \ + assert(b); assert(i) +PERL_CALLCONV void Perl__invlist_invert(pTHX_ SV* const invlist); +#define PERL_ARGS_ASSERT__INVLIST_INVERT \ + assert(invlist) +/* PERL_CALLCONV void _invlist_subtract(pTHX_ SV* const a, SV* const b, SV** result); */ +#define PERL_ARGS_ASSERT__INVLIST_SUBTRACT +/* PERL_CALLCONV void _invlist_union(pTHX_ SV* const a, SV* const b, SV** output); */ +#define PERL_ARGS_ASSERT__INVLIST_UNION +PERL_CALLCONV void Perl__invlist_union_maybe_complement_2nd(pTHX_ SV* const a, SV* const b, const bool complement_b, SV** output); +#define PERL_ARGS_ASSERT__INVLIST_UNION_MAYBE_COMPLEMENT_2ND \ + assert(b); assert(output) +PERL_CALLCONV SV* Perl__new_invlist(pTHX_ IV initial_size) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT__NEW_INVLIST + +PERL_CALLCONV SV* Perl__setup_canned_invlist(pTHX_ const STRLEN size, const UV element0, UV** other_elements_ptr) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT__SETUP_CANNED_INVLIST \ + assert(other_elements_ptr) + #endif +#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_DQUOTE_C) || defined(PERL_IN_TOKE_C) +PERL_CALLCONV const char * 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) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_FORM_ALIEN_DIGIT_MSG \ + assert(first_bad); assert(send) + +PERL_CALLCONV bool Perl_grok_bslash_c(pTHX_ const char source, U8 * result, const char** message, U32 * packed_warn) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_GROK_BSLASH_C \ + assert(result); assert(message) + +PERL_CALLCONV bool 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) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_GROK_BSLASH_O \ + assert(s); assert(send); assert(uv); assert(message) + +PERL_CALLCONV bool 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) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_GROK_BSLASH_X \ + assert(s); assert(send); assert(uv); assert(message) #endif -#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_OP_C) || defined(PERL_IN_DOOP_C) +#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_DQUOTE_C) || defined(PERL_IN_TOKE_C) || defined(PERL_IN_UTF8_C) +PERL_CALLCONV const char * Perl_form_cp_too_large_msg(pTHX_ const U8 which, const char * string, const Size_t len, const UV cp) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_FORM_CP_TOO_LARGE_MSG + +#endif +#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_OP_C) #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE SV* S_add_cp_to_invlist(pTHX_ SV* invlist, const UV cp) +PERL_STATIC_INLINE STRLEN* S_get_invlist_iter_addr(SV* invlist) __attribute__warn_unused_result__; -#define PERL_ARGS_ASSERT_ADD_CP_TO_INVLIST +#define PERL_ARGS_ASSERT_GET_INVLIST_ITER_ADDR \ + assert(invlist) #endif #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE void S_invlist_extend(pTHX_ SV* const invlist, const UV len); -#define PERL_ARGS_ASSERT_INVLIST_EXTEND \ +PERL_STATIC_INLINE void S_invlist_iterfinish(SV* invlist); +#define PERL_ARGS_ASSERT_INVLIST_ITERFINISH \ assert(invlist) #endif #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE UV S_invlist_highest(SV* const invlist) - __attribute__warn_unused_result__; -#define PERL_ARGS_ASSERT_INVLIST_HIGHEST \ +PERL_STATIC_INLINE void S_invlist_iterinit(SV* invlist); +#define PERL_ARGS_ASSERT_INVLIST_ITERINIT \ assert(invlist) #endif - #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE void S_invlist_set_len(pTHX_ SV* const invlist, const UV len, const bool offset); -#define PERL_ARGS_ASSERT_INVLIST_SET_LEN \ - assert(invlist) +PERL_STATIC_INLINE bool S_invlist_iternext(SV* invlist, UV* start, UV* end) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_INVLIST_ITERNEXT \ + assert(invlist); assert(start); assert(end) #endif + #endif #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_PERL_C) || defined(PERL_IN_UTF8_C) PERL_CALLCONV bool Perl__invlistEQ(pTHX_ SV* const a, SV* const b, const bool complement_b); @@ -5855,18 +6052,24 @@ PERL_CALLCONV SV* Perl__new_invlist_C_array(pTHX_ const UV* const list) assert(list) #endif +#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_PP_C) || defined(PERL_IN_TOKE_C) || defined(PERL_IN_UNIVERSAL_C) +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE const char * S_get_regex_charset_name(const U32 flags, STRLEN* const lenp); +#define PERL_ARGS_ASSERT_GET_REGEX_CHARSET_NAME \ + assert(lenp) +#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, ...); +PERL_CALLCONV int Perl_re_printf(pTHX_ const char *fmt, ...) + __attribute__format__(__printf__,pTHX_1,pTHX_2); #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) #endif -#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_TOKE_C) || defined(PERL_IN_UTF8_C) || defined(PERL_IN_PP_C) || defined(PERL_IN_OP_C) || defined(PERL_IN_DOOP_C) +#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_PP_C) || defined(PERL_IN_OP_C) || defined(PERL_IN_TOKE_C) || defined(PERL_IN_UTF8_C) || defined(PERL_IN_DOOP_C) #ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE bool S__invlist_contains_cp(SV* const invlist, const UV cp) __attribute__warn_unused_result__; @@ -5907,76 +6110,28 @@ PERL_STATIC_INLINE bool S_is_invlist(SV* const invlist) #endif #endif +#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_TOKE_C) +PERL_CALLCONV bool Perl_is_grapheme(pTHX_ const U8 * strbeg, const U8 * s, const U8 *strend, const UV cp) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_IS_GRAPHEME \ + assert(strbeg); assert(s); assert(strend) + +#endif +#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C) +PERL_CALLCONV UV Perl__to_fold_latin1(const U8 c, U8 *p, STRLEN *lenp, const unsigned int flags); +#define PERL_ARGS_ASSERT__TO_FOLD_LATIN1 \ + assert(p); assert(lenp) +#endif #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_SV_C) PERL_CALLCONV SV* Perl_invlist_clone(pTHX_ SV* const invlist, SV* newlist); #define PERL_ARGS_ASSERT_INVLIST_CLONE \ 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_REGCOMP_C) || defined(PERL_IN_TOKE_C) || defined(PERL_IN_DQUOTE_C) -PERL_CALLCONV const char * 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) - __attribute__warn_unused_result__; -#define PERL_ARGS_ASSERT_FORM_ALIEN_DIGIT_MSG \ - assert(first_bad); assert(send) - -PERL_CALLCONV bool Perl_grok_bslash_c(pTHX_ const char source, U8 * result, const char** message, U32 * packed_warn) - __attribute__warn_unused_result__; -#define PERL_ARGS_ASSERT_GROK_BSLASH_C \ - assert(result); assert(message) - -PERL_CALLCONV bool 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) - __attribute__warn_unused_result__; -#define PERL_ARGS_ASSERT_GROK_BSLASH_O \ - assert(s); assert(send); assert(uv); assert(message) - -PERL_CALLCONV bool 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) - __attribute__warn_unused_result__; -#define PERL_ARGS_ASSERT_GROK_BSLASH_X \ - assert(s); assert(send); assert(uv); assert(message) - -#endif -#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_TOKE_C) || defined(PERL_IN_DQUOTE_C) || defined(PERL_IN_UTF8_C) -PERL_CALLCONV const char * Perl_form_cp_too_large_msg(pTHX_ const U8 which, const char * string, const Size_t len, const UV cp) - __attribute__warn_unused_result__; -#define PERL_ARGS_ASSERT_FORM_CP_TOO_LARGE_MSG - -#endif -#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_UTF8_C) || defined(PERL_IN_OP_C) || defined(PERL_IN_DOOP_C) -PERL_CALLCONV SV* Perl__add_range_to_invlist(pTHX_ SV* invlist, UV start, UV end) - __attribute__warn_unused_result__; -#define PERL_ARGS_ASSERT__ADD_RANGE_TO_INVLIST - -/* PERL_CALLCONV void _invlist_intersection(pTHX_ SV* const a, SV* const b, SV** i); */ -#define PERL_ARGS_ASSERT__INVLIST_INTERSECTION -PERL_CALLCONV void Perl__invlist_intersection_maybe_complement_2nd(pTHX_ SV* const a, SV* const b, const bool complement_b, SV** i); -#define PERL_ARGS_ASSERT__INVLIST_INTERSECTION_MAYBE_COMPLEMENT_2ND \ - assert(b); assert(i) -PERL_CALLCONV void Perl__invlist_invert(pTHX_ SV* const invlist); -#define PERL_ARGS_ASSERT__INVLIST_INVERT \ - assert(invlist) -/* PERL_CALLCONV void _invlist_subtract(pTHX_ SV* const a, SV* const b, SV** result); */ -#define PERL_ARGS_ASSERT__INVLIST_SUBTRACT -/* PERL_CALLCONV void _invlist_union(pTHX_ SV* const a, SV* const b, SV** output); */ -#define PERL_ARGS_ASSERT__INVLIST_UNION -PERL_CALLCONV void Perl__invlist_union_maybe_complement_2nd(pTHX_ SV* const a, SV* const b, const bool complement_b, SV** output); -#define PERL_ARGS_ASSERT__INVLIST_UNION_MAYBE_COMPLEMENT_2ND \ - assert(b); assert(output) -PERL_CALLCONV SV* Perl__new_invlist(pTHX_ IV initial_size) - __attribute__warn_unused_result__; -#define PERL_ARGS_ASSERT__NEW_INVLIST - -PERL_CALLCONV SV* Perl__setup_canned_invlist(pTHX_ const STRLEN size, const UV element0, UV** other_elements_ptr) - __attribute__warn_unused_result__; -#define PERL_ARGS_ASSERT__SETUP_CANNED_INVLIST \ - assert(other_elements_ptr) #endif #if defined(PERL_IN_REGEXEC_C) @@ -6121,13 +6276,6 @@ STATIC void S_to_utf8_substr(pTHX_ regexp * prog); #define PERL_ARGS_ASSERT_TO_UTF8_SUBSTR \ assert(prog) #endif -#if defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_TOKE_C) -PERL_CALLCONV bool Perl_is_grapheme(pTHX_ const U8 * strbeg, const U8 * s, const U8 *strend, const UV cp) - __attribute__warn_unused_result__; -#define PERL_ARGS_ASSERT_IS_GRAPHEME \ - assert(strbeg); assert(s); assert(strend) - -#endif #if defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C) PERL_CALLCONV bool Perl_isFOO_lc(pTHX_ const U8 classnum, const U8 character) __attribute__warn_unused_result__; @@ -6171,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); @@ -6230,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 \ @@ -6454,11 +6602,6 @@ PERL_CALLCONV UV Perl__to_upper_title_latin1(pTHX_ const U8 c, U8 *p, STRLEN *le #define PERL_ARGS_ASSERT__TO_UPPER_TITLE_LATIN1 \ assert(p); assert(lenp) #endif -#if defined(PERL_IN_UTF8_C) || defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) -PERL_CALLCONV UV Perl__to_fold_latin1(const U8 c, U8 *p, STRLEN *lenp, const unsigned int flags); -#define PERL_ARGS_ASSERT__TO_FOLD_LATIN1 \ - assert(p); assert(lenp) -#endif #if defined(PERL_IN_UTIL_C) STATIC bool S_ckwarn_common(pTHX_ U32 w); #define PERL_ARGS_ASSERT_CKWARN_COMMON @@ -6613,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 \ @@ -6626,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) @@ -6642,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) @@ -6739,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)