X-Git-Url: https://perl5.git.perl.org/perl5.git/blobdiff_plain/56dd984bdb8056d778b964ab6a46cb7dfaef915c..022f6832fbfd92fe11f107f3683107b91ef9b07c:/proto.h diff --git a/proto.h b/proto.h index b1b7987..63814ff 100644 --- a/proto.h +++ b/proto.h @@ -49,6 +49,7 @@ PERL_CALLCONV int Perl_PerlLIO_open_cloexec(pTHX_ const char *file, int flag) #define PERL_ARGS_ASSERT_PERLLIO_OPEN_CLOEXEC \ assert(file) +PERL_CALLCONV const char* Perl_setlocale(const int category, const char* locale); PERL_CALLCONV void* Perl_Slab_Alloc(pTHX_ size_t sz) __attribute__warn_unused_result__; @@ -61,6 +62,11 @@ PERL_CALLCONV char * Perl__byte_dump_string(pTHX_ const U8 * const start, const 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 Size_t Perl__inverse_folds(pTHX_ const UV cp, unsigned int * first_folds_to, const unsigned int ** remaining_folds_to) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT__INVERSE_FOLDS \ + assert(first_folds_to); assert(remaining_folds_to) + 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__; @@ -138,10 +144,13 @@ PERL_CALLCONV UV Perl__to_utf8_upper_flags(pTHX_ const U8 *p, const U8 *e, U8* u #define PERL_ARGS_ASSERT__TO_UTF8_UPPER_FLAGS \ assert(p); assert(ustrp); assert(file) #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE unsigned int S__variant_byte_number(PERL_UINTMAX_T word) - __attribute__warn_unused_result__; +PERL_STATIC_INLINE UV S__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) #endif - +PERL_CALLCONV UV Perl__utf8n_to_uvchr_msgs_helper(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags, U32 * errors, AV ** msgs); +#define PERL_ARGS_ASSERT__UTF8N_TO_UVCHR_MSGS_HELPER \ + assert(s) 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__; @@ -219,6 +228,9 @@ PERL_CALLCONV AV* Perl_av_make(pTHX_ SSize_t size, SV **strp) #define PERL_ARGS_ASSERT_AV_MAKE \ assert(strp) +PERL_CALLCONV SV* Perl_av_nonelem(pTHX_ AV *av, SSize_t ix); +#define PERL_ARGS_ASSERT_AV_NONELEM \ + assert(av) PERL_CALLCONV SV* Perl_av_pop(pTHX_ AV *av); #define PERL_ARGS_ASSERT_AV_POP \ assert(av) @@ -236,7 +248,7 @@ PERL_CALLCONV SV* Perl_av_shift(pTHX_ AV *av) PERL_CALLCONV SV** Perl_av_store(pTHX_ AV *av, SSize_t key, SV *val); #define PERL_ARGS_ASSERT_AV_STORE \ assert(av) -/* PERL_CALLCONV SSize_t Perl_av_tindex(pTHX_ AV *av) +/* PERL_CALLCONV SSize_t av_tindex(pTHX_ AV *av) __attribute__warn_unused_result__; */ #ifndef PERL_NO_INLINE_FUNCTIONS @@ -612,7 +624,7 @@ PERL_CALLCONV_NO_RET void Perl_croak_caller(const char* pat, ...) __attribute__noreturn__ __attribute__format__null_ok__(__printf__,1,2); -PERL_STATIC_NO_RET void S_croak_memory_wrap(void) +PERL_STATIC_INLINE_NO_RET void S_croak_memory_wrap(void) __attribute__noreturn__; PERL_CALLCONV_NO_RET void Perl_croak_no_mem(void) @@ -635,20 +647,24 @@ PERL_CALLCONV_NO_RET void Perl_croak_xs_usage(const CV *const cv, const char *co assert(cv); assert(params) PERL_CALLCONV regexp_engine const * Perl_current_re_engine(pTHX); +#ifndef NO_MATHOMS PERL_CALLCONV const char * Perl_custom_op_desc(pTHX_ const OP *o) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CUSTOM_OP_DESC \ assert(o) +#endif PERL_CALLCONV XOPRETANY Perl_custom_op_get_field(pTHX_ const OP *o, const xop_flags_enum field) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CUSTOM_OP_GET_FIELD \ assert(o) +#ifndef NO_MATHOMS PERL_CALLCONV const char * Perl_custom_op_name(pTHX_ const OP *o) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_CUSTOM_OP_NAME \ assert(o) +#endif PERL_CALLCONV void Perl_custom_op_register(pTHX_ Perl_ppaddr_t ppaddr, const XOP *xop); #define PERL_ARGS_ASSERT_CUSTOM_OP_REGISTER \ @@ -753,9 +769,11 @@ PERL_CALLCONV bool Perl_do_aexec(pTHX_ SV* really, SV** mark, SV** sp); PERL_CALLCONV bool Perl_do_aexec5(pTHX_ SV* really, SV** mark, SV** sp, int fd, int do_report); #define PERL_ARGS_ASSERT_DO_AEXEC5 \ assert(mark); assert(sp) +#ifndef NO_MATHOMS PERL_CALLCONV int Perl_do_binmode(pTHX_ PerlIO *fp, int iotype, int mode); #define PERL_ARGS_ASSERT_DO_BINMODE \ assert(fp) +#endif PERL_CALLCONV bool Perl_do_close(pTHX_ GV* gv, bool not_implicit); PERL_CALLCONV void Perl_do_dump_pad(pTHX_ I32 level, PerlIO *file, PADLIST *padlist, int full); #define PERL_ARGS_ASSERT_DO_DUMP_PAD \ @@ -794,9 +812,11 @@ PERL_CALLCONV bool Perl_do_open(pTHX_ GV* gv, const char* name, I32 len, int as_ PERL_CALLCONV bool Perl_do_open6(pTHX_ GV *gv, const char *oname, STRLEN len, PerlIO *supplied_fp, SV **svp, U32 num); #define PERL_ARGS_ASSERT_DO_OPEN6 \ assert(gv); assert(oname) +#ifndef NO_MATHOMS 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) +#endif 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) @@ -884,6 +904,7 @@ PERL_CALLCONV void Perl_dump_sub_perl(pTHX_ const GV* gv, bool justperl); PERL_CALLCONV void Perl_dump_vindent(pTHX_ I32 level, PerlIO *file, const char* pat, va_list *args); #define PERL_ARGS_ASSERT_DUMP_VINDENT \ assert(file); assert(pat) +PERL_CALLCONV STRLEN* Perl_dup_warnings(pTHX_ STRLEN* warnings); PERL_CALLCONV void Perl_emulate_cop_io(pTHX_ const COP *const c, SV *const sv); #define PERL_ARGS_ASSERT_EMULATE_COP_IO \ assert(c); assert(sv) @@ -956,6 +977,11 @@ PERL_CALLCONV char* Perl_form(pTHX_ const char* pat, ...) PERL_CALLCONV void Perl_free_tied_hv_pool(pTHX); PERL_CALLCONV void Perl_free_tmps(pTHX); +PERL_CALLCONV SV* Perl_get_and_check_backslash_N_name(pTHX_ const char* s, const char* const e, const bool is_utf8, const char** error_msg) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_GET_AND_CHECK_BACKSLASH_N_NAME \ + assert(s); assert(e); assert(error_msg) + PERL_CALLCONV AV* Perl_get_av(pTHX_ const char *name, I32 flags); #define PERL_ARGS_ASSERT_GET_AV \ assert(name) @@ -1072,9 +1098,11 @@ PERL_CALLCONV SV* Perl_gv_const_sv(pTHX_ GV* gv) assert(gv) PERL_CALLCONV void Perl_gv_dump(pTHX_ GV* gv); +#ifndef NO_MATHOMS PERL_CALLCONV void Perl_gv_efullname(pTHX_ SV* sv, const GV* gv); #define PERL_ARGS_ASSERT_GV_EFULLNAME \ assert(sv); assert(gv) +#endif #ifndef NO_MATHOMS PERL_CALLCONV void Perl_gv_efullname3(pTHX_ SV* sv, const GV* gv, const char* prefix); #define PERL_ARGS_ASSERT_GV_EFULLNAME3 \ @@ -1135,9 +1163,11 @@ PERL_CALLCONV GV* Perl_gv_fetchpvn_flags(pTHX_ const char* name, STRLEN len, I32 PERL_CALLCONV GV* Perl_gv_fetchsv(pTHX_ SV *name, I32 flags, const svtype sv_type); #define PERL_ARGS_ASSERT_GV_FETCHSV \ assert(name) +#ifndef NO_MATHOMS PERL_CALLCONV void Perl_gv_fullname(pTHX_ SV* sv, const GV* gv); #define PERL_ARGS_ASSERT_GV_FULLNAME \ assert(sv); assert(gv) +#endif #ifndef NO_MATHOMS PERL_CALLCONV void Perl_gv_fullname3(pTHX_ SV* sv, const GV* gv, const char* prefix); #define PERL_ARGS_ASSERT_GV_FULLNAME3 \ @@ -1361,11 +1391,17 @@ PERL_CALLCONV void Perl_init_constants(pTHX); PERL_CALLCONV void Perl_init_dbargs(pTHX); PERL_CALLCONV void Perl_init_debugger(pTHX); PERL_CALLCONV int Perl_init_i18nl10n(pTHX_ int printwarn); +#ifndef NO_MATHOMS PERL_CALLCONV int Perl_init_i18nl14n(pTHX_ int printwarn); +#endif +PERL_CALLCONV void Perl_init_named_cv(pTHX_ CV *cv, OP *nameop); +#define PERL_ARGS_ASSERT_INIT_NAMED_CV \ + assert(cv); assert(nameop) PERL_CALLCONV void Perl_init_stacks(pTHX); PERL_CALLCONV void Perl_init_tm(pTHX_ struct tm *ptm); #define PERL_ARGS_ASSERT_INIT_TM \ assert(ptm) +PERL_CALLCONV void Perl_init_uniprops(pTHX); #ifndef NO_MATHOMS PERL_CALLCONV char* Perl_instr(const char* big, const char* little) __attribute__warn_unused_result__ @@ -1381,28 +1417,48 @@ PERL_CALLCONV OP* Perl_invert(pTHX_ OP* cmd) PERL_CALLCONV bool Perl_io_close(pTHX_ IO* io, GV *gv, bool not_implicit, bool warn_on_fail); #define PERL_ARGS_ASSERT_IO_CLOSE \ assert(io) +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_isALNUM_lazy(pTHX_ const char* p) __attribute__deprecated__ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_ISALNUM_LAZY \ assert(p) +#endif +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE Size_t S_isC9_STRICT_UTF8_CHAR(const U8 * const s0, const U8 * const e) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_ISC9_STRICT_UTF8_CHAR \ + assert(s0); assert(e) +#endif + +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_isIDFIRST_lazy(pTHX_ const char* p) __attribute__deprecated__ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_ISIDFIRST_LAZY \ assert(p) +#endif -PERL_CALLCONV bool Perl_isSCRIPT_RUN(pTHX_ const U8 *s, const U8 *send, const bool utf8_target) +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE Size_t S_isSTRICT_UTF8_CHAR(const U8 * const s0, const U8 * const e) __attribute__warn_unused_result__; -#define PERL_ARGS_ASSERT_ISSCRIPT_RUN \ - assert(s); assert(send) +#define PERL_ARGS_ASSERT_ISSTRICT_UTF8_CHAR \ + assert(s0); assert(e) +#endif -/* PERL_CALLCONV bool Perl_is_ascii_string(const U8* const s, STRLEN len) +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE Size_t S_isUTF8_CHAR(const U8 * const s0, const U8 * const e) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_ISUTF8_CHAR \ + assert(s0); assert(e) +#endif + +/* PERL_CALLCONV bool is_ascii_string(const U8* const s, STRLEN len) __attribute__warn_unused_result__ __attribute__pure__; */ -/* PERL_CALLCONV bool Perl_is_c9strict_utf8_string(const U8 *s, STRLEN len) +/* PERL_CALLCONV bool is_c9strict_utf8_string(const U8 *s, STRLEN len) __attribute__warn_unused_result__; */ /* PERL_CALLCONV bool is_c9strict_utf8_string_loc(const U8 *s, STRLEN len, const U8 **ep); */ @@ -1411,7 +1467,7 @@ PERL_STATIC_INLINE bool S_is_c9strict_utf8_string_loclen(const U8 *s, STRLEN len #define PERL_ARGS_ASSERT_IS_C9STRICT_UTF8_STRING_LOCLEN \ assert(s) #endif -/* PERL_CALLCONV bool Perl_is_invariant_string(const U8* const s, STRLEN len) +/* PERL_CALLCONV bool is_invariant_string(const U8* const s, STRLEN len) __attribute__warn_unused_result__ __attribute__pure__; */ @@ -1425,7 +1481,7 @@ PERL_STATIC_INLINE bool S_is_safe_syscall(pTHX_ const char *pv, STRLEN len, cons assert(pv); assert(what); assert(op_name) #endif -/* PERL_CALLCONV bool Perl_is_strict_utf8_string(const U8 *s, STRLEN len) +/* PERL_CALLCONV bool is_strict_utf8_string(const U8 *s, STRLEN len) __attribute__warn_unused_result__; */ /* PERL_CALLCONV bool is_strict_utf8_string_loc(const U8 *s, STRLEN len, const U8 **ep); */ @@ -1434,187 +1490,263 @@ PERL_STATIC_INLINE bool S_is_strict_utf8_string_loclen(const U8 *s, STRLEN len, #define PERL_ARGS_ASSERT_IS_STRICT_UTF8_STRING_LOCLEN \ assert(s) #endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_alnum(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_alnum_lc(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_alnumc(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_alnumc_lc(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_alpha(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_alpha_lc(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_ascii(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_ascii_lc(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_blank(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_blank_lc(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_cntrl(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_cntrl_lc(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_digit(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_digit_lc(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_graph(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_graph_lc(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_idfirst(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_idfirst_lc(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_lower(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_lower_lc(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_print(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_print_lc(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_punct(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_punct_lc(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_space(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_space_lc(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_upper(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_upper_lc(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__; +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_xdigit(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_uni_xdigit_lc(pTHX_ UV c) __attribute__deprecated__ __attribute__warn_unused_result__ __attribute__pure__; +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_utf8_alnum(pTHX_ const U8 *p) __attribute__deprecated__ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UTF8_ALNUM \ assert(p) +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_utf8_alnumc(pTHX_ const U8 *p) __attribute__deprecated__ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UTF8_ALNUMC \ assert(p) +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_utf8_alpha(pTHX_ const U8 *p) __attribute__deprecated__ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UTF8_ALPHA \ assert(p) +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_utf8_ascii(pTHX_ const U8 *p) __attribute__deprecated__ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UTF8_ASCII \ assert(p) +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_utf8_blank(pTHX_ const U8 *p) __attribute__deprecated__ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UTF8_BLANK \ assert(p) +#endif +#ifndef NO_MATHOMS PERL_CALLCONV STRLEN Perl_is_utf8_char(const U8 *s) __attribute__deprecated__; #define PERL_ARGS_ASSERT_IS_UTF8_CHAR \ assert(s) +#endif #ifndef NO_MATHOMS PERL_CALLCONV STRLEN Perl_is_utf8_char_buf(const U8 *buf, const U8 *buf_end); #define PERL_ARGS_ASSERT_IS_UTF8_CHAR_BUF \ assert(buf); assert(buf_end) #endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_utf8_cntrl(pTHX_ const U8 *p) __attribute__deprecated__ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UTF8_CNTRL \ assert(p) +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_utf8_digit(pTHX_ const U8 *p) __attribute__deprecated__ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UTF8_DIGIT \ assert(p) +#endif /* PERL_CALLCONV bool is_utf8_fixed_width_buf_flags(const U8 * const s, STRLEN len, const U32 flags); */ /* PERL_CALLCONV bool is_utf8_fixed_width_buf_loc_flags(const U8 * const s, STRLEN len, const U8 **ep, const U32 flags); */ @@ -1623,23 +1755,29 @@ PERL_STATIC_INLINE bool S_is_utf8_fixed_width_buf_loclen_flags(const U8 * const #define PERL_ARGS_ASSERT_IS_UTF8_FIXED_WIDTH_BUF_LOCLEN_FLAGS \ assert(s) #endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_utf8_graph(pTHX_ const U8 *p) __attribute__deprecated__ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UTF8_GRAPH \ assert(p) +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_utf8_idcont(pTHX_ const U8 *p) __attribute__deprecated__ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UTF8_IDCONT \ assert(p) +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_utf8_idfirst(pTHX_ const U8 *p) __attribute__deprecated__ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UTF8_IDFIRST \ assert(p) +#endif /* PERL_CALLCONV bool is_utf8_invariant_string(const U8* const s, STRLEN len) __attribute__warn_unused_result__; */ @@ -1651,55 +1789,71 @@ PERL_STATIC_INLINE bool S_is_utf8_invariant_string_loc(const U8* const s, STRLEN assert(s) #endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_utf8_lower(pTHX_ const U8 *p) __attribute__deprecated__ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UTF8_LOWER \ assert(p) +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_utf8_mark(pTHX_ const U8 *p) __attribute__deprecated__ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UTF8_MARK \ assert(p) +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_utf8_perl_space(pTHX_ const U8 *p) __attribute__deprecated__ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UTF8_PERL_SPACE \ assert(p) +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_utf8_perl_word(pTHX_ const U8 *p) __attribute__deprecated__ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UTF8_PERL_WORD \ assert(p) +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_utf8_posix_digit(pTHX_ const U8 *p) __attribute__deprecated__ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UTF8_POSIX_DIGIT \ assert(p) +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_utf8_print(pTHX_ const U8 *p) __attribute__deprecated__ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UTF8_PRINT \ assert(p) +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_utf8_punct(pTHX_ const U8 *p) __attribute__deprecated__ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UTF8_PUNCT \ assert(p) +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_utf8_space(pTHX_ const U8 *p) __attribute__deprecated__ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UTF8_SPACE \ assert(p) +#endif -/* PERL_CALLCONV bool Perl_is_utf8_string(const U8 *s, STRLEN len) +/* PERL_CALLCONV bool is_utf8_string(const U8 *s, STRLEN len) __attribute__warn_unused_result__; */ #ifndef PERL_NO_INLINE_FUNCTIONS @@ -1710,7 +1864,7 @@ PERL_STATIC_INLINE bool S_is_utf8_string_flags(const U8 *s, STRLEN len, const U3 #endif #ifndef NO_MATHOMS -PERL_CALLCONV bool Perl_is_utf8_string_loc(const U8 *s, STRLEN len, const U8 **ep); +PERL_CALLCONV bool Perl_is_utf8_string_loc(const U8 *s, const STRLEN len, const U8 **ep); #define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOC \ assert(s); assert(ep) #endif @@ -1725,11 +1879,13 @@ PERL_STATIC_INLINE bool S_is_utf8_string_loclen_flags(const U8 *s, STRLEN len, c #define PERL_ARGS_ASSERT_IS_UTF8_STRING_LOCLEN_FLAGS \ assert(s) #endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_utf8_upper(pTHX_ const U8 *p) __attribute__deprecated__ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UTF8_UPPER \ assert(p) +#endif /* PERL_CALLCONV bool is_utf8_valid_partial_char(const U8 * const s, const U8 * const e) __attribute__warn_unused_result__ @@ -1742,23 +1898,29 @@ PERL_STATIC_INLINE bool S_is_utf8_valid_partial_char_flags(const U8 * const s, c assert(s); assert(e) #endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_utf8_xdigit(pTHX_ const U8 *p) __attribute__deprecated__ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UTF8_XDIGIT \ assert(p) +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_utf8_xidcont(pTHX_ const U8 *p) __attribute__deprecated__ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UTF8_XIDCONT \ assert(p) +#endif +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_is_utf8_xidfirst(pTHX_ const U8 *p) __attribute__deprecated__ __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UTF8_XIDFIRST \ assert(p) +#endif PERL_CALLCONV bool Perl_isinfnan(NV nv) __attribute__warn_unused_result__ @@ -1947,6 +2109,9 @@ PERL_CALLCONV int Perl_magic_setmglob(pTHX_ SV* sv, MAGIC* mg); PERL_CALLCONV int Perl_magic_setnkeys(pTHX_ SV* sv, MAGIC* mg); #define PERL_ARGS_ASSERT_MAGIC_SETNKEYS \ assert(sv); assert(mg) +PERL_CALLCONV int Perl_magic_setnonelem(pTHX_ SV* sv, MAGIC* mg); +#define PERL_ARGS_ASSERT_MAGIC_SETNONELEM \ + assert(sv); assert(mg) PERL_CALLCONV int Perl_magic_setpack(pTHX_ SV* sv, MAGIC* mg); #define PERL_ARGS_ASSERT_MAGIC_SETPACK \ assert(sv); assert(mg) @@ -2087,9 +2252,12 @@ PERL_CALLCONV SV* Perl_multideref_stringify(pTHX_ const OP* o, CV *cv); PERL_CALLCONV NV Perl_my_atof(pTHX_ const char *s); #define PERL_ARGS_ASSERT_MY_ATOF \ assert(s) -PERL_CALLCONV char* Perl_my_atof2(pTHX_ const char *s, NV* value); +PERL_CALLCONV char* Perl_my_atof2(pTHX_ const char *orig, NV* value); #define PERL_ARGS_ASSERT_MY_ATOF2 \ - assert(s); assert(value) + assert(orig); assert(value) +PERL_CALLCONV char* Perl_my_atof3(pTHX_ const char *orig, NV* value, const STRLEN len); +#define PERL_ARGS_ASSERT_MY_ATOF3 \ + assert(orig); assert(value) PERL_CALLCONV OP * Perl_my_attrs(pTHX_ OP *o, OP *attrs); #define PERL_ARGS_ASSERT_MY_ATTRS \ assert(o) @@ -2107,6 +2275,11 @@ PERL_CALLCONV Pid_t Perl_my_fork(void); PERL_CALLCONV I32 Perl_my_lstat(pTHX); #endif PERL_CALLCONV I32 Perl_my_lstat_flags(pTHX_ const U32 flags); +PERL_CALLCONV int Perl_my_mkostemp_cloexec(char *templte, int flags) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_MY_MKOSTEMP_CLOEXEC \ + assert(templte) + PERL_CALLCONV int Perl_my_mkstemp_cloexec(char *templte) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_MY_MKSTEMP_CLOEXEC \ @@ -2132,6 +2305,11 @@ PERL_CALLCONV char * Perl_my_strftime(pTHX_ const char *fmt, int sec, int min, i #define PERL_ARGS_ASSERT_MY_STRFTIME \ assert(fmt) +PERL_CALLCONV NV Perl_my_strtod(const char * const s, char ** e) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_MY_STRTOD \ + assert(s) + PERL_CALLCONV void Perl_my_unexec(pTHX); PERL_CALLCONV int Perl_my_vsnprintf(char *buffer, const Size_t len, const char *format, va_list ap); #define PERL_ARGS_ASSERT_MY_VSNPRINTF \ @@ -2359,8 +2537,16 @@ PERL_CALLCONV SV* Perl_newSVpvn_share(pTHX_ const char* s, I32 len, U32 hash) PERL_CALLCONV SV* Perl_newSVrv(pTHX_ SV *const rv, const char *const classname); #define PERL_ARGS_ASSERT_NEWSVRV \ assert(rv) +#ifndef NO_MATHOMS PERL_CALLCONV SV* Perl_newSVsv(pTHX_ SV *const old) __attribute__warn_unused_result__; +#endif + +PERL_CALLCONV SV* Perl_newSVsv_flags(pTHX_ SV *const old, I32 flags) + __attribute__warn_unused_result__; + +/* PERL_CALLCONV SV* newSVsv_nomg(pTHX_ SV *const old) + __attribute__warn_unused_result__; */ PERL_CALLCONV SV* Perl_newSVuv(pTHX_ const UV u) __attribute__warn_unused_result__; @@ -2391,7 +2577,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_numeric(pTHX_ const char* newcoll); PERL_CALLCONV PERL_SI* Perl_new_stackinfo(pTHX_ I32 stitems, I32 cxitems) __attribute__warn_unused_result__; @@ -2406,6 +2591,12 @@ PERL_CALLCONV STRLEN * Perl_new_warnings_bitfield(pTHX_ STRLEN *buffer, const ch PERL_CALLCONV PerlIO* Perl_nextargv(pTHX_ GV* gv, bool nomagicopen); #define PERL_ARGS_ASSERT_NEXTARGV \ assert(gv) +PERL_CALLCONV char* Perl_ninstr(const char* big, const char* bigend, const char* little, const char* lend) + __attribute__warn_unused_result__ + __attribute__pure__; +#define PERL_ARGS_ASSERT_NINSTR \ + assert(big); assert(bigend); assert(little); assert(lend) + PERL_CALLCONV_NO_RET void Perl_noperl_die(const char* pat, ...) __attribute__noreturn__ __attribute__format__(__printf__,1,2); @@ -2448,6 +2639,9 @@ PERL_CALLCONV OP* Perl_op_lvalue_flags(pTHX_ OP* o, I32 type, U32 flags); 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); +#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); @@ -2457,9 +2651,11 @@ PERL_CALLCONV OP* Perl_op_unscope(pTHX_ OP* o); PERL_CALLCONV void Perl_optimize_optree(pTHX_ OP* o); #define PERL_ARGS_ASSERT_OPTIMIZE_OPTREE \ assert(o) +#ifndef NO_MATHOMS PERL_CALLCONV void Perl_pack_cat(pTHX_ SV *cat, const char *pat, const char *patend, SV **beglist, SV **endlist, SV ***next_in_list, U32 flags); #define PERL_ARGS_ASSERT_PACK_CAT \ assert(cat); assert(pat); assert(patend); assert(beglist); assert(endlist); assert(next_in_list) +#endif PERL_CALLCONV void Perl_package(pTHX_ OP* o); #define PERL_ARGS_ASSERT_PACKAGE \ assert(o) @@ -2538,6 +2734,7 @@ PERL_CALLCONV OP* Perl_parse_fullstmt(pTHX_ U32 flags); PERL_CALLCONV SV* Perl_parse_label(pTHX_ U32 flags); PERL_CALLCONV OP* Perl_parse_listexpr(pTHX_ U32 flags); PERL_CALLCONV OP* Perl_parse_stmtseq(pTHX_ U32 flags); +PERL_CALLCONV OP* Perl_parse_subsignature(pTHX_ U32 flags); PERL_CALLCONV OP* Perl_parse_termexpr(pTHX_ U32 flags); PERL_CALLCONV U32 Perl_parse_unicode_opts(pTHX_ const char **popt); #define PERL_ARGS_ASSERT_PARSE_UNICODE_OPTS \ @@ -2626,7 +2823,7 @@ PERL_CALLCONV char* Perl_re_intuit_start(pTHX_ REGEXP * const rx, SV* sv, const PERL_CALLCONV SV* Perl_re_intuit_string(pTHX_ REGEXP *const r); #define PERL_ARGS_ASSERT_RE_INTUIT_STRING \ assert(r) -PERL_CALLCONV REGEXP* Perl_re_op_compile(pTHX_ SV ** const patternp, int pat_count, OP *expr, const regexp_engine* eng, REGEXP *old_re, bool *is_bare_re, U32 rx_flags, U32 pm_flags); +PERL_CALLCONV REGEXP* Perl_re_op_compile(pTHX_ SV ** const patternp, int pat_count, OP *expr, const regexp_engine* eng, REGEXP *old_re, bool *is_bare_re, const U32 rx_flags, const U32 pm_flags); #define PERL_ARGS_ASSERT_RE_OP_COMPILE \ assert(eng) PERL_CALLCONV Malloc_t Perl_realloc(Malloc_t where, MEM_SIZE nbytes) @@ -2701,9 +2898,6 @@ PERL_CALLCONV SV* Perl_reg_qr_package(pTHX_ REGEXP * const rx); PERL_CALLCONV REGEXP* Perl_reg_temp_copy(pTHX_ REGEXP* dsv, REGEXP* ssv); #define PERL_ARGS_ASSERT_REG_TEMP_COPY \ assert(ssv) -PERL_CALLCONV SV* Perl_regclass_swash(pTHX_ const regexp *prog, const struct regnode *node, bool doinit, SV **listsvp, SV **altsvp); -#define PERL_ARGS_ASSERT_REGCLASS_SWASH \ - assert(node) PERL_CALLCONV void Perl_regdump(pTHX_ const regexp* r); #define PERL_ARGS_ASSERT_REGDUMP \ assert(r) @@ -2836,20 +3030,26 @@ PERL_CALLCONV void Perl_save_item(pTHX_ SV* item); PERL_CALLCONV void Perl_save_iv(pTHX_ IV *ivp); #define PERL_ARGS_ASSERT_SAVE_IV \ assert(ivp) +#ifndef NO_MATHOMS PERL_CALLCONV void Perl_save_list(pTHX_ SV** sarg, I32 maxsarg); #define PERL_ARGS_ASSERT_SAVE_LIST \ assert(sarg) +#endif +#ifndef NO_MATHOMS PERL_CALLCONV void Perl_save_long(pTHX_ long* longp); #define PERL_ARGS_ASSERT_SAVE_LONG \ assert(longp) +#endif #ifndef NO_MATHOMS PERL_CALLCONV void Perl_save_mortalizesv(pTHX_ SV* sv); #define PERL_ARGS_ASSERT_SAVE_MORTALIZESV \ assert(sv) #endif +#ifndef NO_MATHOMS PERL_CALLCONV void Perl_save_nogv(pTHX_ GV* gv); #define PERL_ARGS_ASSERT_SAVE_NOGV \ assert(gv) +#endif #ifndef NO_MATHOMS PERL_CALLCONV void Perl_save_op(pTHX); #endif @@ -2930,12 +3130,20 @@ PERL_CALLCONV char* Perl_scan_num(pTHX_ const char* s, YYSTYPE *lvalp); PERL_CALLCONV NV Perl_scan_oct(pTHX_ const char* start, STRLEN len, STRLEN* retlen); #define PERL_ARGS_ASSERT_SCAN_OCT \ assert(start); assert(retlen) +PERL_CALLCONV char* Perl_scan_str(pTHX_ char *start, int keep_quoted, int keep_delims, int re_reparse, char **delimp) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_SCAN_STR \ + assert(start) + PERL_CALLCONV const char* Perl_scan_version(pTHX_ const char *s, SV *rv, bool qv); #define PERL_ARGS_ASSERT_SCAN_VERSION \ assert(s); assert(rv) PERL_CALLCONV char* Perl_scan_vstring(pTHX_ const char *s, const char *const e, SV *sv); #define PERL_ARGS_ASSERT_SCAN_VSTRING \ assert(s); assert(e); assert(sv) +PERL_CALLCONV char* Perl_scan_word(pTHX_ char *s, char *dest, STRLEN destlen, int allow_package, STRLEN *slp); +#define PERL_ARGS_ASSERT_SCAN_WORD \ + assert(s); assert(dest); assert(slp) PERL_CALLCONV U32 Perl_seed(pTHX); PERL_CALLCONV void Perl_set_caret_X(pTHX); PERL_CALLCONV void Perl_set_context(void *t); @@ -2951,10 +3159,14 @@ PERL_CALLCONV void Perl_setfd_cloexec_for_nonsysfd(pTHX_ int fd); PERL_CALLCONV void Perl_setfd_cloexec_or_inhexec_by_sysfdness(pTHX_ int fd); PERL_CALLCONV void Perl_setfd_inhexec(int fd); PERL_CALLCONV void Perl_setfd_inhexec_for_sysfd(pTHX_ int fd); -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 char* Perl_skipspace_flags(pTHX_ char *s, U32 flags) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_SKIPSPACE_FLAGS \ + assert(s) + PERL_CALLCONV void Perl_sortsv(pTHX_ SV** array, size_t num_elts, SVCOMPARE_t cmp); #define PERL_ARGS_ASSERT_SORTSV \ assert(cmp) @@ -2976,7 +3188,11 @@ PERL_CALLCONV NV Perl_str_to_version(pTHX_ SV *sv) PERL_CALLCONV void Perl_sub_crush_depth(pTHX_ CV* cv); #define PERL_ARGS_ASSERT_SUB_CRUSH_DEPTH \ assert(cv) -/* PERL_CALLCONV bool sv_2bool(pTHX_ SV *const sv); */ +#ifndef NO_MATHOMS +PERL_CALLCONV bool Perl_sv_2bool(pTHX_ SV *const sv); +#define PERL_ARGS_ASSERT_SV_2BOOL \ + assert(sv) +#endif PERL_CALLCONV bool Perl_sv_2bool_flags(pTHX_ SV *sv, I32 flags); #define PERL_ARGS_ASSERT_SV_2BOOL_FLAGS \ assert(sv) @@ -3016,9 +3232,14 @@ PERL_CALLCONV char* Perl_sv_2pv_nolen(pTHX_ SV* sv) assert(sv) #endif +#ifndef NO_MATHOMS PERL_CALLCONV char* Perl_sv_2pvbyte(pTHX_ SV *sv, STRLEN *const lp); #define PERL_ARGS_ASSERT_SV_2PVBYTE \ assert(sv) +#endif +PERL_CALLCONV char* Perl_sv_2pvbyte_flags(pTHX_ SV *sv, STRLEN *const lp, const U32 flags); +#define PERL_ARGS_ASSERT_SV_2PVBYTE_FLAGS \ + assert(sv) #ifndef NO_MATHOMS PERL_CALLCONV char* Perl_sv_2pvbyte_nolen(pTHX_ SV* sv) __attribute__warn_unused_result__; @@ -3026,9 +3247,14 @@ PERL_CALLCONV char* Perl_sv_2pvbyte_nolen(pTHX_ SV* sv) assert(sv) #endif +#ifndef NO_MATHOMS PERL_CALLCONV char* Perl_sv_2pvutf8(pTHX_ SV *sv, STRLEN *const lp); #define PERL_ARGS_ASSERT_SV_2PVUTF8 \ assert(sv) +#endif +PERL_CALLCONV char* Perl_sv_2pvutf8_flags(pTHX_ SV *sv, STRLEN *const lp, const U32 flags); +#define PERL_ARGS_ASSERT_SV_2PVUTF8_FLAGS \ + assert(sv) #ifndef NO_MATHOMS PERL_CALLCONV char* Perl_sv_2pvutf8_nolen(pTHX_ SV* sv) __attribute__warn_unused_result__; @@ -3166,7 +3392,9 @@ 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); -/* PERL_CALLCONV I32 sv_eq(pTHX_ SV* sv1, SV* sv2); */ +#ifndef NO_MATHOMS +PERL_CALLCONV I32 Perl_sv_eq(pTHX_ SV* sv1, SV* sv2); +#endif PERL_CALLCONV I32 Perl_sv_eq_flags(pTHX_ SV* sv1, SV* sv2, const U32 flags); #ifndef NO_MATHOMS PERL_CALLCONV void Perl_sv_force_normal(pTHX_ SV *sv); @@ -3204,9 +3432,11 @@ PERL_CALLCONV int Perl_sv_isa(pTHX_ SV* sv, const char *const name); #define PERL_ARGS_ASSERT_SV_ISA \ assert(name) PERL_CALLCONV int Perl_sv_isobject(pTHX_ SV* sv); +#ifndef NO_MATHOMS PERL_CALLCONV IV Perl_sv_iv(pTHX_ SV* sv); #define PERL_ARGS_ASSERT_SV_IV \ assert(sv) +#endif PERL_CALLCONV STRLEN Perl_sv_len(pTHX_ SV *const sv); PERL_CALLCONV STRLEN Perl_sv_len_utf8(pTHX_ SV *const sv); PERL_CALLCONV STRLEN Perl_sv_len_utf8_nomg(pTHX_ SV *const sv); @@ -3240,9 +3470,11 @@ PERL_CALLCONV void Perl_sv_nosharing(pTHX_ SV *sv); #ifndef NO_MATHOMS PERL_CALLCONV void Perl_sv_nounlocking(pTHX_ SV *sv); #endif +#ifndef NO_MATHOMS PERL_CALLCONV NV Perl_sv_nv(pTHX_ SV* sv); #define PERL_ARGS_ASSERT_SV_NV \ assert(sv) +#endif #ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE bool S_sv_only_taint_gmagic(SV *sv); #define PERL_ARGS_ASSERT_SV_ONLY_TAINT_GMAGIC \ @@ -3275,15 +3507,19 @@ PERL_CALLCONV char* Perl_sv_pvbyte(pTHX_ SV *sv) assert(sv) #endif +#ifndef NO_MATHOMS PERL_CALLCONV char* Perl_sv_pvbyten(pTHX_ SV *sv, STRLEN *lp); #define PERL_ARGS_ASSERT_SV_PVBYTEN \ assert(sv); assert(lp) +#endif PERL_CALLCONV char* Perl_sv_pvbyten_force(pTHX_ SV *const sv, STRLEN *const lp); #define PERL_ARGS_ASSERT_SV_PVBYTEN_FORCE \ assert(sv) +#ifndef NO_MATHOMS PERL_CALLCONV char* Perl_sv_pvn(pTHX_ SV *sv, STRLEN *lp); #define PERL_ARGS_ASSERT_SV_PVN \ assert(sv); assert(lp) +#endif #ifndef NO_MATHOMS PERL_CALLCONV char* Perl_sv_pvn_force(pTHX_ SV* sv, STRLEN* lp); #define PERL_ARGS_ASSERT_SV_PVN_FORCE \ @@ -3292,9 +3528,11 @@ PERL_CALLCONV char* Perl_sv_pvn_force(pTHX_ SV* sv, STRLEN* lp); PERL_CALLCONV char* Perl_sv_pvn_force_flags(pTHX_ SV *const sv, STRLEN *const lp, const I32 flags); #define PERL_ARGS_ASSERT_SV_PVN_FORCE_FLAGS \ assert(sv) +#ifndef NO_MATHOMS PERL_CALLCONV char* Perl_sv_pvn_nomg(pTHX_ SV* sv, STRLEN* lp); #define PERL_ARGS_ASSERT_SV_PVN_NOMG \ assert(sv) +#endif #ifndef NO_MATHOMS PERL_CALLCONV char* Perl_sv_pvutf8(pTHX_ SV *sv) __attribute__warn_unused_result__; @@ -3302,9 +3540,11 @@ PERL_CALLCONV char* Perl_sv_pvutf8(pTHX_ SV *sv) assert(sv) #endif +#ifndef NO_MATHOMS PERL_CALLCONV char* Perl_sv_pvutf8n(pTHX_ SV *sv, STRLEN *lp); #define PERL_ARGS_ASSERT_SV_PVUTF8N \ assert(sv); assert(lp) +#endif PERL_CALLCONV char* Perl_sv_pvutf8n_force(pTHX_ SV *const sv, STRLEN *const lp); #define PERL_ARGS_ASSERT_SV_PVUTF8N_FORCE \ assert(sv) @@ -3471,9 +3711,15 @@ PERL_CALLCONV void Perl_sv_usepvn_mg(pTHX_ SV *sv, char *ptr, STRLEN len); PERL_CALLCONV bool Perl_sv_utf8_decode(pTHX_ SV *const sv); #define PERL_ARGS_ASSERT_SV_UTF8_DECODE \ assert(sv) +#ifndef NO_MATHOMS PERL_CALLCONV bool Perl_sv_utf8_downgrade(pTHX_ SV *const sv, const bool fail_ok); #define PERL_ARGS_ASSERT_SV_UTF8_DOWNGRADE \ assert(sv) +#endif +PERL_CALLCONV bool Perl_sv_utf8_downgrade_flags(pTHX_ SV *const sv, const bool fail_ok, const U32 flags); +#define PERL_ARGS_ASSERT_SV_UTF8_DOWNGRADE_FLAGS \ + assert(sv) +/* PERL_CALLCONV bool sv_utf8_downgrade_nomg(pTHX_ SV *const sv, const bool fail_ok); */ PERL_CALLCONV void Perl_sv_utf8_encode(pTHX_ SV *const sv); #define PERL_ARGS_ASSERT_SV_UTF8_ENCODE \ assert(sv) @@ -3482,14 +3728,16 @@ PERL_CALLCONV STRLEN Perl_sv_utf8_upgrade(pTHX_ SV *sv); #define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE \ assert(sv) #endif -/* PERL_CALLCONV STRLEN Perl_sv_utf8_upgrade_flags(pTHX_ SV *const sv, const I32 flags); */ +/* PERL_CALLCONV STRLEN sv_utf8_upgrade_flags(pTHX_ SV *const sv, const I32 flags); */ PERL_CALLCONV STRLEN Perl_sv_utf8_upgrade_flags_grow(pTHX_ SV *const sv, const I32 flags, STRLEN extra); #define PERL_ARGS_ASSERT_SV_UTF8_UPGRADE_FLAGS_GROW \ assert(sv) /* PERL_CALLCONV STRLEN sv_utf8_upgrade_nomg(pTHX_ SV *sv); */ +#ifndef NO_MATHOMS PERL_CALLCONV UV Perl_sv_uv(pTHX_ SV* sv); #define PERL_ARGS_ASSERT_SV_UV \ assert(sv) +#endif PERL_CALLCONV void Perl_sv_vcatpvf(pTHX_ SV *const sv, const char *const pat, va_list *const args); #define PERL_ARGS_ASSERT_SV_VCATPVF \ assert(sv); assert(pat) @@ -3519,7 +3767,8 @@ 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_switch_to_global_locale(void); +PERL_CALLCONV bool Perl_sync_locale(void); PERL_CALLCONV void Perl_sys_init(int* argc, char*** argv); #define PERL_ARGS_ASSERT_SYS_INIT \ assert(argc); assert(argv) @@ -3531,6 +3780,8 @@ PERL_CALLCONV void Perl_taint_env(pTHX); PERL_CALLCONV void Perl_taint_proper(pTHX_ const char* f, const char *const s); #define PERL_ARGS_ASSERT_TAINT_PROPER \ assert(s) +PERL_CALLCONV void Perl_thread_locale_init(void); +PERL_CALLCONV void Perl_thread_locale_term(void); PERL_CALLCONV OP * Perl_tied_method(pTHX_ SV *methname, SV **sp, SV *const sv, const MAGIC *const mg, const U32 flags, U32 argc, ...); #define PERL_ARGS_ASSERT_TIED_METHOD \ assert(methname); assert(sp); assert(sv); assert(mg) @@ -3539,23 +3790,29 @@ PERL_CALLCONV SSize_t Perl_tmps_grow_p(pTHX_ SSize_t ix); PERL_CALLCONV UV Perl_to_uni_lower(pTHX_ UV c, U8 *p, STRLEN *lenp); #define PERL_ARGS_ASSERT_TO_UNI_LOWER \ assert(p); assert(lenp) +#ifndef NO_MATHOMS PERL_CALLCONV U32 Perl_to_uni_lower_lc(pTHX_ U32 c) __attribute__deprecated__ __attribute__warn_unused_result__; +#endif 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) +#ifndef NO_MATHOMS PERL_CALLCONV U32 Perl_to_uni_title_lc(pTHX_ U32 c) __attribute__deprecated__ __attribute__warn_unused_result__; +#endif 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) +#ifndef NO_MATHOMS PERL_CALLCONV U32 Perl_to_uni_upper_lc(pTHX_ U32 c) __attribute__deprecated__ __attribute__warn_unused_result__; +#endif #ifndef NO_MATHOMS PERL_CALLCONV UV Perl_to_utf8_fold(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp) @@ -3587,9 +3844,11 @@ PERL_CALLCONV UV Perl_to_utf8_upper(pTHX_ const U8 *p, U8* ustrp, STRLEN *lenp) PERL_CALLCONV bool Perl_try_amagic_bin(pTHX_ int method, int flags); PERL_CALLCONV bool Perl_try_amagic_un(pTHX_ int method, int flags); +#ifndef NO_MATHOMS PERL_CALLCONV SSize_t 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); #define PERL_ARGS_ASSERT_UNPACK_STR \ assert(pat); assert(patend); assert(s); assert(strend) +#endif PERL_CALLCONV SSize_t Perl_unpackstring(pTHX_ const char *pat, const char *patend, const char *s, const char *strend, U32 flags); #define PERL_ARGS_ASSERT_UNPACKSTRING \ assert(pat); assert(patend); assert(s); assert(strend) @@ -3655,25 +3914,29 @@ PERL_CALLCONV UV Perl_utf8_to_uvchr(pTHX_ const U8 *s, 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) +#ifndef NO_MATHOMS PERL_CALLCONV UV Perl_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen) __attribute__deprecated__; #define PERL_ARGS_ASSERT_UTF8_TO_UVUNI \ assert(s) +#endif PERL_CALLCONV UV Perl_utf8_to_uvuni_buf(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen) __attribute__deprecated__; #define PERL_ARGS_ASSERT_UTF8_TO_UVUNI_BUF \ assert(s); assert(send) -PERL_CALLCONV UV Perl_utf8n_to_uvchr(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags); +PERL_CALLCONV UV Perl_utf8n_to_uvchr(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags); #define PERL_ARGS_ASSERT_UTF8N_TO_UVCHR \ assert(s) -PERL_CALLCONV UV Perl_utf8n_to_uvchr_error(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags, U32 * errors); +PERL_CALLCONV UV Perl_utf8n_to_uvchr_error(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags, U32 * errors); #define PERL_ARGS_ASSERT_UTF8N_TO_UVCHR_ERROR \ assert(s) -PERL_CALLCONV UV Perl_utf8n_to_uvchr_msgs(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags, U32 * errors, AV ** msgs); +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE UV S_utf8n_to_uvchr_msgs(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags, U32 * errors, AV ** msgs); #define PERL_ARGS_ASSERT_UTF8N_TO_UVCHR_MSGS \ assert(s) +#endif PERL_CALLCONV UV Perl_utf8n_to_uvuni(pTHX_ const U8 *s, STRLEN curlen, STRLEN *retlen, U32 flags); #define PERL_ARGS_ASSERT_UTF8N_TO_UVUNI \ assert(s) @@ -3682,9 +3945,13 @@ 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* uvchr_to_utf8_flags_msgs(pTHX_ U8 *d, UV uv, UV flags, HV ** msgs); */ 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_uvoffuni_to_utf8_flags_msgs(pTHX_ U8 *d, UV uv, const UV flags, HV** msgs); +#define PERL_ARGS_ASSERT_UVOFFUNI_TO_UTF8_FLAGS_MSGS \ + assert(d) PERL_CALLCONV U8* Perl_uvuni_to_utf8(pTHX_ U8 *d, UV uv); #define PERL_ARGS_ASSERT_UVUNI_TO_UTF8 \ assert(d) @@ -3698,10 +3965,12 @@ PERL_STATIC_INLINE UV Perl_valid_utf8_to_uvchr(const U8 *s, STRLEN *retlen) assert(s) #endif +#ifndef NO_MATHOMS PERL_CALLCONV UV Perl_valid_utf8_to_uvuni(pTHX_ const U8 *s, STRLEN *retlen) __attribute__deprecated__; #define PERL_ARGS_ASSERT_VALID_UTF8_TO_UVUNI \ assert(s) +#endif PERL_CALLCONV bool Perl_validate_proto(pTHX_ SV *name, SV *proto, bool warn, bool curstash); #define PERL_ARGS_ASSERT_VALIDATE_PROTO \ @@ -3827,14 +4096,6 @@ STATIC int S_sv_2iuv_non_preserve(pTHX_ SV *const sv); # endif # endif #endif -#if !(defined(HAS_MEMMEM)) -PERL_CALLCONV char* Perl_ninstr(const char* big, const char* bigend, const char* little, const char* lend) - __attribute__warn_unused_result__ - __attribute__pure__; -#define PERL_ARGS_ASSERT_NINSTR \ - assert(big); assert(bigend); assert(little); assert(lend) - -#endif #if !(defined(HAS_NL_LANGINFO) && defined(PERL_LANGINFO_H)) PERL_CALLCONV const char* Perl_langinfo(const int item); #endif @@ -3854,9 +4115,9 @@ PERL_CALLCONV bool Perl_do_exec(pTHX_ const char* cmd); #endif #if !(defined(PERL_GLOBAL_STRUCT_PRIVATE)) # if defined(PERL_IMPLICIT_CONTEXT) -PERL_CALLCONV void* Perl_my_cxt_init(pTHX_ int *index, size_t size); +PERL_CALLCONV void* Perl_my_cxt_init(pTHX_ int *indexp, size_t size); #define PERL_ARGS_ASSERT_MY_CXT_INIT \ - assert(index) + assert(indexp) # endif #endif #if !(defined(_MSC_VER)) @@ -3866,6 +4127,13 @@ PERL_CALLCONV_NO_RET int Perl_magic_regdatum_set(pTHX_ SV* sv, MAGIC* mg) assert(sv); assert(mg) #endif +#if !defined(EBCDIC) +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE unsigned int S__variant_byte_number(PERL_UINTMAX_T word) + __attribute__warn_unused_result__; +#endif + +#endif #if !defined(HAS_GETENV_LEN) PERL_CALLCONV char* Perl_getenv_len(pTHX_ const char *env_elem, unsigned long *len); #define PERL_ARGS_ASSERT_GETENV_LEN \ @@ -3954,6 +4222,9 @@ PERL_STATIC_INLINE IV* S_get_invlist_previous_index_addr(SV* invlist) assert(invlist) #endif +STATIC void S_initialize_invlist_guts(pTHX_ SV* invlist, const Size_t initial_size); +#define PERL_ARGS_ASSERT_INITIALIZE_INVLIST_GUTS \ + assert(invlist) #ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE void S_invlist_clear(pTHX_ SV* invlist); #define PERL_ARGS_ASSERT_INVLIST_CLEAR \ @@ -3980,6 +4251,11 @@ 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_len(pTHX_ SV* const invlist, const UV len, const bool offset); +#define PERL_ARGS_ASSERT_INVLIST_SET_LEN \ + assert(invlist) +#endif +#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) @@ -4113,11 +4389,6 @@ STATIC void S_validate_suid(pTHX_ PerlIO *rsfp); assert(rsfp) # endif #endif -#if !defined(USE_QUADMATH) -# if defined(PERL_IN_NUMERIC_C) -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) @@ -4188,7 +4459,7 @@ STATIC const regnode* S_dumpuntil(pTHX_ const regexp *r, const regnode *start, c assert(r); assert(start); assert(node); assert(sv) STATIC bool S_put_charclass_bitmap_innards(pTHX_ SV* sv, char* bitmap, SV* nonbitmap_invlist, SV* only_utf8_locale_invlist, const regnode * const node, const bool force_as_is_display); #define PERL_ARGS_ASSERT_PUT_CHARCLASS_BITMAP_INNARDS \ - assert(sv); assert(bitmap) + assert(sv) STATIC SV* S_put_charclass_bitmap_innards_common(pTHX_ SV* invlist, SV* posixes, SV* only_utf8, SV* not_utf8, SV* only_utf8_locale, const bool invert); #define PERL_ARGS_ASSERT_PUT_CHARCLASS_BITMAP_INNARDS_COMMON \ assert(invlist) @@ -4206,9 +4477,11 @@ PERL_CALLCONV int Perl_re_indentf(pTHX_ const char *fmt, U32 depth, ...); assert(fmt) STATIC void S_regdump_extflags(pTHX_ const char *lead, const U32 flags); STATIC void S_regdump_intflags(pTHX_ const char *lead, const U32 flags); -STATIC U8 S_regtail_study(pTHX_ RExC_state_t *pRExC_state, regnode *p, const regnode *val, U32 depth); +STATIC bool S_regtail_study(pTHX_ RExC_state_t *pRExC_state, regnode_offset p, const regnode_offset val, U32 depth) + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_REGTAIL_STUDY \ assert(pRExC_state); assert(p); assert(val) + # endif # if defined(PERL_IN_REGEXEC_C) STATIC void S_debug_start_match(pTHX_ const REGEXP *prog, const bool do_utf8, const char *start, const char *end, const char *blurb); @@ -4249,14 +4522,6 @@ PERL_CALLCONV void Perl_dump_sv_child(pTHX_ SV *sv); #define PERL_ARGS_ASSERT_DUMP_SV_CHILD \ assert(sv) #endif -#if defined(HAS_MEMMEM) -PERL_CALLCONV char* Perl_ninstr(const char* big, const char* bigend, const char* little, const char* lend) - __attribute__warn_unused_result__ - __attribute__pure__; -#define PERL_ARGS_ASSERT_NINSTR \ - assert(big); assert(bigend); assert(little); assert(lend) - -#endif #if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM) PERL_CALLCONV I32 Perl_do_ipcctl(pTHX_ I32 optype, SV** mark, SV** sp); #define PERL_ARGS_ASSERT_DO_IPCCTL \ @@ -4378,6 +4643,11 @@ PERL_STATIC_INLINE STRLEN S_sv_or_pv_pos_u2b(pTHX_ SV *sv, const char *pv, STRLE #endif #endif #if defined(PERL_CORE) || defined(PERL_EXT) +PERL_CALLCONV bool Perl_isSCRIPT_RUN(pTHX_ const U8 *s, const U8 *send, const bool utf8_target) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_ISSCRIPT_RUN \ + assert(s); assert(send) + #ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE Size_t S_variant_under_utf8_count(const U8* const s, const U8* const e) __attribute__warn_unused_result__; @@ -4454,10 +4724,12 @@ PERL_CALLCONV char* Perl_form_nocontext(const char* pat, ...) #define PERL_ARGS_ASSERT_FORM_NOCONTEXT \ assert(pat) +#ifndef NO_MATHOMS PERL_CALLCONV int Perl_fprintf_nocontext(PerlIO *stream, const char *format, ...) __attribute__format__(__printf__,2,3); #define PERL_ARGS_ASSERT_FPRINTF_NOCONTEXT \ assert(stream); assert(format) +#endif PERL_CALLCONV void Perl_load_module_nocontext(U32 flags, SV* name, SV* ver, ...); #define PERL_ARGS_ASSERT_LOAD_MODULE_NOCONTEXT \ @@ -4472,10 +4744,12 @@ PERL_CALLCONV SV* Perl_newSVpvf_nocontext(const char *const pat, ...) #define PERL_ARGS_ASSERT_NEWSVPVF_NOCONTEXT \ assert(pat) +#ifndef NO_MATHOMS PERL_CALLCONV int Perl_printf_nocontext(const char *format, ...) __attribute__format__(__printf__,1,2); #define PERL_ARGS_ASSERT_PRINTF_NOCONTEXT \ assert(format) +#endif PERL_CALLCONV void Perl_sv_catpvf_mg_nocontext(SV *const sv, const char *const pat, ...) __attribute__format__(__printf__,2,3); @@ -4529,6 +4803,9 @@ STATIC void S_deb_stack_n(pTHX_ SV** stack_base, I32 stack_min, I32 stack_max, I assert(stack_base) #endif #if defined(PERL_IN_DOIO_C) +STATIC bool S_argvout_final(pTHX_ MAGIC *mg, IO *io, bool not_implicit); +#define PERL_ARGS_ASSERT_ARGVOUT_FINAL \ + assert(mg); assert(io) STATIC void S_exec_failed(pTHX_ const char *cmd, int fd, int do_report); #define PERL_ARGS_ASSERT_EXEC_FAILED \ assert(cmd) @@ -4692,21 +4969,29 @@ PERL_CALLCONV SV* Perl_hfree_next_entry(pTHX_ HV *hv, STRLEN *indexp); assert(hv); assert(indexp) #endif #if defined(PERL_IN_LOCALE_C) -STATIC const char* S_category_name(const int category); #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE const char * S_save_to_buffer(const char * string, char **buf, Size_t *buf_size, const Size_t offset); +PERL_STATIC_INLINE const char * S_save_to_buffer(const char * string, char **buf, Size_t *buf_size, const Size_t offset) + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SAVE_TO_BUFFER \ - assert(string); assert(buf_size) + assert(buf_size) #endif + # if defined(USE_LOCALE) +STATIC const char* S_category_name(const int category); 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_new_numeric(pTHX_ const char* newnum); +STATIC void S_restore_switched_locale(pTHX_ const int category, const char * const original_locale); STATIC void S_set_numeric_radix(pTHX_ const bool use_locale); STATIC char* S_stdize_locale(pTHX_ char* locs); #define PERL_ARGS_ASSERT_STDIZE_LOCALE \ assert(locs) +STATIC const char* S_switch_category_locale_to_template(pTHX_ const int switch_category, const int template_category, const char * template_locale); +# if defined(USE_POSIX_2008_LOCALE) +STATIC const char* S_emulate_setlocale(const int category, const char* locale, unsigned int index, const bool is_index_valid); +# endif # if defined(WIN32) STATIC char* S_win32_setlocale(pTHX_ int category, const char* locale); # endif @@ -4794,7 +5079,7 @@ STATIC OP* S_force_list(pTHX_ OP* arg, bool nullit); STATIC void S_forget_pmop(pTHX_ PMOP *const o); #define PERL_ARGS_ASSERT_FORGET_PMOP \ assert(o) -STATIC OP* S_gen_constant_list(pTHX_ OP* o); +STATIC void S_gen_constant_list(pTHX_ OP* o); STATIC void S_inplace_aassign(pTHX_ OP* o); #define PERL_ARGS_ASSERT_INPLACE_AASSIGN \ assert(o) @@ -4878,6 +5163,9 @@ STATIC OP* S_too_few_arguments_pv(pTHX_ OP *o, const char* name, U32 flags) 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) +STATIC OP* S_traverse_op_tree(pTHX_ OP* top, OP* o); +#define PERL_ARGS_ASSERT_TRAVERSE_OP_TREE \ + assert(top); assert(o) # if defined(USE_ITHREADS) #ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE void S_op_relocate_sv(pTHX_ SV** svp, PADOFFSET* targp); @@ -4955,6 +5243,13 @@ STATIC SV* S_refto(pTHX_ SV* sv) #endif #if defined(PERL_IN_PP_C) || defined(PERL_IN_PP_HOT_C) +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE bool S_lossless_NV_to_IV(const NV nv, IV * ivp) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_LOSSLESS_NV_TO_IV \ + assert(ivp) +#endif + PERL_CALLCONV GV* Perl_softref2xv(pTHX_ SV *const sv, const char *const what, const svtype type, SV ***spp) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SOFTREF2XV \ @@ -5158,11 +5453,9 @@ 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 void S_change_engine_size(pTHX_ RExC_state_t *pRExC_state, const Ptrdiff_t size); +#define PERL_ARGS_ASSERT_CHANGE_ENGINE_SIZE \ + assert(pRExC_state) STATIC const char * S_cntrl_to_mnemonic(const U8 c) __attribute__warn_unused_result__; @@ -5179,6 +5472,11 @@ STATIC int S_edit_distance(const UV *src, const UV *tgt, const STRLEN x, const S #define PERL_ARGS_ASSERT_EDIT_DISTANCE \ assert(src); assert(tgt) +STATIC SV * S_get_ANYOFM_contents(pTHX_ const regnode * n) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_GET_ANYOFM_CONTENTS \ + assert(n) + 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) @@ -5189,27 +5487,23 @@ PERL_STATIC_INLINE STRLEN* S_get_invlist_iter_addr(SV* invlist) 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); +STATIC bool S_grok_bslash_N(pTHX_ RExC_state_t *pRExC_state, regnode_offset* nodep, UV *code_point_p, int* cp_count, I32 *flagp, const bool strict, const U32 depth); #define PERL_ARGS_ASSERT_GROK_BSLASH_N \ assert(pRExC_state); assert(flagp) #ifndef PERL_NO_INLINE_FUNCTIONS -PERL_STATIC_INLINE regnode* S_handle_named_backref(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, char * parse_start, char ch); +PERL_STATIC_INLINE regnode_offset S_handle_named_backref(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, char * parse_start, char ch); #define PERL_ARGS_ASSERT_HANDLE_NAMED_BACKREF \ assert(pRExC_state); assert(flagp); assert(parse_start) #endif STATIC 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); +STATIC regnode_offset S_handle_regex_sets(pTHX_ RExC_state_t *pRExC_state, SV ** return_invlist, I32 *flagp, U32 depth, char * const oregcomp_parse); #define PERL_ARGS_ASSERT_HANDLE_REGEX_SETS \ assert(pRExC_state); assert(flagp); assert(oregcomp_parse) -#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 - +PERL_CALLCONV SV * Perl_handle_user_defined_property(pTHX_ const char * name, const STRLEN name_len, const bool is_utf8, const bool to_fold, const bool runtime, const bool deferrable, SV* contents, bool *user_defined_ptr, SV * msg, const STRLEN level); +#define PERL_ARGS_ASSERT_HANDLE_USER_DEFINED_PROPERTY \ + assert(name); assert(contents); assert(user_defined_ptr); assert(msg) STATIC SV* S_invlist_contents(pTHX_ SV* const invlist, const bool traditional_style) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_INVLIST_CONTENTS \ @@ -5244,11 +5538,6 @@ STATIC bool S_invlist_iternext(SV* invlist, UV* start, UV* end) #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) @@ -5266,12 +5555,15 @@ STATIC bool S_new_regcurly(const char *s, const char *e) STATIC void S_nextchar(pTHX_ RExC_state_t *pRExC_state); #define PERL_ARGS_ASSERT_NEXTCHAR \ assert(pRExC_state) -STATIC void S_output_or_return_posix_warnings(pTHX_ RExC_state_t *pRExC_state, AV* posix_warnings, AV** return_posix_warnings); -#define PERL_ARGS_ASSERT_OUTPUT_OR_RETURN_POSIX_WARNINGS \ +STATIC void S_output_posix_warnings(pTHX_ RExC_state_t *pRExC_state, AV* posix_warnings); +#define PERL_ARGS_ASSERT_OUTPUT_POSIX_WARNINGS \ assert(pRExC_state); assert(posix_warnings) STATIC void S_parse_lparen_question_flags(pTHX_ RExC_state_t *pRExC_state); #define PERL_ARGS_ASSERT_PARSE_LPAREN_QUESTION_FLAGS \ assert(pRExC_state) +PERL_CALLCONV SV * Perl_parse_uniprop_string(pTHX_ const char * const name, const Size_t name_len, const bool is_utf8, const bool to_fold, const bool runtime, const bool deferrable, bool * user_defined_ptr, SV * msg, const STRLEN level); +#define PERL_ARGS_ASSERT_PARSE_UNIPROP_STRING \ + assert(name); assert(user_defined_ptr); assert(msg) STATIC void S_populate_ANYOF_from_invlist(pTHX_ regnode *node, SV** invlist_ptr); #define PERL_ARGS_ASSERT_POPULATE_ANYOF_FROM_INVLIST \ assert(node); assert(invlist_ptr) @@ -5280,13 +5572,13 @@ PERL_STATIC_NO_RET void S_re_croak2(pTHX_ bool utf8, const char* pat1, const cha #define PERL_ARGS_ASSERT_RE_CROAK2 \ assert(pat1); assert(pat2) -STATIC regnode* S_reg(pTHX_ RExC_state_t *pRExC_state, I32 paren, I32 *flagp, U32 depth); +STATIC regnode_offset S_reg(pTHX_ RExC_state_t *pRExC_state, I32 paren, I32 *flagp, U32 depth); #define PERL_ARGS_ASSERT_REG \ assert(pRExC_state); assert(flagp) -STATIC regnode* S_reg2Lanode(pTHX_ RExC_state_t *pRExC_state, const U8 op, const U32 arg1, const I32 arg2); +STATIC regnode_offset S_reg2Lanode(pTHX_ RExC_state_t *pRExC_state, const U8 op, const U32 arg1, const I32 arg2); #define PERL_ARGS_ASSERT_REG2LANODE \ assert(pRExC_state) -STATIC regnode* S_reg_node(pTHX_ RExC_state_t *pRExC_state, U8 op); +STATIC regnode_offset S_reg_node(pTHX_ RExC_state_t *pRExC_state, U8 op); #define PERL_ARGS_ASSERT_REG_NODE \ assert(pRExC_state) STATIC SV * S_reg_scan_name(pTHX_ RExC_state_t *pRExC_state, U32 flags); @@ -5297,39 +5589,44 @@ 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); +STATIC regnode_offset S_reganode(pTHX_ RExC_state_t *pRExC_state, U8 op, U32 arg); #define PERL_ARGS_ASSERT_REGANODE \ assert(pRExC_state) -STATIC regnode* S_regatom(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth); +STATIC regnode_offset S_regatom(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth); #define PERL_ARGS_ASSERT_REGATOM \ assert(pRExC_state); assert(flagp) -STATIC regnode* S_regbranch(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, I32 first, U32 depth); +STATIC regnode_offset S_regbranch(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, I32 first, U32 depth); #define PERL_ARGS_ASSERT_REGBRANCH \ assert(pRExC_state); assert(flagp) -STATIC regnode* S_regclass(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth, const bool stop_at_1, bool allow_multi_fold, const bool silence_non_portable, const bool strict, bool optimizable, SV** ret_invlist, AV** return_posix_warnings); +STATIC regnode_offset S_regclass(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth, const bool stop_at_1, bool allow_multi_fold, const bool silence_non_portable, const bool strict, bool optimizable, SV** ret_invlist); #define PERL_ARGS_ASSERT_REGCLASS \ assert(pRExC_state); assert(flagp) STATIC unsigned int S_regex_set_precedence(const U8 my_operator) __attribute__warn_unused_result__; -STATIC void S_reginsert(pTHX_ RExC_state_t *pRExC_state, U8 op, regnode *operand, U32 depth); +STATIC void S_reginsert(pTHX_ RExC_state_t *pRExC_state, const U8 op, const regnode_offset operand, const U32 depth); #define PERL_ARGS_ASSERT_REGINSERT \ - 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); + assert(pRExC_state) +STATIC regnode_offset 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) -STATIC regnode* S_regpiece(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth); +STATIC regnode_offset S_regpiece(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth); #define PERL_ARGS_ASSERT_REGPIECE \ assert(pRExC_state); assert(flagp) -STATIC void S_regtail(pTHX_ RExC_state_t * pRExC_state, const regnode * const p, const regnode * const val, const U32 depth); +STATIC bool S_regtail(pTHX_ RExC_state_t * pRExC_state, const regnode_offset p, const regnode_offset val, const U32 depth) + __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_REGTAIL \ assert(pRExC_state); assert(p); assert(val) + STATIC void S_scan_commit(pTHX_ const RExC_state_t *pRExC_state, struct scan_data_t *data, SSize_t *minlenp, int is_inf); #define PERL_ARGS_ASSERT_SCAN_COMMIT \ assert(pRExC_state); assert(data); assert(minlenp) -STATIC void S_set_ANYOF_arg(pTHX_ RExC_state_t* const pRExC_state, regnode* const node, SV* const cp_list, SV* const runtime_defns, SV* const only_utf8_locale_list, SV* const swash, const bool has_user_defined_property); +STATIC void S_set_ANYOF_arg(pTHX_ RExC_state_t* const pRExC_state, regnode* const node, SV* const cp_list, SV* const runtime_defns, SV* const only_utf8_locale_list); #define PERL_ARGS_ASSERT_SET_ANYOF_ARG \ assert(pRExC_state); assert(node) +STATIC void S_set_regex_pv(pTHX_ RExC_state_t *pRExC_state, REGEXP *Rx); +#define PERL_ARGS_ASSERT_SET_REGEX_PV \ + assert(pRExC_state); assert(Rx) STATIC void S_skip_to_be_ignored_text(pTHX_ RExC_state_t *pRExC_state, char ** p, const bool force_to_xmod); #define PERL_ARGS_ASSERT_SKIP_TO_BE_IGNORED_TEXT \ assert(pRExC_state); assert(p) @@ -5406,7 +5703,6 @@ PERL_CALLCONV SV* Perl__new_invlist_C_array(pTHX_ const UV* const list) PERL_CALLCONV SV* Perl__get_regclass_nonbitmap_data(pTHX_ const regexp *prog, const struct regnode *node, bool doinit, SV **listsvp, SV **lonly_utf8_locale, SV **output_invlist); #define PERL_ARGS_ASSERT__GET_REGCLASS_NONBITMAP_DATA \ assert(node) -PERL_CALLCONV void Perl__load_PL_utf8_foldclosures(pTHX); PERL_CALLCONV int Perl_re_printf(pTHX_ const char *fmt, ...); #define PERL_ARGS_ASSERT_RE_PRINTF \ assert(fmt) @@ -5414,12 +5710,7 @@ PERL_CALLCONV void Perl_regprop(pTHX_ const regexp *prog, SV* sv, const regnode* #define PERL_ARGS_ASSERT_REGPROP \ assert(sv); assert(o) #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) - __attribute__warn_unused_result__; -#define PERL_ARGS_ASSERT__GET_SWASH_INVLIST \ - assert(swash) - +#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_TOKE_C) || defined(PERL_IN_UTF8_C) || defined(PERL_IN_PP_C) #ifndef PERL_NO_INLINE_FUNCTIONS PERL_STATIC_INLINE bool S__invlist_contains_cp(SV* const invlist, const UV cp) __attribute__warn_unused_result__; @@ -5439,11 +5730,6 @@ PERL_CALLCONV SSize_t Perl__invlist_search(SV* const invlist, const UV cp) #define PERL_ARGS_ASSERT__INVLIST_SEARCH \ assert(invlist) -PERL_CALLCONV HV* Perl__swash_inversion_hash(pTHX_ SV* const swash) - __attribute__warn_unused_result__; -#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__; @@ -5458,11 +5744,16 @@ PERL_STATIC_INLINE UV* S_invlist_array(SV* const invlist) assert(invlist) #endif +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE bool S_is_invlist(SV* const invlist) + __attribute__warn_unused_result__; #endif -#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || defined(PERL_IN_UTF8_C) || defined(PERL_IN_TOKE_C) -PERL_CALLCONV SV* Perl__core_swash_init(pTHX_ const char* pkg, const char* name, SV* listsv, I32 minbits, I32 none, SV* invlist, U8* const flags_p); -#define PERL_ARGS_ASSERT__CORE_SWASH_INIT \ - assert(pkg); assert(name); assert(listsv) + +#endif +#if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_SV_C) +PERL_CALLCONV SV* Perl_invlist_clone(pTHX_ SV* const invlist, SV* newlist); +#define PERL_ARGS_ASSERT_INVLIST_CLONE \ + assert(invlist) #endif #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_TOKE_C) || defined(PERL_IN_DQUOTE_C) #ifndef PERL_NO_INLINE_FUNCTIONS @@ -5504,9 +5795,6 @@ PERL_CALLCONV void Perl__invlist_intersection_maybe_complement_2nd(pTHX_ SV* con 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(SV* const invlist, const UV start, const UV end, U8* swatch); -#define PERL_ARGS_ASSERT__INVLIST_POPULATE_SWATCH \ - assert(invlist); assert(swatch) /* PERL_CALLCONV void _invlist_subtract(pTHX_ SV* const a, SV* const b, SV** result); */ /* PERL_CALLCONV void _invlist_union(pTHX_ SV* const a, SV* const b, SV** output); */ PERL_CALLCONV void Perl__invlist_union_maybe_complement_2nd(pTHX_ SV* const a, SV* const b, const bool complement_b, SV** output); @@ -5520,11 +5808,6 @@ PERL_CALLCONV SV* Perl__setup_canned_invlist(pTHX_ const STRLEN size, const UV e #define PERL_ARGS_ASSERT__SETUP_CANNED_INVLIST \ assert(other_elements_ptr) -PERL_CALLCONV SV* Perl__swash_to_invlist(pTHX_ SV* const swash) - __attribute__warn_unused_result__; -#define PERL_ARGS_ASSERT__SWASH_TO_INVLIST \ - assert(swash) - #endif #if defined(PERL_IN_REGEXEC_C) STATIC LB_enum S_advance_one_LB(pTHX_ U8 ** curpos, const U8 * const strend, const bool utf8_target) @@ -5567,20 +5850,30 @@ 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 char * S_find_next_ascii(char* s, const char * send, const bool is_utf8) +STATIC U8 * S_find_next_masked(U8 * s, const U8 * send, const U8 byte, const U8 mask) __attribute__warn_unused_result__; -#define PERL_ARGS_ASSERT_FIND_NEXT_ASCII \ +#define PERL_ARGS_ASSERT_FIND_NEXT_MASKED \ assert(s); assert(send) -STATIC char * S_find_next_non_ascii(char* s, const char * send, const bool is_utf8) +STATIC U8 * S_find_span_end(U8* s, const U8 * send, const U8 span_byte) __attribute__warn_unused_result__; -#define PERL_ARGS_ASSERT_FIND_NEXT_NON_ASCII \ +#define PERL_ARGS_ASSERT_FIND_SPAN_END \ assert(s); assert(send) -STATIC bool S_isFOO_utf8_lc(pTHX_ const U8 classnum, const U8* character) +STATIC U8 * S_find_span_end_mask(U8 * s, const U8 * send, const U8 span_byte, const U8 mask) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_FIND_SPAN_END_MASK \ + assert(s); assert(send) + +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE I32 S_foldEQ_latin1_s2_folded(const char* a, const char* b, I32 len); +#define PERL_ARGS_ASSERT_FOLDEQ_LATIN1_S2_FOLDED \ + assert(a); assert(b) +#endif +STATIC bool S_isFOO_utf8_lc(pTHX_ const U8 classnum, const U8* character, const U8* e) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_ISFOO_UTF8_LC \ - assert(character) + assert(character); assert(e) STATIC bool S_isGCB(pTHX_ const GCB_enum before, const GCB_enum after, const U8 * const strbeg, const U8 * const curpos, const bool utf8_target) __attribute__warn_unused_result__; @@ -5641,10 +5934,10 @@ 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 _pDEPTH) +STATIC I32 S_regrepeat(pTHX_ regexp *prog, char **startposp, const regnode *p, char *loceol, regmatch_info *const reginfo, I32 max _pDEPTH) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_REGREPEAT \ - assert(prog); assert(startposp); assert(p); assert(reginfo) + assert(prog); assert(startposp); assert(p); assert(loceol); assert(reginfo) STATIC bool S_regtry(pTHX_ regmatch_info *reginfo, char **startposp) __attribute__warn_unused_result__; @@ -5747,10 +6040,12 @@ 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) +#ifndef PERL_NO_INLINE_FUNCTIONS +PERL_STATIC_INLINE 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 \ assert(buf); assert(peob) +#endif STATIC void S_utf8_mg_len_cache_update(pTHX_ SV *const sv, MAGIC **const mgp, const STRLEN ulen); #define PERL_ARGS_ASSERT_UTF8_MG_LEN_CACHE_UPDATE \ @@ -5810,9 +6105,9 @@ 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) -STATIC 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_wrapper(pTHX_ const char* s, const char* const e) __attribute__warn_unused_result__; -#define PERL_ARGS_ASSERT_GET_AND_CHECK_BACKSLASH_N_NAME \ +#define PERL_ARGS_ASSERT_GET_AND_CHECK_BACKSLASH_N_NAME_WRAPPER \ assert(s); assert(e) STATIC void S_incline(pTHX_ const char *s, const char *end); @@ -5830,7 +6125,7 @@ STATIC I32 S_lop(pTHX_ I32 f, U8 x, char *s); PERL_STATIC_NO_RET void S_missingterm(pTHX_ char *s, STRLEN len) __attribute__noreturn__; -STATIC SV* S_new_constant(pTHX_ const char *s, STRLEN len, const char *key, STRLEN keylen, SV *sv, SV *pv, const char *type, STRLEN typelen); +STATIC SV* S_new_constant(pTHX_ const char *s, STRLEN len, const char *key, STRLEN keylen, SV *sv, SV *pv, const char *type, STRLEN typelen, const char ** error_msg); #define PERL_ARGS_ASSERT_NEW_CONSTANT \ assert(key); assert(sv) STATIC void S_no_op(pTHX_ const char *const what, char *s); @@ -5868,11 +6163,6 @@ 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, char **delimp) - __attribute__warn_unused_result__; -#define PERL_ARGS_ASSERT_SCAN_STR \ - assert(start) - STATIC char* S_scan_subst(pTHX_ char *start) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_SCAN_SUBST \ @@ -5883,14 +6173,6 @@ STATIC char* S_scan_trans(pTHX_ char *start) #define PERL_ARGS_ASSERT_SCAN_TRANS \ assert(start) -STATIC char* S_scan_word(pTHX_ char *s, char *dest, STRLEN destlen, int allow_package, STRLEN *slp); -#define PERL_ARGS_ASSERT_SCAN_WORD \ - assert(s); assert(dest); assert(slp) -STATIC char* S_skipspace_flags(pTHX_ char *s, U32 flags) - __attribute__warn_unused_result__; -#define PERL_ARGS_ASSERT_SKIPSPACE_FLAGS \ - assert(s) - STATIC I32 S_sublex_done(pTHX) __attribute__warn_unused_result__; @@ -5924,9 +6206,9 @@ 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 UV S__to_utf8_case(pTHX_ const UV uv1, const U8 *p, U8* ustrp, STRLEN *lenp, SV **swashp, const char *normal, const char *special); +STATIC UV S__to_utf8_case(pTHX_ const UV uv1, const U8 *p, U8* ustrp, STRLEN *lenp, SV *invlist, const int * const invmap, const unsigned int * const * const aux_tables, const U8 * const aux_table_lengths, const char * const normal); #define PERL_ARGS_ASSERT__TO_UTF8_CASE \ - assert(p); assert(ustrp); assert(swashp); assert(normal) + assert(ustrp); assert(lenp); assert(invlist); assert(invmap); 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) @@ -5950,17 +6232,17 @@ PERL_STATIC_INLINE int S_isFF_OVERLONG(const U8 * const s, const STRLEN len) #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) +PERL_STATIC_INLINE bool S_is_utf8_common(pTHX_ const U8 *const p, SV* const invlist) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UTF8_COMMON \ - assert(p); assert(swash); assert(swashname) + assert(p) #endif #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) +PERL_STATIC_INLINE bool S_is_utf8_common_with_len(pTHX_ const U8 *const p, const U8 *const e, SV* const invlist) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT_IS_UTF8_COMMON_WITH_LEN \ - assert(p); assert(e); assert(swash); assert(swashname) + assert(p); assert(e) #endif #ifndef PERL_NO_INLINE_FUNCTIONS @@ -5970,6 +6252,11 @@ PERL_STATIC_INLINE int S_is_utf8_overlong_given_start_byte_ok(const U8 * const s assert(s) #endif +STATIC HV * S_new_msg_hv(pTHX_ const char * const message, U32 categories, U32 flag) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_NEW_MSG_HV \ + assert(message) + 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__; #define PERL_ARGS_ASSERT_SWASH_SCAN_LIST_LINE \ @@ -5983,6 +6270,15 @@ STATIC SV* S_swatch_get(pTHX_ SV* swash, UV start, UV span) STATIC U8 S_to_lower_latin1(const U8 c, U8 *p, STRLEN *lenp, const char dummy) __attribute__warn_unused_result__; +STATIC UV S_turkic_fc(pTHX_ const U8 * const p, const U8 * const e, U8* ustrp, STRLEN *lenp); +#define PERL_ARGS_ASSERT_TURKIC_FC \ + assert(p); assert(e); assert(ustrp); assert(lenp) +STATIC UV S_turkic_lc(pTHX_ const U8 * const p0, const U8 * const e, U8* ustrp, STRLEN *lenp); +#define PERL_ARGS_ASSERT_TURKIC_LC \ + assert(p0); assert(e); assert(ustrp); assert(lenp) +STATIC UV S_turkic_uc(pTHX_ const U8 * const p, const U8 * const e, U8* ustrp, STRLEN *lenp); +#define PERL_ARGS_ASSERT_TURKIC_UC \ + assert(p); assert(e); assert(ustrp); assert(lenp) 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 \ @@ -5998,7 +6294,7 @@ PERL_CALLCONV UV Perl__to_upper_title_latin1(pTHX_ const U8 c, U8 *p, STRLEN *le assert(p); assert(lenp) #endif #if defined(PERL_IN_UTF8_C) || defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) -PERL_CALLCONV UV Perl__to_fold_latin1(pTHX_ const U8 c, U8 *p, STRLEN *lenp, const unsigned int flags); +PERL_CALLCONV UV Perl__to_fold_latin1(const U8 c, U8 *p, STRLEN *lenp, const unsigned int flags); #define PERL_ARGS_ASSERT__TO_FOLD_LATIN1 \ assert(p); assert(lenp) #endif @@ -6029,11 +6325,6 @@ PERL_CALLCONV Malloc_t Perl_mem_log_realloc(const UV n, const UV typesize, const #define PERL_ARGS_ASSERT_MEM_LOG_REALLOC \ assert(type_name); assert(filename); assert(funcname) #endif -#if defined(PERL_OP_PARENT) -PERL_CALLCONV OP* Perl_op_parent(OP *o); -#define PERL_ARGS_ASSERT_OP_PARENT \ - assert(o) -#endif #if defined(PERL_USES_PL_PIDSTATUS) && defined(PERL_IN_UTIL_C) STATIC void S_pidgone(pTHX_ Pid_t pid, int status); #endif @@ -6171,7 +6462,7 @@ 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_IN_MG_C) || defined (PERL_EXT_POSIX)) +#if defined(USE_LOCALE) && ( defined(PERL_IN_LOCALE_C) || defined(PERL_IN_MG_C) || defined (PERL_EXT_POSIX) || defined (PERL_EXT_LANGINFO)) PERL_CALLCONV bool Perl__is_cur_LC_category_utf8(pTHX_ int category); #endif #if defined(USE_LOCALE_COLLATE) @@ -6183,7 +6474,11 @@ PERL_CALLCONV char* Perl_mem_collxfrm(pTHX_ const char* input_string, STRLEN len #define PERL_ARGS_ASSERT_MEM_COLLXFRM \ assert(input_string); assert(xlen) #endif -/* PERL_CALLCONV char* sv_collxfrm(pTHX_ SV *const sv, STRLEN *const nxp); */ +#ifndef NO_MATHOMS +PERL_CALLCONV char* Perl_sv_collxfrm(pTHX_ SV *const sv, STRLEN *const nxp); +#define PERL_ARGS_ASSERT_SV_COLLXFRM \ + assert(sv); assert(nxp) +#endif PERL_CALLCONV char* Perl_sv_collxfrm_flags(pTHX_ SV *const sv, STRLEN *const nxp, I32 const flags); #define PERL_ARGS_ASSERT_SV_COLLXFRM_FLAGS \ assert(sv); assert(nxp)