X-Git-Url: https://perl5.git.perl.org/perl5.git/blobdiff_plain/67049a5ffa8b7757041edb8f972a0a74fbe5d63d..3f2f854a8971dad2da7193c73a1a3d2bdc3085d4:/inline.h diff --git a/inline.h b/inline.h index e5fe5f5..951818a 100644 --- a/inline.h +++ b/inline.h @@ -40,7 +40,7 @@ SOFTWARE. /* ------------------------------- av.h ------------------------------- */ PERL_STATIC_INLINE SSize_t -S_av_top_index(pTHX_ AV *av) +Perl_av_top_index(pTHX_ AV *av) { PERL_ARGS_ASSERT_AV_TOP_INDEX; assert(SvTYPE(av) == SVt_PVAV); @@ -51,7 +51,7 @@ S_av_top_index(pTHX_ AV *av) /* ------------------------------- cv.h ------------------------------- */ PERL_STATIC_INLINE GV * -S_CvGV(pTHX_ CV *sv) +Perl_CvGV(pTHX_ CV *sv) { return CvNAMED(sv) ? Perl_cvgv_from_hek(aTHX_ sv) @@ -59,7 +59,7 @@ S_CvGV(pTHX_ CV *sv) } PERL_STATIC_INLINE I32 * -S_CvDEPTHp(const CV * const sv) +Perl_CvDEPTHp(const CV * const sv) { assert(SvTYPE(sv) == SVt_PVCV || SvTYPE(sv) == SVt_PVFM); return &((XPVCV*)SvANY(sv))->xcv_depth; @@ -153,7 +153,7 @@ PadnameIN_SCOPE(const PADNAME * const pn, const U32 seq) /* ------------------------------- pp.h ------------------------------- */ PERL_STATIC_INLINE I32 -S_TOPMARK(pTHX) +Perl_TOPMARK(pTHX) { DEBUG_s(DEBUG_v(PerlIO_printf(Perl_debug_log, "MARK top %p %" IVdf "\n", @@ -163,7 +163,7 @@ S_TOPMARK(pTHX) } PERL_STATIC_INLINE I32 -S_POPMARK(pTHX) +Perl_POPMARK(pTHX) { DEBUG_s(DEBUG_v(PerlIO_printf(Perl_debug_log, "MARK pop %p %" IVdf "\n", @@ -176,7 +176,7 @@ S_POPMARK(pTHX) /* ----------------------------- regexp.h ----------------------------- */ PERL_STATIC_INLINE struct regexp * -S_ReANY(const REGEXP * const re) +Perl_ReANY(const REGEXP * const re) { XPV* const p = (XPV*)SvANY(re); assert(isREGEXP(re)); @@ -187,26 +187,28 @@ S_ReANY(const REGEXP * const re) /* ------------------------------- sv.h ------------------------------- */ PERL_STATIC_INLINE SV * -S_SvREFCNT_inc(SV *sv) +Perl_SvREFCNT_inc(SV *sv) { if (LIKELY(sv != NULL)) SvREFCNT(sv)++; return sv; } PERL_STATIC_INLINE SV * -S_SvREFCNT_inc_NN(SV *sv) +Perl_SvREFCNT_inc_NN(SV *sv) { + PERL_ARGS_ASSERT_SVREFCNT_INC_NN; + SvREFCNT(sv)++; return sv; } PERL_STATIC_INLINE void -S_SvREFCNT_inc_void(SV *sv) +Perl_SvREFCNT_inc_void(SV *sv) { if (LIKELY(sv != NULL)) SvREFCNT(sv)++; } PERL_STATIC_INLINE void -S_SvREFCNT_dec(pTHX_ SV *sv) +Perl_SvREFCNT_dec(pTHX_ SV *sv) { if (LIKELY(sv != NULL)) { U32 rc = SvREFCNT(sv); @@ -218,9 +220,12 @@ S_SvREFCNT_dec(pTHX_ SV *sv) } PERL_STATIC_INLINE void -S_SvREFCNT_dec_NN(pTHX_ SV *sv) +Perl_SvREFCNT_dec_NN(pTHX_ SV *sv) { U32 rc = SvREFCNT(sv); + + PERL_ARGS_ASSERT_SVREFCNT_DEC_NN; + if (LIKELY(rc > 1)) SvREFCNT(sv) = rc - 1; else @@ -241,13 +246,13 @@ SvAMAGIC_off(SV *sv) } PERL_STATIC_INLINE U32 -S_SvPADSTALE_on(SV *sv) +Perl_SvPADSTALE_on(SV *sv) { assert(!(SvFLAGS(sv) & SVs_PADTMP)); return SvFLAGS(sv) |= SVs_PADSTALE; } PERL_STATIC_INLINE U32 -S_SvPADSTALE_off(SV *sv) +Perl_SvPADSTALE_off(SV *sv) { assert(!(SvFLAGS(sv) & SVs_PADTMP)); return SvFLAGS(sv) &= ~SVs_PADSTALE; @@ -271,7 +276,7 @@ S_sv_or_pv_pos_u2b(pTHX_ SV *sv, const char *pv, STRLEN pos, STRLEN *lenp) /* saves machine code for a common noreturn idiom typically used in Newx*() */ GCC_DIAG_IGNORE_DECL(-Wunused-function); static void -S_croak_memory_wrap(void) +Perl_croak_memory_wrap(void) { Perl_croak_nocontext("%s",PL_memory_wrap); } @@ -284,7 +289,7 @@ GCC_DIAG_RESTORE_DECL; */ PERL_STATIC_INLINE void -S_append_utf8_from_native_byte(const U8 byte, U8** dest) +Perl_append_utf8_from_native_byte(const U8 byte, U8** dest) { /* Takes an input 'byte' (Latin1 or EBCDIC) and appends it to the UTF-8 * encoded string at '*dest', updating '*dest' to include it */ @@ -301,10 +306,10 @@ S_append_utf8_from_native_byte(const U8 byte, U8** dest) /* =for apidoc valid_utf8_to_uvchr -Like C>, but should only be called when it is known that -the next character in the input UTF-8 string C is well-formed (I, -it passes C>. Surrogates, non-character code points, and -non-Unicode code points are allowed. +Like C>, but should only be called when it is +known that the next character in the input UTF-8 string C is well-formed +(I, it passes C>. Surrogates, non-character code +points, and non-Unicode code points are allowed. =cut @@ -394,7 +399,7 @@ UTF-8 invariant, this function does not change the contents of C<*ep>. */ PERL_STATIC_INLINE bool -S_is_utf8_invariant_string_loc(const U8* const s, STRLEN len, const U8 ** ep) +Perl_is_utf8_invariant_string_loc(const U8* const s, STRLEN len, const U8 ** ep) { const U8* send; const U8* x = s; @@ -466,7 +471,7 @@ S_is_utf8_invariant_string_loc(const U8* const s, STRLEN len, const U8 ** ep) # if BYTEORDER == 0x1234 || BYTEORDER == 0x12345678 \ || BYTEORDER == 0x4321 || BYTEORDER == 0x87654321 - *ep = x + _variant_byte_number(* (PERL_UINTMAX_T *) x); + *ep = x + variant_byte_number(* (PERL_UINTMAX_T *) x); assert(*ep >= s && *ep < send); return FALSE; @@ -504,7 +509,7 @@ S_is_utf8_invariant_string_loc(const U8* const s, STRLEN len, const U8 ** ep) #ifndef EBCDIC PERL_STATIC_INLINE unsigned int -S__variant_byte_number(PERL_UINTMAX_T word) +Perl_variant_byte_number(PERL_UINTMAX_T word) { /* This returns the position in a word (0..7) of the first variant byte in @@ -549,8 +554,8 @@ S__variant_byte_number(PERL_UINTMAX_T word) * x..xx01..1 Subtract 1, turns all the trailing zeros into 1's and * the 1 just to their left into a 0; the remainder is * untouched - * 0..0011..1 The xor with x..xx10..0 clears that remainder, sets - * bottom to all 1 + * 0..0011..1 The xor with the original, x..xx10..0, clears that + * remainder, sets the bottom to all 1 * 0..0100..0 Add 1 to clear the word except for the bit in 's' * * Another method is to do 'word &= -word'; but it generates a compiler @@ -891,7 +896,7 @@ C>. */ PERL_STATIC_INLINE bool -S_is_utf8_string_flags(const U8 *s, STRLEN len, const U32 flags) +Perl_is_utf8_string_flags(const U8 *s, STRLEN len, const U32 flags) { const U8 * first_variant; @@ -1013,7 +1018,7 @@ Perl_is_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el) /* -=for apidoc Am|STRLEN|isUTF8_CHAR|const U8 *s|const U8 *e +=for apidoc isUTF8_CHAR Evaluates to non-zero if the first few bytes of the string starting at C and looking no further than S> are well-formed UTF-8, as extended by Perl, @@ -1045,12 +1050,12 @@ This uses an adaptation of the table and algorithm given in http://bjoern.hoehrmann.de/utf-8/decoder/dfa/, which provides comprehensive documentation of the original version. A copyright notice for the original version is given at the beginning of this file. The Perl adapation is -documented at the definition of perl_extended_utf8_dfa_tab[]. +documented at the definition of PL_extended_utf8_dfa_tab[]. */ PERL_STATIC_INLINE Size_t -S_isUTF8_CHAR(const U8 * const s0, const U8 * const e) +Perl_isUTF8_CHAR(const U8 * const s0, const U8 * const e) { const U8 * s = s0; UV state = 0; @@ -1064,9 +1069,9 @@ S_isUTF8_CHAR(const U8 * const s0, const U8 * const e) * helper function for the other platforms. */ while (s < e && LIKELY(state != 1)) { - state = perl_extended_utf8_dfa_tab[256 + state = PL_extended_utf8_dfa_tab[256 + state - + perl_extended_utf8_dfa_tab[*s]]; + + PL_extended_utf8_dfa_tab[*s]]; if (state != 0) { s++; continue; @@ -1078,7 +1083,7 @@ S_isUTF8_CHAR(const U8 * const s0, const U8 * const e) #if defined(UV_IS_QUAD) || defined(EBCDIC) if (NATIVE_UTF8_TO_I8(*s0) == 0xFF && e - s0 >= UTF8_MAXBYTES) { - return _is_utf8_char_helper(s0, e, 0); + return is_utf8_char_helper(s0, e, 0); } #endif @@ -1124,7 +1129,7 @@ documented at the definition of strict_extended_utf8_dfa_tab[]. */ PERL_STATIC_INLINE Size_t -S_isSTRICT_UTF8_CHAR(const U8 * const s0, const U8 * const e) +Perl_isSTRICT_UTF8_CHAR(const U8 * const s0, const U8 * const e) { const U8 * s = s0; UV state = 0; @@ -1132,7 +1137,7 @@ S_isSTRICT_UTF8_CHAR(const U8 * const s0, const U8 * const e) PERL_ARGS_ASSERT_ISSTRICT_UTF8_CHAR; while (s < e && LIKELY(state != 1)) { - state = strict_utf8_dfa_tab[256 + state + strict_utf8_dfa_tab[*s]]; + state = PL_strict_utf8_dfa_tab[256 + state + PL_strict_utf8_dfa_tab[*s]]; if (state != 0) { s++; @@ -1156,6 +1161,63 @@ S_isSTRICT_UTF8_CHAR(const U8 * const s0, const U8 * const e) /* +=for apidoc isC9_STRICT_UTF8_CHAR + +Evaluates to non-zero if the first few bytes of the string starting at C and +looking no further than S> are well-formed UTF-8 that represents some +Unicode non-surrogate code point; otherwise it evaluates to 0. If non-zero, +the value gives how many bytes starting at C comprise the code point's +representation. Any bytes remaining before C, but beyond the ones needed to +form the first code point in C, are not examined. + +The largest acceptable code point is the Unicode maximum 0x10FFFF. This +differs from C> only in that it accepts non-character +code points. This corresponds to +L. +which said that non-character code points are merely discouraged rather than +completely forbidden in open interchange. See +L. + +Use C> to check for Perl's extended UTF-8; and +C> for a more customized definition. + +Use C>, C>, and +C> to check entire strings. + +=cut + +This uses an adaptation of the tables and algorithm given in +http://bjoern.hoehrmann.de/utf-8/decoder/dfa/, which provides comprehensive +documentation of the original version. A copyright notice for the original +version is given at the beginning of this file. The Perl adapation is +documented at the definition of PL_c9_utf8_dfa_tab[]. + +*/ + +PERL_STATIC_INLINE Size_t +Perl_isC9_STRICT_UTF8_CHAR(const U8 * const s0, const U8 * const e) +{ + const U8 * s = s0; + UV state = 0; + + PERL_ARGS_ASSERT_ISC9_STRICT_UTF8_CHAR; + + while (s < e && LIKELY(state != 1)) { + state = PL_c9_utf8_dfa_tab[256 + state + PL_c9_utf8_dfa_tab[*s]]; + + if (state != 0) { + s++; + continue; + } + + return s - s0 + 1; + } + + return 0; +} + +/* + =for apidoc is_strict_utf8_string_loc Like C> but stores the location of the failure (in the @@ -1185,7 +1247,7 @@ See also C>. */ PERL_STATIC_INLINE bool -S_is_strict_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el) +Perl_is_strict_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el) { const U8 * first_variant; @@ -1262,7 +1324,7 @@ See also C>. */ PERL_STATIC_INLINE bool -S_is_c9strict_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el) +Perl_is_c9strict_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el) { const U8 * first_variant; @@ -1344,7 +1406,7 @@ See also C>. */ PERL_STATIC_INLINE bool -S_is_utf8_string_loclen_flags(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el, const U32 flags) +Perl_is_utf8_string_loclen_flags(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el, const U32 flags) { const U8 * first_variant; @@ -1540,9 +1602,9 @@ Perl_utf8_hop_back(const U8 *s, SSize_t off, const U8 *start) assert(off <= 0); while (off++ && s > start) { - s--; - while (UTF8_IS_CONTINUATION(*s) && s > start) + do { s--; + } while (UTF8_IS_CONTINUATION(*s) && s > start); } GCC_DIAG_IGNORE(-Wcast-qual) @@ -1634,7 +1696,7 @@ determined from just the first one or two bytes. */ PERL_STATIC_INLINE bool -S_is_utf8_valid_partial_char_flags(const U8 * const s, const U8 * const e, const U32 flags) +Perl_is_utf8_valid_partial_char_flags(const U8 * const s, const U8 * const e, const U32 flags) { PERL_ARGS_ASSERT_IS_UTF8_VALID_PARTIAL_CHAR_FLAGS; @@ -1645,7 +1707,7 @@ S_is_utf8_valid_partial_char_flags(const U8 * const s, const U8 * const e, const return FALSE; } - return cBOOL(_is_utf8_char_helper(s, e, flags)); + return cBOOL(is_utf8_char_helper(s, e, flags)); } /* @@ -1702,7 +1764,7 @@ complete, valid characters found in the C pointer. */ PERL_STATIC_INLINE bool -S_is_utf8_fixed_width_buf_loclen_flags(const U8 * const s, +Perl_is_utf8_fixed_width_buf_loclen_flags(const U8 * const s, STRLEN len, const U8 **ep, STRLEN *el, @@ -1723,7 +1785,7 @@ S_is_utf8_fixed_width_buf_loclen_flags(const U8 * const s, } PERL_STATIC_INLINE UV -S_utf8n_to_uvchr_msgs(const U8 *s, +Perl_utf8n_to_uvchr_msgs(const U8 *s, STRLEN curlen, STRLEN *retlen, const U32 flags, @@ -1740,12 +1802,12 @@ S_utf8n_to_uvchr_msgs(const U8 *s, * http://bjoern.hoehrmann.de/utf-8/decoder/dfa/, which provides * comprehensive documentation of the original version. A copyright notice * for the original version is given at the beginning of this file. The - * Perl adapation is documented at the definition of strict_utf8_dfa_tab[]. + * Perl adapation is documented at the definition of PL_strict_utf8_dfa_tab[]. */ const U8 * const s0 = s; const U8 * send = s0 + curlen; - UV uv; + UV uv = 0; /* The 0 silences some stupid compilers */ UV state = 0; PERL_ARGS_ASSERT_UTF8N_TO_UVCHR_MSGS; @@ -1756,12 +1818,12 @@ S_utf8n_to_uvchr_msgs(const U8 *s, * cases. */ while (s < send && LIKELY(state != 1)) { - UV type = strict_utf8_dfa_tab[*s]; + UV type = PL_strict_utf8_dfa_tab[*s]; uv = (state == 0) ? ((0xff >> type) & NATIVE_UTF8_TO_I8(*s)) : UTF8_ACCUMULATE(uv, *s); - state = strict_utf8_dfa_tab[256 + state + type]; + state = PL_strict_utf8_dfa_tab[256 + state + type]; if (state != 0) { s++; @@ -1778,19 +1840,44 @@ S_utf8n_to_uvchr_msgs(const U8 *s, *msgs = NULL; } - return uv; + return UNI_TO_NATIVE(uv); } /* Here is potentially problematic. Use the full mechanism */ return _utf8n_to_uvchr_msgs_helper(s0, curlen, retlen, flags, errors, msgs); } +PERL_STATIC_INLINE UV +Perl_utf8_to_uvchr_buf_helper(pTHX_ const U8 *s, const U8 *send, STRLEN *retlen) +{ + PERL_ARGS_ASSERT_UTF8_TO_UVCHR_BUF_HELPER; + + assert(s < send); + + if (! ckWARN_d(WARN_UTF8)) { + + /* EMPTY is not really allowed, and asserts on debugging builds. But + * on non-debugging we have to deal with it, and this causes it to + * return the REPLACEMENT CHARACTER, as the documentation indicates */ + return utf8n_to_uvchr(s, send - s, retlen, + (UTF8_ALLOW_ANY | UTF8_ALLOW_EMPTY)); + } + else { + UV ret = utf8n_to_uvchr(s, send - s, retlen, 0); + if (retlen && ret == 0 && *s != '\0') { + *retlen = (STRLEN) -1; + } + + return ret; + } +} + /* ------------------------------- perl.h ----------------------------- */ /* =head1 Miscellaneous Functions -=for apidoc AiR|bool|is_safe_syscall|const char *pv|STRLEN len|const char *what|const char *op_name +=for apidoc is_safe_syscall Test that the given C doesn't contain any internal C characters. If it does, set C to C, optionally warn, and return FALSE. @@ -1803,7 +1890,7 @@ Used by the C macro. */ PERL_STATIC_INLINE bool -S_is_safe_syscall(pTHX_ const char *pv, STRLEN len, const char *what, const char *op_name) { +Perl_is_safe_syscall(pTHX_ const char *pv, STRLEN len, const char *what, const char *op_name) { /* While the Windows CE API provides only UCS-16 (or UTF-16) APIs * perl itself uses xce*() functions which accept 8-bit strings. */ @@ -1856,6 +1943,40 @@ S_should_warn_nl(const char *pv) { #endif +#if defined(PERL_IN_PP_C) || defined(PERL_IN_PP_HOT_C) + +PERL_STATIC_INLINE bool +S_lossless_NV_to_IV(const NV nv, IV *ivp) +{ + /* This function determines if the input NV 'nv' may be converted without + * loss of data to an IV. If not, it returns FALSE taking no other action. + * But if it is possible, it does the conversion, returning TRUE, and + * storing the converted result in '*ivp' */ + + PERL_ARGS_ASSERT_LOSSLESS_NV_TO_IV; + +# if defined(Perl_isnan) + + if (UNLIKELY(Perl_isnan(nv))) { + return FALSE; + } + +# endif + + if (UNLIKELY(nv < IV_MIN) || UNLIKELY(nv > IV_MAX)) { + return FALSE; + } + + if ((IV) nv != nv) { + return FALSE; + } + + *ivp = (IV) nv; + return TRUE; +} + +#endif + /* ------------------ pp.c, regcomp.c, toke.c, universal.c ------------ */ #define MAX_CHARSET_NAME_LENGTH 2 @@ -1890,7 +2011,7 @@ Return false if any get magic is on the SV other than taint magic. */ PERL_STATIC_INLINE bool -S_sv_only_taint_gmagic(SV *sv) { +Perl_sv_only_taint_gmagic(SV *sv) { MAGIC *mg = SvMAGIC(sv); PERL_ARGS_ASSERT_SV_ONLY_TAINT_GMAGIC; @@ -1913,7 +2034,7 @@ S_sv_only_taint_gmagic(SV *sv) { /* Enter a block. Push a new base context and return its address. */ PERL_STATIC_INLINE PERL_CONTEXT * -S_cx_pushblock(pTHX_ U8 type, U8 gimme, SV** sp, I32 saveix) +Perl_cx_pushblock(pTHX_ U8 type, U8 gimme, SV** sp, I32 saveix) { PERL_CONTEXT * cx; @@ -1940,7 +2061,7 @@ S_cx_pushblock(pTHX_ U8 type, U8 gimme, SV** sp, I32 saveix) /* Exit a block (RETURN and LAST). */ PERL_STATIC_INLINE void -S_cx_popblock(pTHX_ PERL_CONTEXT *cx) +Perl_cx_popblock(pTHX_ PERL_CONTEXT *cx) { PERL_ARGS_ASSERT_CX_POPBLOCK; @@ -1965,7 +2086,7 @@ S_cx_popblock(pTHX_ PERL_CONTEXT *cx) * *after* cx_pushblock() was called. */ PERL_STATIC_INLINE void -S_cx_topblock(pTHX_ PERL_CONTEXT *cx) +Perl_cx_topblock(pTHX_ PERL_CONTEXT *cx) { PERL_ARGS_ASSERT_CX_TOPBLOCK; @@ -1980,7 +2101,7 @@ S_cx_topblock(pTHX_ PERL_CONTEXT *cx) PERL_STATIC_INLINE void -S_cx_pushsub(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, bool hasargs) +Perl_cx_pushsub(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, bool hasargs) { U8 phlags = CX_PUSHSUB_GET_LVALUE_MASK(Perl_was_lvalue_sub); @@ -2000,7 +2121,7 @@ S_cx_pushsub(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, bool hasargs) /* subsets of cx_popsub() */ PERL_STATIC_INLINE void -S_cx_popsub_common(pTHX_ PERL_CONTEXT *cx) +Perl_cx_popsub_common(pTHX_ PERL_CONTEXT *cx) { CV *cv; @@ -2019,7 +2140,7 @@ S_cx_popsub_common(pTHX_ PERL_CONTEXT *cx) /* handle the @_ part of leaving a sub */ PERL_STATIC_INLINE void -S_cx_popsub_args(pTHX_ PERL_CONTEXT *cx) +Perl_cx_popsub_args(pTHX_ PERL_CONTEXT *cx) { AV *av; @@ -2041,7 +2162,7 @@ S_cx_popsub_args(pTHX_ PERL_CONTEXT *cx) PERL_STATIC_INLINE void -S_cx_popsub(pTHX_ PERL_CONTEXT *cx) +Perl_cx_popsub(pTHX_ PERL_CONTEXT *cx) { PERL_ARGS_ASSERT_CX_POPSUB; assert(CxTYPE(cx) == CXt_SUB); @@ -2055,7 +2176,7 @@ S_cx_popsub(pTHX_ PERL_CONTEXT *cx) PERL_STATIC_INLINE void -S_cx_pushformat(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, GV *gv) +Perl_cx_pushformat(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, GV *gv) { PERL_ARGS_ASSERT_CX_PUSHFORMAT; @@ -2073,7 +2194,7 @@ S_cx_pushformat(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, GV *gv) PERL_STATIC_INLINE void -S_cx_popformat(pTHX_ PERL_CONTEXT *cx) +Perl_cx_popformat(pTHX_ PERL_CONTEXT *cx) { CV *cv; GV *dfout; @@ -2096,7 +2217,7 @@ S_cx_popformat(pTHX_ PERL_CONTEXT *cx) PERL_STATIC_INLINE void -S_cx_pusheval(pTHX_ PERL_CONTEXT *cx, OP *retop, SV *namesv) +Perl_cx_pusheval(pTHX_ PERL_CONTEXT *cx, OP *retop, SV *namesv) { PERL_ARGS_ASSERT_CX_PUSHEVAL; @@ -2114,7 +2235,7 @@ S_cx_pusheval(pTHX_ PERL_CONTEXT *cx, OP *retop, SV *namesv) PERL_STATIC_INLINE void -S_cx_popeval(pTHX_ PERL_CONTEXT *cx) +Perl_cx_popeval(pTHX_ PERL_CONTEXT *cx) { SV *sv; @@ -2146,7 +2267,7 @@ S_cx_popeval(pTHX_ PERL_CONTEXT *cx) */ PERL_STATIC_INLINE void -S_cx_pushloop_plain(pTHX_ PERL_CONTEXT *cx) +Perl_cx_pushloop_plain(pTHX_ PERL_CONTEXT *cx) { PERL_ARGS_ASSERT_CX_PUSHLOOP_PLAIN; cx->blk_loop.my_op = cLOOP; @@ -2158,7 +2279,7 @@ S_cx_pushloop_plain(pTHX_ PERL_CONTEXT *cx) */ PERL_STATIC_INLINE void -S_cx_pushloop_for(pTHX_ PERL_CONTEXT *cx, void *itervarp, SV* itersave) +Perl_cx_pushloop_for(pTHX_ PERL_CONTEXT *cx, void *itervarp, SV* itersave) { PERL_ARGS_ASSERT_CX_PUSHLOOP_FOR; @@ -2176,7 +2297,7 @@ S_cx_pushloop_for(pTHX_ PERL_CONTEXT *cx, void *itervarp, SV* itersave) /* pop all loop types, including plain */ PERL_STATIC_INLINE void -S_cx_poploop(pTHX_ PERL_CONTEXT *cx) +Perl_cx_poploop(pTHX_ PERL_CONTEXT *cx) { PERL_ARGS_ASSERT_CX_POPLOOP; @@ -2209,7 +2330,7 @@ S_cx_poploop(pTHX_ PERL_CONTEXT *cx) PERL_STATIC_INLINE void -S_cx_pushwhen(pTHX_ PERL_CONTEXT *cx) +Perl_cx_pushwhen(pTHX_ PERL_CONTEXT *cx) { PERL_ARGS_ASSERT_CX_PUSHWHEN; @@ -2218,7 +2339,7 @@ S_cx_pushwhen(pTHX_ PERL_CONTEXT *cx) PERL_STATIC_INLINE void -S_cx_popwhen(pTHX_ PERL_CONTEXT *cx) +Perl_cx_popwhen(pTHX_ PERL_CONTEXT *cx) { PERL_ARGS_ASSERT_CX_POPWHEN; assert(CxTYPE(cx) == CXt_WHEN); @@ -2230,7 +2351,7 @@ S_cx_popwhen(pTHX_ PERL_CONTEXT *cx) PERL_STATIC_INLINE void -S_cx_pushgiven(pTHX_ PERL_CONTEXT *cx, SV *orig_defsv) +Perl_cx_pushgiven(pTHX_ PERL_CONTEXT *cx, SV *orig_defsv) { PERL_ARGS_ASSERT_CX_PUSHGIVEN; @@ -2240,7 +2361,7 @@ S_cx_pushgiven(pTHX_ PERL_CONTEXT *cx, SV *orig_defsv) PERL_STATIC_INLINE void -S_cx_popgiven(pTHX_ PERL_CONTEXT *cx) +Perl_cx_popgiven(pTHX_ PERL_CONTEXT *cx) { SV *sv; @@ -2290,10 +2411,10 @@ Perl_foldEQ(const char *s1, const char *s2, I32 len) PERL_STATIC_INLINE I32 Perl_foldEQ_latin1(const char *s1, const char *s2, I32 len) { - /* Compare non-utf8 using Unicode (Latin1) semantics. Does not work on - * MICRO_SIGN, LATIN_SMALL_LETTER_SHARP_S, nor - * LATIN_SMALL_LETTER_Y_WITH_DIAERESIS, and does not check for these. Nor - * does it check that the strings each have at least 'len' characters */ + /* Compare non-UTF-8 using Unicode (Latin1) semantics. Works on all folds + * representable without UTF-8, except for LATIN_SMALL_LETTER_SHARP_S, and + * does not check for this. Nor does it check that the strings each have + * at least 'len' characters. */ const U8 *a = (const U8 *)s1; const U8 *b = (const U8 *)s2;