This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Add tests for is_valid_partial_utf8_char_flags()
[perl5.git] / inline.h
CommitLineData
25468daa
FC
1/* inline.h
2 *
3 * Copyright (C) 2012 by Larry Wall and others
4 *
5 * You may distribute under the terms of either the GNU General Public
6 * License or the Artistic License, as specified in the README file.
7 *
8 * This file is a home for static inline functions that cannot go in other
9 * headers files, because they depend on proto.h (included after most other
10 * headers) or struct definitions.
11 *
12 * Each section names the header file that the functions "belong" to.
13 */
27669aa4 14
be3a7a5d
KW
15/* ------------------------------- av.h ------------------------------- */
16
c70927a6 17PERL_STATIC_INLINE SSize_t
be3a7a5d
KW
18S_av_top_index(pTHX_ AV *av)
19{
20 PERL_ARGS_ASSERT_AV_TOP_INDEX;
21 assert(SvTYPE(av) == SVt_PVAV);
22
23 return AvFILL(av);
24}
25
1afe1db1
FC
26/* ------------------------------- cv.h ------------------------------- */
27
ae77754a
FC
28PERL_STATIC_INLINE GV *
29S_CvGV(pTHX_ CV *sv)
30{
31 return CvNAMED(sv)
32 ? Perl_cvgv_from_hek(aTHX_ sv)
33 : ((XPVCV*)MUTABLE_PTR(SvANY(sv)))->xcv_gv_u.xcv_gv;
34}
35
1afe1db1
FC
36PERL_STATIC_INLINE I32 *
37S_CvDEPTHp(const CV * const sv)
38{
39 assert(SvTYPE(sv) == SVt_PVCV || SvTYPE(sv) == SVt_PVFM);
8de47657 40 return &((XPVCV*)SvANY(sv))->xcv_depth;
1afe1db1
FC
41}
42
d16269d8
PM
43/*
44 CvPROTO returns the prototype as stored, which is not necessarily what
45 the interpreter should be using. Specifically, the interpreter assumes
46 that spaces have been stripped, which has been the case if the prototype
47 was added by toke.c, but is generally not the case if it was added elsewhere.
48 Since we can't enforce the spacelessness at assignment time, this routine
49 provides a temporary copy at parse time with spaces removed.
50 I<orig> is the start of the original buffer, I<len> is the length of the
51 prototype and will be updated when this returns.
52 */
53
5b67adb8 54#ifdef PERL_CORE
d16269d8
PM
55PERL_STATIC_INLINE char *
56S_strip_spaces(pTHX_ const char * orig, STRLEN * const len)
57{
58 SV * tmpsv;
59 char * tmps;
60 tmpsv = newSVpvn_flags(orig, *len, SVs_TEMP);
61 tmps = SvPVX(tmpsv);
62 while ((*len)--) {
63 if (!isSPACE(*orig))
64 *tmps++ = *orig;
65 orig++;
66 }
67 *tmps = '\0';
68 *len = tmps - SvPVX(tmpsv);
69 return SvPVX(tmpsv);
70}
5b67adb8 71#endif
d16269d8 72
25fdce4a
FC
73/* ------------------------------- mg.h ------------------------------- */
74
75#if defined(PERL_CORE) || defined(PERL_EXT)
76/* assumes get-magic and stringification have already occurred */
77PERL_STATIC_INLINE STRLEN
78S_MgBYTEPOS(pTHX_ MAGIC *mg, SV *sv, const char *s, STRLEN len)
79{
80 assert(mg->mg_type == PERL_MAGIC_regex_global);
81 assert(mg->mg_len != -1);
82 if (mg->mg_flags & MGf_BYTES || !DO_UTF8(sv))
83 return (STRLEN)mg->mg_len;
84 else {
85 const STRLEN pos = (STRLEN)mg->mg_len;
86 /* Without this check, we may read past the end of the buffer: */
87 if (pos > sv_or_pv_len_utf8(sv, s, len)) return len+1;
88 return sv_or_pv_pos_u2b(sv, s, pos, NULL);
89 }
90}
91#endif
92
03414f05
FC
93/* ------------------------------- pad.h ------------------------------ */
94
95#if defined(PERL_IN_PAD_C) || defined(PERL_IN_OP_C)
96PERL_STATIC_INLINE bool
97PadnameIN_SCOPE(const PADNAME * const pn, const U32 seq)
98{
99 /* is seq within the range _LOW to _HIGH ?
100 * This is complicated by the fact that PL_cop_seqmax
101 * may have wrapped around at some point */
102 if (COP_SEQ_RANGE_LOW(pn) == PERL_PADSEQ_INTRO)
103 return FALSE; /* not yet introduced */
104
105 if (COP_SEQ_RANGE_HIGH(pn) == PERL_PADSEQ_INTRO) {
106 /* in compiling scope */
107 if (
108 (seq > COP_SEQ_RANGE_LOW(pn))
109 ? (seq - COP_SEQ_RANGE_LOW(pn) < (U32_MAX >> 1))
110 : (COP_SEQ_RANGE_LOW(pn) - seq > (U32_MAX >> 1))
111 )
112 return TRUE;
113 }
114 else if (
115 (COP_SEQ_RANGE_LOW(pn) > COP_SEQ_RANGE_HIGH(pn))
116 ?
117 ( seq > COP_SEQ_RANGE_LOW(pn)
118 || seq <= COP_SEQ_RANGE_HIGH(pn))
119
120 : ( seq > COP_SEQ_RANGE_LOW(pn)
121 && seq <= COP_SEQ_RANGE_HIGH(pn))
122 )
123 return TRUE;
124 return FALSE;
125}
126#endif
127
33a4312b
FC
128/* ------------------------------- pp.h ------------------------------- */
129
130PERL_STATIC_INLINE I32
131S_TOPMARK(pTHX)
132{
133 DEBUG_s(DEBUG_v(PerlIO_printf(Perl_debug_log,
134 "MARK top %p %"IVdf"\n",
135 PL_markstack_ptr,
136 (IV)*PL_markstack_ptr)));
137 return *PL_markstack_ptr;
138}
139
140PERL_STATIC_INLINE I32
141S_POPMARK(pTHX)
142{
143 DEBUG_s(DEBUG_v(PerlIO_printf(Perl_debug_log,
144 "MARK pop %p %"IVdf"\n",
145 (PL_markstack_ptr-1),
146 (IV)*(PL_markstack_ptr-1))));
147 assert((PL_markstack_ptr > PL_markstack) || !"MARK underflow");
148 return *PL_markstack_ptr--;
149}
150
8d919b0a
FC
151/* ----------------------------- regexp.h ----------------------------- */
152
153PERL_STATIC_INLINE struct regexp *
154S_ReANY(const REGEXP * const re)
155{
156 assert(isREGEXP(re));
157 return re->sv_u.svu_rx;
158}
159
27669aa4
FC
160/* ------------------------------- sv.h ------------------------------- */
161
162PERL_STATIC_INLINE SV *
163S_SvREFCNT_inc(SV *sv)
164{
2439e033 165 if (LIKELY(sv != NULL))
27669aa4
FC
166 SvREFCNT(sv)++;
167 return sv;
168}
169PERL_STATIC_INLINE SV *
170S_SvREFCNT_inc_NN(SV *sv)
171{
172 SvREFCNT(sv)++;
173 return sv;
174}
175PERL_STATIC_INLINE void
176S_SvREFCNT_inc_void(SV *sv)
177{
2439e033 178 if (LIKELY(sv != NULL))
27669aa4
FC
179 SvREFCNT(sv)++;
180}
75e16a44
FC
181PERL_STATIC_INLINE void
182S_SvREFCNT_dec(pTHX_ SV *sv)
183{
2439e033 184 if (LIKELY(sv != NULL)) {
75a9bf96 185 U32 rc = SvREFCNT(sv);
79e2a32a 186 if (LIKELY(rc > 1))
75a9bf96
DM
187 SvREFCNT(sv) = rc - 1;
188 else
189 Perl_sv_free2(aTHX_ sv, rc);
75e16a44
FC
190 }
191}
541377b1
FC
192
193PERL_STATIC_INLINE void
4a9a56a7
DM
194S_SvREFCNT_dec_NN(pTHX_ SV *sv)
195{
196 U32 rc = SvREFCNT(sv);
79e2a32a 197 if (LIKELY(rc > 1))
4a9a56a7
DM
198 SvREFCNT(sv) = rc - 1;
199 else
200 Perl_sv_free2(aTHX_ sv, rc);
201}
202
203PERL_STATIC_INLINE void
541377b1
FC
204SvAMAGIC_on(SV *sv)
205{
206 assert(SvROK(sv));
207 if (SvOBJECT(SvRV(sv))) HvAMAGIC_on(SvSTASH(SvRV(sv)));
208}
209PERL_STATIC_INLINE void
210SvAMAGIC_off(SV *sv)
211{
212 if (SvROK(sv) && SvOBJECT(SvRV(sv)))
213 HvAMAGIC_off(SvSTASH(SvRV(sv)));
214}
215
216PERL_STATIC_INLINE U32
541377b1
FC
217S_SvPADSTALE_on(SV *sv)
218{
c0683843 219 assert(!(SvFLAGS(sv) & SVs_PADTMP));
541377b1
FC
220 return SvFLAGS(sv) |= SVs_PADSTALE;
221}
222PERL_STATIC_INLINE U32
223S_SvPADSTALE_off(SV *sv)
224{
c0683843 225 assert(!(SvFLAGS(sv) & SVs_PADTMP));
541377b1
FC
226 return SvFLAGS(sv) &= ~SVs_PADSTALE;
227}
25fdce4a 228#if defined(PERL_CORE) || defined (PERL_EXT)
4ddea69a 229PERL_STATIC_INLINE STRLEN
6964422a 230S_sv_or_pv_pos_u2b(pTHX_ SV *sv, const char *pv, STRLEN pos, STRLEN *lenp)
4ddea69a 231{
25fdce4a 232 PERL_ARGS_ASSERT_SV_OR_PV_POS_U2B;
4ddea69a
FC
233 if (SvGAMAGIC(sv)) {
234 U8 *hopped = utf8_hop((U8 *)pv, pos);
235 if (lenp) *lenp = (STRLEN)(utf8_hop(hopped, *lenp) - hopped);
236 return (STRLEN)(hopped - (U8 *)pv);
237 }
238 return sv_pos_u2b_flags(sv,pos,lenp,SV_CONST_RETURN);
239}
240#endif
f019c49e 241
d1decf2b
TC
242/* ------------------------------- handy.h ------------------------------- */
243
244/* saves machine code for a common noreturn idiom typically used in Newx*() */
c1d6452f 245#ifdef GCC_DIAG_PRAGMA
6ab56f1e 246GCC_DIAG_IGNORE(-Wunused-function) /* Intentionally left semicolonless. */
c1d6452f 247#endif
d1decf2b
TC
248static void
249S_croak_memory_wrap(void)
250{
251 Perl_croak_nocontext("%s",PL_memory_wrap);
252}
c1d6452f 253#ifdef GCC_DIAG_PRAGMA
6ab56f1e 254GCC_DIAG_RESTORE /* Intentionally left semicolonless. */
c1d6452f 255#endif
d1decf2b 256
a8a2ceaa
KW
257/* ------------------------------- utf8.h ------------------------------- */
258
2fe720e2
KW
259/*
260=head1 Unicode Support
261*/
262
55d09dc8
KW
263PERL_STATIC_INLINE void
264S_append_utf8_from_native_byte(const U8 byte, U8** dest)
265{
266 /* Takes an input 'byte' (Latin1 or EBCDIC) and appends it to the UTF-8
267 * encoded string at '*dest', updating '*dest' to include it */
268
55d09dc8
KW
269 PERL_ARGS_ASSERT_APPEND_UTF8_FROM_NATIVE_BYTE;
270
6f2d5cbc 271 if (NATIVE_BYTE_IS_INVARIANT(byte))
a09ec51a 272 *((*dest)++) = byte;
55d09dc8 273 else {
a09ec51a
KW
274 *((*dest)++) = UTF8_EIGHT_BIT_HI(byte);
275 *((*dest)++) = UTF8_EIGHT_BIT_LO(byte);
55d09dc8
KW
276 }
277}
278
e123187a 279/*
2fe720e2
KW
280=for apidoc valid_utf8_to_uvchr
281Like L</utf8_to_uvchr_buf>(), but should only be called when it is known that
282the next character in the input UTF-8 string C<s> is well-formed (I<e.g.>,
283it passes C<L</isUTF8_CHAR>>. Surrogates, non-character code points, and
284non-Unicode code points are allowed.
285
286=cut
287
288 */
289
290PERL_STATIC_INLINE UV
291Perl_valid_utf8_to_uvchr(const U8 *s, STRLEN *retlen)
292{
293 UV expectlen = UTF8SKIP(s);
294 const U8* send = s + expectlen;
295 UV uv = *s;
296
297 PERL_ARGS_ASSERT_VALID_UTF8_TO_UVCHR;
298
299 if (retlen) {
300 *retlen = expectlen;
301 }
302
303 /* An invariant is trivially returned */
304 if (expectlen == 1) {
305 return uv;
306 }
307
308 /* Remove the leading bits that indicate the number of bytes, leaving just
309 * the bits that are part of the value */
310 uv = NATIVE_UTF8_TO_I8(uv) & UTF_START_MASK(expectlen);
311
312 /* Now, loop through the remaining bytes, accumulating each into the
313 * working total as we go. (I khw tried unrolling the loop for up to 4
314 * bytes, but there was no performance improvement) */
315 for (++s; s < send; s++) {
316 uv = UTF8_ACCUMULATE(uv, *s);
317 }
318
319 return UNI_TO_NATIVE(uv);
320
321}
322
1e599354
KW
323/*
324=for apidoc is_utf8_invariant_string
325
326Returns true iff the first C<len> bytes of the string C<s> are the same
327regardless of the UTF-8 encoding of the string (or UTF-EBCDIC encoding on
328EBCDIC machines). That is, if they are UTF-8 invariant. On ASCII-ish
329machines, all the ASCII characters and only the ASCII characters fit this
330definition. On EBCDIC machines, the ASCII-range characters are invariant, but
331so also are the C1 controls and C<\c?> (which isn't in the ASCII range on
332EBCDIC).
333
334If C<len> is 0, it will be calculated using C<strlen(s)>, (which means if you
335use this option, that C<s> can't have embedded C<NUL> characters and has to
336have a terminating C<NUL> byte).
337
338See also L</is_utf8_string>(), L</is_utf8_string_loclen>(), and
339L</is_utf8_string_loc>().
340
341=cut
342*/
343
344PERL_STATIC_INLINE bool
345S_is_utf8_invariant_string(const U8* const s, const STRLEN len)
346{
347 const U8* const send = s + (len ? len : strlen((const char *)s));
348 const U8* x = s;
349
350 PERL_ARGS_ASSERT_IS_UTF8_INVARIANT_STRING;
351
352 for (; x < send; ++x) {
353 if (!UTF8_IS_INVARIANT(*x))
354 return FALSE;
355 }
356
357 return TRUE;
358}
359
7c93d8f0 360/*
5ff889fb
KW
361=for apidoc is_utf8_string
362
363Returns true if the first C<len> bytes of string C<s> form a valid
364UTF-8 string, false otherwise. If C<len> is 0, it will be calculated
365using C<strlen(s)> (which means if you use this option, that C<s> can't have
366embedded C<NUL> characters and has to have a terminating C<NUL> byte). Note
367that all characters being ASCII constitute 'a valid UTF-8 string'.
368
369See also L</is_utf8_invariant_string>(), L</is_utf8_string_loclen>(), and
370L</is_utf8_string_loc>().
371
372=cut
373*/
374
56e4cf64 375PERL_STATIC_INLINE bool
5ff889fb
KW
376Perl_is_utf8_string(const U8 *s, STRLEN len)
377{
35936d22
KW
378 /* This is now marked pure in embed.fnc, because isUTF8_CHAR now is pure.
379 * Be aware of possible changes to that */
380
5ff889fb
KW
381 const U8* const send = s + (len ? len : strlen((const char *)s));
382 const U8* x = s;
383
384 PERL_ARGS_ASSERT_IS_UTF8_STRING;
385
386 while (x < send) {
387 STRLEN len = isUTF8_CHAR(x, send);
388 if (UNLIKELY(! len)) {
389 return FALSE;
390 }
391 x += len;
392 }
393
394 return TRUE;
395}
396
397/*
398Implemented as a macro in utf8.h
399
400=for apidoc is_utf8_string_loc
401
402Like L</is_utf8_string> but stores the location of the failure (in the
403case of "utf8ness failure") or the location C<s>+C<len> (in the case of
404"utf8ness success") in the C<ep>.
405
406See also L</is_utf8_string_loclen>() and L</is_utf8_string>().
407
408=for apidoc is_utf8_string_loclen
409
410Like L</is_utf8_string>() but stores the location of the failure (in the
411case of "utf8ness failure") or the location C<s>+C<len> (in the case of
412"utf8ness success") in the C<ep>, and the number of UTF-8
413encoded characters in the C<el>.
414
415See also L</is_utf8_string_loc>() and L</is_utf8_string>().
416
417=cut
418*/
419
56e4cf64 420PERL_STATIC_INLINE bool
5ff889fb
KW
421Perl_is_utf8_string_loclen(const U8 *s, STRLEN len, const U8 **ep, STRLEN *el)
422{
423 const U8* const send = s + (len ? len : strlen((const char *)s));
424 const U8* x = s;
425 STRLEN outlen = 0;
426
427 PERL_ARGS_ASSERT_IS_UTF8_STRING_LOCLEN;
428
429 while (x < send) {
430 STRLEN len = isUTF8_CHAR(x, send);
431 if (UNLIKELY(! len)) {
432 break;
433 }
434 x += len;
435 outlen++;
436 }
437
438 if (el)
439 *el = outlen;
440
441 if (ep) {
442 *ep = x;
443 }
444
445 return (x == send);
446}
447
448/*
7c93d8f0
KW
449=for apidoc utf8_distance
450
451Returns the number of UTF-8 characters between the UTF-8 pointers C<a>
452and C<b>.
453
454WARNING: use only if you *know* that the pointers point inside the
455same UTF-8 buffer.
456
457=cut
458*/
459
460PERL_STATIC_INLINE IV
461Perl_utf8_distance(pTHX_ const U8 *a, const U8 *b)
462{
463 PERL_ARGS_ASSERT_UTF8_DISTANCE;
464
465 return (a < b) ? -1 * (IV) utf8_length(a, b) : (IV) utf8_length(b, a);
466}
467
468/*
469=for apidoc utf8_hop
470
471Return the UTF-8 pointer C<s> displaced by C<off> characters, either
472forward or backward.
473
474WARNING: do not use the following unless you *know* C<off> is within
475the UTF-8 data pointed to by C<s> *and* that on entry C<s> is aligned
476on the first byte of character or just after the last byte of a character.
477
478=cut
479*/
480
481PERL_STATIC_INLINE U8 *
482Perl_utf8_hop(const U8 *s, SSize_t off)
483{
484 PERL_ARGS_ASSERT_UTF8_HOP;
485
486 /* Note: cannot use UTF8_IS_...() too eagerly here since e.g
487 * the bitops (especially ~) can create illegal UTF-8.
488 * In other words: in Perl UTF-8 is not just for Unicode. */
489
490 if (off >= 0) {
491 while (off--)
492 s += UTF8SKIP(s);
493 }
494 else {
495 while (off++) {
496 s--;
497 while (UTF8_IS_CONTINUATION(*s))
498 s--;
499 }
500 }
501 return (U8 *)s;
502}
503
4dab108f
KW
504/*
505
506=for apidoc is_utf8_valid_partial_char
507
6cbb9248
KW
508Returns 0 if the sequence of bytes starting at C<s> and looking no further than
509S<C<e - 1>> is the UTF-8 encoding, as extended by Perl, for one or more code
510points. Otherwise, it returns 1 if there exists at least one non-empty
511sequence of bytes that when appended to sequence C<s>, starting at position
512C<e> causes the entire sequence to be the well-formed UTF-8 of some code point;
513otherwise returns 0.
514
515In other words this returns TRUE if C<s> points to a partial UTF-8-encoded code
516point.
517
518This is useful when a fixed-length buffer is being tested for being well-formed
519UTF-8, but the final few bytes in it don't comprise a full character; that is,
520it is split somewhere in the middle of the final code point's UTF-8
521representation. (Presumably when the buffer is refreshed with the next chunk
522of data, the new first bytes will complete the partial code point.) This
523function is used to verify that the final bytes in the current buffer are in
524fact the legal beginning of some code point, so that if they aren't, the
525failure can be signalled without having to wait for the next read.
4dab108f
KW
526
527=cut
528*/
f1c999a7
KW
529#define is_utf8_valid_partial_char(s, e) is_utf8_valid_partial_char_flags(s, e, 0)
530
531/*
532
533=for apidoc is_utf8_valid_partial_char_flags
534
535Like C<L</is_utf8_valid_partial_char>>, it returns a boolean giving whether
536or not the input is a valid UTF-8 encoded partial character, but it takes an
537extra parameter, C<flags>, which can further restrict which code points are
538considered valid.
539
540If C<flags> is 0, this behaves identically to
541C<L</is_utf8_valid_partial_char>>. Otherwise C<flags> can be any combination
542of the C<UTF8_DISALLOW_I<foo>> flags accepted by C<L</utf8n_to_uvchr>>. If
543there is any sequence of bytes that can complete the input partial character in
544such a way that a non-prohibited character is formed, the function returns
545TRUE; otherwise FALSE. Non characters cannot be determined based on partial
546character input. But many of the other possible excluded types can be
547determined from just the first one or two bytes.
548
549=cut
550 */
551
56e4cf64 552PERL_STATIC_INLINE bool
f1c999a7 553S_is_utf8_valid_partial_char_flags(const U8 * const s, const U8 * const e, const U32 flags)
4dab108f 554{
f1c999a7 555 PERL_ARGS_ASSERT_IS_UTF8_VALID_PARTIAL_CHAR_FLAGS;
4dab108f 556
f1c999a7
KW
557 assert(0 == (flags & ~(UTF8_DISALLOW_ILLEGAL_INTERCHANGE
558 |UTF8_DISALLOW_ABOVE_31_BIT)));
4dab108f 559
8875bd48 560 if (s >= e || s + UTF8SKIP(s) <= e) {
4dab108f
KW
561 return FALSE;
562 }
563
f1c999a7 564 return cBOOL(_is_utf8_char_helper(s, e, flags));
4dab108f
KW
565}
566
c8028aa6
TC
567/* ------------------------------- perl.h ----------------------------- */
568
569/*
dcccc8ff
KW
570=head1 Miscellaneous Functions
571
41188aa0 572=for apidoc AiR|bool|is_safe_syscall|const char *pv|STRLEN len|const char *what|const char *op_name
c8028aa6 573
6602b933 574Test that the given C<pv> doesn't contain any internal C<NUL> characters.
796b6530 575If it does, set C<errno> to C<ENOENT>, optionally warn, and return FALSE.
c8028aa6
TC
576
577Return TRUE if the name is safe.
578
796b6530 579Used by the C<IS_SAFE_SYSCALL()> macro.
c8028aa6
TC
580
581=cut
582*/
583
584PERL_STATIC_INLINE bool
41188aa0 585S_is_safe_syscall(pTHX_ const char *pv, STRLEN len, const char *what, const char *op_name) {
c8028aa6
TC
586 /* While the Windows CE API provides only UCS-16 (or UTF-16) APIs
587 * perl itself uses xce*() functions which accept 8-bit strings.
588 */
589
590 PERL_ARGS_ASSERT_IS_SAFE_SYSCALL;
591
6c4650b3 592 if (len > 1) {
c8028aa6 593 char *null_at;
41188aa0 594 if (UNLIKELY((null_at = (char *)memchr(pv, 0, len-1)) != NULL)) {
c8028aa6 595 SETERRNO(ENOENT, LIB_INVARG);
1d505182 596 Perl_ck_warner(aTHX_ packWARN(WARN_SYSCALLS),
c8028aa6 597 "Invalid \\0 character in %s for %s: %s\\0%s",
41188aa0 598 what, op_name, pv, null_at+1);
c8028aa6
TC
599 return FALSE;
600 }
601 }
602
603 return TRUE;
604}
605
606/*
7cb3f959
TC
607
608Return true if the supplied filename has a newline character
fa6c7d00 609immediately before the first (hopefully only) NUL.
7cb3f959
TC
610
611My original look at this incorrectly used the len from SvPV(), but
612that's incorrect, since we allow for a NUL in pv[len-1].
613
614So instead, strlen() and work from there.
615
616This allow for the user reading a filename, forgetting to chomp it,
617then calling:
618
619 open my $foo, "$file\0";
620
621*/
622
623#ifdef PERL_CORE
624
625PERL_STATIC_INLINE bool
626S_should_warn_nl(const char *pv) {
627 STRLEN len;
628
629 PERL_ARGS_ASSERT_SHOULD_WARN_NL;
630
631 len = strlen(pv);
632
633 return len > 0 && pv[len-1] == '\n';
634}
635
636#endif
637
81d52ecd
JH
638/* ------------------ pp.c, regcomp.c, toke.c, universal.c ------------ */
639
640#define MAX_CHARSET_NAME_LENGTH 2
641
642PERL_STATIC_INLINE const char *
643get_regex_charset_name(const U32 flags, STRLEN* const lenp)
644{
645 /* Returns a string that corresponds to the name of the regex character set
646 * given by 'flags', and *lenp is set the length of that string, which
647 * cannot exceed MAX_CHARSET_NAME_LENGTH characters */
648
649 *lenp = 1;
650 switch (get_regex_charset(flags)) {
651 case REGEX_DEPENDS_CHARSET: return DEPENDS_PAT_MODS;
652 case REGEX_LOCALE_CHARSET: return LOCALE_PAT_MODS;
653 case REGEX_UNICODE_CHARSET: return UNICODE_PAT_MODS;
654 case REGEX_ASCII_RESTRICTED_CHARSET: return ASCII_RESTRICT_PAT_MODS;
655 case REGEX_ASCII_MORE_RESTRICTED_CHARSET:
656 *lenp = 2;
657 return ASCII_MORE_RESTRICT_PAT_MODS;
658 }
659 /* The NOT_REACHED; hides an assert() which has a rather complex
660 * definition in perl.h. */
661 NOT_REACHED; /* NOTREACHED */
662 return "?"; /* Unknown */
663}
664
7cb3f959 665/*
ed382232
TC
666
667Return false if any get magic is on the SV other than taint magic.
668
669*/
670
671PERL_STATIC_INLINE bool
672S_sv_only_taint_gmagic(SV *sv) {
673 MAGIC *mg = SvMAGIC(sv);
674
675 PERL_ARGS_ASSERT_SV_ONLY_TAINT_GMAGIC;
676
677 while (mg) {
678 if (mg->mg_type != PERL_MAGIC_taint
679 && !(mg->mg_flags & MGf_GSKIP)
680 && mg->mg_virtual->svt_get) {
681 return FALSE;
682 }
683 mg = mg->mg_moremagic;
684 }
685
686 return TRUE;
687}
688
ed8ff0f3
DM
689/* ------------------ cop.h ------------------------------------------- */
690
691
692/* Enter a block. Push a new base context and return its address. */
693
694PERL_STATIC_INLINE PERL_CONTEXT *
695S_cx_pushblock(pTHX_ U8 type, U8 gimme, SV** sp, I32 saveix)
696{
697 PERL_CONTEXT * cx;
698
699 PERL_ARGS_ASSERT_CX_PUSHBLOCK;
700
701 CXINC;
702 cx = CX_CUR();
703 cx->cx_type = type;
704 cx->blk_gimme = gimme;
705 cx->blk_oldsaveix = saveix;
4caf7d8c 706 cx->blk_oldsp = (I32)(sp - PL_stack_base);
ed8ff0f3 707 cx->blk_oldcop = PL_curcop;
4caf7d8c 708 cx->blk_oldmarksp = (I32)(PL_markstack_ptr - PL_markstack);
ed8ff0f3
DM
709 cx->blk_oldscopesp = PL_scopestack_ix;
710 cx->blk_oldpm = PL_curpm;
ce8bb8d8 711 cx->blk_old_tmpsfloor = PL_tmps_floor;
ed8ff0f3
DM
712
713 PL_tmps_floor = PL_tmps_ix;
714 CX_DEBUG(cx, "PUSH");
715 return cx;
716}
717
718
719/* Exit a block (RETURN and LAST). */
720
721PERL_STATIC_INLINE void
722S_cx_popblock(pTHX_ PERL_CONTEXT *cx)
723{
724 PERL_ARGS_ASSERT_CX_POPBLOCK;
725
726 CX_DEBUG(cx, "POP");
727 /* these 3 are common to cx_popblock and cx_topblock */
728 PL_markstack_ptr = PL_markstack + cx->blk_oldmarksp;
729 PL_scopestack_ix = cx->blk_oldscopesp;
730 PL_curpm = cx->blk_oldpm;
731
732 /* LEAVE_SCOPE() should have made this true. /(?{})/ cheats
733 * and leaves a CX entry lying around for repeated use, so
734 * skip for multicall */ \
735 assert( (CxTYPE(cx) == CXt_SUB && CxMULTICALL(cx))
736 || PL_savestack_ix == cx->blk_oldsaveix);
737 PL_curcop = cx->blk_oldcop;
ce8bb8d8 738 PL_tmps_floor = cx->blk_old_tmpsfloor;
ed8ff0f3
DM
739}
740
741/* Continue a block elsewhere (e.g. NEXT, REDO, GOTO).
742 * Whereas cx_popblock() restores the state to the point just before
743 * cx_pushblock() was called, cx_topblock() restores it to the point just
744 * *after* cx_pushblock() was called. */
745
746PERL_STATIC_INLINE void
747S_cx_topblock(pTHX_ PERL_CONTEXT *cx)
748{
749 PERL_ARGS_ASSERT_CX_TOPBLOCK;
750
751 CX_DEBUG(cx, "TOP");
752 /* these 3 are common to cx_popblock and cx_topblock */
753 PL_markstack_ptr = PL_markstack + cx->blk_oldmarksp;
754 PL_scopestack_ix = cx->blk_oldscopesp;
755 PL_curpm = cx->blk_oldpm;
756
757 PL_stack_sp = PL_stack_base + cx->blk_oldsp;
758}
759
760
a73d8813
DM
761PERL_STATIC_INLINE void
762S_cx_pushsub(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, bool hasargs)
763{
764 U8 phlags = CX_PUSHSUB_GET_LVALUE_MASK(Perl_was_lvalue_sub);
765
766 PERL_ARGS_ASSERT_CX_PUSHSUB;
767
3f6bd23a 768 PERL_DTRACE_PROBE_ENTRY(cv);
a73d8813
DM
769 cx->blk_sub.cv = cv;
770 cx->blk_sub.olddepth = CvDEPTH(cv);
771 cx->blk_sub.prevcomppad = PL_comppad;
772 cx->cx_type |= (hasargs) ? CXp_HASARGS : 0;
773 cx->blk_sub.retop = retop;
774 SvREFCNT_inc_simple_void_NN(cv);
775 cx->blk_u16 = PL_op->op_private & (phlags|OPpDEREF);
776}
777
778
779/* subsets of cx_popsub() */
780
781PERL_STATIC_INLINE void
782S_cx_popsub_common(pTHX_ PERL_CONTEXT *cx)
783{
784 CV *cv;
785
786 PERL_ARGS_ASSERT_CX_POPSUB_COMMON;
787 assert(CxTYPE(cx) == CXt_SUB);
788
789 PL_comppad = cx->blk_sub.prevcomppad;
790 PL_curpad = LIKELY(PL_comppad) ? AvARRAY(PL_comppad) : NULL;
791 cv = cx->blk_sub.cv;
792 CvDEPTH(cv) = cx->blk_sub.olddepth;
793 cx->blk_sub.cv = NULL;
794 SvREFCNT_dec(cv);
795}
796
797
798/* handle the @_ part of leaving a sub */
799
800PERL_STATIC_INLINE void
801S_cx_popsub_args(pTHX_ PERL_CONTEXT *cx)
802{
803 AV *av;
804
805 PERL_ARGS_ASSERT_CX_POPSUB_ARGS;
806 assert(CxTYPE(cx) == CXt_SUB);
807 assert(AvARRAY(MUTABLE_AV(
808 PadlistARRAY(CvPADLIST(cx->blk_sub.cv))[
809 CvDEPTH(cx->blk_sub.cv)])) == PL_curpad);
810
811 CX_POP_SAVEARRAY(cx);
812 av = MUTABLE_AV(PAD_SVl(0));
813 if (UNLIKELY(AvREAL(av)))
814 /* abandon @_ if it got reified */
815 clear_defarray(av, 0);
816 else {
817 CLEAR_ARGARRAY(av);
818 }
819}
820
821
822PERL_STATIC_INLINE void
823S_cx_popsub(pTHX_ PERL_CONTEXT *cx)
824{
825 PERL_ARGS_ASSERT_CX_POPSUB;
826 assert(CxTYPE(cx) == CXt_SUB);
827
3f6bd23a 828 PERL_DTRACE_PROBE_RETURN(cx->blk_sub.cv);
a73d8813
DM
829
830 if (CxHASARGS(cx))
831 cx_popsub_args(cx);
832 cx_popsub_common(cx);
833}
834
835
6a7d52cc
DM
836PERL_STATIC_INLINE void
837S_cx_pushformat(pTHX_ PERL_CONTEXT *cx, CV *cv, OP *retop, GV *gv)
838{
839 PERL_ARGS_ASSERT_CX_PUSHFORMAT;
840
841 cx->blk_format.cv = cv;
842 cx->blk_format.retop = retop;
843 cx->blk_format.gv = gv;
844 cx->blk_format.dfoutgv = PL_defoutgv;
845 cx->blk_format.prevcomppad = PL_comppad;
846 cx->blk_u16 = 0;
847
848 SvREFCNT_inc_simple_void_NN(cv);
849 CvDEPTH(cv)++;
850 SvREFCNT_inc_void(cx->blk_format.dfoutgv);
851}
852
853
854PERL_STATIC_INLINE void
855S_cx_popformat(pTHX_ PERL_CONTEXT *cx)
856{
857 CV *cv;
858 GV *dfout;
859
860 PERL_ARGS_ASSERT_CX_POPFORMAT;
861 assert(CxTYPE(cx) == CXt_FORMAT);
862
863 dfout = cx->blk_format.dfoutgv;
864 setdefout(dfout);
865 cx->blk_format.dfoutgv = NULL;
866 SvREFCNT_dec_NN(dfout);
867
868 PL_comppad = cx->blk_format.prevcomppad;
869 PL_curpad = LIKELY(PL_comppad) ? AvARRAY(PL_comppad) : NULL;
870 cv = cx->blk_format.cv;
871 cx->blk_format.cv = NULL;
872 --CvDEPTH(cv);
873 SvREFCNT_dec_NN(cv);
874}
875
876
13febba5
DM
877PERL_STATIC_INLINE void
878S_cx_pusheval(pTHX_ PERL_CONTEXT *cx, OP *retop, SV *namesv)
879{
880 PERL_ARGS_ASSERT_CX_PUSHEVAL;
881
882 cx->blk_eval.retop = retop;
883 cx->blk_eval.old_namesv = namesv;
884 cx->blk_eval.old_eval_root = PL_eval_root;
885 cx->blk_eval.cur_text = PL_parser ? PL_parser->linestr : NULL;
886 cx->blk_eval.cv = NULL; /* later set by doeval_compile() */
887 cx->blk_eval.cur_top_env = PL_top_env;
888
889 assert(!(PL_in_eval & ~ 0x7F));
890 assert(!(PL_op->op_type & ~0x1FF));
891 cx->blk_u16 = (PL_in_eval & 0x7F) | ((U16)PL_op->op_type << 7);
892}
893
894
895PERL_STATIC_INLINE void
896S_cx_popeval(pTHX_ PERL_CONTEXT *cx)
897{
898 SV *sv;
899
900 PERL_ARGS_ASSERT_CX_POPEVAL;
901 assert(CxTYPE(cx) == CXt_EVAL);
902
903 PL_in_eval = CxOLD_IN_EVAL(cx);
904 PL_eval_root = cx->blk_eval.old_eval_root;
905 sv = cx->blk_eval.cur_text;
906 if (sv && SvSCREAM(sv)) {
907 cx->blk_eval.cur_text = NULL;
908 SvREFCNT_dec_NN(sv);
909 }
910
911 sv = cx->blk_eval.old_namesv;
2a1e0dfe
DM
912 if (sv) {
913 cx->blk_eval.old_namesv = NULL;
914 SvREFCNT_dec_NN(sv);
915 }
13febba5 916}
6a7d52cc 917
a73d8813 918
d1b6bf72
DM
919/* push a plain loop, i.e.
920 * { block }
921 * while (cond) { block }
922 * for (init;cond;continue) { block }
923 * This loop can be last/redo'ed etc.
924 */
925
926PERL_STATIC_INLINE void
927S_cx_pushloop_plain(pTHX_ PERL_CONTEXT *cx)
928{
929 PERL_ARGS_ASSERT_CX_PUSHLOOP_PLAIN;
930 cx->blk_loop.my_op = cLOOP;
931}
932
933
934/* push a true for loop, i.e.
935 * for var (list) { block }
936 */
937
938PERL_STATIC_INLINE void
939S_cx_pushloop_for(pTHX_ PERL_CONTEXT *cx, void *itervarp, SV* itersave)
940{
941 PERL_ARGS_ASSERT_CX_PUSHLOOP_FOR;
942
943 /* this one line is common with cx_pushloop_plain */
944 cx->blk_loop.my_op = cLOOP;
945
946 cx->blk_loop.itervar_u.svp = (SV**)itervarp;
947 cx->blk_loop.itersave = itersave;
948#ifdef USE_ITHREADS
949 cx->blk_loop.oldcomppad = PL_comppad;
950#endif
951}
952
953
954/* pop all loop types, including plain */
955
956PERL_STATIC_INLINE void
957S_cx_poploop(pTHX_ PERL_CONTEXT *cx)
958{
959 PERL_ARGS_ASSERT_CX_POPLOOP;
960
961 assert(CxTYPE_is_LOOP(cx));
962 if ( CxTYPE(cx) == CXt_LOOP_ARY
963 || CxTYPE(cx) == CXt_LOOP_LAZYSV)
964 {
965 /* Free ary or cur. This assumes that state_u.ary.ary
966 * aligns with state_u.lazysv.cur. See cx_dup() */
967 SV *sv = cx->blk_loop.state_u.lazysv.cur;
968 cx->blk_loop.state_u.lazysv.cur = NULL;
969 SvREFCNT_dec_NN(sv);
970 if (CxTYPE(cx) == CXt_LOOP_LAZYSV) {
971 sv = cx->blk_loop.state_u.lazysv.end;
972 cx->blk_loop.state_u.lazysv.end = NULL;
973 SvREFCNT_dec_NN(sv);
974 }
975 }
976 if (cx->cx_type & (CXp_FOR_PAD|CXp_FOR_GV)) {
977 SV *cursv;
978 SV **svp = (cx)->blk_loop.itervar_u.svp;
979 if ((cx->cx_type & CXp_FOR_GV))
980 svp = &GvSV((GV*)svp);
981 cursv = *svp;
982 *svp = cx->blk_loop.itersave;
983 cx->blk_loop.itersave = NULL;
984 SvREFCNT_dec(cursv);
985 }
986}
987
2a7b7c61
DM
988
989PERL_STATIC_INLINE void
990S_cx_pushwhen(pTHX_ PERL_CONTEXT *cx)
991{
992 PERL_ARGS_ASSERT_CX_PUSHWHEN;
993
994 cx->blk_givwhen.leave_op = cLOGOP->op_other;
995}
996
997
998PERL_STATIC_INLINE void
999S_cx_popwhen(pTHX_ PERL_CONTEXT *cx)
1000{
1001 PERL_ARGS_ASSERT_CX_POPWHEN;
1002 assert(CxTYPE(cx) == CXt_WHEN);
1003
1004 PERL_UNUSED_ARG(cx);
59a14f30 1005 PERL_UNUSED_CONTEXT;
2a7b7c61
DM
1006 /* currently NOOP */
1007}
1008
1009
1010PERL_STATIC_INLINE void
1011S_cx_pushgiven(pTHX_ PERL_CONTEXT *cx, SV *orig_defsv)
1012{
1013 PERL_ARGS_ASSERT_CX_PUSHGIVEN;
1014
1015 cx->blk_givwhen.leave_op = cLOGOP->op_other;
1016 cx->blk_givwhen.defsv_save = orig_defsv;
1017}
1018
1019
1020PERL_STATIC_INLINE void
1021S_cx_popgiven(pTHX_ PERL_CONTEXT *cx)
1022{
1023 SV *sv;
1024
1025 PERL_ARGS_ASSERT_CX_POPGIVEN;
1026 assert(CxTYPE(cx) == CXt_GIVEN);
1027
1028 sv = GvSV(PL_defgv);
1029 GvSV(PL_defgv) = cx->blk_givwhen.defsv_save;
1030 cx->blk_givwhen.defsv_save = NULL;
1031 SvREFCNT_dec(sv);
1032}
1033
ed382232 1034/*
c8028aa6
TC
1035 * ex: set ts=8 sts=4 sw=4 et:
1036 */