X-Git-Url: https://perl5.git.perl.org/perl5.git/blobdiff_plain/45661033e6be88d16397139fbd546cb1c7f8cd56..f446eca7ef7f31dd356f4dba9401fc3326be139c:/proto.h diff --git a/proto.h b/proto.h index 228e84e..d6df7f4 100644 --- a/proto.h +++ b/proto.h @@ -41,6 +41,12 @@ PERL_CALLCONV void* Perl_Slab_Alloc(pTHX_ size_t sz) PERL_CALLCONV void Perl_Slab_Free(pTHX_ void *op); #define PERL_ARGS_ASSERT_SLAB_FREE \ assert(op) +PERL_CALLCONV char * Perl__byte_dump_string(pTHX_ const U8 * s, const STRLEN len, const bool format); +#define PERL_ARGS_ASSERT__BYTE_DUMP_STRING \ + assert(s) +PERL_CALLCONV void Perl__force_out_malformed_utf8_message(pTHX_ const U8 *const p, const U8 * const e, const U32 flags, const bool die_here); +#define PERL_ARGS_ASSERT__FORCE_OUT_MALFORMED_UTF8_MESSAGE \ + assert(p); assert(e) 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__; @@ -51,10 +57,21 @@ PERL_CALLCONV bool Perl__is_uni_perl_idcont(pTHX_ UV c) PERL_CALLCONV bool Perl__is_uni_perl_idstart(pTHX_ UV c) __attribute__warn_unused_result__; -PERL_CALLCONV bool Perl__is_utf8_FOO(pTHX_ const U8 classnum, const U8 *p) +PERL_CALLCONV bool Perl__is_utf8_FOO(pTHX_ U8 classnum, const U8 * const p, const char * const name, const char * const alternative, const bool use_utf8, const bool use_locale, const char * const file, const unsigned line) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT__IS_UTF8_FOO \ - assert(p) + assert(p); assert(name); assert(alternative); assert(file) + +PERL_CALLCONV bool Perl__is_utf8_FOO_with_len(pTHX_ const U8 classnum, const U8 *p, const U8 * const e) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT__IS_UTF8_FOO_WITH_LEN \ + assert(p); assert(e) + +PERL_CALLCONV STRLEN Perl__is_utf8_char_helper(const U8 * const s, const U8 * e, const U32 flags) + __attribute__warn_unused_result__ + __attribute__pure__; +#define PERL_ARGS_ASSERT__IS_UTF8_CHAR_HELPER \ + assert(s); assert(e) PERL_CALLCONV bool Perl__is_utf8_idcont(pTHX_ const U8 *p) __attribute__warn_unused_result__; @@ -71,15 +88,15 @@ PERL_CALLCONV bool Perl__is_utf8_mark(pTHX_ const U8 *p) #define PERL_ARGS_ASSERT__IS_UTF8_MARK \ assert(p) -PERL_CALLCONV bool Perl__is_utf8_perl_idcont(pTHX_ const U8 *p) +PERL_CALLCONV bool Perl__is_utf8_perl_idcont_with_len(pTHX_ const U8 *p, const U8 * const e) __attribute__warn_unused_result__; -#define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDCONT \ - assert(p) +#define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDCONT_WITH_LEN \ + assert(p); assert(e) -PERL_CALLCONV bool Perl__is_utf8_perl_idstart(pTHX_ const U8 *p) +PERL_CALLCONV bool Perl__is_utf8_perl_idstart_with_len(pTHX_ const U8 *p, const U8 * const e) __attribute__warn_unused_result__; -#define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDSTART \ - assert(p) +#define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDSTART_WITH_LEN \ + assert(p); assert(e) PERL_CALLCONV bool Perl__is_utf8_xidcont(pTHX_ const U8 *p) __attribute__warn_unused_result__; @@ -94,19 +111,24 @@ PERL_CALLCONV bool Perl__is_utf8_xidstart(pTHX_ const U8 *p) PERL_CALLCONV UV Perl__to_uni_fold_flags(pTHX_ UV c, U8 *p, STRLEN *lenp, U8 flags); #define PERL_ARGS_ASSERT__TO_UNI_FOLD_FLAGS \ assert(p); assert(lenp) -PERL_CALLCONV UV Perl__to_utf8_fold_flags(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp, U8 flags); +PERL_CALLCONV UV Perl__to_utf8_fold_flags(pTHX_ const U8 *p, const U8 *e, U8* ustrp, STRLEN *lenp, U8 flags, const char * const file, const int line); #define PERL_ARGS_ASSERT__TO_UTF8_FOLD_FLAGS \ - assert(p); assert(ustrp) -PERL_CALLCONV UV Perl__to_utf8_lower_flags(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp, bool flags); + assert(p); assert(ustrp); assert(file) +PERL_CALLCONV UV Perl__to_utf8_lower_flags(pTHX_ const U8 *p, const U8* e, U8* ustrp, STRLEN *lenp, bool flags, const char * const file, const int line); #define PERL_ARGS_ASSERT__TO_UTF8_LOWER_FLAGS \ - assert(p); assert(ustrp) -PERL_CALLCONV UV Perl__to_utf8_title_flags(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp, bool flags); + assert(p); assert(ustrp); assert(file) +PERL_CALLCONV UV Perl__to_utf8_title_flags(pTHX_ const U8 *p, const U8* e, U8* ustrp, STRLEN *lenp, bool flags, const char * const file, const int line); #define PERL_ARGS_ASSERT__TO_UTF8_TITLE_FLAGS \ - assert(p); assert(ustrp) -PERL_CALLCONV UV Perl__to_utf8_upper_flags(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp, bool flags); + assert(p); assert(ustrp); assert(file) +PERL_CALLCONV UV Perl__to_utf8_upper_flags(pTHX_ const U8 *p, const U8 *e, U8* ustrp, STRLEN *lenp, bool flags, const char * const file, const int line); #define PERL_ARGS_ASSERT__TO_UTF8_UPPER_FLAGS \ - assert(p); assert(ustrp) + assert(p); assert(ustrp); assert(file) PERL_CALLCONV void Perl__warn_problematic_locale(void); +PERL_CALLCONV_NO_RET void Perl_abort_execution(pTHX_ const char * const msg, const char * const name) + __attribute__noreturn__; +#define PERL_ARGS_ASSERT_ABORT_EXECUTION \ + assert(msg); assert(name) + PERL_CALLCONV LOGOP* Perl_alloc_LOGOP(pTHX_ I32 type, OP *first, OP *other); PERL_CALLCONV PADOFFSET Perl_allocmy(pTHX_ const char *const name, const STRLEN len, const U32 flags); #define PERL_ARGS_ASSERT_ALLOCMY \ @@ -118,6 +140,11 @@ PERL_CALLCONV SV * Perl_amagic_deref_call(pTHX_ SV *ref, int method); #define PERL_ARGS_ASSERT_AMAGIC_DEREF_CALL \ assert(ref) PERL_CALLCONV bool Perl_amagic_is_enabled(pTHX_ int method); +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE void S_append_utf8_from_native_byte(const U8 byte, U8** dest); +#define PERL_ARGS_ASSERT_APPEND_UTF8_FROM_NATIVE_BYTE \ + assert(dest) +#endif PERL_CALLCONV I32 Perl_apply(pTHX_ I32 type, SV** mark, SV** sp); #define PERL_ARGS_ASSERT_APPLY \ assert(mark); assert(sp) @@ -193,6 +220,13 @@ PERL_CALLCONV SV** Perl_av_store(pTHX_ AV *av, SSize_t key, SV *val); /* PERL_CALLCONV SSize_t Perl_av_tindex(pTHX_ AV *av) __attribute__warn_unused_result__; */ +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE SSize_t S_av_top_index(pTHX_ AV *av) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_AV_TOP_INDEX \ + assert(av) +#endif + PERL_CALLCONV void Perl_av_undef(pTHX_ AV *av); #define PERL_ARGS_ASSERT_AV_UNDEF \ assert(av) @@ -222,12 +256,15 @@ PERL_CALLCONV void Perl_boot_core_mro(pTHX); PERL_CALLCONV int Perl_bytes_cmp_utf8(pTHX_ const U8 *b, STRLEN blen, const U8 *u, STRLEN ulen); #define PERL_ARGS_ASSERT_BYTES_CMP_UTF8 \ assert(b); assert(u) -PERL_CALLCONV U8* Perl_bytes_from_utf8(pTHX_ const U8 *s, STRLEN *len, bool *is_utf8); +PERL_CALLCONV U8* Perl_bytes_from_utf8(pTHX_ const U8 *s, STRLEN *lenp, bool *is_utf8p); #define PERL_ARGS_ASSERT_BYTES_FROM_UTF8 \ - assert(s); assert(len) -PERL_CALLCONV U8* Perl_bytes_to_utf8(pTHX_ const U8 *s, STRLEN *len); + assert(s); assert(lenp); assert(is_utf8p) +PERL_CALLCONV U8* Perl_bytes_from_utf8_loc(const U8 *s, STRLEN *lenp, bool *is_utf8p, const U8 ** first_unconverted); +#define PERL_ARGS_ASSERT_BYTES_FROM_UTF8_LOC \ + assert(s); assert(lenp); assert(is_utf8p) +PERL_CALLCONV U8* Perl_bytes_to_utf8(pTHX_ const U8 *s, STRLEN *lenp); #define PERL_ARGS_ASSERT_BYTES_TO_UTF8 \ - assert(s); assert(len) + assert(s); assert(lenp) PERL_CALLCONV I32 Perl_call_argv(pTHX_ const char* sub_name, I32 flags, char** argv); #define PERL_ARGS_ASSERT_CALL_ARGV \ assert(sub_name); assert(argv) @@ -521,8 +558,14 @@ PERL_CALLCONV void Perl_ck_warner_d(pTHX_ U32 err, const char* pat, ...) #define PERL_ARGS_ASSERT_CK_WARNER_D \ assert(pat) -PERL_CALLCONV bool Perl_ckwarn(pTHX_ U32 w); -PERL_CALLCONV bool Perl_ckwarn_d(pTHX_ U32 w); +PERL_CALLCONV bool Perl_ckwarn(pTHX_ U32 w) + __attribute__warn_unused_result__ + __attribute__pure__; + +PERL_CALLCONV bool Perl_ckwarn_d(pTHX_ U32 w) + __attribute__warn_unused_result__ + __attribute__pure__; + PERL_CALLCONV void Perl_clear_defarray(pTHX_ AV* av, bool abandon); #define PERL_ARGS_ASSERT_CLEAR_DEFARRAY \ assert(av) @@ -591,9 +634,7 @@ PERL_CALLCONV const char * Perl_custom_op_name(pTHX_ const OP *o) PERL_CALLCONV void Perl_custom_op_register(pTHX_ Perl_ppaddr_t ppaddr, const XOP *xop); #define PERL_ARGS_ASSERT_CUSTOM_OP_REGISTER \ assert(ppaddr); assert(xop) -/* PERL_CALLCONV const XOP * Perl_custom_op_xop(pTHX_ const OP *o) - __attribute__pure__; */ - +/* PERL_CALLCONV const XOP * Perl_custom_op_xop(pTHX_ const OP *o); */ PERL_CALLCONV void Perl_cv_ckproto_len_flags(pTHX_ const CV* cv, const GV* gv, const char* p, const STRLEN len, const U32 flags); #define PERL_ARGS_ASSERT_CV_CKPROTO_LEN_FLAGS \ assert(cv) @@ -735,7 +776,7 @@ PERL_CALLCONV bool Perl_do_open6(pTHX_ GV *gv, const char *oname, STRLEN len, Pe PERL_CALLCONV bool Perl_do_open9(pTHX_ GV *gv, const char *name, I32 len, int as_raw, int rawmode, int rawperm, PerlIO *supplied_fp, SV *svs, I32 num); #define PERL_ARGS_ASSERT_DO_OPEN9 \ assert(gv); assert(name); assert(svs) -PERL_CALLCONV bool Perl_do_open_raw(pTHX_ GV *gv, const char *oname, STRLEN len, int rawmode, int rawperm); +PERL_CALLCONV bool Perl_do_open_raw(pTHX_ GV *gv, const char *oname, STRLEN len, int rawmode, int rawperm, Stat_t *statbufp); #define PERL_ARGS_ASSERT_DO_OPEN_RAW \ assert(gv); assert(oname) PERL_CALLCONV bool Perl_do_openn(pTHX_ GV *gv, const char *oname, I32 len, int as_raw, int rawmode, int rawperm, PerlIO *supplied_fp, SV **svp, I32 num); @@ -751,7 +792,7 @@ PERL_CALLCONV OP* Perl_do_readline(pTHX) __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_do_seek(pTHX_ GV* gv, Off_t pos, int whence); -PERL_CALLCONV void Perl_do_sprintf(pTHX_ SV* sv, I32 len, SV** sarg); +PERL_CALLCONV void Perl_do_sprintf(pTHX_ SV* sv, SSize_t len, SV** sarg); #define PERL_ARGS_ASSERT_DO_SPRINTF \ assert(sv); assert(sarg) PERL_CALLCONV void Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim); @@ -768,7 +809,7 @@ PERL_CALLCONV Off_t Perl_do_tell(pTHX_ GV* gv) PERL_CALLCONV I32 Perl_do_trans(pTHX_ SV* sv); #define PERL_ARGS_ASSERT_DO_TRANS \ assert(sv) -PERL_CALLCONV UV Perl_do_vecget(pTHX_ SV* sv, SSize_t offset, int size); +PERL_CALLCONV UV Perl_do_vecget(pTHX_ SV* sv, STRLEN offset, int size); #define PERL_ARGS_ASSERT_DO_VECGET \ assert(sv) PERL_CALLCONV void Perl_do_vecset(pTHX_ SV* sv); @@ -868,21 +909,21 @@ PERL_CALLCONV PADOFFSET Perl_find_rundefsvoffset(pTHX) PERL_CALLCONV char* Perl_find_script(pTHX_ const char *scriptname, bool dosearch, const char *const *const search_ext, I32 flags); #define PERL_ARGS_ASSERT_FIND_SCRIPT \ assert(scriptname) -PERL_CALLCONV I32 Perl_foldEQ(const char* a, const char* b, I32 len) - __attribute__pure__; +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE I32 Perl_foldEQ(const char* a, const char* b, I32 len); #define PERL_ARGS_ASSERT_FOLDEQ \ assert(a); assert(b) - -PERL_CALLCONV I32 Perl_foldEQ_latin1(const char* a, const char* b, I32 len) - __attribute__pure__; +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE I32 Perl_foldEQ_latin1(const char* a, const char* b, I32 len); #define PERL_ARGS_ASSERT_FOLDEQ_LATIN1 \ assert(a); assert(b) - -PERL_CALLCONV I32 Perl_foldEQ_locale(const char* a, const char* b, I32 len) - __attribute__pure__; +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE I32 Perl_foldEQ_locale(const char* a, const char* b, I32 len); #define PERL_ARGS_ASSERT_FOLDEQ_LOCALE \ assert(a); assert(b) - +#endif /* PERL_CALLCONV I32 foldEQ_utf8(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2); */ PERL_CALLCONV I32 Perl_foldEQ_utf8_flags(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2, U32 flags); #define PERL_ARGS_ASSERT_FOLDEQ_UTF8_FLAGS \ @@ -1280,8 +1321,14 @@ PERL_CALLCONV SV** Perl_hv_store_flags(pTHX_ HV *hv, const char *key, I32 klen, #endif /* PERL_CALLCONV void hv_undef(pTHX_ HV *hv); */ PERL_CALLCONV void Perl_hv_undef_flags(pTHX_ HV *hv, U32 flags); -/* PERL_CALLCONV I32 ibcmp(pTHX_ const char* a, const char* b, I32 len); */ -/* PERL_CALLCONV I32 ibcmp_locale(pTHX_ const char* a, const char* b, I32 len); */ +/* PERL_CALLCONV I32 ibcmp(pTHX_ const char* a, const char* b, I32 len) + __attribute__warn_unused_result__ + __attribute__pure__; */ + +/* PERL_CALLCONV I32 ibcmp_locale(pTHX_ const char* a, const char* b, I32 len) + __attribute__warn_unused_result__ + __attribute__pure__; */ + /* PERL_CALLCONV I32 ibcmp_utf8(pTHX_ const char *s1, char **pe1, UV l1, bool u1, const char *s2, char **pe2, UV l2, bool u2); */ PERL_CALLCONV void Perl_init_argv_symbols(pTHX_ int argc, char **argv); #define PERL_ARGS_ASSERT_INIT_ARGV_SYMBOLS \ @@ -1312,15 +1359,13 @@ PERL_CALLCONV bool Perl_io_close(pTHX_ IO* io, GV *gv, bool not_implicit, bool w assert(io) PERL_CALLCONV bool Perl_isALNUM_lazy(pTHX_ const char* p) __attribute__deprecated__ - __attribute__warn_unused_result__ - __attribute__pure__; + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_ISALNUM_LAZY \ assert(p) PERL_CALLCONV bool Perl_isIDFIRST_lazy(pTHX_ const char* p) __attribute__deprecated__ - __attribute__warn_unused_result__ - __attribute__pure__; + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_ISIDFIRST_LAZY \ assert(p) @@ -1328,15 +1373,19 @@ PERL_CALLCONV bool Perl_isIDFIRST_lazy(pTHX_ const char* p) __attribute__warn_unused_result__ __attribute__pure__; */ +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE bool S_is_c9strict_utf8_string(const U8 *s, const STRLEN len) - __attribute__pure__; + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_C9STRICT_UTF8_STRING \ assert(s) +#endif /* PERL_CALLCONV bool is_c9strict_utf8_string_loc(const U8 *s, const STRLEN len, const U8 **ep); */ +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE bool S_is_c9strict_utf8_string_loclen(const U8 *s, const STRLEN len, const U8 **ep, STRLEN *el); #define PERL_ARGS_ASSERT_IS_C9STRICT_UTF8_STRING_LOCLEN \ assert(s) +#endif /* PERL_CALLCONV bool Perl_is_invariant_string(const U8* const s, const STRLEN len) __attribute__warn_unused_result__ __attribute__pure__; */ @@ -1344,44 +1393,49 @@ PERL_STATIC_INLINE bool S_is_c9strict_utf8_string_loclen(const U8 *s, const STRL PERL_CALLCONV I32 Perl_is_lvalue_sub(pTHX) __attribute__warn_unused_result__; +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE bool S_is_safe_syscall(pTHX_ const char *pv, STRLEN len, const char *what, const char *op_name) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_IS_SAFE_SYSCALL \ + assert(pv); assert(what); assert(op_name) +#endif + +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE bool S_is_strict_utf8_string(const U8 *s, const STRLEN len) - __attribute__pure__; + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_STRICT_UTF8_STRING \ assert(s) +#endif /* PERL_CALLCONV bool is_strict_utf8_string_loc(const U8 *s, const STRLEN len, const U8 **ep); */ +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE bool S_is_strict_utf8_string_loclen(const U8 *s, const STRLEN len, const U8 **ep, STRLEN *el); #define PERL_ARGS_ASSERT_IS_STRICT_UTF8_STRING_LOCLEN \ assert(s) +#endif PERL_CALLCONV bool Perl_is_uni_alnum(pTHX_ UV c) __attribute__deprecated__ - __attribute__warn_unused_result__ - __attribute__pure__; + __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_is_uni_alnum_lc(pTHX_ UV c) __attribute__deprecated__ - __attribute__warn_unused_result__ - __attribute__pure__; + __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_is_uni_alnumc(pTHX_ UV c) __attribute__deprecated__ - __attribute__warn_unused_result__ - __attribute__pure__; + __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_is_uni_alnumc_lc(pTHX_ UV c) __attribute__deprecated__ - __attribute__warn_unused_result__ - __attribute__pure__; + __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_is_uni_alpha(pTHX_ UV c) __attribute__deprecated__ - __attribute__warn_unused_result__ - __attribute__pure__; + __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_is_uni_alpha_lc(pTHX_ UV c) __attribute__deprecated__ - __attribute__warn_unused_result__ - __attribute__pure__; + __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_is_uni_ascii(pTHX_ UV c) __attribute__deprecated__ @@ -1415,63 +1469,51 @@ PERL_CALLCONV bool Perl_is_uni_cntrl_lc(pTHX_ UV c) PERL_CALLCONV bool Perl_is_uni_digit(pTHX_ UV c) __attribute__deprecated__ - __attribute__warn_unused_result__ - __attribute__pure__; + __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_is_uni_digit_lc(pTHX_ UV c) __attribute__deprecated__ - __attribute__warn_unused_result__ - __attribute__pure__; + __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_is_uni_graph(pTHX_ UV c) __attribute__deprecated__ - __attribute__warn_unused_result__ - __attribute__pure__; + __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_is_uni_graph_lc(pTHX_ UV c) __attribute__deprecated__ - __attribute__warn_unused_result__ - __attribute__pure__; + __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_is_uni_idfirst(pTHX_ UV c) __attribute__deprecated__ - __attribute__warn_unused_result__ - __attribute__pure__; + __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_is_uni_idfirst_lc(pTHX_ UV c) __attribute__deprecated__ - __attribute__warn_unused_result__ - __attribute__pure__; + __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_is_uni_lower(pTHX_ UV c) __attribute__deprecated__ - __attribute__warn_unused_result__ - __attribute__pure__; + __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_is_uni_lower_lc(pTHX_ UV c) __attribute__deprecated__ - __attribute__warn_unused_result__ - __attribute__pure__; + __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_is_uni_print(pTHX_ UV c) __attribute__deprecated__ - __attribute__warn_unused_result__ - __attribute__pure__; + __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_is_uni_print_lc(pTHX_ UV c) __attribute__deprecated__ - __attribute__warn_unused_result__ - __attribute__pure__; + __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_is_uni_punct(pTHX_ UV c) __attribute__deprecated__ - __attribute__warn_unused_result__ - __attribute__pure__; + __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_is_uni_punct_lc(pTHX_ UV c) __attribute__deprecated__ - __attribute__warn_unused_result__ - __attribute__pure__; + __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_is_uni_space(pTHX_ UV c) __attribute__deprecated__ @@ -1485,13 +1527,11 @@ PERL_CALLCONV bool Perl_is_uni_space_lc(pTHX_ UV c) PERL_CALLCONV bool Perl_is_uni_upper(pTHX_ UV c) __attribute__deprecated__ - __attribute__warn_unused_result__ - __attribute__pure__; + __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_is_uni_upper_lc(pTHX_ UV c) __attribute__deprecated__ - __attribute__warn_unused_result__ - __attribute__pure__; + __attribute__warn_unused_result__; PERL_CALLCONV bool Perl_is_uni_xdigit(pTHX_ UV c) __attribute__deprecated__ @@ -1557,9 +1597,11 @@ PERL_CALLCONV bool Perl_is_utf8_digit(pTHX_ const U8 *p) /* PERL_CALLCONV bool is_utf8_fixed_width_buf_flags(const U8 * const s, const STRLEN len, const U32 flags); */ /* PERL_CALLCONV bool is_utf8_fixed_width_buf_loc_flags(const U8 * const s, const STRLEN len, const U8 **ep, const U32 flags); */ +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE bool S_is_utf8_fixed_width_buf_loclen_flags(const U8 * const s, const STRLEN len, const U8 **ep, STRLEN *el, const U32 flags); #define PERL_ARGS_ASSERT_IS_UTF8_FIXED_WIDTH_BUF_LOCLEN_FLAGS \ assert(s) +#endif PERL_CALLCONV bool Perl_is_utf8_graph(pTHX_ const U8 *p) __attribute__deprecated__ __attribute__warn_unused_result__; @@ -1578,11 +1620,15 @@ PERL_CALLCONV bool Perl_is_utf8_idfirst(pTHX_ const U8 *p) #define PERL_ARGS_ASSERT_IS_UTF8_IDFIRST \ assert(p) -PERL_STATIC_INLINE bool S_is_utf8_invariant_string(const U8* const s, STRLEN const len) - __attribute__warn_unused_result__ - __attribute__pure__; -#define PERL_ARGS_ASSERT_IS_UTF8_INVARIANT_STRING \ +/* PERL_CALLCONV bool is_utf8_invariant_string(const U8* const s, STRLEN const len) + __attribute__warn_unused_result__; */ + +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE bool S_is_utf8_invariant_string_loc(const U8* const s, STRLEN const len, const U8 ** ep) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_IS_UTF8_INVARIANT_STRING_LOC \ assert(s) +#endif PERL_CALLCONV bool Perl_is_utf8_lower(pTHX_ const U8 *p) __attribute__deprecated__ @@ -1632,15 +1678,19 @@ PERL_CALLCONV bool Perl_is_utf8_space(pTHX_ const U8 *p) #define PERL_ARGS_ASSERT_IS_UTF8_SPACE \ assert(p) +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE bool Perl_is_utf8_string(const U8 *s, const STRLEN len) - __attribute__pure__; + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UTF8_STRING \ assert(s) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE bool S_is_utf8_string_flags(const U8 *s, const STRLEN len, const U32 flags) - __attribute__pure__; + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UTF8_STRING_FLAGS \ assert(s) +#endif #ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_utf8_string_loc(const U8 *s, const STRLEN len, const U8 **ep); @@ -1648,12 +1698,16 @@ PERL_CALLCONV bool Perl_is_utf8_string_loc(const U8 *s, const STRLEN len, const assert(s); assert(ep) #endif /* PERL_CALLCONV bool is_utf8_string_loc_flags(const U8 *s, const STRLEN len, const U8 **ep, const U32 flags); */ +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE bool Perl_is_utf8_string_loclen(const U8 *s, const STRLEN len, const U8 **ep, STRLEN *el); #define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOCLEN \ assert(s) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE bool S_is_utf8_string_loclen_flags(const U8 *s, const STRLEN len, const U8 **ep, STRLEN *el, const U32 flags); #define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOCLEN_FLAGS \ assert(s) +#endif PERL_CALLCONV bool Perl_is_utf8_upper(pTHX_ const U8 *p) __attribute__deprecated__ __attribute__warn_unused_result__; @@ -1661,12 +1715,15 @@ PERL_CALLCONV bool Perl_is_utf8_upper(pTHX_ const U8 *p) assert(p) /* PERL_CALLCONV bool is_utf8_valid_partial_char(const U8 * const s, const U8 * const e) + __attribute__warn_unused_result__ __attribute__pure__; */ +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE bool S_is_utf8_valid_partial_char_flags(const U8 * const s, const U8 * const e, const U32 flags) - __attribute__pure__; + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UTF8_VALID_PARTIAL_CHAR_FLAGS \ assert(s); assert(e) +#endif PERL_CALLCONV bool Perl_is_utf8_xdigit(pTHX_ const U8 *p) __attribute__deprecated__ @@ -1686,7 +1743,10 @@ 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 bool Perl_isinfnan(NV nv) + __attribute__warn_unused_result__ + __attribute__pure__; + PERL_CALLCONV bool Perl_isinfnansv(pTHX_ SV *sv); #define PERL_ARGS_ASSERT_ISINFNANSV \ assert(sv) @@ -1694,6 +1754,7 @@ PERL_CALLCONV OP* Perl_jmaybe(pTHX_ OP *o); #define PERL_ARGS_ASSERT_JMAYBE \ assert(o) PERL_CALLCONV I32 Perl_keyword(pTHX_ const char *name, I32 len, bool all_keywords) + __attribute__warn_unused_result__ __attribute__pure__; #define PERL_ARGS_ASSERT_KEYWORD \ assert(name) @@ -2258,7 +2319,7 @@ PERL_CALLCONV SV* Perl_newSVpvf(pTHX_ const char *const pat, ...) #define PERL_ARGS_ASSERT_NEWSVPVF \ assert(pat) -PERL_CALLCONV SV* Perl_newSVpvn(pTHX_ const char *const s, const STRLEN len) +PERL_CALLCONV SV* Perl_newSVpvn(pTHX_ const char *const buffer, const STRLEN len) __attribute__warn_unused_result__; PERL_CALLCONV SV* Perl_newSVpvn_flags(pTHX_ const char *const s, const STRLEN len, const U32 flags) @@ -2302,10 +2363,6 @@ PERL_CALLCONV CV * Perl_newXS_flags(pTHX_ const char *name, XSUBADDR_t subaddr, PERL_CALLCONV CV * Perl_newXS_len_flags(pTHX_ const char *name, STRLEN len, XSUBADDR_t subaddr, const char *const filename, const char *const proto, SV **const_svp, U32 flags); #define PERL_ARGS_ASSERT_NEWXS_LEN_FLAGS \ assert(subaddr) -PERL_CALLCONV void Perl_new_collate(pTHX_ const char* newcoll); -PERL_CALLCONV void Perl_new_ctype(pTHX_ const char* newctype); -#define PERL_ARGS_ASSERT_NEW_CTYPE \ - assert(newctype) PERL_CALLCONV void Perl_new_numeric(pTHX_ const char* newcoll); PERL_CALLCONV PERL_SI* Perl_new_stackinfo(pTHX_ I32 stitems, I32 cxitems) __attribute__warn_unused_result__; @@ -2328,6 +2385,7 @@ PERL_CALLCONV_NO_RET void Perl_noperl_die(const char* pat, ...) assert(pat) PERL_CALLCONV int Perl_nothreadhook(pTHX); +PERL_CALLCONV void Perl_notify_parser_that_changed_to_utf8(pTHX); PERL_CALLCONV OP* Perl_oopsAV(pTHX_ OP* o) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_OOPSAV \ @@ -2340,6 +2398,7 @@ PERL_CALLCONV OP* Perl_oopsHV(pTHX_ OP* o) PERL_CALLCONV OP* Perl_op_append_elem(pTHX_ I32 optype, OP* first, OP* last); PERL_CALLCONV OP* Perl_op_append_list(pTHX_ I32 optype, OP* first, OP* last); +PERL_CALLCONV OPclass Perl_op_class(pTHX_ const OP *o); PERL_CALLCONV void Perl_op_clear(pTHX_ OP* o); #define PERL_ARGS_ASSERT_OP_CLEAR \ assert(o) @@ -2637,6 +2696,7 @@ PERL_CALLCONV void Perl_require_pv(pTHX_ const char* pv); #define PERL_ARGS_ASSERT_REQUIRE_PV \ assert(pv) PERL_CALLCONV char* Perl_rninstr(const char* big, const char* bigend, const char* little, const char* lend) + __attribute__warn_unused_result__ __attribute__pure__; #define PERL_ARGS_ASSERT_RNINSTR \ assert(big); assert(bigend); assert(little); assert(lend) @@ -2851,12 +2911,12 @@ PERL_CALLCONV void Perl_set_context(void *t); #define PERL_ARGS_ASSERT_SET_CONTEXT \ assert(t) PERL_CALLCONV void Perl_set_numeric_local(pTHX); -PERL_CALLCONV void Perl_set_numeric_radix(pTHX); PERL_CALLCONV void Perl_set_numeric_standard(pTHX); PERL_CALLCONV void Perl_setdefout(pTHX_ GV* gv); #define PERL_ARGS_ASSERT_SETDEFOUT \ assert(gv) -PERL_CALLCONV HEK* Perl_share_hek(pTHX_ const char* str, I32 len, U32 hash); +PERL_CALLCONV char* Perl_setlocale(int category, const char* locale); +PERL_CALLCONV HEK* Perl_share_hek(pTHX_ const char* str, SSize_t len, U32 hash); #define PERL_ARGS_ASSERT_SHARE_HEK \ assert(str) PERL_CALLCONV void Perl_sortsv(pTHX_ SV** array, size_t num_elts, SVCOMPARE_t cmp); @@ -3070,8 +3130,6 @@ PERL_CALLCONV bool Perl_sv_does_sv(pTHX_ SV* sv, SV* namesv, U32 flags) assert(sv); assert(namesv) PERL_CALLCONV void Perl_sv_dump(pTHX_ SV* sv); -#define PERL_ARGS_ASSERT_SV_DUMP \ - assert(sv) /* PERL_CALLCONV I32 sv_eq(pTHX_ SV* sv1, SV* sv2); */ PERL_CALLCONV I32 Perl_sv_eq_flags(pTHX_ SV* sv1, SV* sv2, const U32 flags); #ifndef NO_MATHOMS @@ -3087,11 +3145,9 @@ PERL_CALLCONV void Perl_sv_free2(pTHX_ SV *const sv, const U32 refcnt); #define PERL_ARGS_ASSERT_SV_FREE2 \ assert(sv) PERL_CALLCONV void Perl_sv_free_arenas(pTHX); -PERL_CALLCONV SV* Perl_sv_get_backrefs(SV *const sv) - __attribute__pure__; +PERL_CALLCONV SV* Perl_sv_get_backrefs(SV *const sv); #define PERL_ARGS_ASSERT_SV_GET_BACKREFS \ assert(sv) - PERL_CALLCONV char* Perl_sv_gets(pTHX_ SV *const sv, PerlIO *const fp, I32 append); #define PERL_ARGS_ASSERT_SV_GETS \ assert(sv); assert(fp) @@ -3105,7 +3161,7 @@ PERL_CALLCONV void Perl_sv_insert(pTHX_ SV *const bigstr, const STRLEN offset, c #define PERL_ARGS_ASSERT_SV_INSERT \ assert(bigstr); assert(little) #endif -PERL_CALLCONV void Perl_sv_insert_flags(pTHX_ SV *const bigstr, const STRLEN offset, const STRLEN len, const char *const little, const STRLEN littlelen, const U32 flags); +PERL_CALLCONV void Perl_sv_insert_flags(pTHX_ SV *const bigstr, const STRLEN offset, const STRLEN len, const char *little, const STRLEN littlelen, const U32 flags); #define PERL_ARGS_ASSERT_SV_INSERT_FLAGS \ assert(bigstr); assert(little) PERL_CALLCONV int Perl_sv_isa(pTHX_ SV* sv, const char *const name); @@ -3151,6 +3207,11 @@ PERL_CALLCONV void Perl_sv_nounlocking(pTHX_ SV *sv); PERL_CALLCONV NV Perl_sv_nv(pTHX_ SV* sv); #define PERL_ARGS_ASSERT_SV_NV \ assert(sv) +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE bool S_sv_only_taint_gmagic(SV *sv); +#define PERL_ARGS_ASSERT_SV_ONLY_TAINT_GMAGIC \ + assert(sv) +#endif PERL_CALLCONV char* Perl_sv_peek(pTHX_ SV* sv); PERL_CALLCONV void Perl_sv_pos_b2u(pTHX_ SV *const sv, I32 *const offsetp); #define PERL_ARGS_ASSERT_SV_POS_B2U \ @@ -3233,6 +3294,9 @@ PERL_CALLCONV void Perl_sv_resetpvn(pTHX_ const char* s, STRLEN len, HV *const s PERL_CALLCONV SV* Perl_sv_rvweaken(pTHX_ SV *const sv); #define PERL_ARGS_ASSERT_SV_RVWEAKEN \ assert(sv) +PERL_CALLCONV void Perl_sv_set_undef(pTHX_ SV *sv); +#define PERL_ARGS_ASSERT_SV_SET_UNDEF \ + assert(sv) PERL_CALLCONV void Perl_sv_sethek(pTHX_ SV *const sv, const HEK *const hek); #define PERL_ARGS_ASSERT_SV_SETHEK \ assert(sv) @@ -3392,10 +3456,10 @@ PERL_CALLCONV void Perl_sv_vcatpvf(pTHX_ SV *const sv, const char *const pat, va PERL_CALLCONV void Perl_sv_vcatpvf_mg(pTHX_ SV *const sv, const char *const pat, va_list *const args); #define PERL_ARGS_ASSERT_SV_VCATPVF_MG \ assert(sv); assert(pat) -PERL_CALLCONV void Perl_sv_vcatpvfn(pTHX_ SV *const sv, const char *const pat, const STRLEN patlen, va_list *const args, SV **const svargs, const I32 svmax, bool *const maybe_tainted); +PERL_CALLCONV void Perl_sv_vcatpvfn(pTHX_ SV *const sv, const char *const pat, const STRLEN patlen, va_list *const args, SV **const svargs, const Size_t sv_count, bool *const maybe_tainted); #define PERL_ARGS_ASSERT_SV_VCATPVFN \ assert(sv); assert(pat) -PERL_CALLCONV void Perl_sv_vcatpvfn_flags(pTHX_ SV *const sv, const char *const pat, const STRLEN patlen, va_list *const args, SV **const svargs, const I32 svmax, bool *const maybe_tainted, const U32 flags); +PERL_CALLCONV void Perl_sv_vcatpvfn_flags(pTHX_ SV *const sv, const char *const pat, const STRLEN patlen, va_list *const args, SV **const svargs, const Size_t sv_count, bool *const maybe_tainted, const U32 flags); #define PERL_ARGS_ASSERT_SV_VCATPVFN_FLAGS \ assert(sv); assert(pat) PERL_CALLCONV void Perl_sv_vsetpvf(pTHX_ SV *const sv, const char *const pat, va_list *const args); @@ -3404,7 +3468,7 @@ PERL_CALLCONV void Perl_sv_vsetpvf(pTHX_ SV *const sv, const char *const pat, va PERL_CALLCONV void Perl_sv_vsetpvf_mg(pTHX_ SV *const sv, const char *const pat, va_list *const args); #define PERL_ARGS_ASSERT_SV_VSETPVF_MG \ assert(sv); assert(pat) -PERL_CALLCONV void Perl_sv_vsetpvfn(pTHX_ SV *const sv, const char *const pat, const STRLEN patlen, va_list *const args, SV **const svargs, const I32 svmax, bool *const maybe_tainted); +PERL_CALLCONV void Perl_sv_vsetpvfn(pTHX_ SV *const sv, const char *const pat, const STRLEN patlen, va_list *const args, SV **const svargs, const Size_t sv_count, bool *const maybe_tainted); #define PERL_ARGS_ASSERT_SV_VSETPVFN \ assert(sv); assert(pat) PERL_CALLCONV UV Perl_swash_fetch(pTHX_ SV *swash, const U8 *ptr, bool do_utf8); @@ -3437,50 +3501,50 @@ PERL_CALLCONV UV Perl_to_uni_lower(pTHX_ UV c, U8 *p, STRLEN *lenp); assert(p); assert(lenp) PERL_CALLCONV U32 Perl_to_uni_lower_lc(pTHX_ U32 c) __attribute__deprecated__ - __attribute__warn_unused_result__ - __attribute__pure__; + __attribute__warn_unused_result__; PERL_CALLCONV UV Perl_to_uni_title(pTHX_ UV c, U8 *p, STRLEN *lenp); #define PERL_ARGS_ASSERT_TO_UNI_TITLE \ assert(p); assert(lenp) PERL_CALLCONV U32 Perl_to_uni_title_lc(pTHX_ U32 c) __attribute__deprecated__ - __attribute__warn_unused_result__ - __attribute__pure__; + __attribute__warn_unused_result__; PERL_CALLCONV UV Perl_to_uni_upper(pTHX_ UV c, U8 *p, STRLEN *lenp); #define PERL_ARGS_ASSERT_TO_UNI_UPPER \ assert(p); assert(lenp) PERL_CALLCONV U32 Perl_to_uni_upper_lc(pTHX_ U32 c) __attribute__deprecated__ - __attribute__warn_unused_result__ - __attribute__pure__; - -PERL_CALLCONV UV Perl_to_utf8_case(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp, SV **swashp, const char *normal, const char *special) - __attribute__deprecated__; -#define PERL_ARGS_ASSERT_TO_UTF8_CASE \ - assert(p); assert(ustrp); assert(swashp); assert(normal) + __attribute__warn_unused_result__; #ifndef NO_MATHOMS -PERL_CALLCONV UV Perl_to_utf8_fold(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp); +PERL_CALLCONV UV Perl_to_utf8_fold(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp) + __attribute__deprecated__; #define PERL_ARGS_ASSERT_TO_UTF8_FOLD \ assert(p); assert(ustrp) #endif + #ifndef NO_MATHOMS -PERL_CALLCONV UV Perl_to_utf8_lower(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp); +PERL_CALLCONV UV Perl_to_utf8_lower(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp) + __attribute__deprecated__; #define PERL_ARGS_ASSERT_TO_UTF8_LOWER \ assert(p); assert(ustrp) #endif + #ifndef NO_MATHOMS -PERL_CALLCONV UV Perl_to_utf8_title(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp); +PERL_CALLCONV UV Perl_to_utf8_title(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp) + __attribute__deprecated__; #define PERL_ARGS_ASSERT_TO_UTF8_TITLE \ assert(p); assert(ustrp) #endif + #ifndef NO_MATHOMS -PERL_CALLCONV UV Perl_to_utf8_upper(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp); +PERL_CALLCONV UV Perl_to_utf8_upper(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp) + __attribute__deprecated__; #define PERL_ARGS_ASSERT_TO_UTF8_UPPER \ assert(p); assert(ustrp) #endif + PERL_CALLCONV bool Perl_try_amagic_bin(pTHX_ int method, int flags); PERL_CALLCONV bool Perl_try_amagic_un(pTHX_ int method, int flags); PERL_CALLCONV I32 Perl_unpack_str(pTHX_ const char *pat, const char *patend, const char *s, const char *strbeg, const char *strend, char **new_s, I32 ocnt, U32 flags); @@ -3500,17 +3564,40 @@ PERL_CALLCONV U8* Perl_utf16_to_utf8(pTHX_ U8* p, U8 *d, I32 bytelen, I32 *newle PERL_CALLCONV U8* Perl_utf16_to_utf8_reversed(pTHX_ U8* p, U8 *d, I32 bytelen, I32 *newlen); #define PERL_ARGS_ASSERT_UTF16_TO_UTF8_REVERSED \ assert(p); assert(d); assert(newlen) +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE IV Perl_utf8_distance(pTHX_ const U8 *a, const U8 *b) - __attribute__warn_unused_result__ - __attribute__pure__; + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_UTF8_DISTANCE \ assert(a); assert(b) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE U8* Perl_utf8_hop(const U8 *s, SSize_t off) - __attribute__warn_unused_result__ - __attribute__pure__; + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_UTF8_HOP \ assert(s) +#endif + +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE U8* Perl_utf8_hop_back(const U8 *s, SSize_t off, const U8 *start) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_UTF8_HOP_BACK \ + assert(s); assert(start) +#endif + +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE U8* Perl_utf8_hop_forward(const U8 *s, SSize_t off, const U8 *end) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_UTF8_HOP_FORWARD \ + assert(s); assert(end) +#endif + +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE U8* Perl_utf8_hop_safe(const U8 *s, SSize_t off, const U8 *start, const U8 *end) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_UTF8_HOP_SAFE \ + assert(s); assert(start); assert(end) +#endif PERL_CALLCONV STRLEN Perl_utf8_length(pTHX_ const U8* s, const U8 *e) __attribute__warn_unused_result__ @@ -3518,15 +3605,17 @@ PERL_CALLCONV STRLEN Perl_utf8_length(pTHX_ const U8* s, const U8 *e) #define PERL_ARGS_ASSERT_UTF8_LENGTH \ assert(s); assert(e) -PERL_CALLCONV U8* Perl_utf8_to_bytes(pTHX_ U8 *s, STRLEN *len); +PERL_CALLCONV U8* Perl_utf8_to_bytes(pTHX_ U8 *s, STRLEN *lenp); #define PERL_ARGS_ASSERT_UTF8_TO_BYTES \ - assert(s); assert(len) + assert(s); assert(lenp) PERL_CALLCONV UV Perl_utf8_to_uvchr(pTHX_ const U8 *s, STRLEN *retlen) __attribute__deprecated__; #define PERL_ARGS_ASSERT_UTF8_TO_UVCHR \ assert(s) -/* PERL_CALLCONV UV utf8_to_uvchr_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen); */ +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 \ + assert(s); assert(send) PERL_CALLCONV UV Perl_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen) __attribute__deprecated__; #define PERL_ARGS_ASSERT_UTF8_TO_UVUNI \ @@ -3551,7 +3640,7 @@ PERL_CALLCONV void Perl_utilize(pTHX_ int aver, I32 floor, OP* version, OP* idop assert(idop) /* PERL_CALLCONV U8* uvchr_to_utf8(pTHX_ U8 *d, UV uv); */ /* PERL_CALLCONV U8* uvchr_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags); */ -PERL_CALLCONV U8* Perl_uvoffuni_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags); +PERL_CALLCONV U8* Perl_uvoffuni_to_utf8_flags(pTHX_ U8 *d, UV uv, const UV flags); #define PERL_ARGS_ASSERT_UVOFFUNI_TO_UTF8_FLAGS \ assert(d) PERL_CALLCONV U8* Perl_uvuni_to_utf8(pTHX_ U8 *d, UV uv); @@ -3560,10 +3649,12 @@ PERL_CALLCONV U8* Perl_uvuni_to_utf8(pTHX_ U8 *d, UV uv); PERL_CALLCONV U8* Perl_uvuni_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags); #define PERL_ARGS_ASSERT_UVUNI_TO_UTF8_FLAGS \ assert(d) +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE UV Perl_valid_utf8_to_uvchr(const U8 *s, STRLEN *retlen) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_VALID_UTF8_TO_UVCHR \ assert(s) +#endif PERL_CALLCONV UV Perl_valid_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen) __attribute__deprecated__; @@ -3671,10 +3762,9 @@ PERL_CALLCONV int Perl_yyerror_pv(pTHX_ const char *const s, U32 flags); #define PERL_ARGS_ASSERT_YYERROR_PV \ assert(s) PERL_CALLCONV int Perl_yyerror_pvn(pTHX_ const char *const s, STRLEN len, U32 flags); -#define PERL_ARGS_ASSERT_YYERROR_PVN \ - assert(s) PERL_CALLCONV int Perl_yylex(pTHX); PERL_CALLCONV int Perl_yyparse(pTHX_ int gramtype); +PERL_CALLCONV void Perl_yyquit(pTHX); PERL_CALLCONV void Perl_yyunlex(pTHX); #if !(defined(DEBUGGING)) # if !defined(NV_PRESERVES_UV) @@ -3687,6 +3777,7 @@ STATIC int S_sv_2iuv_non_preserve(pTHX_ SV *const sv); #endif #if !(defined(HAS_MEMMEM)) PERL_CALLCONV char* Perl_ninstr(const char* big, const char* bigend, const char* little, const char* lend) + __attribute__warn_unused_result__ __attribute__pure__; #define PERL_ARGS_ASSERT_NINSTR \ assert(big); assert(bigend); assert(little); assert(lend) @@ -3708,11 +3799,6 @@ PERL_CALLCONV void* Perl_my_cxt_init(pTHX_ int *index, size_t size); assert(index) # endif #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 int Perl_magic_regdatum_set(pTHX_ SV* sv, MAGIC* mg) __attribute__noreturn__; @@ -3732,6 +3818,7 @@ PERL_CALLCONV char* Perl_getenv_len(pTHX_ const char *env_elem, unsigned long *l #endif #if !defined(HAS_MEMCMP) || !defined(HAS_SANE_MEMCMP) PERL_CALLCONV int Perl_my_memcmp(const void* vs1, const void* vs2, size_t len) + __attribute__warn_unused_result__ __attribute__pure__; #define PERL_ARGS_ASSERT_MY_MEMCMP \ assert(vs1); assert(vs2) @@ -3763,6 +3850,7 @@ PERL_CALLCONV I32 Perl_same_dirent(pTHX_ const char* a, const char* b); #endif #if !defined(HAS_SIGNBIT) PERL_CALLCONV int Perl_signbit(NV f) + __attribute__warn_unused_result__ __attribute__pure__; #endif @@ -3800,41 +3888,55 @@ STATIC PerlIO * S_doopen_pm(pTHX_ SV *name) STATIC void S__append_range_to_invlist(pTHX_ SV* const invlist, const UV start, const UV end); #define PERL_ARGS_ASSERT__APPEND_RANGE_TO_INVLIST \ assert(invlist) +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE UV* S__invlist_array_init(SV* const invlist, const bool will_have_0) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT__INVLIST_ARRAY_INIT \ assert(invlist) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE IV* S_get_invlist_previous_index_addr(SV* invlist) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_GET_INVLIST_PREVIOUS_INDEX_ADDR \ assert(invlist) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE void S_invlist_clear(pTHX_ SV* invlist); #define PERL_ARGS_ASSERT_INVLIST_CLEAR \ assert(invlist) +#endif STATIC void S_invlist_extend(pTHX_ SV* const invlist, const UV len); #define PERL_ARGS_ASSERT_INVLIST_EXTEND \ assert(invlist) +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE UV S_invlist_max(SV* const invlist) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_INVLIST_MAX \ assert(invlist) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE IV S_invlist_previous_index(SV* const invlist) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_INVLIST_PREVIOUS_INDEX \ assert(invlist) +#endif STATIC void S_invlist_replace_list_destroys_src(pTHX_ SV *dest, SV *src); #define PERL_ARGS_ASSERT_INVLIST_REPLACE_LIST_DESTROYS_SRC \ assert(dest); assert(src) +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE void S_invlist_set_previous_index(SV* const invlist, const IV index); #define PERL_ARGS_ASSERT_INVLIST_SET_PREVIOUS_INDEX \ assert(invlist) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE void S_invlist_trim(SV* invlist); #define PERL_ARGS_ASSERT_INVLIST_TRIM \ assert(invlist) +#endif # endif #endif #if !defined(PERL_IMPLICIT_SYS) @@ -3851,82 +3953,96 @@ STATIC SV * S_incpush_if_exists(pTHX_ AV *const av, SV *dir, SV *const stem); # endif #endif #if !defined(PERL_NO_INLINE_FUNCTIONS) -PERL_CALLCONV STRLEN Perl__is_utf8_char_helper(const U8 * const s, const U8 * e, const U32 flags) - __attribute__warn_unused_result__ - __attribute__pure__; -#define PERL_ARGS_ASSERT__IS_UTF8_CHAR_HELPER \ - assert(s); assert(e) - -PERL_STATIC_INLINE void S_append_utf8_from_native_byte(const U8 byte, U8** dest); -#define PERL_ARGS_ASSERT_APPEND_UTF8_FROM_NATIVE_BYTE \ - assert(dest) -PERL_STATIC_INLINE SSize_t S_av_top_index(pTHX_ AV *av) - __attribute__warn_unused_result__; -#define PERL_ARGS_ASSERT_AV_TOP_INDEX \ - assert(av) - +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE void S_cx_popblock(pTHX_ PERL_CONTEXT *cx); #define PERL_ARGS_ASSERT_CX_POPBLOCK \ assert(cx) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE void S_cx_popeval(pTHX_ PERL_CONTEXT *cx); #define PERL_ARGS_ASSERT_CX_POPEVAL \ assert(cx) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE void S_cx_popformat(pTHX_ PERL_CONTEXT *cx); #define PERL_ARGS_ASSERT_CX_POPFORMAT \ assert(cx) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE void S_cx_popgiven(pTHX_ PERL_CONTEXT *cx); #define PERL_ARGS_ASSERT_CX_POPGIVEN \ assert(cx) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE void S_cx_poploop(pTHX_ PERL_CONTEXT *cx); #define PERL_ARGS_ASSERT_CX_POPLOOP \ assert(cx) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE void S_cx_popsub(pTHX_ PERL_CONTEXT *cx); #define PERL_ARGS_ASSERT_CX_POPSUB \ assert(cx) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE void S_cx_popsub_args(pTHX_ PERL_CONTEXT *cx); #define PERL_ARGS_ASSERT_CX_POPSUB_ARGS \ assert(cx) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE void S_cx_popsub_common(pTHX_ PERL_CONTEXT *cx); #define PERL_ARGS_ASSERT_CX_POPSUB_COMMON \ assert(cx) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE void S_cx_popwhen(pTHX_ PERL_CONTEXT *cx); #define PERL_ARGS_ASSERT_CX_POPWHEN \ assert(cx) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE PERL_CONTEXT * S_cx_pushblock(pTHX_ U8 type, U8 gimme, SV** sp, I32 saveix); #define PERL_ARGS_ASSERT_CX_PUSHBLOCK \ assert(sp) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE void S_cx_pusheval(pTHX_ PERL_CONTEXT *cx, OP *retop, SV *namesv); #define PERL_ARGS_ASSERT_CX_PUSHEVAL \ assert(cx) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE void S_cx_pushformat(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, GV *gv); #define PERL_ARGS_ASSERT_CX_PUSHFORMAT \ assert(cx); assert(cv) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE void S_cx_pushgiven(pTHX_ PERL_CONTEXT *cx, SV *orig_defsv); #define PERL_ARGS_ASSERT_CX_PUSHGIVEN \ assert(cx) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE void S_cx_pushloop_for(pTHX_ PERL_CONTEXT *cx, void *itervarp, SV *itersave); #define PERL_ARGS_ASSERT_CX_PUSHLOOP_FOR \ assert(cx); assert(itervarp) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE void S_cx_pushloop_plain(pTHX_ PERL_CONTEXT *cx); #define PERL_ARGS_ASSERT_CX_PUSHLOOP_PLAIN \ assert(cx) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE void S_cx_pushsub(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, bool hasargs); #define PERL_ARGS_ASSERT_CX_PUSHSUB \ assert(cx); assert(cv) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE void S_cx_pushwhen(pTHX_ PERL_CONTEXT *cx); #define PERL_ARGS_ASSERT_CX_PUSHWHEN \ assert(cx) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE void S_cx_topblock(pTHX_ PERL_CONTEXT *cx); #define PERL_ARGS_ASSERT_CX_TOPBLOCK \ assert(cx) -PERL_STATIC_INLINE bool S_is_safe_syscall(pTHX_ const char *pv, STRLEN len, const char *what, const char *op_name) - __attribute__warn_unused_result__; -#define PERL_ARGS_ASSERT_IS_SAFE_SYSCALL \ - assert(pv); assert(what); assert(op_name) - -PERL_STATIC_INLINE bool S_sv_only_taint_gmagic(SV *sv); -#define PERL_ARGS_ASSERT_SV_ONLY_TAINT_GMAGIC \ - assert(sv) +#endif #endif #if !defined(PERL_NO_UTF16_FILTER) # if defined(PERL_IN_TOKE_C) @@ -3955,6 +4071,15 @@ PERL_CALLCONV int Perl_my_sprintf(char *buffer, const char *pat, ...); STATIC NV S_mulexp10(NV value, I32 exponent); # endif #endif +#if !defined(UV_IS_QUAD) +# if defined(PERL_IN_UTF8_C) +STATIC int S_is_utf8_cp_above_31_bits(const U8 * const s, const U8 * const e, const bool consider_overlongs) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_IS_UTF8_CP_ABOVE_31_BITS \ + assert(s); assert(e) + +# endif +#endif #if !defined(WIN32) PERL_CALLCONV bool Perl_do_exec3(pTHX_ const char *incmd, int fd, int do_report); #define PERL_ARGS_ASSERT_DO_EXEC3 \ @@ -4044,16 +4169,23 @@ STATIC int S_tokereport(pTHX_ I32 rv, const YYSTYPE* lvalp); #define PERL_ARGS_ASSERT_TOKEREPORT \ assert(lvalp) # endif -# if defined(USE_LOCALE) && (defined(PERL_IN_LOCALE_C) || defined (PERL_EXT_POSIX)) -PERL_CALLCONV char * Perl__setlocale_debug_string(const int category, const char* const locale, const char* const retval) - __attribute__warn_unused_result__ - __attribute__pure__; - -# endif # if defined(USE_LOCALE) && defined(PERL_IN_LOCALE_C) +STATIC void S_print_bytes_for_locale(pTHX_ const char * const s, const char * const e, const bool is_utf8); +#define PERL_ARGS_ASSERT_PRINT_BYTES_FOR_LOCALE \ + assert(s); assert(e) STATIC void S_print_collxfrm_input_and_return(pTHX_ const char * const s, const char * const e, const STRLEN * const xlen, const bool is_utf8); #define PERL_ARGS_ASSERT_PRINT_COLLXFRM_INPUT_AND_RETURN \ assert(s); assert(e) +STATIC char * S_setlocale_debug_string(const int category, const char* const locale, const char* const retval) + __attribute__warn_unused_result__; + +# endif +#endif +#if defined(DEBUGGING) && defined(ENABLE_REGEX_SETS_DEBUGGING) +# if defined(PERL_IN_REGCOMP_C) +STATIC void S_dump_regex_sets_structures(pTHX_ RExC_state_t *pRExC_state, AV * stack, const IV fence, AV * fence_stack); +#define PERL_ARGS_ASSERT_DUMP_REGEX_SETS_STRUCTURES \ + assert(pRExC_state); assert(stack); assert(fence_stack) # endif #endif #if defined(DEBUG_LEAKING_SCALARS_FORK_DUMP) @@ -4063,6 +4195,7 @@ PERL_CALLCONV void Perl_dump_sv_child(pTHX_ SV *sv); #endif #if defined(HAS_MEMMEM) PERL_CALLCONV char* Perl_ninstr(const char* big, const char* bigend, const char* little, const char* lend) + __attribute__warn_unused_result__ __attribute__pure__; #define PERL_ARGS_ASSERT_NINSTR \ assert(big); assert(bigend); assert(little); assert(lend) @@ -4135,10 +4268,12 @@ PERL_CALLCONV void Perl_opslab_free_nopad(pTHX_ OPSLAB *slab); PERL_CALLCONV void Perl_parser_free_nexttoke_ops(pTHX_ yy_parser *parser, OPSLAB *slab); #define PERL_ARGS_ASSERT_PARSER_FREE_NEXTTOKE_OPS \ assert(parser); assert(slab) +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE bool S_should_warn_nl(const char *pv) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SHOULD_WARN_NL \ assert(pv) +#endif # if defined(PERL_DEBUG_READONLY_OPS) PERL_CALLCONV void Perl_Slab_to_ro(pTHX_ OPSLAB *slab); @@ -4150,10 +4285,12 @@ PERL_CALLCONV void Perl_Slab_to_rw(pTHX_ OPSLAB *const slab); # endif #endif #if defined(PERL_CORE) || defined (PERL_EXT) +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE STRLEN S_sv_or_pv_pos_u2b(pTHX_ SV *sv, const char *pv, STRLEN pos, STRLEN *lenp); #define PERL_ARGS_ASSERT_SV_OR_PV_POS_U2B \ assert(sv); assert(pv) #endif +#endif #if defined(PERL_CR_FILTER) # if defined(PERL_IN_TOKE_C) STATIC I32 S_cr_textfilter(pTHX_ int idx, SV *sv, int maxlen); @@ -4303,7 +4440,7 @@ STATIC void S_exec_failed(pTHX_ const char *cmd, int fd, int do_report); STATIC bool S_ingroup(pTHX_ Gid_t testgid, bool effective) __attribute__warn_unused_result__; -STATIC bool S_openn_cleanup(pTHX_ GV *gv, IO *io, PerlIO *fp, char *mode, const char *oname, PerlIO *saveifp, PerlIO *saveofp, int savefd, char savetype, int writing, bool was_fdopen, const char *type); +STATIC bool S_openn_cleanup(pTHX_ GV *gv, IO *io, PerlIO *fp, char *mode, const char *oname, PerlIO *saveifp, PerlIO *saveofp, int savefd, char savetype, int writing, bool was_fdopen, const char *type, Stat_t *statbufp); #define PERL_ARGS_ASSERT_OPENN_CLEANUP \ assert(gv); assert(io); assert(mode); assert(oname) STATIC IO * S_openn_setup(pTHX_ GV *gv, char *mode, PerlIO **saveifp, PerlIO **saveofp, int *savefd, char *savetype); @@ -4361,7 +4498,9 @@ PERL_CALLCONV void Perl_hv_kill_backrefs(pTHX_ HV *hv); STATIC bool S_find_default_stash(pTHX_ HV **stash, const char *name, STRLEN len, const U32 is_utf8, const I32 add, const svtype sv_type); #define PERL_ARGS_ASSERT_FIND_DEFAULT_STASH \ assert(stash); assert(name) +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE GV* S_gv_fetchmeth_internal(pTHX_ HV* stash, SV* meth, const char* name, STRLEN len, I32 level, U32 flags); +#endif STATIC void S_gv_init_svtype(pTHX_ GV *gv, const svtype sv_type); #define PERL_ARGS_ASSERT_GV_INIT_SVTYPE \ assert(gv) @@ -4374,10 +4513,14 @@ STATIC bool S_gv_magicalize(pTHX_ GV *gv, HV *stash, const char *name, STRLEN le STATIC void S_gv_magicalize_isa(pTHX_ GV *gv); #define PERL_ARGS_ASSERT_GV_MAGICALIZE_ISA \ assert(gv) +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE HV* S_gv_stashpvn_internal(pTHX_ const char* name, U32 namelen, I32 flags); #define PERL_ARGS_ASSERT_GV_STASHPVN_INTERNAL \ assert(name) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE HV* S_gv_stashsvpvn_cached(pTHX_ SV *namesv, const char* name, U32 namelen, I32 flags); +#endif STATIC void S_maybe_multimagic_gv(pTHX_ GV *gv, const char *name, const svtype sv_type); #define PERL_ARGS_ASSERT_MAYBE_MULTIMAGIC_GV \ assert(gv); assert(name) @@ -4397,9 +4540,6 @@ PERL_CALLCONV void Perl_sv_add_backref(pTHX_ SV *const tsv, SV *const sv); STATIC void S_clear_placeholders(pTHX_ HV *hv, U32 items); #define PERL_ARGS_ASSERT_CLEAR_PLACEHOLDERS \ assert(hv) -STATIC void S_hfreeentries(pTHX_ HV *hv); -#define PERL_ARGS_ASSERT_HFREEENTRIES \ - assert(hv) STATIC void S_hsplit(pTHX_ HV *hv, STRLEN const oldsize, STRLEN newsize); #define PERL_ARGS_ASSERT_HSPLIT \ assert(hv) @@ -4413,6 +4553,9 @@ STATIC SV* S_hv_delete_common(pTHX_ HV *hv, SV *keysv, const char *key, STRLEN k STATIC SV* S_hv_free_ent_ret(pTHX_ HV *hv, HE *entry); #define PERL_ARGS_ASSERT_HV_FREE_ENT_RET \ assert(hv); assert(entry) +STATIC void S_hv_free_entries(pTHX_ HV *hv); +#define PERL_ARGS_ASSERT_HV_FREE_ENTRIES \ + assert(hv) STATIC void S_hv_magic_check(HV *hv, bool *needs_copy, bool *needs_store); #define PERL_ARGS_ASSERT_HV_MAGIC_CHECK \ assert(hv); assert(needs_copy); assert(needs_store) @@ -4424,7 +4567,9 @@ PERL_STATIC_NO_RET void S_hv_notallowed(pTHX_ int flags, const char *key, I32 kl STATIC HE* S_new_he(pTHX) __attribute__warn_unused_result__; +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE U32 S_ptr_hash(PTRV u); +#endif STATIC SV * S_refcounted_he_value(pTHX_ const struct refcounted_he *he); #define PERL_ARGS_ASSERT_REFCOUNTED_HE_VALUE \ assert(he) @@ -4434,7 +4579,7 @@ STATIC HEK* S_save_hek_flags(const char *str, I32 len, U32 hash, int flags) #define PERL_ARGS_ASSERT_SAVE_HEK_FLAGS \ assert(str) -STATIC HEK* S_share_hek_flags(pTHX_ const char *str, I32 len, U32 hash, int flags) +STATIC HEK* S_share_hek_flags(pTHX_ const char *str, STRLEN len, U32 hash, int flags) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SHARE_HEK_FLAGS \ assert(str) @@ -4526,7 +4671,7 @@ STATIC void S_finalize_op(pTHX_ OP* o); STATIC void S_find_and_forget_pmops(pTHX_ OP *o); #define PERL_ARGS_ASSERT_FIND_AND_FORGET_PMOPS \ assert(o) -STATIC OP* S_fold_constants(pTHX_ OP *o); +STATIC OP* S_fold_constants(pTHX_ OP * const o); #define PERL_ARGS_ASSERT_FOLD_CONSTANTS \ assert(o) STATIC OP* S_force_list(pTHX_ OP* arg, bool nullit); @@ -4556,7 +4701,9 @@ STATIC OP * S_my_kid(pTHX_ OP *o, OP *attrs, OP **imopsp); STATIC OP* S_newGIVWHENOP(pTHX_ OP* cond, OP *block, I32 enter_opcode, I32 leave_opcode, PADOFFSET entertarg); #define PERL_ARGS_ASSERT_NEWGIVWHENOP \ assert(block) +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE OP* S_newMETHOP_internal(pTHX_ I32 type, I32 flags, OP* dynamic_meth, SV* const_meth); +#endif STATIC OP* S_new_logop(pTHX_ I32 type, I32 flags, OP **firstp, OP **otherp) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_NEW_LOGOP \ @@ -4570,12 +4717,16 @@ STATIC OP* S_no_fh_allowed(pTHX_ OP *o) #define PERL_ARGS_ASSERT_NO_FH_ALLOWED \ assert(o) +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE OP* S_op_integerize(pTHX_ OP *o); #define PERL_ARGS_ASSERT_OP_INTEGERIZE \ assert(o) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE OP* S_op_std_init(pTHX_ OP *o); #define PERL_ARGS_ASSERT_OP_STD_INIT \ assert(o) +#endif STATIC OP* S_pmtrans(pTHX_ OP* o, OP* expr, OP* repl); #define PERL_ARGS_ASSERT_PMTRANS \ assert(o); assert(expr); assert(repl) @@ -4609,9 +4760,11 @@ STATIC OP* S_too_many_arguments_pv(pTHX_ OP *o, const char* name, U32 flags); #define PERL_ARGS_ASSERT_TOO_MANY_ARGUMENTS_PV \ assert(o); assert(name) # if defined(USE_ITHREADS) +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE void S_op_relocate_sv(pTHX_ SV** svp, PADOFFSET* targp); #define PERL_ARGS_ASSERT_OP_RELOCATE_SV \ assert(svp); assert(targp) +#endif # endif #endif #if defined(PERL_IN_OP_C) || defined(PERL_IN_SV_C) @@ -4699,7 +4852,7 @@ STATIC void S_destroy_matcher(pTHX_ PMOP* matcher); #define PERL_ARGS_ASSERT_DESTROY_MATCHER \ assert(matcher) STATIC OP* S_do_smartmatch(pTHX_ HV* seen_this, HV* seen_other, const bool copied); -STATIC OP* S_docatch(pTHX_ OP *o) +STATIC OP* S_docatch(pTHX_ Perl_ppaddr_t firstpp) __attribute__warn_unused_result__; STATIC bool S_doeval_compile(pTHX_ U8 gimme, CV* outside, U32 seq, HV* hh); @@ -4746,10 +4899,12 @@ STATIC bool S_matcher_matches_sv(pTHX_ PMOP* matcher, SV* sv) STATIC bool S_num_overflow(NV value, I32 fldsize, I32 frcsize) __attribute__warn_unused_result__; +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE bool S_path_is_searchable(const char *name) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_PATH_IS_SEARCHABLE \ assert(name) +#endif STATIC I32 S_run_user_filter(pTHX_ int idx, SV *buf_sv, int maxlen) __attribute__warn_unused_result__; @@ -4770,10 +4925,12 @@ STATIC void S_save_lines(pTHX_ AV *array, SV *sv); STATIC void S_do_oddball(pTHX_ SV **oddkey, SV **firstkey); #define PERL_ARGS_ASSERT_DO_ODDBALL \ assert(oddkey); assert(firstkey) +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE HV* S_opmethod_stash(pTHX_ SV* meth); #define PERL_ARGS_ASSERT_OPMETHOD_STASH \ assert(meth) #endif +#endif #if defined(PERL_IN_PP_PACK_C) STATIC int S_div128(pTHX_ SV *pnum, bool *done); #define PERL_ARGS_ASSERT_DIV128 \ @@ -4872,8 +5029,10 @@ STATIC SV* S__make_exactf_invlist(pTHX_ RExC_state_t *pRExC_state, regnode *node STATIC void S_add_above_Latin1_folds(pTHX_ RExC_state_t *pRExC_state, const U8 cp, SV** invlist); #define PERL_ARGS_ASSERT_ADD_ABOVE_LATIN1_FOLDS \ assert(pRExC_state); assert(invlist) +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE SV* S_add_cp_to_invlist(pTHX_ SV* invlist, const UV cp) __attribute__warn_unused_result__; +#endif STATIC U32 S_add_data(RExC_state_t* const pRExC_state, const char* const s, const U32 n) __attribute__warn_unused_result__; @@ -4883,77 +5042,97 @@ STATIC U32 S_add_data(RExC_state_t* const pRExC_state, const char* const s, cons STATIC AV* S_add_multi_match(pTHX_ AV* multi_char_matches, SV* multi_string, const STRLEN cp_count); #define PERL_ARGS_ASSERT_ADD_MULTI_MATCH \ assert(multi_string) +#ifndef PERL_NO_INLINE_FUNCTIONS 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); #define PERL_ARGS_ASSERT_ALLOC_MAYBE_POPULATE_EXACT \ assert(pRExC_state); assert(node); assert(flagp) +#endif STATIC const char * S_cntrl_to_mnemonic(const U8 c) - __attribute__pure__; + __attribute__warn_unused_result__; +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE 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) STATIC int S_edit_distance(const UV *src, const UV *tgt, const STRLEN x, const STRLEN y, const SSize_t maxDistance) - __attribute__pure__; + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_EDIT_DISTANCE \ assert(src); assert(tgt) STATIC SV* S_get_ANYOF_cp_list_for_ssc(pTHX_ const RExC_state_t *pRExC_state, const regnode_charclass* const node); #define PERL_ARGS_ASSERT_GET_ANYOF_CP_LIST_FOR_SSC \ assert(pRExC_state); assert(node) +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE STRLEN* S_get_invlist_iter_addr(SV* invlist) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_GET_INVLIST_ITER_ADDR \ assert(invlist) +#endif STATIC bool S_grok_bslash_N(pTHX_ RExC_state_t *pRExC_state, regnode** 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* 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 int S_handle_possible_posix(pTHX_ RExC_state_t *pRExC_state, const char* const s, char ** updated_parse_ptr, AV** posix_warnings, const bool check_only); #define PERL_ARGS_ASSERT_HANDLE_POSSIBLE_POSIX \ assert(pRExC_state); assert(s) STATIC regnode* S_handle_regex_sets(pTHX_ RExC_state_t *pRExC_state, SV ** return_invlist, I32 *flagp, U32 depth, char * const oregcomp_parse); #define PERL_ARGS_ASSERT_HANDLE_REGEX_SETS \ assert(pRExC_state); assert(flagp); assert(oregcomp_parse) +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE SV* S_invlist_clone(pTHX_ SV* const invlist) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_INVLIST_CLONE \ assert(invlist) +#endif STATIC SV* S_invlist_contents(pTHX_ SV* const invlist, const bool traditional_style) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_INVLIST_CONTENTS \ assert(invlist) +#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 \ assert(invlist) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE bool S_invlist_is_iterating(SV* const invlist) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_INVLIST_IS_ITERATING \ assert(invlist) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS 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 void S_invlist_iterinit(SV* invlist); #define PERL_ARGS_ASSERT_INVLIST_ITERINIT \ assert(invlist) +#endif STATIC 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) +#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) +#endif STATIC bool S_is_ssc_worth_it(const RExC_state_t * pRExC_state, const regnode_ssc * ssc); #define PERL_ARGS_ASSERT_IS_SSC_WORTH_IT \ assert(pRExC_state); assert(ssc) @@ -4963,6 +5142,11 @@ STATIC U32 S_join_exact(pTHX_ RExC_state_t *pRExC_state, regnode *scan, UV *min_ STATIC I32 S_make_trie(pTHX_ RExC_state_t *pRExC_state, regnode *startbranch, regnode *first, regnode *last, regnode *tail, U32 word_count, U32 flags, U32 depth); #define PERL_ARGS_ASSERT_MAKE_TRIE \ assert(pRExC_state); assert(startbranch); assert(first); assert(last); assert(tail) +STATIC bool S_new_regcurly(const char *s, const char *e) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEW_REGCURLY \ + assert(s); assert(e) + STATIC void S_nextchar(pTHX_ RExC_state_t *pRExC_state); #define PERL_ARGS_ASSERT_NEXTCHAR \ assert(pRExC_state) @@ -4992,9 +5176,11 @@ STATIC regnode* S_reg_node(pTHX_ RExC_state_t *pRExC_state, U8 op); STATIC SV * S_reg_scan_name(pTHX_ RExC_state_t *pRExC_state, U32 flags); #define PERL_ARGS_ASSERT_REG_SCAN_NAME \ assert(pRExC_state) +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE char * S_reg_skipcomment(RExC_state_t *pRExC_state, char * p); #define PERL_ARGS_ASSERT_REG_SKIPCOMMENT \ assert(pRExC_state); assert(p) +#endif STATIC regnode* S_reganode(pTHX_ RExC_state_t *pRExC_state, U8 op, U32 arg); #define PERL_ARGS_ASSERT_REGANODE \ assert(pRExC_state) @@ -5008,11 +5194,11 @@ STATIC regnode* S_regclass(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 dept #define PERL_ARGS_ASSERT_REGCLASS \ assert(pRExC_state); assert(flagp) STATIC unsigned int S_regex_set_precedence(const U8 my_operator) - __attribute__pure__; + __attribute__warn_unused_result__; -STATIC void S_reginsert(pTHX_ RExC_state_t *pRExC_state, U8 op, regnode *opnd, U32 depth); +STATIC void S_reginsert(pTHX_ RExC_state_t *pRExC_state, U8 op, regnode *operand, U32 depth); #define PERL_ARGS_ASSERT_REGINSERT \ - assert(pRExC_state); assert(opnd) + assert(pRExC_state); assert(operand) STATIC regnode* S_regnode_guts(pTHX_ RExC_state_t *pRExC_state, const U8 op, const STRLEN extra_len, const char* const name); #define PERL_ARGS_ASSERT_REGNODE_GUTS \ assert(pRExC_state); assert(name) @@ -5031,30 +5217,38 @@ STATIC void S_set_ANYOF_arg(pTHX_ RExC_state_t* const pRExC_state, regnode* cons 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); #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); #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); #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); #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 \ @@ -5068,9 +5262,11 @@ 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); #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); #define PERL_ARGS_ASSERT_STUDY_CHUNK \ assert(pRExC_state); assert(scanp); assert(minlenp); assert(deltap); assert(last) @@ -5108,15 +5304,19 @@ PERL_CALLCONV SV* Perl__get_swash_invlist(pTHX_ SV* const swash) #define PERL_ARGS_ASSERT__GET_SWASH_INVLIST \ assert(swash) +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE bool S__invlist_contains_cp(SV* const invlist, const UV cp) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT__INVLIST_CONTAINS_CP \ assert(invlist) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE UV S__invlist_len(SV* const invlist) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT__INVLIST_LEN \ assert(invlist) +#endif PERL_CALLCONV SSize_t Perl__invlist_search(SV* const invlist, const UV cp) __attribute__warn_unused_result__; @@ -5128,15 +5328,19 @@ PERL_CALLCONV HV* Perl__swash_inversion_hash(pTHX_ SV* const swash) #define PERL_ARGS_ASSERT__SWASH_INVERSION_HASH \ assert(swash) +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE bool* S_get_invlist_offset_addr(SV* invlist) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_GET_INVLIST_OFFSET_ADDR \ assert(invlist) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE UV* S_invlist_array(SV* const invlist) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_INVLIST_ARRAY \ assert(invlist) +#endif #endif #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C) || defined(PERL_IN_TOKE_C) @@ -5145,10 +5349,12 @@ PERL_CALLCONV SV* Perl__core_swash_init(pTHX_ const char* pkg, const char* name, assert(pkg); assert(name); assert(listsv) #endif #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_TOKE_C) || defined(PERL_IN_DQUOTE_C) +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE char* S_form_short_octal_warning(pTHX_ const char * const s, const STRLEN len) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_FORM_SHORT_OCTAL_WARNING \ assert(s) +#endif PERL_CALLCONV char Perl_grok_bslash_c(pTHX_ const char source, const bool output_warning) __attribute__warn_unused_result__; @@ -5163,11 +5369,12 @@ PERL_CALLCONV bool Perl_grok_bslash_x(pTHX_ char** s, UV* uv, const char** error #define PERL_ARGS_ASSERT_GROK_BSLASH_X \ assert(s); assert(uv); assert(error_msg) +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE I32 S_regcurly(const char *s) - __attribute__warn_unused_result__ - __attribute__pure__; + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_REGCURLY \ assert(s) +#endif #endif #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_UTF8_C) @@ -5244,9 +5451,6 @@ STATIC char* S_find_byclass(pTHX_ regexp * prog, const regnode *c, char *s, cons #define PERL_ARGS_ASSERT_FIND_BYCLASS \ assert(prog); assert(c); assert(s); assert(strend) -STATIC bool S_isFOO_lc(pTHX_ const U8 classnum, const U8 character) - __attribute__warn_unused_result__; - STATIC bool S_isFOO_utf8_lc(pTHX_ const U8 classnum, const U8* character) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_ISFOO_UTF8_LC \ @@ -5277,10 +5481,13 @@ STATIC I32 S_reg_check_named_buff_matched(const regexp *rex, const regnode *scan #define PERL_ARGS_ASSERT_REG_CHECK_NAMED_BUFF_MATCHED \ assert(rex); assert(scan) -STATIC void S_regcppop(pTHX_ regexp *rex, U32 *maxopenparen_p); +STATIC void S_regcp_restore(pTHX_ regexp *rex, I32 ix, U32 *maxopenparen_p _pDEPTH); +#define PERL_ARGS_ASSERT_REGCP_RESTORE \ + assert(rex); assert(maxopenparen_p) +STATIC void S_regcppop(pTHX_ regexp *rex, U32 *maxopenparen_p _pDEPTH); #define PERL_ARGS_ASSERT_REGCPPOP \ assert(rex); assert(maxopenparen_p) -STATIC CHECKPOINT S_regcppush(pTHX_ const regexp *rex, I32 parenfloor, U32 maxopenparen); +STATIC CHECKPOINT S_regcppush(pTHX_ const regexp *rex, I32 parenfloor, U32 maxopenparen _pDEPTH); #define PERL_ARGS_ASSERT_REGCPPUSH \ assert(rex) STATIC U8* S_reghop3(U8 *s, SSize_t off, const U8 *lim) @@ -5308,7 +5515,7 @@ STATIC SSize_t S_regmatch(pTHX_ regmatch_info *reginfo, char *startpos, regnode #define PERL_ARGS_ASSERT_REGMATCH \ assert(reginfo); assert(startpos); assert(prog) -STATIC I32 S_regrepeat(pTHX_ regexp *prog, char **startposp, const regnode *p, regmatch_info *const reginfo, I32 max, int depth) +STATIC I32 S_regrepeat(pTHX_ regexp *prog, char **startposp, const regnode *p, regmatch_info *const reginfo, I32 max _pDEPTH) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_REGREPEAT \ assert(prog); assert(startposp); assert(p); assert(reginfo) @@ -5325,6 +5532,18 @@ 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_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__; + +#endif #if defined(PERL_IN_SCOPE_C) STATIC void S_save_pushptri32ptr(pTHX_ void *const ptr1, const I32 i, void *const ptr2, const int type); STATIC SV* S_save_scalar_at(pTHX_ SV **sptr, const U32 flags); @@ -5344,7 +5563,7 @@ STATIC void S_assert_uft8_cache_coherent(pTHX_ const char *const func, STRLEN fr STATIC bool S_curse(pTHX_ SV * const sv, const bool check_refcnt); #define PERL_ARGS_ASSERT_CURSE \ assert(sv) -STATIC I32 S_expect_number(pTHX_ char **const pattern) +STATIC STRLEN S_expect_number(pTHX_ const char **const pattern) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_EXPECT_NUMBER \ assert(pattern) @@ -5397,9 +5616,11 @@ STATIC STRLEN S_sv_pos_u2b_forwards(const U8 *const start, const U8 *const send, STATIC STRLEN S_sv_pos_u2b_midway(const U8 *const start, const U8 *send, STRLEN uoffset, const STRLEN uend); #define PERL_ARGS_ASSERT_SV_POS_U2B_MIDWAY \ assert(start); assert(send) +#ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE void S_sv_unglob(pTHX_ SV *const sv, U32 flags); #define PERL_ARGS_ASSERT_SV_UNGLOB \ assert(sv) +#endif STATIC char * S_uiv_2buf(char *const buf, const IV iv, UV uv, const int is_uv, char **const peob) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_UIV_2BUF \ @@ -5439,7 +5660,6 @@ STATIC void S_check_uni(pTHX); STATIC void S_checkcomma(pTHX_ const char *s, const char *name, const char *what); #define PERL_ARGS_ASSERT_CHECKCOMMA \ assert(s); assert(name); assert(what) -STATIC int S_deprecate_commaless_var_list(pTHX); STATIC char * S_filter_gets(pTHX_ SV *sv, STRLEN append) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_FILTER_GETS \ @@ -5464,7 +5684,7 @@ STATIC char* S_force_version(pTHX_ char *s, int guessing); STATIC char* S_force_word(pTHX_ char *start, int token, int check_keyword, int allow_pack); #define PERL_ARGS_ASSERT_FORCE_WORD \ assert(start) -PERL_STATIC_INLINE SV* S_get_and_check_backslash_N_name(pTHX_ const char* s, const char* const e) +STATIC SV* S_get_and_check_backslash_N_name(pTHX_ const char* s, const char* const e) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_GET_AND_CHECK_BACKSLASH_N_NAME \ assert(s); assert(e) @@ -5478,7 +5698,7 @@ STATIC int S_intuit_method(pTHX_ char *s, SV *ioname, CV *cv); STATIC int S_intuit_more(pTHX_ char *s); #define PERL_ARGS_ASSERT_INTUIT_MORE \ assert(s) -STATIC I32 S_lop(pTHX_ I32 f, int x, char *s); +STATIC I32 S_lop(pTHX_ I32 f, U8 x, char *s); #define PERL_ARGS_ASSERT_LOP \ assert(s) PERL_STATIC_NO_RET void S_missingterm(pTHX_ char *s) @@ -5578,39 +5798,51 @@ STATIC bool S_isa_lookup(pTHX_ HV *stash, const char * const name, STRLEN len, U assert(stash); assert(name) #endif #if defined(PERL_IN_UTF8_C) -STATIC char * S__byte_dump_string(pTHX_ const U8 * s, const STRLEN len); -#define PERL_ARGS_ASSERT__BYTE_DUMP_STRING \ - assert(s) STATIC UV S__to_utf8_case(pTHX_ const UV uv1, const U8 *p, U8* ustrp, STRLEN *lenp, SV **swashp, const char *normal, const char *special); #define PERL_ARGS_ASSERT__TO_UTF8_CASE \ assert(p); assert(ustrp); assert(swashp); assert(normal) +STATIC U32 S_check_and_deprecate(pTHX_ const U8 * p, const U8 ** e, const unsigned type, const bool use_locale, const char * const file, const unsigned line); +#define PERL_ARGS_ASSERT_CHECK_AND_DEPRECATE \ + assert(p); assert(e); assert(file) STATIC UV S_check_locale_boundary_crossing(pTHX_ const U8* const p, const UV result, U8* const ustrp, STRLEN *lenp) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CHECK_LOCALE_BOUNDARY_CROSSING \ assert(p); assert(ustrp); assert(lenp) -PERL_STATIC_INLINE bool S_does_utf8_overflow(const U8 * const s, const U8 * e) - __attribute__warn_unused_result__ - __attribute__pure__; +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE int S_does_utf8_overflow(const U8 * const s, const U8 * e, const bool consider_overlongs) + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_DOES_UTF8_OVERFLOW \ assert(s); assert(e) +#endif + +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE int S_isFF_OVERLONG(const U8 * const s, const STRLEN len) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_ISFF_OVERLONG \ + assert(s) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS 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__; #define PERL_ARGS_ASSERT_IS_UTF8_COMMON \ assert(p); assert(swash); assert(swashname) +#endif -PERL_STATIC_INLINE bool S_is_utf8_cp_above_31_bits(const U8 * const s, const U8 * const e) - __attribute__warn_unused_result__ - __attribute__pure__; -#define PERL_ARGS_ASSERT_IS_UTF8_CP_ABOVE_31_BITS \ - assert(s); assert(e) +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE bool S_is_utf8_common_with_len(pTHX_ const U8 *const p, const U8 *const e, SV **swash, const char * const swashname, SV* const invlist) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_IS_UTF8_COMMON_WITH_LEN \ + assert(p); assert(e); assert(swash); assert(swashname) +#endif -PERL_STATIC_INLINE bool S_is_utf8_overlong_given_start_byte_ok(const U8 * const s, const STRLEN len) - __attribute__warn_unused_result__ - __attribute__pure__; +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE int S_is_utf8_overlong_given_start_byte_ok(const U8 * const s, const STRLEN len) + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UTF8_OVERLONG_GIVEN_START_BYTE_OK \ assert(s) +#endif 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__; @@ -5622,14 +5854,17 @@ STATIC SV* S_swatch_get(pTHX_ SV* swash, UV start, UV span) #define PERL_ARGS_ASSERT_SWATCH_GET \ assert(swash) -STATIC U8 S_to_lower_latin1(const U8 c, U8 *p, STRLEN *lenp) +STATIC U8 S_to_lower_latin1(const U8 c, U8 *p, STRLEN *lenp, const char dummy) __attribute__warn_unused_result__; -STATIC char * S_unexpected_non_continuation_text(pTHX_ const U8 * const s, const STRLEN print_len, const STRLEN non_cont_byte_pos, const STRLEN expect_len) +STATIC char * S_unexpected_non_continuation_text(pTHX_ const U8 * const s, STRLEN print_len, const STRLEN non_cont_byte_pos, const STRLEN expect_len) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_UNEXPECTED_NON_CONTINUATION_TEXT \ assert(s) +STATIC void S_warn_on_first_deprecated_use(pTHX_ const char * const name, const char * const alternative, const bool use_locale, const char * const file, const unsigned line); +#define PERL_ARGS_ASSERT_WARN_ON_FIRST_DEPRECATED_USE \ + assert(name); assert(alternative); assert(file) #endif #if defined(PERL_IN_UTF8_C) || defined(PERL_IN_PP_C) PERL_CALLCONV UV Perl__to_upper_title_latin1(pTHX_ const U8 c, U8 *p, STRLEN *lenp, const char S_or_s); @@ -5814,9 +6049,17 @@ PERL_CALLCONV SV* Perl_sv_dup_inc(pTHX_ const SV *const sstr, CLONE_PARAMS *cons PERL_CALLCONV bool Perl__is_cur_LC_category_utf8(pTHX_ int category); #endif #if defined(USE_LOCALE) && defined(PERL_IN_LOCALE_C) +STATIC void S_new_collate(pTHX_ const char* newcoll); +STATIC void S_new_ctype(pTHX_ const char* newctype); +#define PERL_ARGS_ASSERT_NEW_CTYPE \ + assert(newctype) +STATIC void S_set_numeric_radix(pTHX); STATIC char* S_stdize_locale(pTHX_ char* locs); #define PERL_ARGS_ASSERT_STDIZE_LOCALE \ assert(locs) +# if defined(WIN32) +STATIC char* S_my_setlocale(pTHX_ int category, const char* locale); +# endif #endif #if defined(USE_LOCALE_COLLATE) PERL_CALLCONV int Perl_magic_setcollxfrm(pTHX_ SV* sv, MAGIC* mg); @@ -5883,9 +6126,6 @@ PERL_CALLCONV const char* Perl_quadmath_format_single(const char* format); assert(format) #endif #if defined(WIN32) -PERL_CALLCONV char* Perl_my_setlocale(pTHX_ int category, const char* locale) - __attribute__pure__; - PERL_CALLCONV_NO_RET void win32_croak_not_implemented(const char * fname) __attribute__noreturn__; #define PERL_ARGS_ASSERT_WIN32_CROAK_NOT_IMPLEMENTED \