X-Git-Url: https://perl5.git.perl.org/perl5.git/blobdiff_plain/81f54ac7f5f6cf7337babd8633132716c21d851a..2eaf799e74b14dc77b90d5484a3fd4ceac12b46a:/proto.h diff --git a/proto.h b/proto.h index 140d7f3..a540fc7 100644 --- a/proto.h +++ b/proto.h @@ -42,6 +42,7 @@ PERL_CALLCONV void Perl_Slab_Free(pTHX_ void *op) #define PERL_ARGS_ASSERT_SLAB_FREE \ assert(op) +PERL_CALLCONV bool Perl__is_in_locale_category(pTHX_ const bool compiling, const int category); PERL_CALLCONV bool Perl__is_uni_FOO(pTHX_ const U8 classnum, const UV c) __attribute__warn_unused_result__; @@ -57,6 +58,25 @@ PERL_CALLCONV bool Perl__is_utf8_FOO(pTHX_ const U8 classnum, const U8 *p) #define PERL_ARGS_ASSERT__IS_UTF8_FOO \ assert(p) +PERL_STATIC_INLINE STRLEN S__is_utf8_char_slow(const U8 *s, const U8 *e) + __attribute__warn_unused_result__ + __attribute__nonnull__(1) + __attribute__nonnull__(2); +#define PERL_ARGS_ASSERT__IS_UTF8_CHAR_SLOW \ + assert(s); assert(e) + +PERL_CALLCONV bool Perl__is_utf8_idcont(pTHX_ const U8 *p) + __attribute__warn_unused_result__ + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT__IS_UTF8_IDCONT \ + assert(p) + +PERL_CALLCONV bool Perl__is_utf8_idstart(pTHX_ const U8 *p) + __attribute__warn_unused_result__ + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT__IS_UTF8_IDSTART \ + assert(p) + PERL_CALLCONV bool Perl__is_utf8_mark(pTHX_ const U8 *p) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); @@ -75,6 +95,18 @@ PERL_CALLCONV bool Perl__is_utf8_perl_idstart(pTHX_ const U8 *p) #define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDSTART \ assert(p) +PERL_CALLCONV bool Perl__is_utf8_xidcont(pTHX_ const U8 *p) + __attribute__warn_unused_result__ + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT__IS_UTF8_XIDCONT \ + assert(p) + +PERL_CALLCONV bool Perl__is_utf8_xidstart(pTHX_ const U8 *p) + __attribute__warn_unused_result__ + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT__IS_UTF8_XIDSTART \ + assert(p) + PERL_CALLCONV UV Perl__to_uni_fold_flags(pTHX_ UV c, U8 *p, STRLEN *lenp, U8 flags) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3); @@ -342,16 +374,16 @@ PERL_CALLCONV bool Perl_cando(pTHX_ Mode_t mode, bool effective, const Stat_t* s #define PERL_ARGS_ASSERT_CANDO \ assert(statbufp) -PERL_CALLCONV I32 Perl_cast_i32(pTHX_ NV f) +PERL_CALLCONV I32 Perl_cast_i32(NV f) __attribute__warn_unused_result__; -PERL_CALLCONV IV Perl_cast_iv(pTHX_ NV f) +PERL_CALLCONV IV Perl_cast_iv(NV f) __attribute__warn_unused_result__; -PERL_CALLCONV U32 Perl_cast_ulong(pTHX_ NV f) +PERL_CALLCONV U32 Perl_cast_ulong(NV f) __attribute__warn_unused_result__; -PERL_CALLCONV UV Perl_cast_uv(pTHX_ NV f) +PERL_CALLCONV UV Perl_cast_uv(NV f) __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_check_utf8_print(pTHX_ const U8 *s, const STRLEN len) @@ -761,10 +793,10 @@ PERL_CALLCONV CV* Perl_cv_clone_into(pTHX_ CV* proto, CV *target) #define PERL_ARGS_ASSERT_CV_CLONE_INTO \ assert(proto); assert(target) -PERL_CALLCONV SV* Perl_cv_const_sv(pTHX_ const CV *const cv) +PERL_CALLCONV SV* Perl_cv_const_sv(const CV *const cv) __attribute__warn_unused_result__; -PERL_CALLCONV SV* Perl_cv_const_sv_or_av(pTHX_ const CV *const cv) +PERL_CALLCONV SV* Perl_cv_const_sv_or_av(const CV *const cv) __attribute__warn_unused_result__; PERL_CALLCONV void Perl_cv_forget_slab(pTHX_ CV *cv) @@ -779,6 +811,11 @@ PERL_CALLCONV void Perl_cv_get_call_checker(pTHX_ CV *cv, Perl_call_checker *ckf #define PERL_ARGS_ASSERT_CV_GET_CALL_CHECKER \ assert(cv); assert(ckfun_p); assert(ckobj_p) +PERL_CALLCONV SV * Perl_cv_name(pTHX_ CV *cv, SV *sv) + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_CV_NAME \ + assert(cv) + PERL_CALLCONV void Perl_cv_set_call_checker(pTHX_ CV *cv, Perl_call_checker ckfun, SV *ckobj) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) @@ -791,6 +828,11 @@ PERL_CALLCONV void Perl_cv_undef(pTHX_ CV* cv) #define PERL_ARGS_ASSERT_CV_UNDEF \ assert(cv) +PERL_CALLCONV GV * Perl_cvgv_from_hek(pTHX_ CV* cv) + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_CVGV_FROM_HEK \ + assert(cv) + PERL_CALLCONV void Perl_cvgv_set(pTHX_ CV* cv, GV* gv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_CVGV_SET \ @@ -841,14 +883,6 @@ PERL_CALLCONV char* Perl_delimcpy(char* to, const char* toend, const char* from, assert(to); assert(toend); assert(from); assert(fromend); assert(retlen) PERL_CALLCONV void Perl_despatch_signals(pTHX); -PERL_CALLCONV OP* Perl_die(pTHX_ const char* pat, ...) - __attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2); - -PERL_CALLCONV OP* Perl_die_sv(pTHX_ SV *baseex) - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_DIE_SV \ - assert(baseex) - PERL_CALLCONV_NO_RET void Perl_die_unwind(pTHX_ SV* msv) __attribute__noreturn__ __attribute__nonnull__(pTHX_1); @@ -1265,6 +1299,11 @@ PERL_CALLCONV int Perl_getcwd_sv(pTHX_ SV* sv) PERL_CALLCONV void Perl_gp_free(pTHX_ GV* gv); PERL_CALLCONV GP* Perl_gp_ref(pTHX_ GP* gp); +PERL_CALLCONV UV Perl_grok_atou(const char* pv, const char** endptr) + __attribute__nonnull__(1); +#define PERL_ARGS_ASSERT_GROK_ATOU \ + assert(pv) + PERL_CALLCONV UV Perl_grok_bin(pTHX_ const char* start, STRLEN* len_p, I32* flags, NV *result) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) @@ -1279,11 +1318,22 @@ PERL_CALLCONV UV Perl_grok_hex(pTHX_ const char* start, STRLEN* len_p, I32* flag #define PERL_ARGS_ASSERT_GROK_HEX \ assert(start); assert(len_p); assert(flags) +PERL_CALLCONV int Perl_grok_infnan(const char** sp, const char *send) + __attribute__nonnull__(1) + __attribute__nonnull__(2); +#define PERL_ARGS_ASSERT_GROK_INFNAN \ + assert(sp); assert(send) + PERL_CALLCONV int Perl_grok_number(pTHX_ const char *pv, STRLEN len, UV *valuep) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_GROK_NUMBER \ assert(pv) +PERL_CALLCONV int Perl_grok_number_flags(pTHX_ const char *pv, STRLEN len, UV *valuep, U32 flags) + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_GROK_NUMBER_FLAGS \ + assert(pv) + PERL_CALLCONV bool Perl_grok_numeric_radix(pTHX_ const char **sp, const char *send) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) @@ -1762,7 +1812,7 @@ PERL_CALLCONV bool Perl_io_close(pTHX_ IO* io, bool not_implicit) #define PERL_ARGS_ASSERT_IO_CLOSE \ assert(io) -PERL_STATIC_INLINE bool S_isALNUM_lazy(pTHX_ const char* p) +PERL_CALLCONV bool Perl_isALNUM_lazy(pTHX_ const char* p) __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__ @@ -1770,7 +1820,7 @@ PERL_STATIC_INLINE bool S_isALNUM_lazy(pTHX_ const char* p) #define PERL_ARGS_ASSERT_ISALNUM_LAZY \ assert(p) -PERL_STATIC_INLINE bool S_isIDFIRST_lazy(pTHX_ const char* p) +PERL_CALLCONV bool Perl_isIDFIRST_lazy(pTHX_ const char* p) __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__ @@ -1985,9 +2035,9 @@ 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) +/* PERL_CALLCONV STRLEN Perl_is_utf8_char_buf(const U8 *buf, const U8 *buf_end) __attribute__nonnull__(1) - __attribute__nonnull__(2); + __attribute__nonnull__(2); */ #define PERL_ARGS_ASSERT_IS_UTF8_CHAR_BUF \ assert(buf); assert(buf_end) @@ -2125,6 +2175,7 @@ PERL_CALLCONV bool Perl_is_utf8_xidfirst(pTHX_ const U8 *p) #define PERL_ARGS_ASSERT_IS_UTF8_XIDFIRST \ assert(p) +PERL_CALLCONV bool Perl_isinfnan(NV nv); PERL_CALLCONV OP* Perl_jmaybe(pTHX_ OP *o) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_JMAYBE \ @@ -2503,7 +2554,7 @@ PERL_CALLCONV Malloc_t Perl_malloc(MEM_SIZE nbytes) __attribute__malloc__ __attribute__warn_unused_result__; -PERL_CALLCONV void Perl_markstack_grow(pTHX); +PERL_CALLCONV I32 * Perl_markstack_grow(pTHX); PERL_CALLCONV SV* Perl_mess(pTHX_ const char* pat, ...) __attribute__format__(__printf__,pTHX_1,pTHX_2) __attribute__nonnull__(pTHX_1); @@ -2527,7 +2578,7 @@ PERL_CALLCONV int Perl_mg_copy(pTHX_ SV *sv, SV *nsv, const char *key, I32 klen) #define PERL_ARGS_ASSERT_MG_COPY \ assert(sv); assert(nsv) -PERL_CALLCONV MAGIC* Perl_mg_find(pTHX_ const SV* sv, int type) +PERL_CALLCONV MAGIC* Perl_mg_find(const SV* sv, int type) __attribute__warn_unused_result__; PERL_CALLCONV MAGIC* Perl_mg_find_mglob(pTHX_ SV* sv) @@ -2536,7 +2587,7 @@ PERL_CALLCONV MAGIC* Perl_mg_find_mglob(pTHX_ SV* sv) #define PERL_ARGS_ASSERT_MG_FIND_MGLOB \ assert(sv) -PERL_CALLCONV MAGIC* Perl_mg_findext(pTHX_ const SV* sv, int type, const MGVTBL *vtbl) +PERL_CALLCONV MAGIC* Perl_mg_findext(const SV* sv, int type, const MGVTBL *vtbl) __attribute__warn_unused_result__; PERL_CALLCONV int Perl_mg_free(pTHX_ SV* sv) @@ -2566,8 +2617,8 @@ PERL_CALLCONV void Perl_mg_localize(pTHX_ SV* sv, SV* nsv, bool setmagic) #define PERL_ARGS_ASSERT_MG_LOCALIZE \ assert(sv); assert(nsv) -PERL_CALLCONV void Perl_mg_magical(pTHX_ SV* sv) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV void Perl_mg_magical(SV* sv) + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_MG_MAGICAL \ assert(sv) @@ -2581,8 +2632,8 @@ PERL_CALLCONV I32 Perl_mg_size(pTHX_ SV* sv) #define PERL_ARGS_ASSERT_MG_SIZE \ assert(sv) -PERL_CALLCONV void Perl_mini_mktime(pTHX_ struct tm *ptm) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV void Perl_mini_mktime(struct tm *ptm) + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_MINI_MKTIME \ assert(ptm) @@ -2664,7 +2715,7 @@ PERL_CALLCONV OP * Perl_my_attrs(pTHX_ OP *o, OP *attrs) assert(o) PERL_CALLCONV void Perl_my_clearenv(pTHX); -PERL_CALLCONV int Perl_my_dirfd(pTHX_ DIR* dir); +PERL_CALLCONV int Perl_my_dirfd(DIR* dir); PERL_CALLCONV_NO_RET void Perl_my_exit(pTHX_ U32 status) __attribute__noreturn__; @@ -2692,6 +2743,7 @@ PERL_CALLCONV int Perl_my_snprintf(char *buffer, const Size_t len, const char *f PERL_CALLCONV int Perl_my_socketpair(int family, int type, int protocol, int fd[2]); /* PERL_CALLCONV I32 Perl_my_stat(pTHX); */ 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) __attribute__format__(__strftime__,pTHX_1,0) __attribute__nonnull__(pTHX_1); @@ -2748,6 +2800,7 @@ PERL_CALLCONV OP* Perl_newCVREF(pTHX_ I32 flags, OP* o) __attribute__malloc__ __attribute__warn_unused_result__; +PERL_CALLCONV void Perl_newFORM(pTHX_ I32 floor, OP* o, OP* block); PERL_CALLCONV OP* Perl_newFOROP(pTHX_ I32 flags, OP* sv, OP* expr, OP* block, OP* cont) __attribute__malloc__ __attribute__warn_unused_result__ @@ -3090,10 +3143,20 @@ PERL_CALLCONV void Perl_op_null(pTHX_ OP* o) #define PERL_ARGS_ASSERT_OP_NULL \ assert(o) +PERL_CALLCONV OP* Perl_op_parent(OP *o) + __attribute__nonnull__(1); +#define PERL_ARGS_ASSERT_OP_PARENT \ + assert(o) + PERL_CALLCONV OP* Perl_op_prepend_elem(pTHX_ I32 optype, OP* first, OP* last); PERL_CALLCONV void Perl_op_refcnt_lock(pTHX); PERL_CALLCONV void Perl_op_refcnt_unlock(pTHX); PERL_CALLCONV OP* Perl_op_scope(pTHX_ OP* o); +PERL_CALLCONV OP* Perl_op_sibling_splice(OP *parent, OP *start, int del_count, OP* insert) + __attribute__nonnull__(1); +#define PERL_ARGS_ASSERT_OP_SIBLING_SPLICE \ + assert(parent) + PERL_CALLCONV OP* Perl_op_unscope(pTHX_ OP* o); 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__nonnull__(pTHX_1) @@ -3105,6 +3168,11 @@ PERL_CALLCONV void Perl_pack_cat(pTHX_ SV *cat, const char *pat, const char *pat #define PERL_ARGS_ASSERT_PACK_CAT \ assert(cat); assert(pat); assert(patend); assert(beglist); assert(endlist); assert(next_in_list) +PERL_CALLCONV void Perl_package(pTHX_ OP* o) + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_PACKAGE \ + assert(o) + PERL_CALLCONV void Perl_package_version(pTHX_ OP* v) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_PACKAGE_VERSION \ @@ -3822,13 +3890,6 @@ PERL_CALLCONV char* Perl_scan_vstring(pTHX_ const char *s, const char *const e, #define PERL_ARGS_ASSERT_SCAN_VSTRING \ assert(s); assert(e); assert(sv) -PERL_CALLCONV char* Perl_screaminstr(pTHX_ SV *bigstr, SV *littlestr, I32 start_shift, I32 end_shift, I32 *old_posp, I32 last) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_5); -#define PERL_ARGS_ASSERT_SCREAMINSTR \ - assert(bigstr); assert(littlestr); assert(old_posp) - PERL_CALLCONV U32 Perl_seed(pTHX); PERL_CALLCONV void Perl_set_caret_X(pTHX); PERL_CALLCONV void Perl_set_context(void *t) @@ -3971,8 +4032,8 @@ PERL_CALLCONV UV Perl_sv_2uv_flags(pTHX_ SV *const sv, const I32 flags) #define PERL_ARGS_ASSERT_SV_2UV_FLAGS \ assert(sv) -PERL_CALLCONV int Perl_sv_backoff(pTHX_ SV *const sv) - __attribute__nonnull__(pTHX_1); +PERL_CALLCONV int Perl_sv_backoff(SV *const sv) + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_SV_BACKOFF \ assert(sv) @@ -4646,6 +4707,7 @@ PERL_CALLCONV SV* Perl_swash_init(pTHX_ const char* pkg, const char* name, SV* l #define PERL_ARGS_ASSERT_SWASH_INIT \ assert(pkg); assert(name); assert(listsv) +PERL_CALLCONV void Perl_sync_locale(pTHX); PERL_CALLCONV void Perl_sys_init(int* argc, char*** argv) __attribute__nonnull__(1) __attribute__nonnull__(2); @@ -4791,10 +4853,10 @@ 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(pTHX_ const U8 *s, I32 off) +PERL_CALLCONV U8* Perl_utf8_hop(const U8 *s, I32 off) __attribute__warn_unused_result__ __attribute__pure__ - __attribute__nonnull__(pTHX_1); + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_UTF8_HOP \ assert(s) @@ -4845,6 +4907,11 @@ PERL_CALLCONV UV Perl_utf8n_to_uvuni(pTHX_ const U8 *s, STRLEN curlen, STRLEN *r #define PERL_ARGS_ASSERT_UTF8N_TO_UVUNI \ assert(s) +PERL_CALLCONV void Perl_utilize(pTHX_ int aver, I32 floor, OP* version, OP* idop, OP* arg) + __attribute__nonnull__(pTHX_4); +#define PERL_ARGS_ASSERT_UTILIZE \ + assert(idop) + /* PERL_CALLCONV U8* uvchr_to_utf8(pTHX_ U8 *d, UV uv) __attribute__nonnull__(pTHX_1); */ @@ -5081,25 +5148,22 @@ PERL_CALLCONV void* Perl_my_cxt_init(pTHX_ int *index, size_t size) # endif #endif -#if !(defined(PERL_MAD)) -PERL_CALLCONV void Perl_newFORM(pTHX_ I32 floor, OP* o, OP* block); -PERL_CALLCONV void Perl_package(pTHX_ OP* o) - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_PACKAGE \ - assert(o) - -PERL_CALLCONV void Perl_utilize(pTHX_ int aver, I32 floor, OP* version, OP* idop, OP* arg) - __attribute__nonnull__(pTHX_4); -#define PERL_ARGS_ASSERT_UTILIZE \ - assert(idop) - -#endif #if !(defined(WIN32)) /* PERL_CALLCONV char* my_setlocale(pTHX_ int category, const char* locale) __attribute__pure__; */ #endif #if !(defined(_MSC_VER)) +PERL_CALLCONV_NO_RET OP* Perl_die(pTHX_ const char* pat, ...) + __attribute__noreturn__ + __attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2); + +PERL_CALLCONV_NO_RET OP* Perl_die_sv(pTHX_ SV *baseex) + __attribute__noreturn__ + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_DIE_SV \ + assert(baseex) + PERL_CALLCONV_NO_RET int Perl_magic_regdatum_set(pTHX_ SV* sv, MAGIC* mg) __attribute__noreturn__ __attribute__nonnull__(pTHX_1) @@ -5107,6 +5171,20 @@ PERL_CALLCONV_NO_RET int Perl_magic_regdatum_set(pTHX_ SV* sv, MAGIC* mg) #define PERL_ARGS_ASSERT_MAGIC_REGDATUM_SET \ assert(sv); assert(mg) +PERL_CALLCONV_NO_RET char* Perl_screaminstr(pTHX_ SV *bigstr, SV *littlestr, I32 start_shift, I32 end_shift, I32 *old_posp, I32 last) + __attribute__noreturn__ + __attribute__nonnull__(pTHX_1) + __attribute__nonnull__(pTHX_2) + __attribute__nonnull__(pTHX_5); +#define PERL_ARGS_ASSERT_SCREAMINSTR \ + assert(bigstr); assert(littlestr); assert(old_posp) + +# if defined(PERL_IMPLICIT_CONTEXT) +PERL_CALLCONV_NO_RET OP* Perl_die_nocontext(const char* pat, ...) + __attribute__noreturn__ + __attribute__format__null_ok__(__printf__,1,2); + +# endif #endif #if !defined(HAS_BZERO) && !defined(HAS_MEMSET) PERL_CALLCONV char* Perl_my_bzero(char* loc, I32 len) @@ -5288,6 +5366,9 @@ STATIC void S_cv_dump(pTHX_ const CV *cv, const char *title) # endif # if defined(PERL_IN_REGCOMP_C) +STATIC const char * S_cntrl_to_mnemonic(const U8 c) + __attribute__pure__; + STATIC void S_dump_trie(pTHX_ const struct _reg_trie_data *trie, HV* widecharmap, AV *revcharmap, U32 depth) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_3); @@ -5314,18 +5395,18 @@ STATIC const regnode* S_dumpuntil(pTHX_ const regexp *r, const regnode *start, c #define PERL_ARGS_ASSERT_DUMPUNTIL \ assert(r); assert(start); assert(node); assert(sv) -STATIC void S_put_byte(pTHX_ SV* sv, int c) - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_PUT_BYTE \ - assert(sv) - -STATIC bool S_put_latin1_charclass_innards(pTHX_ SV* sv, char* bitmap) +STATIC bool S_put_charclass_bitmap_innards(pTHX_ SV* sv, char* bitmap, SV** bitmap_invlist) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); -#define PERL_ARGS_ASSERT_PUT_LATIN1_CHARCLASS_INNARDS \ +#define PERL_ARGS_ASSERT_PUT_CHARCLASS_BITMAP_INNARDS \ assert(sv); assert(bitmap) -STATIC void S_put_range(pTHX_ SV* sv, UV start, UV end) +STATIC void S_put_code_point(pTHX_ SV* sv, UV c) + __attribute__nonnull__(pTHX_1); +#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) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_PUT_RANGE \ assert(sv) @@ -5596,9 +5677,6 @@ PERL_CALLCONV void Perl_deb_nocontext(const char* pat, ...) #define PERL_ARGS_ASSERT_DEB_NOCONTEXT \ assert(pat) -PERL_CALLCONV OP* Perl_die_nocontext(const char* pat, ...) - __attribute__format__null_ok__(__printf__,1,2); - PERL_CALLCONV char* Perl_form_nocontext(const char* pat, ...) __attribute__format__(__printf__,1,2) __attribute__nonnull__(1); @@ -5675,6 +5753,11 @@ PERL_CALLCONV void Perl_warner_nocontext(U32 err, const char* pat, ...) #define PERL_ARGS_ASSERT_WARNER_NOCONTEXT \ assert(pat) +# if defined(_MSC_VER) +PERL_CALLCONV OP* Perl_die_nocontext(const char* pat, ...) + __attribute__format__null_ok__(__printf__,1,2); + +# endif #endif #if defined(PERL_IMPLICIT_SYS) PERL_CALLCONV PerlInterpreter* perl_alloc_using(struct IPerlMem *ipM, struct IPerlMem *ipMS, struct IPerlMem *ipMP, struct IPerlEnv *ipE, struct IPerlStdIO *ipStd, struct IPerlLIO *ipLIO, struct IPerlDir *ipD, struct IPerlSock *ipS, struct IPerlProc *ipP) @@ -5800,15 +5883,6 @@ STATIC SV* S_pm_description(pTHX_ const PMOP *pm) assert(pm) STATIC UV S_sequence_num(pTHX_ const OP *o); -# if defined(PERL_MAD) -STATIC void S_xmldump_attr(pTHX_ I32 level, PerlIO *file, const char* pat, ...) - __attribute__format__(__printf__,pTHX_3,pTHX_4) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_3); -#define PERL_ARGS_ASSERT_XMLDUMP_ATTR \ - assert(file); assert(pat) - -# endif #endif #if defined(PERL_IN_DUMP_C) || defined(PERL_IN_HV_C) || defined(PERL_IN_SV_C) || defined(PERL_IN_SCOPE_C) PERL_CALLCONV void Perl_hv_kill_backrefs(pTHX_ HV *hv) @@ -5846,6 +5920,12 @@ STATIC void S_gv_magicalize_isa(pTHX_ GV *gv) #define PERL_ARGS_ASSERT_GV_MAGICALIZE_ISA \ assert(gv) +PERL_STATIC_INLINE HV* S_gv_stashpvn_internal(pTHX_ const char* name, U32 namelen, I32 flags) + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_GV_STASHPVN_INTERNAL \ + assert(name) + +PERL_STATIC_INLINE HV* S_gv_stashsvpvn_cached(pTHX_ SV *namesv, const char* name, U32 namelen, I32 flags); STATIC void S_maybe_multimagic_gv(pTHX_ GV *gv, const char *name, const svtype sv_type) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); @@ -5965,14 +6045,6 @@ PERL_CALLCONV SV* Perl_hfree_next_entry(pTHX_ HV *hv, STRLEN *indexp) assert(hv); assert(indexp) #endif -#if defined(PERL_IN_LOCALE_C) && defined(USE_LOCALE) -STATIC bool S_is_cur_LC_category_utf8(pTHX_ int category); -STATIC char* S_stdize_locale(pTHX_ char* locs) - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_STDIZE_LOCALE \ - assert(locs) - -#endif #if defined(PERL_IN_MALLOC_C) STATIC int S_adjust_size_and_find_bucket(size_t *nbytes_p) __attribute__nonnull__(1); @@ -6009,9 +6081,9 @@ STATIC void S_save_magic_flags(pTHX_ I32 mgs_ix, SV *sv, U32 flags) STATIC void S_unwind_handler_stack(pTHX_ const void *p); #endif #if defined(PERL_IN_MG_C) || defined(PERL_IN_PP_C) -PERL_CALLCONV bool Perl_translate_substr_offsets(pTHX_ STRLEN curlen, IV pos1_iv, bool pos1_is_uv, IV len_iv, bool len_is_uv, STRLEN *posp, STRLEN *lenp) - __attribute__nonnull__(pTHX_6) - __attribute__nonnull__(pTHX_7); +PERL_CALLCONV bool Perl_translate_substr_offsets(STRLEN curlen, IV pos1_iv, bool pos1_is_uv, IV len_iv, bool len_is_uv, STRLEN *posp, STRLEN *lenp) + __attribute__nonnull__(6) + __attribute__nonnull__(7); #define PERL_ARGS_ASSERT_TRANSLATE_SUBSTR_OFFSETS \ assert(posp); assert(lenp) @@ -6068,6 +6140,13 @@ STATIC void S_bad_type_pv(pTHX_ I32 n, const char *t, const char *name, U32 flag #define PERL_ARGS_ASSERT_BAD_TYPE_PV \ assert(t); assert(name); assert(kid) +STATIC void S_clear_special_blocks(pTHX_ const char *const fullname, GV *const gv, CV *const cv) + __attribute__nonnull__(pTHX_1) + __attribute__nonnull__(pTHX_2) + __attribute__nonnull__(pTHX_3); +#define PERL_ARGS_ASSERT_CLEAR_SPECIAL_BLOCKS \ + assert(fullname); assert(gv); assert(cv) + STATIC void S_cop_free(pTHX_ COP *cop) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_COP_FREE \ @@ -6093,7 +6172,7 @@ STATIC OP* S_fold_constants(pTHX_ OP *o) #define PERL_ARGS_ASSERT_FOLD_CONSTANTS \ assert(o) -STATIC OP* S_force_list(pTHX_ OP* arg); +STATIC OP* S_force_list(pTHX_ OP* arg, bool nullit); STATIC void S_forget_pmop(pTHX_ PMOP *const o) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_FORGET_PMOP \ @@ -6186,7 +6265,7 @@ STATIC OP* S_pmtrans(pTHX_ OP* o, OP* expr, OP* repl) #define PERL_ARGS_ASSERT_PMTRANS \ assert(o); assert(expr); assert(repl) -STATIC void S_process_special_blocks(pTHX_ I32 floor, const char *const fullname, GV *const gv, CV *const cv) +STATIC bool S_process_special_blocks(pTHX_ I32 floor, const char *const fullname, GV *const gv, CV *const cv) __attribute__nonnull__(pTHX_2) __attribute__nonnull__(pTHX_3) __attribute__nonnull__(pTHX_4); @@ -6563,12 +6642,6 @@ STATIC I32 S_amagic_cmp(pTHX_ SV *const str1, SV *const str2) #define PERL_ARGS_ASSERT_AMAGIC_CMP \ assert(str1); assert(str2) -STATIC I32 S_amagic_cmp_locale(pTHX_ SV *const str1, SV *const str2) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); -#define PERL_ARGS_ASSERT_AMAGIC_CMP_LOCALE \ - assert(str1); assert(str2) - STATIC I32 S_amagic_i_ncmp(pTHX_ SV *const a, SV *const b) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); @@ -6616,6 +6689,14 @@ STATIC I32 S_sv_ncmp(pTHX_ SV *const a, SV *const b) #define PERL_ARGS_ASSERT_SV_NCMP \ assert(a); assert(b) +# if defined(USE_LOCALE_COLLATE) +STATIC I32 S_amagic_cmp_locale(pTHX_ SV *const str1, SV *const str2) + __attribute__nonnull__(pTHX_1) + __attribute__nonnull__(pTHX_2); +#define PERL_ARGS_ASSERT_AMAGIC_CMP_LOCALE \ + assert(str1); assert(str2) + +# endif #endif #if defined(PERL_IN_PP_SYS_C) STATIC OP* S_doform(pTHX_ CV *cv, GV *gv, OP *retop) @@ -6636,12 +6717,18 @@ STATIC void S__append_range_to_invlist(pTHX_ SV* const invlist, const UV start, #define PERL_ARGS_ASSERT__APPEND_RANGE_TO_INVLIST \ assert(invlist) -PERL_STATIC_INLINE UV* S__invlist_array_init(pTHX_ SV* const invlist, const bool will_have_0) +PERL_STATIC_INLINE UV* S__invlist_array_init(SV* const invlist, const bool will_have_0) __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT__INVLIST_ARRAY_INIT \ assert(invlist) +STATIC void S_add_above_Latin1_folds(pTHX_ RExC_state_t *pRExC_state, const U8 cp, SV** invlist) + __attribute__nonnull__(pTHX_1) + __attribute__nonnull__(pTHX_3); +#define PERL_ARGS_ASSERT_ADD_ABOVE_LATIN1_FOLDS \ + assert(pRExC_state); assert(invlist) + PERL_STATIC_INLINE SV* S_add_cp_to_invlist(pTHX_ SV* invlist, const UV cp) __attribute__warn_unused_result__; @@ -6652,6 +6739,11 @@ STATIC U32 S_add_data(RExC_state_t* const pRExC_state, const char* const s, cons #define PERL_ARGS_ASSERT_ADD_DATA \ assert(pRExC_state); assert(s) +STATIC AV* S_add_multi_match(pTHX_ AV* multi_char_matches, SV* multi_string, const STRLEN cp_count) + __attribute__nonnull__(pTHX_2); +#define PERL_ARGS_ASSERT_ADD_MULTI_MATCH \ + assert(multi_string) + PERL_STATIC_INLINE void S_alloc_maybe_populate_EXACT(pTHX_ RExC_state_t *pRExC_state, regnode *node, I32 *flagp, STRLEN len, UV code_point, bool downgradable) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) @@ -6659,13 +6751,19 @@ PERL_STATIC_INLINE void S_alloc_maybe_populate_EXACT(pTHX_ RExC_state_t *pRExC_s #define PERL_ARGS_ASSERT_ALLOC_MAYBE_POPULATE_EXACT \ assert(pRExC_state); assert(node); assert(flagp) -PERL_STATIC_INLINE U8 S_compute_EXACTish(pTHX_ RExC_state_t *pRExC_state) - __attribute__nonnull__(pTHX_1); +PERL_STATIC_INLINE U8 S_compute_EXACTish(RExC_state_t *pRExC_state) + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_COMPUTE_EXACTISH \ assert(pRExC_state) -STATIC bool S_could_it_be_a_POSIX_class(pTHX_ RExC_state_t *pRExC_state) - __attribute__nonnull__(pTHX_1); +STATIC regnode * S_construct_ahocorasick_from_trie(pTHX_ RExC_state_t *pRExC_state, regnode *source, U32 depth) + __attribute__nonnull__(pTHX_1) + __attribute__nonnull__(pTHX_2); +#define PERL_ARGS_ASSERT_CONSTRUCT_AHOCORASICK_FROM_TRIE \ + assert(pRExC_state); assert(source) + +STATIC bool S_could_it_be_a_POSIX_class(RExC_state_t *pRExC_state) + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_COULD_IT_BE_A_POSIX_CLASS \ assert(pRExC_state) @@ -6675,19 +6773,19 @@ STATIC SV* S_get_ANYOF_cp_list_for_ssc(pTHX_ const RExC_state_t *pRExC_state, co #define PERL_ARGS_ASSERT_GET_ANYOF_CP_LIST_FOR_SSC \ assert(pRExC_state); assert(node) -PERL_STATIC_INLINE STRLEN* S_get_invlist_iter_addr(pTHX_ SV* invlist) +PERL_STATIC_INLINE STRLEN* S_get_invlist_iter_addr(SV* invlist) __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_GET_INVLIST_ITER_ADDR \ assert(invlist) -PERL_STATIC_INLINE IV* S_get_invlist_previous_index_addr(pTHX_ SV* invlist) +PERL_STATIC_INLINE IV* S_get_invlist_previous_index_addr(SV* invlist) __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_GET_INVLIST_PREVIOUS_INDEX_ADDR \ assert(invlist) -STATIC bool S_grok_bslash_N(pTHX_ RExC_state_t *pRExC_state, regnode** nodep, UV *valuep, I32 *flagp, U32 depth, bool in_char_class, const bool strict) +STATIC STRLEN S_grok_bslash_N(pTHX_ RExC_state_t *pRExC_state, regnode** nodep, UV *valuep, I32 *flagp, U32 depth, SV** substitute_parse) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_4); #define PERL_ARGS_ASSERT_GROK_BSLASH_N \ @@ -6700,9 +6798,9 @@ STATIC regnode* S_handle_regex_sets(pTHX_ RExC_state_t *pRExC_state, SV ** retur #define PERL_ARGS_ASSERT_HANDLE_REGEX_SETS \ assert(pRExC_state); assert(flagp); assert(oregcomp_parse) -PERL_STATIC_INLINE UV* S_invlist_array(pTHX_ SV* const invlist) +PERL_STATIC_INLINE UV* S_invlist_array(SV* const invlist) __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_INVLIST_ARRAY \ assert(invlist) @@ -6717,45 +6815,45 @@ STATIC void S_invlist_extend(pTHX_ SV* const invlist, const UV len) #define PERL_ARGS_ASSERT_INVLIST_EXTEND \ assert(invlist) -PERL_STATIC_INLINE UV S_invlist_highest(pTHX_ SV* const invlist) +PERL_STATIC_INLINE UV S_invlist_highest(SV* const invlist) __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_INVLIST_HIGHEST \ assert(invlist) -PERL_STATIC_INLINE bool S_invlist_is_iterating(pTHX_ SV* const invlist) +PERL_STATIC_INLINE bool S_invlist_is_iterating(SV* const invlist) __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_INVLIST_IS_ITERATING \ assert(invlist) -PERL_STATIC_INLINE void S_invlist_iterfinish(pTHX_ SV* invlist) - __attribute__nonnull__(pTHX_1); +PERL_STATIC_INLINE void S_invlist_iterfinish(SV* invlist) + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_INVLIST_ITERFINISH \ assert(invlist) -PERL_STATIC_INLINE void S_invlist_iterinit(pTHX_ SV* invlist) - __attribute__nonnull__(pTHX_1); +PERL_STATIC_INLINE void S_invlist_iterinit(SV* invlist) + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_INVLIST_ITERINIT \ assert(invlist) -STATIC bool S_invlist_iternext(pTHX_ SV* invlist, UV* start, UV* end) +STATIC bool S_invlist_iternext(SV* invlist, UV* start, UV* end) __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_3); + __attribute__nonnull__(1) + __attribute__nonnull__(2) + __attribute__nonnull__(3); #define PERL_ARGS_ASSERT_INVLIST_ITERNEXT \ assert(invlist); assert(start); assert(end) -PERL_STATIC_INLINE UV S_invlist_max(pTHX_ SV* const invlist) +PERL_STATIC_INLINE UV S_invlist_max(SV* const invlist) __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_INVLIST_MAX \ assert(invlist) -PERL_STATIC_INLINE IV S_invlist_previous_index(pTHX_ SV* const invlist) +PERL_STATIC_INLINE IV S_invlist_previous_index(SV* const invlist) __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_INVLIST_PREVIOUS_INDEX \ assert(invlist) @@ -6764,13 +6862,13 @@ PERL_STATIC_INLINE void S_invlist_set_len(pTHX_ SV* const invlist, const UV len, #define PERL_ARGS_ASSERT_INVLIST_SET_LEN \ assert(invlist) -PERL_STATIC_INLINE void S_invlist_set_previous_index(pTHX_ SV* const invlist, const IV index) - __attribute__nonnull__(pTHX_1); +PERL_STATIC_INLINE void S_invlist_set_previous_index(SV* const invlist, const IV index) + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_INVLIST_SET_PREVIOUS_INDEX \ assert(invlist) -PERL_STATIC_INLINE void S_invlist_trim(pTHX_ SV* const invlist) - __attribute__nonnull__(pTHX_1); +PERL_STATIC_INLINE void S_invlist_trim(SV* const invlist) + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_INVLIST_TRIM \ assert(invlist) @@ -6791,13 +6889,6 @@ STATIC I32 S_make_trie(pTHX_ RExC_state_t *pRExC_state, regnode *startbranch, re #define PERL_ARGS_ASSERT_MAKE_TRIE \ assert(pRExC_state); assert(startbranch); assert(first); assert(last); assert(tail) -STATIC void S_make_trie_failtable(pTHX_ RExC_state_t *pRExC_state, regnode *source, regnode *stclass, U32 depth) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_3); -#define PERL_ARGS_ASSERT_MAKE_TRIE_FAILTABLE \ - assert(pRExC_state); assert(source); assert(stclass) - STATIC char * S_nextchar(pTHX_ RExC_state_t *pRExC_state) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_NEXTCHAR \ @@ -6842,10 +6933,11 @@ STATIC SV * S_reg_scan_name(pTHX_ RExC_state_t *pRExC_state, U32 flags) #define PERL_ARGS_ASSERT_REG_SCAN_NAME \ assert(pRExC_state) -STATIC bool S_reg_skipcomment(pTHX_ RExC_state_t *pRExC_state) - __attribute__nonnull__(pTHX_1); +PERL_STATIC_INLINE char * S_reg_skipcomment(RExC_state_t *pRExC_state, char * p) + __attribute__nonnull__(1) + __attribute__nonnull__(2); #define PERL_ARGS_ASSERT_REG_SKIPCOMMENT \ - assert(pRExC_state) + assert(pRExC_state); assert(p) STATIC regnode* S_reganode(pTHX_ RExC_state_t *pRExC_state, U8 op, U32 arg) __attribute__nonnull__(pTHX_1); @@ -6907,13 +6999,6 @@ PERL_STATIC_INLINE STRLEN S_reguni(pTHX_ const RExC_state_t *pRExC_state, UV uv, #define PERL_ARGS_ASSERT_REGUNI \ assert(pRExC_state); assert(s) -STATIC char * S_regwhite(RExC_state_t *pRExC_state, char *p) - __attribute__warn_unused_result__ - __attribute__nonnull__(1) - __attribute__nonnull__(2); -#define PERL_ARGS_ASSERT_REGWHITE \ - assert(pRExC_state); assert(p) - STATIC void S_scan_commit(pTHX_ const RExC_state_t *pRExC_state, struct scan_data_t *data, SSize_t *minlenp, int is_inf) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) @@ -6944,8 +7029,8 @@ STATIC void S_ssc_anything(pTHX_ regnode_ssc *ssc) #define PERL_ARGS_ASSERT_SSC_ANYTHING \ assert(ssc) -PERL_STATIC_INLINE void S_ssc_clear_locale(pTHX_ regnode_ssc *ssc) - __attribute__nonnull__(pTHX_1); +PERL_STATIC_INLINE void S_ssc_clear_locale(regnode_ssc *ssc) + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_SSC_CLEAR_LOCALE \ assert(ssc) @@ -6972,16 +7057,16 @@ PERL_STATIC_INLINE void S_ssc_intersection(pTHX_ regnode_ssc *ssc, SV* const inv #define PERL_ARGS_ASSERT_SSC_INTERSECTION \ assert(ssc); assert(invlist) -STATIC int S_ssc_is_anything(pTHX_ const regnode_ssc *ssc) +STATIC int S_ssc_is_anything(const regnode_ssc *ssc) __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_SSC_IS_ANYTHING \ assert(ssc) -STATIC int S_ssc_is_cp_posixl_init(pTHX_ const RExC_state_t *pRExC_state, const regnode_ssc *ssc) +STATIC int S_ssc_is_cp_posixl_init(const RExC_state_t *pRExC_state, const regnode_ssc *ssc) __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); + __attribute__nonnull__(1) + __attribute__nonnull__(2); #define PERL_ARGS_ASSERT_SSC_IS_CP_POSIXL_INIT \ assert(pRExC_state); assert(ssc) @@ -7026,11 +7111,12 @@ 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) +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) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT__GET_REGCLASS_NONBITMAP_DATA \ assert(node) +PERL_CALLCONV void Perl__load_PL_utf8_foldclosures(pTHX); #endif #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C) PERL_CALLCONV SV* Perl__get_swash_invlist(pTHX_ SV* const swash) @@ -7039,9 +7125,9 @@ PERL_CALLCONV SV* Perl__get_swash_invlist(pTHX_ SV* const swash) #define PERL_ARGS_ASSERT__GET_SWASH_INVLIST \ assert(swash) -PERL_STATIC_INLINE bool S__invlist_contains_cp(pTHX_ SV* const invlist, const UV cp) +PERL_STATIC_INLINE bool S__invlist_contains_cp(SV* const invlist, const UV cp) __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT__INVLIST_CONTAINS_CP \ assert(invlist) @@ -7051,15 +7137,15 @@ PERL_CALLCONV SV* Perl__invlist_contents(pTHX_ SV* const invlist) #define PERL_ARGS_ASSERT__INVLIST_CONTENTS \ assert(invlist) -PERL_STATIC_INLINE UV S__invlist_len(pTHX_ SV* const invlist) +PERL_STATIC_INLINE UV S__invlist_len(SV* const invlist) __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT__INVLIST_LEN \ assert(invlist) -PERL_CALLCONV IV Perl__invlist_search(pTHX_ SV* const invlist, const UV cp) +PERL_CALLCONV IV Perl__invlist_search(SV* const invlist, const UV cp) __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT__INVLIST_SEARCH \ assert(invlist) @@ -7069,9 +7155,9 @@ PERL_CALLCONV HV* Perl__swash_inversion_hash(pTHX_ SV* const swash) #define PERL_ARGS_ASSERT__SWASH_INVERSION_HASH \ assert(swash) -PERL_STATIC_INLINE bool* S_get_invlist_offset_addr(pTHX_ SV* invlist) +PERL_STATIC_INLINE bool* S_get_invlist_offset_addr(SV* invlist) __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1); + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_GET_INVLIST_OFFSET_ADDR \ assert(invlist) @@ -7112,10 +7198,10 @@ PERL_STATIC_INLINE bool S_grok_bslash_x(pTHX_ char** s, UV* uv, const char** err #define PERL_ARGS_ASSERT_GROK_BSLASH_X \ assert(s); assert(uv); assert(error_msg) -PERL_STATIC_INLINE I32 S_regcurly(pTHX_ const char *s, const bool rbrace_must_be_escaped) +PERL_STATIC_INLINE I32 S_regcurly(const char *s) __attribute__warn_unused_result__ __attribute__pure__ - __attribute__nonnull__(pTHX_1); + __attribute__nonnull__(1); #define PERL_ARGS_ASSERT_REGCURLY \ assert(s) @@ -7140,9 +7226,9 @@ PERL_CALLCONV void Perl__invlist_invert(pTHX_ SV* const invlist) #define PERL_ARGS_ASSERT__INVLIST_INVERT \ assert(invlist) -PERL_CALLCONV void Perl__invlist_populate_swatch(pTHX_ SV* const invlist, const UV start, const UV end, U8* swatch) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_4); +PERL_CALLCONV void Perl__invlist_populate_swatch(SV* const invlist, const UV start, const UV end, U8* swatch) + __attribute__nonnull__(1) + __attribute__nonnull__(4); #define PERL_ARGS_ASSERT__INVLIST_POPULATE_SWATCH \ assert(invlist); assert(swatch) @@ -7196,10 +7282,10 @@ STATIC bool S_isFOO_utf8_lc(pTHX_ const U8 classnum, const U8* character) #define PERL_ARGS_ASSERT_ISFOO_UTF8_LC \ assert(character) -STATIC I32 S_reg_check_named_buff_matched(pTHX_ const regexp *rex, const regnode *scan) +STATIC I32 S_reg_check_named_buff_matched(const regexp *rex, const regnode *scan) __attribute__warn_unused_result__ - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); + __attribute__nonnull__(1) + __attribute__nonnull__(2); #define PERL_ARGS_ASSERT_REG_CHECK_NAMED_BUFF_MATCHED \ assert(rex); assert(scan) @@ -7351,6 +7437,11 @@ STATIC void S_not_a_number(pTHX_ SV *const sv) #define PERL_ARGS_ASSERT_NOT_A_NUMBER \ assert(sv) +STATIC void S_not_incrementable(pTHX_ SV *const sv) + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_NOT_INCREMENTABLE \ + assert(sv) + STATIC PTR_TBL_ENT_t * S_ptr_table_find(PTR_TBL_t *const tbl, const void *const sv) __attribute__warn_unused_result__ __attribute__nonnull__(1); @@ -7367,6 +7458,12 @@ STATIC void S_sv_add_arena(pTHX_ char *const ptr, const U32 size, const U32 flag #define PERL_ARGS_ASSERT_SV_ADD_ARENA \ assert(ptr) +STATIC const char * S_sv_display(pTHX_ SV *const sv, char *tmpbuf, STRLEN tmpbuf_size) + __attribute__nonnull__(pTHX_1) + __attribute__nonnull__(pTHX_2); +#define PERL_ARGS_ASSERT_SV_DISPLAY \ + assert(sv); assert(tmpbuf) + STATIC STRLEN S_sv_pos_b2u_midway(pTHX_ const U8 *const s, const U8 *const target, const U8 *end, STRLEN endu) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2) @@ -7518,7 +7615,7 @@ STATIC void S_incline(pTHX_ const char *s) #define PERL_ARGS_ASSERT_INCLINE \ assert(s) -STATIC int S_intuit_method(pTHX_ char *s, GV *gv, CV *cv) +STATIC int S_intuit_method(pTHX_ char *s, SV *ioname, CV *cv) __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_INTUIT_METHOD \ assert(s) @@ -7591,7 +7688,7 @@ STATIC char* S_scan_pat(pTHX_ char *start, I32 type) #define PERL_ARGS_ASSERT_SCAN_PAT \ assert(start) -STATIC char* S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims, int re_reparse, bool deprecate_escaped_matching, char **delimp) +STATIC char* S_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims, int re_reparse, char **delimp) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SCAN_STR \ @@ -7654,25 +7751,6 @@ STATIC int S_yywarn(pTHX_ const char *const s, U32 flags) #define PERL_ARGS_ASSERT_YYWARN \ assert(s) -# if defined(PERL_MAD) -STATIC void S_curmad(pTHX_ char slot, SV *sv); -STATIC char* S_skipspace0(pTHX_ char *s) - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_SKIPSPACE0 \ - assert(s) - -STATIC char* S_skipspace1(pTHX_ char *s) - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_SKIPSPACE1 \ - assert(s) - -STATIC char* S_skipspace2(pTHX_ char *s, SV **sv) - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_SKIPSPACE2 \ - assert(s) - -STATIC void S_start_force(pTHX_ int where); -# endif #endif #if defined(PERL_IN_UNIVERSAL_C) STATIC bool S_isa_lookup(pTHX_ HV *stash, const char * const name, STRLEN len, U32 flags) @@ -7691,12 +7769,6 @@ STATIC UV S_check_locale_boundary_crossing(pTHX_ const U8* const p, const UV res #define PERL_ARGS_ASSERT_CHECK_LOCALE_BOUNDARY_CROSSING \ assert(p); assert(ustrp); assert(lenp) -PERL_STATIC_INLINE STRLEN S_is_utf8_char_slow(const U8 *s, const STRLEN len) - __attribute__warn_unused_result__ - __attribute__nonnull__(1); -#define PERL_ARGS_ASSERT_IS_UTF8_CHAR_SLOW \ - assert(s) - PERL_STATIC_INLINE bool S_is_utf8_common(pTHX_ const U8 *const p, SV **swash, const char * const swashname, SV* const invlist) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1) @@ -7705,13 +7777,24 @@ PERL_STATIC_INLINE bool S_is_utf8_common(pTHX_ const U8 *const p, SV **swash, co #define PERL_ARGS_ASSERT_IS_UTF8_COMMON \ assert(p); assert(swash); assert(swashname) +STATIC U8* S_swash_scan_list_line(pTHX_ U8* l, U8* const lend, UV* min, UV* max, UV* val, const bool wants_value, const U8* const typestr) + __attribute__warn_unused_result__ + __attribute__nonnull__(pTHX_1) + __attribute__nonnull__(pTHX_2) + __attribute__nonnull__(pTHX_3) + __attribute__nonnull__(pTHX_4) + __attribute__nonnull__(pTHX_5) + __attribute__nonnull__(pTHX_7); +#define PERL_ARGS_ASSERT_SWASH_SCAN_LIST_LINE \ + assert(l); assert(lend); assert(min); assert(max); assert(val); assert(typestr) + STATIC SV* S_swatch_get(pTHX_ SV* swash, UV start, UV span) __attribute__warn_unused_result__ __attribute__nonnull__(pTHX_1); #define PERL_ARGS_ASSERT_SWATCH_GET \ assert(swash) -STATIC U8 S_to_lower_latin1(pTHX_ const U8 c, U8 *p, STRLEN *lenp) +STATIC U8 S_to_lower_latin1(const U8 c, U8 *p, STRLEN *lenp) __attribute__warn_unused_result__; #endif @@ -7750,129 +7833,6 @@ STATIC void S_mem_log_common(enum mem_log_type mlt, const UV n, const UV typesiz # endif #endif -#if defined(PERL_MAD) -PERL_CALLCONV void Perl_addmad(pTHX_ MADPROP* tm, MADPROP** root, char slot); -PERL_CALLCONV void Perl_append_madprops(pTHX_ MADPROP* tm, OP* o, char slot); -PERL_CALLCONV void Perl_do_op_xmldump(pTHX_ I32 level, PerlIO *file, const OP *o) - __attribute__nonnull__(pTHX_2); -#define PERL_ARGS_ASSERT_DO_OP_XMLDUMP \ - assert(file) - -PERL_CALLCONV void Perl_do_pmop_xmldump(pTHX_ I32 level, PerlIO *file, const PMOP *pm) - __attribute__nonnull__(pTHX_2); -#define PERL_ARGS_ASSERT_DO_PMOP_XMLDUMP \ - assert(file) - -PERL_CALLCONV void Perl_mad_free(pTHX_ MADPROP* mp); -PERL_CALLCONV int Perl_madlex(pTHX); -PERL_CALLCONV int Perl_madparse(pTHX_ int gramtype); -PERL_CALLCONV OP* Perl_newFORM(pTHX_ I32 floor, OP* o, OP* block); -PERL_CALLCONV MADPROP* Perl_newMADPROP(pTHX_ char key, char type, void* val, I32 vlen); -PERL_CALLCONV MADPROP* Perl_newMADsv(pTHX_ char key, SV* sv) - __attribute__nonnull__(pTHX_2); -#define PERL_ARGS_ASSERT_NEWMADSV \ - assert(sv) - -PERL_CALLCONV TOKEN* Perl_newTOKEN(pTHX_ I32 optype, YYSTYPE lval, MADPROP* madprop); -PERL_CALLCONV void Perl_op_getmad(pTHX_ OP* from, OP* o, char slot); -PERL_CALLCONV void Perl_op_getmad_weak(pTHX_ OP* from, OP* o, char slot); -PERL_CALLCONV void Perl_op_xmldump(pTHX_ const OP *o) - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_OP_XMLDUMP \ - assert(o) - -PERL_CALLCONV OP* Perl_package(pTHX_ OP* o) - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_PACKAGE \ - assert(o) - -PERL_CALLCONV void Perl_pad_peg(const char* s) - __attribute__nonnull__(1); -#define PERL_ARGS_ASSERT_PAD_PEG \ - assert(s) - -PERL_CALLCONV void Perl_pmop_xmldump(pTHX_ const PMOP* pm); -PERL_CALLCONV void Perl_prepend_madprops(pTHX_ MADPROP* mp, OP* o, char slot); -PERL_CALLCONV char* Perl_sv_catxmlpv(pTHX_ SV *dsv, const char *pv, int utf8) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); -#define PERL_ARGS_ASSERT_SV_CATXMLPV \ - assert(dsv); assert(pv) - -PERL_CALLCONV char* Perl_sv_catxmlpvn(pTHX_ SV *dsv, const char *pv, STRLEN len, int utf8) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); -#define PERL_ARGS_ASSERT_SV_CATXMLPVN \ - assert(dsv); assert(pv) - -PERL_CALLCONV char* Perl_sv_catxmlsv(pTHX_ SV *dsv, SV *ssv) - __attribute__nonnull__(pTHX_1) - __attribute__nonnull__(pTHX_2); -#define PERL_ARGS_ASSERT_SV_CATXMLSV \ - assert(dsv); assert(ssv) - -PERL_CALLCONV char* Perl_sv_xmlpeek(pTHX_ SV* sv) - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_SV_XMLPEEK \ - assert(sv) - -PERL_CALLCONV void Perl_token_free(pTHX_ TOKEN *tk) - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_TOKEN_FREE \ - assert(tk) - -PERL_CALLCONV void Perl_token_getmad(pTHX_ TOKEN *tk, OP *o, char slot) - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_TOKEN_GETMAD \ - assert(tk) - -PERL_CALLCONV OP * Perl_utilize(pTHX_ int aver, I32 floor, OP* version, OP* idop, OP* arg) - __attribute__nonnull__(pTHX_4); -#define PERL_ARGS_ASSERT_UTILIZE \ - assert(idop) - -PERL_CALLCONV void Perl_xmldump_all(pTHX); -PERL_CALLCONV void Perl_xmldump_all_perl(pTHX_ bool justperl); -PERL_CALLCONV void Perl_xmldump_eval(pTHX); -PERL_CALLCONV void Perl_xmldump_form(pTHX_ const GV* gv) - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_XMLDUMP_FORM \ - assert(gv) - -PERL_CALLCONV void Perl_xmldump_indent(pTHX_ I32 level, PerlIO *file, const char* pat, ...) - __attribute__format__(__printf__,pTHX_3,pTHX_4) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_3); -#define PERL_ARGS_ASSERT_XMLDUMP_INDENT \ - assert(file); assert(pat) - -PERL_CALLCONV void Perl_xmldump_packsubs(pTHX_ const HV* stash) - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_XMLDUMP_PACKSUBS \ - assert(stash) - -PERL_CALLCONV void Perl_xmldump_packsubs_perl(pTHX_ const HV* stash, bool justperl) - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_XMLDUMP_PACKSUBS_PERL \ - assert(stash) - -PERL_CALLCONV void Perl_xmldump_sub(pTHX_ const GV* gv) - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_XMLDUMP_SUB \ - assert(gv) - -PERL_CALLCONV void Perl_xmldump_sub_perl(pTHX_ const GV* gv, bool justperl) - __attribute__nonnull__(pTHX_1); -#define PERL_ARGS_ASSERT_XMLDUMP_SUB_PERL \ - assert(gv) - -PERL_CALLCONV void Perl_xmldump_vindent(pTHX_ I32 level, PerlIO *file, const char* pat, va_list *args) - __attribute__nonnull__(pTHX_2) - __attribute__nonnull__(pTHX_3); -#define PERL_ARGS_ASSERT_XMLDUMP_VINDENT \ - assert(file); assert(pat) - -#endif #if defined(PERL_USES_PL_PIDSTATUS) && defined(PERL_IN_UTIL_C) STATIC void S_pidgone(pTHX_ Pid_t pid, int status); #endif @@ -7883,6 +7843,18 @@ PERL_CALLCONV I32 Perl_unlnk(pTHX_ const char* f) assert(f) #endif +#if defined(USE_C_BACKTRACE) +PERL_CALLCONV bool Perl_dump_c_backtrace(pTHX_ PerlIO* fp, int max_depth, int skip) + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_DUMP_C_BACKTRACE \ + assert(fp) + +/* PERL_CALLCONV void free_c_backtrace(pTHX_ Perl_c_backtrace* bt) + __attribute__nonnull__(pTHX_1); */ + +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_ITHREADS) PERL_CALLCONV PADOFFSET Perl_alloccopstash(pTHX_ HV *hv) __attribute__nonnull__(pTHX_1); @@ -8025,6 +7997,14 @@ PERL_CALLCONV SV* Perl_sv_dup_inc(pTHX_ const SV *const sstr, CLONE_PARAMS *cons assert(param) #endif +#if defined(USE_LOCALE) && (defined(PERL_IN_LOCALE_C) || defined (PERL_EXT_POSIX)) +PERL_CALLCONV bool Perl__is_cur_LC_category_utf8(pTHX_ int category); +STATIC char* S_stdize_locale(pTHX_ char* locs) + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_STDIZE_LOCALE \ + assert(locs) + +#endif #if defined(USE_LOCALE_COLLATE) PERL_CALLCONV int Perl_magic_setcollxfrm(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) @@ -8125,12 +8105,27 @@ PERL_CALLCONV int Perl_do_spawn_nowait(pTHX_ char* cmd) #endif #if defined(_MSC_VER) +PERL_CALLCONV OP* Perl_die(pTHX_ const char* pat, ...) + __attribute__format__null_ok__(__printf__,pTHX_1,pTHX_2); + +PERL_CALLCONV OP* Perl_die_sv(pTHX_ SV *baseex) + __attribute__nonnull__(pTHX_1); +#define PERL_ARGS_ASSERT_DIE_SV \ + assert(baseex) + PERL_CALLCONV int Perl_magic_regdatum_set(pTHX_ SV* sv, MAGIC* mg) __attribute__nonnull__(pTHX_1) __attribute__nonnull__(pTHX_2); #define PERL_ARGS_ASSERT_MAGIC_REGDATUM_SET \ assert(sv); assert(mg) +PERL_CALLCONV char* Perl_screaminstr(pTHX_ SV *bigstr, SV *littlestr, I32 start_shift, I32 end_shift, I32 *old_posp, I32 last) + __attribute__nonnull__(pTHX_1) + __attribute__nonnull__(pTHX_2) + __attribute__nonnull__(pTHX_5); +#define PERL_ARGS_ASSERT_SCREAMINSTR \ + assert(bigstr); assert(littlestr); assert(old_posp) + #endif #ifdef PERL_CORE # include "pp_proto.h"