This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Merge Hash::Util::FieldHash::_test_uvar_{get,set,same} using ALIAS.
[perl5.git] / pp_ctl.c
CommitLineData
a0d0e21e
LW
1/* pp_ctl.c
2 *
1129b882
NC
3 * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
4 * 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by Larry Wall and others
a0d0e21e
LW
5 *
6 * You may distribute under the terms of either the GNU General Public
7 * License or the Artistic License, as specified in the README file.
8 *
9 */
10
11/*
4ac71550
TC
12 * Now far ahead the Road has gone,
13 * And I must follow, if I can,
14 * Pursuing it with eager feet,
15 * Until it joins some larger way
16 * Where many paths and errands meet.
17 * And whither then? I cannot say.
18 *
19 * [Bilbo on p.35 of _The Lord of the Rings_, I/i: "A Long-Expected Party"]
a0d0e21e
LW
20 */
21
166f8a29
DM
22/* This file contains control-oriented pp ("push/pop") functions that
23 * execute the opcodes that make up a perl program. A typical pp function
24 * expects to find its arguments on the stack, and usually pushes its
25 * results onto the stack, hence the 'pp' terminology. Each OP structure
26 * contains a pointer to the relevant pp_foo() function.
27 *
28 * Control-oriented means things like pp_enteriter() and pp_next(), which
29 * alter the flow of control of the program.
30 */
31
32
a0d0e21e 33#include "EXTERN.h"
864dbfa3 34#define PERL_IN_PP_CTL_C
a0d0e21e
LW
35#include "perl.h"
36
37#ifndef WORD_ALIGN
dea28490 38#define WORD_ALIGN sizeof(U32)
a0d0e21e
LW
39#endif
40
54310121 41#define DOCATCH(o) ((CATCH_GET == TRUE) ? docatch(o) : (o))
1e422769 42
94fcd414
NC
43#define dopoptosub(plop) dopoptosub_at(cxstack, (plop))
44
a0d0e21e
LW
45PP(pp_wantarray)
46{
97aff369 47 dVAR;
39644a26 48 dSP;
a0d0e21e
LW
49 I32 cxix;
50 EXTEND(SP, 1);
51
52 cxix = dopoptosub(cxstack_ix);
53 if (cxix < 0)
54 RETPUSHUNDEF;
55
54310121
PP
56 switch (cxstack[cxix].blk_gimme) {
57 case G_ARRAY:
a0d0e21e 58 RETPUSHYES;
54310121 59 case G_SCALAR:
a0d0e21e 60 RETPUSHNO;
54310121
PP
61 default:
62 RETPUSHUNDEF;
63 }
a0d0e21e
LW
64}
65
2cd61cdb
IZ
66PP(pp_regcreset)
67{
97aff369 68 dVAR;
2cd61cdb
IZ
69 /* XXXX Should store the old value to allow for tie/overload - and
70 restore in regcomp, where marked with XXXX. */
3280af22 71 PL_reginterp_cnt = 0;
0b4182de 72 TAINT_NOT;
2cd61cdb
IZ
73 return NORMAL;
74}
75
b3eb6a9b
GS
76PP(pp_regcomp)
77{
97aff369 78 dVAR;
39644a26 79 dSP;
a0d0e21e 80 register PMOP *pm = (PMOP*)cLOGOP->op_other;
a0d0e21e 81 SV *tmpstr;
84679df5 82 REGEXP *re = NULL;
bfed75c6 83
4b5a0d1c 84 /* prevent recompiling under /o and ithreads. */
3db8f154 85#if defined(USE_ITHREADS)
131b3ad0
DM
86 if (pm->op_pmflags & PMf_KEEP && PM_GETRE(pm)) {
87 if (PL_op->op_flags & OPf_STACKED) {
88 dMARK;
89 SP = MARK;
90 }
91 else
92 (void)POPs;
93 RETURN;
94 }
513629ba 95#endif
d4b87e75
BM
96
97#define tryAMAGICregexp(rx) \
98 STMT_START { \
6f1401dc 99 SvGETMAGIC(rx); \
d4b87e75
BM
100 if (SvROK(rx) && SvAMAGIC(rx)) { \
101 SV *sv = AMG_CALLun(rx, regexp); \
102 if (sv) { \
103 if (SvROK(sv)) \
104 sv = SvRV(sv); \
105 if (SvTYPE(sv) != SVt_REGEXP) \
106 Perl_croak(aTHX_ "Overloaded qr did not return a REGEXP"); \
107 rx = sv; \
108 } \
109 } \
110 } STMT_END
111
112
131b3ad0
DM
113 if (PL_op->op_flags & OPf_STACKED) {
114 /* multiple args; concatentate them */
115 dMARK; dORIGMARK;
116 tmpstr = PAD_SV(ARGTARG);
76f68e9b 117 sv_setpvs(tmpstr, "");
131b3ad0 118 while (++MARK <= SP) {
d4b87e75 119 SV *msv = *MARK;
79a8d529 120 SV *sv;
d4b87e75 121
79a8d529 122 tryAMAGICregexp(msv);
d4b87e75 123
79a8d529
DM
124 if ((SvAMAGIC(tmpstr) || SvAMAGIC(msv)) &&
125 (sv = amagic_call(tmpstr, msv, concat_amg, AMGf_assign)))
126 {
127 sv_setsv(tmpstr, sv);
128 continue;
131b3ad0 129 }
a9984b10 130 sv_catsv_nomg(tmpstr, msv);
131b3ad0
DM
131 }
132 SvSETMAGIC(tmpstr);
133 SP = ORIGMARK;
134 }
d4b87e75 135 else {
131b3ad0 136 tmpstr = POPs;
d4b87e75
BM
137 tryAMAGICregexp(tmpstr);
138 }
139
140#undef tryAMAGICregexp
513629ba 141
b3eb6a9b 142 if (SvROK(tmpstr)) {
d8f6592e 143 SV * const sv = SvRV(tmpstr);
5c35adbb 144 if (SvTYPE(sv) == SVt_REGEXP)
d2f13c59 145 re = (REGEXP*) sv;
c277df42 146 }
d4b87e75
BM
147 else if (SvTYPE(tmpstr) == SVt_REGEXP)
148 re = (REGEXP*) tmpstr;
149
5c35adbb 150 if (re) {
69dc4b30
FC
151 /* The match's LHS's get-magic might need to access this op's reg-
152 exp (as is sometimes the case with $'; see bug 70764). So we
153 must call get-magic now before we replace the regexp. Hopeful-
154 ly this hack can be replaced with the approach described at
155 http://www.nntp.perl.org/group/perl.perl5.porters/2007/03
156 /msg122415.html some day. */
455d9033
FC
157 if(pm->op_type == OP_MATCH) {
158 SV *lhs;
159 const bool was_tainted = PL_tainted;
160 if (pm->op_flags & OPf_STACKED)
69dc4b30 161 lhs = TOPs;
455d9033
FC
162 else if (pm->op_private & OPpTARGET_MY)
163 lhs = PAD_SV(pm->op_targ);
164 else lhs = DEFSV;
165 SvGETMAGIC(lhs);
166 /* Restore the previous value of PL_tainted (which may have been
167 modified by get-magic), to avoid incorrectly setting the
168 RXf_TAINTED flag further down. */
169 PL_tainted = was_tainted;
170 }
69dc4b30 171
f0826785 172 re = reg_temp_copy(NULL, re);
aaa362c4 173 ReREFCNT_dec(PM_GETRE(pm));
28d8d7f4 174 PM_SETRE(pm, re);
c277df42
IZ
175 }
176 else {
f3ec07c7
DM
177 STRLEN len = 0;
178 const char *t = SvOK(tmpstr) ? SvPV_nomg_const(tmpstr, len) : "";
179
c737faaf 180 re = PM_GETRE(pm);
14a49a24 181 assert (re != (REGEXP*) &PL_sv_undef);
c277df42 182
20408e3c 183 /* Check against the last compiled regexp. */
a11c8683 184 if (!re || !RX_PRECOMP(re) || RX_PRELEN(re) != len ||
220fc49f 185 memNE(RX_PRECOMP(re), t, len))
85aff577 186 {
07bc277f 187 const regexp_engine *eng = re ? RX_ENGINE(re) : NULL;
c737faaf 188 U32 pm_flags = pm->op_pmflags & PMf_COMPILETIME;
d8f6592e
AL
189 if (re) {
190 ReREFCNT_dec(re);
14a49a24
NC
191#ifdef USE_ITHREADS
192 PM_SETRE(pm, (REGEXP*) &PL_sv_undef);
193#else
4608196e 194 PM_SETRE(pm, NULL); /* crucial if regcomp aborts */
14a49a24 195#endif
1e2e3d02 196 } else if (PL_curcop->cop_hints_hash) {
20439bc7 197 SV *ptr = cop_hints_fetch_pvs(PL_curcop, "regcomp", 0);
1e2e3d02
YO
198 if (ptr && SvIOK(ptr) && SvIV(ptr))
199 eng = INT2PTR(regexp_engine*,SvIV(ptr));
c277df42 200 }
664e119d 201
533c011a 202 if (PL_op->op_flags & OPf_SPECIAL)
3280af22 203 PL_reginterp_cnt = I32_MAX; /* Mark as safe. */
a0d0e21e 204
b9ad30b4
NC
205 if (DO_UTF8(tmpstr)) {
206 assert (SvUTF8(tmpstr));
207 } else if (SvUTF8(tmpstr)) {
208 /* Not doing UTF-8, despite what the SV says. Is this only if
209 we're trapped in use 'bytes'? */
210 /* Make a copy of the octet sequence, but without the flag on,
211 as the compiler now honours the SvUTF8 flag on tmpstr. */
212 STRLEN len;
213 const char *const p = SvPV(tmpstr, len);
214 tmpstr = newSVpvn_flags(p, len, SVs_TEMP);
215 }
f3ec07c7
DM
216 else if (SvAMAGIC(tmpstr)) {
217 /* make a copy to avoid extra stringifies */
0479a84a 218 tmpstr = newSVpvn_flags(t, len, SVs_TEMP | SvUTF8(tmpstr));
f3ec07c7 219 }
c737faaf 220
a9984b10
FC
221 /* If it is gmagical, create a mortal copy, but without calling
222 get-magic, as we have already done that. */
223 if(SvGMAGICAL(tmpstr)) {
224 SV *mortalcopy = sv_newmortal();
225 sv_setsv_flags(mortalcopy, tmpstr, 0);
226 tmpstr = mortalcopy;
227 }
228
5a8697a7 229 if (eng)
3ab4a224 230 PM_SETRE(pm, CALLREGCOMP_ENG(eng, tmpstr, pm_flags));
5a8697a7 231 else
3ab4a224 232 PM_SETRE(pm, CALLREGCOMP(tmpstr, pm_flags));
c737faaf 233
f86aaa29 234 PL_reginterp_cnt = 0; /* XXXX Be extra paranoid - needed
2cd61cdb 235 inside tie/overload accessors. */
c277df42 236 }
4633a7c4 237 }
c737faaf
YO
238
239 re = PM_GETRE(pm);
a0d0e21e 240
72311751 241#ifndef INCOMPLETE_TAINTS
3280af22
NIS
242 if (PL_tainting) {
243 if (PL_tainted)
07bc277f 244 RX_EXTFLAGS(re) |= RXf_TAINTED;
72311751 245 else
07bc277f 246 RX_EXTFLAGS(re) &= ~RXf_TAINTED;
72311751
GS
247 }
248#endif
249
220fc49f 250 if (!RX_PRELEN(PM_GETRE(pm)) && PL_curpm)
3280af22 251 pm = PL_curpm;
a0d0e21e 252
c737faaf
YO
253
254#if !defined(USE_ITHREADS)
255 /* can't change the optree at runtime either */
256 /* PMf_KEEP is handled differently under threads to avoid these problems */
a0d0e21e 257 if (pm->op_pmflags & PMf_KEEP) {
c90c0ff4 258 pm->op_private &= ~OPpRUNTIME; /* no point compiling again */
533c011a 259 cLOGOP->op_first->op_next = PL_op->op_next;
a0d0e21e 260 }
c737faaf 261#endif
a0d0e21e
LW
262 RETURN;
263}
264
265PP(pp_substcont)
266{
97aff369 267 dVAR;
39644a26 268 dSP;
c09156bb 269 register PERL_CONTEXT *cx = &cxstack[cxstack_ix];
901017d6
AL
270 register PMOP * const pm = (PMOP*) cLOGOP->op_other;
271 register SV * const dstr = cx->sb_dstr;
a0d0e21e
LW
272 register char *s = cx->sb_s;
273 register char *m = cx->sb_m;
274 char *orig = cx->sb_orig;
901017d6 275 register REGEXP * const rx = cx->sb_rx;
c445ea15 276 SV *nsv = NULL;
988e6e7e 277 REGEXP *old = PM_GETRE(pm);
f410a211
NC
278
279 PERL_ASYNC_CHECK();
280
988e6e7e 281 if(old != rx) {
bfed75c6 282 if(old)
988e6e7e 283 ReREFCNT_dec(old);
d6106309 284 PM_SETRE(pm,ReREFCNT_inc(rx));
d8f2cf8a
AB
285 }
286
d9f97599 287 rxres_restore(&cx->sb_rxres, rx);
01b35787 288 RX_MATCH_UTF8_set(rx, DO_UTF8(cx->sb_targ));
c90c0ff4 289
a0d0e21e 290 if (cx->sb_iters++) {
a3b680e6 291 const I32 saviters = cx->sb_iters;
a0d0e21e 292 if (cx->sb_iters > cx->sb_maxiters)
cea2e8a9 293 DIE(aTHX_ "Substitution loop");
a0d0e21e 294
447ee134
DM
295 SvGETMAGIC(TOPs); /* possibly clear taint on $1 etc: #67962 */
296
48c036b1
GS
297 if (!(cx->sb_rxtainted & 2) && SvTAINTED(TOPs))
298 cx->sb_rxtainted |= 2;
447ee134 299 sv_catsv_nomg(dstr, POPs);
2c296965
YO
300 /* XXX: adjust for positive offsets of \G for instance s/(.)\G//g with positive pos() */
301 s -= RX_GOFS(rx);
a0d0e21e
LW
302
303 /* Are we done */
2c296965
YO
304 if (CxONCE(cx) || s < orig ||
305 !CALLREGEXEC(rx, s, cx->sb_strend, orig,
306 (s == m) + RX_GOFS(rx), cx->sb_targ, NULL,
307 ((cx->sb_rflags & REXEC_COPY_STR)
308 ? (REXEC_IGNOREPOS|REXEC_NOT_FIRST)
309 : (REXEC_COPY_STR|REXEC_IGNOREPOS|REXEC_NOT_FIRST))))
a0d0e21e 310 {
823a54a3 311 SV * const targ = cx->sb_targ;
748a9306 312
078c425b
JH
313 assert(cx->sb_strend >= s);
314 if(cx->sb_strend > s) {
315 if (DO_UTF8(dstr) && !SvUTF8(targ))
316 sv_catpvn_utf8_upgrade(dstr, s, cx->sb_strend - s, nsv);
317 else
318 sv_catpvn(dstr, s, cx->sb_strend - s);
319 }
48c036b1 320 cx->sb_rxtainted |= RX_MATCH_TAINTED(rx);
9212bbba 321
f8c7b90f 322#ifdef PERL_OLD_COPY_ON_WRITE
ed252734
NC
323 if (SvIsCOW(targ)) {
324 sv_force_normal_flags(targ, SV_COW_DROP_PV);
325 } else
326#endif
327 {
8bd4d4c5 328 SvPV_free(targ);
ed252734 329 }
f880fe2f 330 SvPV_set(targ, SvPVX(dstr));
748a9306
LW
331 SvCUR_set(targ, SvCUR(dstr));
332 SvLEN_set(targ, SvLEN(dstr));
1aa99e6b
IH
333 if (DO_UTF8(dstr))
334 SvUTF8_on(targ);
6136c704 335 SvPV_set(dstr, NULL);
48c036b1
GS
336
337 TAINT_IF(cx->sb_rxtainted & 1);
4f4d7508
DC
338 if (pm->op_pmflags & PMf_NONDESTRUCT)
339 PUSHs(targ);
340 else
341 mPUSHi(saviters - 1);
48c036b1 342
ffc61ed2 343 (void)SvPOK_only_UTF8(targ);
48c036b1 344 TAINT_IF(cx->sb_rxtainted);
a0d0e21e 345 SvSETMAGIC(targ);
9212bbba 346 SvTAINT(targ);
5cd24f17 347
4633a7c4 348 LEAVE_SCOPE(cx->sb_oldsave);
a0d0e21e
LW
349 POPSUBST(cx);
350 RETURNOP(pm->op_next);
351 }
8e5e9ebe 352 cx->sb_iters = saviters;
a0d0e21e 353 }
07bc277f 354 if (RX_MATCH_COPIED(rx) && RX_SUBBEG(rx) != orig) {
a0d0e21e
LW
355 m = s;
356 s = orig;
07bc277f 357 cx->sb_orig = orig = RX_SUBBEG(rx);
a0d0e21e
LW
358 s = orig + (m - s);
359 cx->sb_strend = s + (cx->sb_strend - m);
360 }
07bc277f 361 cx->sb_m = m = RX_OFFS(rx)[0].start + orig;
db79b45b 362 if (m > s) {
bfed75c6 363 if (DO_UTF8(dstr) && !SvUTF8(cx->sb_targ))
db79b45b
JH
364 sv_catpvn_utf8_upgrade(dstr, s, m - s, nsv);
365 else
366 sv_catpvn(dstr, s, m-s);
367 }
07bc277f 368 cx->sb_s = RX_OFFS(rx)[0].end + orig;
084916e3 369 { /* Update the pos() information. */
44f8325f 370 SV * const sv = cx->sb_targ;
084916e3 371 MAGIC *mg;
7a7f3e45 372 SvUPGRADE(sv, SVt_PVMG);
14befaf4 373 if (!(mg = mg_find(sv, PERL_MAGIC_regex_global))) {
d83f0a82 374#ifdef PERL_OLD_COPY_ON_WRITE
51a9ea20 375 if (SvIsCOW(sv))
d83f0a82
NC
376 sv_force_normal_flags(sv, 0);
377#endif
378 mg = sv_magicext(sv, NULL, PERL_MAGIC_regex_global, &PL_vtbl_mglob,
379 NULL, 0);
084916e3 380 }
ce474962 381 mg->mg_len = m - orig;
084916e3 382 }
988e6e7e 383 if (old != rx)
d6106309 384 (void)ReREFCNT_inc(rx);
d9f97599
GS
385 cx->sb_rxtainted |= RX_MATCH_TAINTED(rx);
386 rxres_save(&cx->sb_rxres, rx);
af9838cc 387 PL_curpm = pm;
29f2e912 388 RETURNOP(pm->op_pmstashstartu.op_pmreplstart);
a0d0e21e
LW
389}
390
c90c0ff4 391void
864dbfa3 392Perl_rxres_save(pTHX_ void **rsp, REGEXP *rx)
c90c0ff4
PP
393{
394 UV *p = (UV*)*rsp;
395 U32 i;
7918f24d
NC
396
397 PERL_ARGS_ASSERT_RXRES_SAVE;
96a5add6 398 PERL_UNUSED_CONTEXT;
c90c0ff4 399
07bc277f 400 if (!p || p[1] < RX_NPARENS(rx)) {
f8c7b90f 401#ifdef PERL_OLD_COPY_ON_WRITE
07bc277f 402 i = 7 + RX_NPARENS(rx) * 2;
ed252734 403#else
07bc277f 404 i = 6 + RX_NPARENS(rx) * 2;
ed252734 405#endif
c90c0ff4 406 if (!p)
a02a5408 407 Newx(p, i, UV);
c90c0ff4
PP
408 else
409 Renew(p, i, UV);
410 *rsp = (void*)p;
411 }
412
07bc277f 413 *p++ = PTR2UV(RX_MATCH_COPIED(rx) ? RX_SUBBEG(rx) : NULL);
cf93c79d 414 RX_MATCH_COPIED_off(rx);
c90c0ff4 415
f8c7b90f 416#ifdef PERL_OLD_COPY_ON_WRITE
bdd9a1b1
NC
417 *p++ = PTR2UV(RX_SAVED_COPY(rx));
418 RX_SAVED_COPY(rx) = NULL;
ed252734
NC
419#endif
420
07bc277f 421 *p++ = RX_NPARENS(rx);
c90c0ff4 422
07bc277f
NC
423 *p++ = PTR2UV(RX_SUBBEG(rx));
424 *p++ = (UV)RX_SUBLEN(rx);
425 for (i = 0; i <= RX_NPARENS(rx); ++i) {
426 *p++ = (UV)RX_OFFS(rx)[i].start;
427 *p++ = (UV)RX_OFFS(rx)[i].end;
c90c0ff4
PP
428 }
429}
430
9c105995
NC
431static void
432S_rxres_restore(pTHX_ void **rsp, REGEXP *rx)
c90c0ff4
PP
433{
434 UV *p = (UV*)*rsp;
435 U32 i;
7918f24d
NC
436
437 PERL_ARGS_ASSERT_RXRES_RESTORE;
96a5add6 438 PERL_UNUSED_CONTEXT;
c90c0ff4 439
ed252734 440 RX_MATCH_COPY_FREE(rx);
cf93c79d 441 RX_MATCH_COPIED_set(rx, *p);
c90c0ff4
PP
442 *p++ = 0;
443
f8c7b90f 444#ifdef PERL_OLD_COPY_ON_WRITE
bdd9a1b1
NC
445 if (RX_SAVED_COPY(rx))
446 SvREFCNT_dec (RX_SAVED_COPY(rx));
447 RX_SAVED_COPY(rx) = INT2PTR(SV*,*p);
ed252734
NC
448 *p++ = 0;
449#endif
450
07bc277f 451 RX_NPARENS(rx) = *p++;
c90c0ff4 452
07bc277f
NC
453 RX_SUBBEG(rx) = INT2PTR(char*,*p++);
454 RX_SUBLEN(rx) = (I32)(*p++);
455 for (i = 0; i <= RX_NPARENS(rx); ++i) {
456 RX_OFFS(rx)[i].start = (I32)(*p++);
457 RX_OFFS(rx)[i].end = (I32)(*p++);
c90c0ff4
PP
458 }
459}
460
9c105995
NC
461static void
462S_rxres_free(pTHX_ void **rsp)
c90c0ff4 463{
44f8325f 464 UV * const p = (UV*)*rsp;
7918f24d
NC
465
466 PERL_ARGS_ASSERT_RXRES_FREE;
96a5add6 467 PERL_UNUSED_CONTEXT;
c90c0ff4
PP
468
469 if (p) {
94010e71
NC
470#ifdef PERL_POISON
471 void *tmp = INT2PTR(char*,*p);
472 Safefree(tmp);
473 if (*p)
7e337ee0 474 PoisonFree(*p, 1, sizeof(*p));
94010e71 475#else
56431972 476 Safefree(INT2PTR(char*,*p));
94010e71 477#endif
f8c7b90f 478#ifdef PERL_OLD_COPY_ON_WRITE
ed252734
NC
479 if (p[1]) {
480 SvREFCNT_dec (INT2PTR(SV*,p[1]));
481 }
482#endif
c90c0ff4 483 Safefree(p);
4608196e 484 *rsp = NULL;
c90c0ff4
PP
485 }
486}
487
a0d0e21e
LW
488PP(pp_formline)
489{
97aff369 490 dVAR; dSP; dMARK; dORIGMARK;
823a54a3 491 register SV * const tmpForm = *++MARK;
dea28490 492 register U32 *fpc;
a0d0e21e 493 register char *t;
245d4a47 494 const char *f;
a0d0e21e 495 register I32 arg;
c445ea15
AL
496 register SV *sv = NULL;
497 const char *item = NULL;
9c5ffd7c
JH
498 I32 itemsize = 0;
499 I32 fieldsize = 0;
a0d0e21e 500 I32 lines = 0;
c445ea15
AL
501 bool chopspace = (strchr(PL_chopset, ' ') != NULL);
502 const char *chophere = NULL;
503 char *linemark = NULL;
65202027 504 NV value;
9c5ffd7c 505 bool gotsome = FALSE;
a0d0e21e 506 STRLEN len;
823a54a3 507 const STRLEN fudge = SvPOK(tmpForm)
24c89738 508 ? (SvCUR(tmpForm) * (IN_BYTES ? 1 : 3) + 1) : 0;
1bd51a4c
IH
509 bool item_is_utf8 = FALSE;
510 bool targ_is_utf8 = FALSE;
c445ea15 511 SV * nsv = NULL;
cbbf8932 512 OP * parseres = NULL;
bfed75c6 513 const char *fmt;
a0d0e21e 514
76e3520e 515 if (!SvMAGICAL(tmpForm) || !SvCOMPILED(tmpForm)) {
445b3f51
GS
516 if (SvREADONLY(tmpForm)) {
517 SvREADONLY_off(tmpForm);
a1b95068 518 parseres = doparseform(tmpForm);
445b3f51
GS
519 SvREADONLY_on(tmpForm);
520 }
521 else
a1b95068
LW
522 parseres = doparseform(tmpForm);
523 if (parseres)
524 return parseres;
a0d0e21e 525 }
3280af22 526 SvPV_force(PL_formtarget, len);
1bd51a4c
IH
527 if (DO_UTF8(PL_formtarget))
528 targ_is_utf8 = TRUE;
a0ed51b3 529 t = SvGROW(PL_formtarget, len + fudge + 1); /* XXX SvCUR bad */
a0d0e21e 530 t += len;
245d4a47 531 f = SvPV_const(tmpForm, len);
a0d0e21e 532 /* need to jump to the next word */
245d4a47 533 fpc = (U32*)(f + len + WORD_ALIGN - SvCUR(tmpForm) % WORD_ALIGN);
a0d0e21e
LW
534
535 for (;;) {
536 DEBUG_f( {
bfed75c6 537 const char *name = "???";
a0d0e21e
LW
538 arg = -1;
539 switch (*fpc) {
540 case FF_LITERAL: arg = fpc[1]; name = "LITERAL"; break;
541 case FF_BLANK: arg = fpc[1]; name = "BLANK"; break;
542 case FF_SKIP: arg = fpc[1]; name = "SKIP"; break;
543 case FF_FETCH: arg = fpc[1]; name = "FETCH"; break;
544 case FF_DECIMAL: arg = fpc[1]; name = "DECIMAL"; break;
545
546 case FF_CHECKNL: name = "CHECKNL"; break;
547 case FF_CHECKCHOP: name = "CHECKCHOP"; break;
548 case FF_SPACE: name = "SPACE"; break;
549 case FF_HALFSPACE: name = "HALFSPACE"; break;
550 case FF_ITEM: name = "ITEM"; break;
551 case FF_CHOP: name = "CHOP"; break;
552 case FF_LINEGLOB: name = "LINEGLOB"; break;
553 case FF_NEWLINE: name = "NEWLINE"; break;
554 case FF_MORE: name = "MORE"; break;
555 case FF_LINEMARK: name = "LINEMARK"; break;
556 case FF_END: name = "END"; break;
bfed75c6 557 case FF_0DECIMAL: name = "0DECIMAL"; break;
a1b95068 558 case FF_LINESNGL: name = "LINESNGL"; break;
a0d0e21e
LW
559 }
560 if (arg >= 0)
bf49b057 561 PerlIO_printf(Perl_debug_log, "%-16s%ld\n", name, (long) arg);
a0d0e21e 562 else
bf49b057 563 PerlIO_printf(Perl_debug_log, "%-16s\n", name);
5f80b19c 564 } );
a0d0e21e
LW
565 switch (*fpc++) {
566 case FF_LINEMARK:
567 linemark = t;
a0d0e21e
LW
568 lines++;
569 gotsome = FALSE;
570 break;
571
572 case FF_LITERAL:
573 arg = *fpc++;
1bd51a4c 574 if (targ_is_utf8 && !SvUTF8(tmpForm)) {
b15aece3 575 SvCUR_set(PL_formtarget, t - SvPVX_const(PL_formtarget));
78da4d13
JH
576 *t = '\0';
577 sv_catpvn_utf8_upgrade(PL_formtarget, f, arg, nsv);
578 t = SvEND(PL_formtarget);
f3f2f1a3 579 f += arg;
1bd51a4c
IH
580 break;
581 }
582 if (!targ_is_utf8 && DO_UTF8(tmpForm)) {
b15aece3 583 SvCUR_set(PL_formtarget, t - SvPVX_const(PL_formtarget));
1bd51a4c 584 *t = '\0';
7bf79863 585 sv_utf8_upgrade_flags_grow(PL_formtarget, SV_GMAGIC, fudge + 1);
1bd51a4c
IH
586 t = SvEND(PL_formtarget);
587 targ_is_utf8 = TRUE;
588 }
a0d0e21e
LW
589 while (arg--)
590 *t++ = *f++;
591 break;
592
593 case FF_SKIP:
594 f += *fpc++;
595 break;
596
597 case FF_FETCH:
598 arg = *fpc++;
599 f += arg;
600 fieldsize = arg;
601
602 if (MARK < SP)
603 sv = *++MARK;
604 else {
3280af22 605 sv = &PL_sv_no;
a2a5de95 606 Perl_ck_warner(aTHX_ packWARN(WARN_SYNTAX), "Not enough format arguments");
a0d0e21e
LW
607 }
608 break;
609
610 case FF_CHECKNL:
5a34cab7
NC
611 {
612 const char *send;
613 const char *s = item = SvPV_const(sv, len);
614 itemsize = len;
615 if (DO_UTF8(sv)) {
616 itemsize = sv_len_utf8(sv);
617 if (itemsize != (I32)len) {
618 I32 itembytes;
619 if (itemsize > fieldsize) {
620 itemsize = fieldsize;
621 itembytes = itemsize;
622 sv_pos_u2b(sv, &itembytes, 0);
623 }
624 else
625 itembytes = len;
626 send = chophere = s + itembytes;
627 while (s < send) {
628 if (*s & ~31)
629 gotsome = TRUE;
630 else if (*s == '\n')
631 break;
632 s++;
633 }
634 item_is_utf8 = TRUE;
635 itemsize = s - item;
636 sv_pos_b2u(sv, &itemsize);
637 break;
a0ed51b3 638 }
a0ed51b3 639 }
5a34cab7
NC
640 item_is_utf8 = FALSE;
641 if (itemsize > fieldsize)
642 itemsize = fieldsize;
643 send = chophere = s + itemsize;
644 while (s < send) {
645 if (*s & ~31)
646 gotsome = TRUE;
647 else if (*s == '\n')
648 break;
649 s++;
650 }
651 itemsize = s - item;
652 break;
a0ed51b3 653 }
a0d0e21e
LW
654
655 case FF_CHECKCHOP:
5a34cab7
NC
656 {
657 const char *s = item = SvPV_const(sv, len);
658 itemsize = len;
659 if (DO_UTF8(sv)) {
660 itemsize = sv_len_utf8(sv);
661 if (itemsize != (I32)len) {
662 I32 itembytes;
663 if (itemsize <= fieldsize) {
664 const char *send = chophere = s + itemsize;
665 while (s < send) {
666 if (*s == '\r') {
667 itemsize = s - item;
a0ed51b3 668 chophere = s;
a0ed51b3 669 break;
5a34cab7
NC
670 }
671 if (*s++ & ~31)
a0ed51b3 672 gotsome = TRUE;
a0ed51b3 673 }
a0ed51b3 674 }
5a34cab7
NC
675 else {
676 const char *send;
677 itemsize = fieldsize;
678 itembytes = itemsize;
679 sv_pos_u2b(sv, &itembytes, 0);
680 send = chophere = s + itembytes;
681 while (s < send || (s == send && isSPACE(*s))) {
682 if (isSPACE(*s)) {
683 if (chopspace)
684 chophere = s;
685 if (*s == '\r')
686 break;
687 }
688 else {
689 if (*s & ~31)
690 gotsome = TRUE;
691 if (strchr(PL_chopset, *s))
692 chophere = s + 1;
693 }
694 s++;
695 }
696 itemsize = chophere - item;
697 sv_pos_b2u(sv, &itemsize);
698 }
699 item_is_utf8 = TRUE;
a0d0e21e
LW
700 break;
701 }
a0d0e21e 702 }
5a34cab7
NC
703 item_is_utf8 = FALSE;
704 if (itemsize <= fieldsize) {
705 const char *const send = chophere = s + itemsize;
706 while (s < send) {
707 if (*s == '\r') {
708 itemsize = s - item;
a0d0e21e 709 chophere = s;
a0d0e21e 710 break;
5a34cab7
NC
711 }
712 if (*s++ & ~31)
a0d0e21e 713 gotsome = TRUE;
a0d0e21e 714 }
a0d0e21e 715 }
5a34cab7
NC
716 else {
717 const char *send;
718 itemsize = fieldsize;
719 send = chophere = s + itemsize;
720 while (s < send || (s == send && isSPACE(*s))) {
721 if (isSPACE(*s)) {
722 if (chopspace)
723 chophere = s;
724 if (*s == '\r')
725 break;
726 }
727 else {
728 if (*s & ~31)
729 gotsome = TRUE;
730 if (strchr(PL_chopset, *s))
731 chophere = s + 1;
732 }
733 s++;
734 }
735 itemsize = chophere - item;
736 }
737 break;
a0d0e21e 738 }
a0d0e21e
LW
739
740 case FF_SPACE:
741 arg = fieldsize - itemsize;
742 if (arg) {
743 fieldsize -= arg;
744 while (arg-- > 0)
745 *t++ = ' ';
746 }
747 break;
748
749 case FF_HALFSPACE:
750 arg = fieldsize - itemsize;
751 if (arg) {
752 arg /= 2;
753 fieldsize -= arg;
754 while (arg-- > 0)
755 *t++ = ' ';
756 }
757 break;
758
759 case FF_ITEM:
5a34cab7
NC
760 {
761 const char *s = item;
762 arg = itemsize;
763 if (item_is_utf8) {
764 if (!targ_is_utf8) {
765 SvCUR_set(PL_formtarget, t - SvPVX_const(PL_formtarget));
766 *t = '\0';
7bf79863
KW
767 sv_utf8_upgrade_flags_grow(PL_formtarget, SV_GMAGIC,
768 fudge + 1);
5a34cab7
NC
769 t = SvEND(PL_formtarget);
770 targ_is_utf8 = TRUE;
a0ed51b3 771 }
5a34cab7
NC
772 while (arg--) {
773 if (UTF8_IS_CONTINUED(*s)) {
774 STRLEN skip = UTF8SKIP(s);
775 switch (skip) {
776 default:
777 Move(s,t,skip,char);
778 s += skip;
779 t += skip;
780 break;
781 case 7: *t++ = *s++;
782 case 6: *t++ = *s++;
783 case 5: *t++ = *s++;
784 case 4: *t++ = *s++;
785 case 3: *t++ = *s++;
786 case 2: *t++ = *s++;
787 case 1: *t++ = *s++;
788 }
789 }
790 else {
791 if ( !((*t++ = *s++) & ~31) )
792 t[-1] = ' ';
793 }
a0ed51b3 794 }
5a34cab7 795 break;
a0ed51b3 796 }
5a34cab7
NC
797 if (targ_is_utf8 && !item_is_utf8) {
798 SvCUR_set(PL_formtarget, t - SvPVX_const(PL_formtarget));
799 *t = '\0';
800 sv_catpvn_utf8_upgrade(PL_formtarget, s, arg, nsv);
801 for (; t < SvEND(PL_formtarget); t++) {
78da4d13 802#ifdef EBCDIC
901017d6 803 const int ch = *t;
5a34cab7 804 if (iscntrl(ch))
78da4d13 805#else
5a34cab7 806 if (!(*t & ~31))
78da4d13 807#endif
5a34cab7
NC
808 *t = ' ';
809 }
810 break;
78da4d13 811 }
5a34cab7 812 while (arg--) {
9d116dd7 813#ifdef EBCDIC
901017d6 814 const int ch = *t++ = *s++;
5a34cab7 815 if (iscntrl(ch))
a0d0e21e 816#else
5a34cab7 817 if ( !((*t++ = *s++) & ~31) )
a0d0e21e 818#endif
5a34cab7
NC
819 t[-1] = ' ';
820 }
821 break;
a0d0e21e 822 }
a0d0e21e
LW
823
824 case FF_CHOP:
5a34cab7
NC
825 {
826 const char *s = chophere;
827 if (chopspace) {
af68e756 828 while (isSPACE(*s))
5a34cab7
NC
829 s++;
830 }
831 sv_chop(sv,s);
832 SvSETMAGIC(sv);
833 break;
a0d0e21e 834 }
a0d0e21e 835
a1b95068
LW
836 case FF_LINESNGL:
837 chopspace = 0;
a0d0e21e 838 case FF_LINEGLOB:
5a34cab7 839 {
e32383e2 840 const bool oneline = fpc[-1] == FF_LINESNGL;
5a34cab7 841 const char *s = item = SvPV_const(sv, len);
f3f2f1a3 842 item_is_utf8 = DO_UTF8(sv);
5a34cab7 843 itemsize = len;
5a34cab7 844 if (itemsize) {
e8e72d41 845 STRLEN to_copy = itemsize;
5a34cab7 846 const char *const send = s + len;
35c6393c 847 const U8 *source = (const U8 *) s;
e8e72d41
NC
848 U8 *tmp = NULL;
849
5a34cab7
NC
850 gotsome = TRUE;
851 chophere = s + itemsize;
852 while (s < send) {
853 if (*s++ == '\n') {
854 if (oneline) {
e8e72d41 855 to_copy = s - SvPVX_const(sv) - 1;
5a34cab7
NC
856 chophere = s;
857 break;
858 } else {
859 if (s == send) {
860 itemsize--;
e8e72d41 861 to_copy--;
5a34cab7
NC
862 } else
863 lines++;
864 }
1bd51a4c 865 }
a0d0e21e 866 }
e8e72d41 867 if (targ_is_utf8 && !item_is_utf8) {
35c6393c 868 source = tmp = bytes_to_utf8(source, &to_copy);
e8e72d41
NC
869 SvCUR_set(PL_formtarget,
870 t - SvPVX_const(PL_formtarget));
871 } else {
872 if (item_is_utf8 && !targ_is_utf8) {
873 /* Upgrade targ to UTF8, and then we reduce it to
874 a problem we have a simple solution for. */
875 SvCUR_set(PL_formtarget,
876 t - SvPVX_const(PL_formtarget));
877 targ_is_utf8 = TRUE;
878 /* Don't need get magic. */
7bf79863 879 sv_utf8_upgrade_nomg(PL_formtarget);
e8e72d41
NC
880 } else {
881 SvCUR_set(PL_formtarget,
882 t - SvPVX_const(PL_formtarget));
883 }
e8e72d41
NC
884
885 /* Easy. They agree. */
886 assert (item_is_utf8 == targ_is_utf8);
887 }
888 SvGROW(PL_formtarget,
889 SvCUR(PL_formtarget) + to_copy + fudge + 1);
5a34cab7 890 t = SvPVX(PL_formtarget) + SvCUR(PL_formtarget);
e8e72d41
NC
891
892 Copy(source, t, to_copy, char);
893 t += to_copy;
894 SvCUR_set(PL_formtarget, SvCUR(PL_formtarget) + to_copy);
f3f2f1a3 895 if (item_is_utf8) {
e8e72d41
NC
896 if (SvGMAGICAL(sv)) {
897 /* Mustn't call sv_pos_b2u() as it does a second
898 mg_get(). Is this a bug? Do we need a _flags()
899 variant? */
900 itemsize = utf8_length(source, source + itemsize);
901 } else {
902 sv_pos_b2u(sv, &itemsize);
903 }
904 assert(!tmp);
905 } else if (tmp) {
906 Safefree(tmp);
f3f2f1a3 907 }
a0d0e21e 908 }
5a34cab7 909 break;
a0d0e21e 910 }
a0d0e21e 911
a1b95068
LW
912 case FF_0DECIMAL:
913 arg = *fpc++;
914#if defined(USE_LONG_DOUBLE)
10edeb5d
JH
915 fmt = (const char *)
916 ((arg & 256) ?
917 "%#0*.*" PERL_PRIfldbl : "%0*.*" PERL_PRIfldbl);
a1b95068 918#else
10edeb5d
JH
919 fmt = (const char *)
920 ((arg & 256) ?
921 "%#0*.*f" : "%0*.*f");
a1b95068
LW
922#endif
923 goto ff_dec;
a0d0e21e 924 case FF_DECIMAL:
a0d0e21e 925 arg = *fpc++;
65202027 926#if defined(USE_LONG_DOUBLE)
10edeb5d
JH
927 fmt = (const char *)
928 ((arg & 256) ? "%#*.*" PERL_PRIfldbl : "%*.*" PERL_PRIfldbl);
65202027 929#else
10edeb5d
JH
930 fmt = (const char *)
931 ((arg & 256) ? "%#*.*f" : "%*.*f");
65202027 932#endif
a1b95068 933 ff_dec:
784707d5
JP
934 /* If the field is marked with ^ and the value is undefined,
935 blank it out. */
784707d5
JP
936 if ((arg & 512) && !SvOK(sv)) {
937 arg = fieldsize;
938 while (arg--)
939 *t++ = ' ';
940 break;
941 }
942 gotsome = TRUE;
943 value = SvNV(sv);
a1b95068 944 /* overflow evidence */
bfed75c6 945 if (num_overflow(value, fieldsize, arg)) {
a1b95068
LW
946 arg = fieldsize;
947 while (arg--)
948 *t++ = '#';
949 break;
950 }
784707d5
JP
951 /* Formats aren't yet marked for locales, so assume "yes". */
952 {
953 STORE_NUMERIC_STANDARD_SET_LOCAL();
d9fad198 954 my_snprintf(t, SvLEN(PL_formtarget) - (t - SvPVX(PL_formtarget)), fmt, (int) fieldsize, (int) arg & 255, value);
784707d5
JP
955 RESTORE_NUMERIC_STANDARD();
956 }
957 t += fieldsize;
958 break;
a1b95068 959
a0d0e21e
LW
960 case FF_NEWLINE:
961 f++;
962 while (t-- > linemark && *t == ' ') ;
963 t++;
964 *t++ = '\n';
965 break;
966
967 case FF_BLANK:
968 arg = *fpc++;
969 if (gotsome) {
970 if (arg) { /* repeat until fields exhausted? */
971 *t = '\0';
b15aece3 972 SvCUR_set(PL_formtarget, t - SvPVX_const(PL_formtarget));
3280af22 973 lines += FmLINES(PL_formtarget);
1bd51a4c
IH
974 if (targ_is_utf8)
975 SvUTF8_on(PL_formtarget);
3280af22 976 FmLINES(PL_formtarget) = lines;
a0d0e21e
LW
977 SP = ORIGMARK;
978 RETURNOP(cLISTOP->op_first);
979 }
980 }
981 else {
982 t = linemark;
983 lines--;
984 }
985 break;
986
987 case FF_MORE:
5a34cab7
NC
988 {
989 const char *s = chophere;
990 const char *send = item + len;
991 if (chopspace) {
af68e756 992 while (isSPACE(*s) && (s < send))
5a34cab7 993 s++;
a0d0e21e 994 }
5a34cab7
NC
995 if (s < send) {
996 char *s1;
997 arg = fieldsize - itemsize;
998 if (arg) {
999 fieldsize -= arg;
1000 while (arg-- > 0)
1001 *t++ = ' ';
1002 }
1003 s1 = t - 3;
1004 if (strnEQ(s1," ",3)) {
1005 while (s1 > SvPVX_const(PL_formtarget) && isSPACE(s1[-1]))
1006 s1--;
1007 }
1008 *s1++ = '.';
1009 *s1++ = '.';
1010 *s1++ = '.';
a0d0e21e 1011 }
5a34cab7 1012 break;
a0d0e21e 1013 }
a0d0e21e
LW
1014 case FF_END:
1015 *t = '\0';
b15aece3 1016 SvCUR_set(PL_formtarget, t - SvPVX_const(PL_formtarget));
1bd51a4c
IH
1017 if (targ_is_utf8)
1018 SvUTF8_on(PL_formtarget);
3280af22 1019 FmLINES(PL_formtarget) += lines;
a0d0e21e
LW
1020 SP = ORIGMARK;
1021 RETPUSHYES;
1022 }
1023 }
1024}
1025
1026PP(pp_grepstart)
1027{
27da23d5 1028 dVAR; dSP;
a0d0e21e
LW
1029 SV *src;
1030
3280af22 1031 if (PL_stack_base + *PL_markstack_ptr == SP) {
a0d0e21e 1032 (void)POPMARK;
54310121 1033 if (GIMME_V == G_SCALAR)
6e449a3a 1034 mXPUSHi(0);
533c011a 1035 RETURNOP(PL_op->op_next->op_next);
a0d0e21e 1036 }
3280af22 1037 PL_stack_sp = PL_stack_base + *PL_markstack_ptr + 1;
cea2e8a9
GS
1038 pp_pushmark(); /* push dst */
1039 pp_pushmark(); /* push src */
d343c3ef 1040 ENTER_with_name("grep"); /* enter outer scope */
a0d0e21e
LW
1041
1042 SAVETMPS;
59f00321
RGS
1043 if (PL_op->op_private & OPpGREP_LEX)
1044 SAVESPTR(PAD_SVl(PL_op->op_targ));
1045 else
1046 SAVE_DEFSV;
d343c3ef 1047 ENTER_with_name("grep_item"); /* enter inner scope */
7766f137 1048 SAVEVPTR(PL_curpm);
a0d0e21e 1049
3280af22 1050 src = PL_stack_base[*PL_markstack_ptr];
a0d0e21e 1051 SvTEMP_off(src);
59f00321
RGS
1052 if (PL_op->op_private & OPpGREP_LEX)
1053 PAD_SVl(PL_op->op_targ) = src;
1054 else
414bf5ae 1055 DEFSV_set(src);
a0d0e21e
LW
1056
1057 PUTBACK;
533c011a 1058 if (PL_op->op_type == OP_MAPSTART)
cea2e8a9 1059 pp_pushmark(); /* push top */
533c011a 1060 return ((LOGOP*)PL_op->op_next)->op_other;
a0d0e21e
LW
1061}
1062
a0d0e21e
LW
1063PP(pp_mapwhile)
1064{
27da23d5 1065 dVAR; dSP;
f54cb97a 1066 const I32 gimme = GIMME_V;
544f3153 1067 I32 items = (SP - PL_stack_base) - *PL_markstack_ptr; /* how many new items */
a0d0e21e
LW
1068 I32 count;
1069 I32 shift;
1070 SV** src;
ac27b0f5 1071 SV** dst;
a0d0e21e 1072
544f3153 1073 /* first, move source pointer to the next item in the source list */
3280af22 1074 ++PL_markstack_ptr[-1];
544f3153
GS
1075
1076 /* if there are new items, push them into the destination list */
4c90a460 1077 if (items && gimme != G_VOID) {
544f3153
GS
1078 /* might need to make room back there first */
1079 if (items > PL_markstack_ptr[-1] - PL_markstack_ptr[-2]) {
1080 /* XXX this implementation is very pessimal because the stack
1081 * is repeatedly extended for every set of items. Is possible
1082 * to do this without any stack extension or copying at all
1083 * by maintaining a separate list over which the map iterates
18ef8bea 1084 * (like foreach does). --gsar */
544f3153
GS
1085
1086 /* everything in the stack after the destination list moves
1087 * towards the end the stack by the amount of room needed */
1088 shift = items - (PL_markstack_ptr[-1] - PL_markstack_ptr[-2]);
1089
1090 /* items to shift up (accounting for the moved source pointer) */
1091 count = (SP - PL_stack_base) - (PL_markstack_ptr[-1] - 1);
18ef8bea
BT
1092
1093 /* This optimization is by Ben Tilly and it does
1094 * things differently from what Sarathy (gsar)
1095 * is describing. The downside of this optimization is
1096 * that leaves "holes" (uninitialized and hopefully unused areas)
1097 * to the Perl stack, but on the other hand this
1098 * shouldn't be a problem. If Sarathy's idea gets
1099 * implemented, this optimization should become
1100 * irrelevant. --jhi */
1101 if (shift < count)
1102 shift = count; /* Avoid shifting too often --Ben Tilly */
bfed75c6 1103
924508f0
GS
1104 EXTEND(SP,shift);
1105 src = SP;
1106 dst = (SP += shift);
3280af22
NIS
1107 PL_markstack_ptr[-1] += shift;
1108 *PL_markstack_ptr += shift;
544f3153 1109 while (count--)
a0d0e21e
LW
1110 *dst-- = *src--;
1111 }
544f3153 1112 /* copy the new items down to the destination list */
ac27b0f5 1113 dst = PL_stack_base + (PL_markstack_ptr[-2] += items) - 1;
22023b26 1114 if (gimme == G_ARRAY) {
b2a2a901
DM
1115 /* add returned items to the collection (making mortal copies
1116 * if necessary), then clear the current temps stack frame
1117 * *except* for those items. We do this splicing the items
1118 * into the start of the tmps frame (so some items may be on
1119 * the tmps stack twice), then moving PL_stack_floor above
1120 * them, then freeing the frame. That way, the only tmps that
1121 * accumulate over iterations are the return values for map.
1122 * We have to do to this way so that everything gets correctly
1123 * freed if we die during the map.
1124 */
1125 I32 tmpsbase;
1126 I32 i = items;
1127 /* make space for the slice */
1128 EXTEND_MORTAL(items);
1129 tmpsbase = PL_tmps_floor + 1;
1130 Move(PL_tmps_stack + tmpsbase,
1131 PL_tmps_stack + tmpsbase + items,
1132 PL_tmps_ix - PL_tmps_floor,
1133 SV*);
1134 PL_tmps_ix += items;
1135
1136 while (i-- > 0) {
1137 SV *sv = POPs;
1138 if (!SvTEMP(sv))
1139 sv = sv_mortalcopy(sv);
1140 *dst-- = sv;
1141 PL_tmps_stack[tmpsbase++] = SvREFCNT_inc_simple(sv);
1142 }
1143 /* clear the stack frame except for the items */
1144 PL_tmps_floor += items;
1145 FREETMPS;
1146 /* FREETMPS may have cleared the TEMP flag on some of the items */
1147 i = items;
1148 while (i-- > 0)
1149 SvTEMP_on(PL_tmps_stack[--tmpsbase]);
22023b26 1150 }
bfed75c6 1151 else {
22023b26
TP
1152 /* scalar context: we don't care about which values map returns
1153 * (we use undef here). And so we certainly don't want to do mortal
1154 * copies of meaningless values. */
1155 while (items-- > 0) {
b988aa42 1156 (void)POPs;
22023b26
TP
1157 *dst-- = &PL_sv_undef;
1158 }
b2a2a901 1159 FREETMPS;
22023b26 1160 }
a0d0e21e 1161 }
b2a2a901
DM
1162 else {
1163 FREETMPS;
1164 }
d343c3ef 1165 LEAVE_with_name("grep_item"); /* exit inner scope */
a0d0e21e
LW
1166
1167 /* All done yet? */
3280af22 1168 if (PL_markstack_ptr[-1] > *PL_markstack_ptr) {
a0d0e21e
LW
1169
1170 (void)POPMARK; /* pop top */
d343c3ef 1171 LEAVE_with_name("grep"); /* exit outer scope */
a0d0e21e 1172 (void)POPMARK; /* pop src */
3280af22 1173 items = --*PL_markstack_ptr - PL_markstack_ptr[-1];
a0d0e21e 1174 (void)POPMARK; /* pop dst */
3280af22 1175 SP = PL_stack_base + POPMARK; /* pop original mark */
54310121 1176 if (gimme == G_SCALAR) {
7cc47870
RGS
1177 if (PL_op->op_private & OPpGREP_LEX) {
1178 SV* sv = sv_newmortal();
1179 sv_setiv(sv, items);
1180 PUSHs(sv);
1181 }
1182 else {
1183 dTARGET;
1184 XPUSHi(items);
1185 }
a0d0e21e 1186 }
54310121
PP
1187 else if (gimme == G_ARRAY)
1188 SP += items;
a0d0e21e
LW
1189 RETURN;
1190 }
1191 else {
1192 SV *src;
1193
d343c3ef 1194 ENTER_with_name("grep_item"); /* enter inner scope */
7766f137 1195 SAVEVPTR(PL_curpm);
a0d0e21e 1196
544f3153 1197 /* set $_ to the new source item */
3280af22 1198 src = PL_stack_base[PL_markstack_ptr[-1]];
a0d0e21e 1199 SvTEMP_off(src);
59f00321
RGS
1200 if (PL_op->op_private & OPpGREP_LEX)
1201 PAD_SVl(PL_op->op_targ) = src;
1202 else
414bf5ae 1203 DEFSV_set(src);
a0d0e21e
LW
1204
1205 RETURNOP(cLOGOP->op_other);
1206 }
1207}
1208
a0d0e21e
LW
1209/* Range stuff. */
1210
1211PP(pp_range)
1212{
97aff369 1213 dVAR;
a0d0e21e 1214 if (GIMME == G_ARRAY)
1a67a97c 1215 return NORMAL;
538573f7 1216 if (SvTRUEx(PAD_SV(PL_op->op_targ)))
1a67a97c 1217 return cLOGOP->op_other;
538573f7 1218 else
1a67a97c 1219 return NORMAL;
a0d0e21e
LW
1220}
1221
1222PP(pp_flip)
1223{
97aff369 1224 dVAR;
39644a26 1225 dSP;
a0d0e21e
LW
1226
1227 if (GIMME == G_ARRAY) {
1a67a97c 1228 RETURNOP(((LOGOP*)cUNOP->op_first)->op_other);
a0d0e21e
LW
1229 }
1230 else {
1231 dTOPss;
44f8325f 1232 SV * const targ = PAD_SV(PL_op->op_targ);
bfed75c6 1233 int flip = 0;
790090df 1234
bfed75c6 1235 if (PL_op->op_private & OPpFLIP_LINENUM) {
4e3399f9
YST
1236 if (GvIO(PL_last_in_gv)) {
1237 flip = SvIV(sv) == (IV)IoLINES(GvIOp(PL_last_in_gv));
1238 }
1239 else {
fafc274c 1240 GV * const gv = gv_fetchpvs(".", GV_ADD|GV_NOTQUAL, SVt_PV);
44f8325f
AL
1241 if (gv && GvSV(gv))
1242 flip = SvIV(sv) == SvIV(GvSV(gv));
4e3399f9 1243 }
bfed75c6
AL
1244 } else {
1245 flip = SvTRUE(sv);
1246 }
1247 if (flip) {
a0d0e21e 1248 sv_setiv(PAD_SV(cUNOP->op_first->op_targ), 1);
533c011a 1249 if (PL_op->op_flags & OPf_SPECIAL) {
a0d0e21e 1250 sv_setiv(targ, 1);
3e3baf6d 1251 SETs(targ);
a0d0e21e
LW
1252 RETURN;
1253 }
1254 else {
1255 sv_setiv(targ, 0);
924508f0 1256 SP--;
1a67a97c 1257 RETURNOP(((LOGOP*)cUNOP->op_first)->op_other);
a0d0e21e
LW
1258 }
1259 }
76f68e9b 1260 sv_setpvs(TARG, "");
a0d0e21e
LW
1261 SETs(targ);
1262 RETURN;
1263 }
1264}
1265
8e9bbdb9
RGS
1266/* This code tries to decide if "$left .. $right" should use the
1267 magical string increment, or if the range is numeric (we make
1268 an exception for .."0" [#18165]). AMS 20021031. */
1269
1270#define RANGE_IS_NUMERIC(left,right) ( \
b0e74086
RGS
1271 SvNIOKp(left) || (SvOK(left) && !SvPOKp(left)) || \
1272 SvNIOKp(right) || (SvOK(right) && !SvPOKp(right)) || \
e0ab1c0e 1273 (((!SvOK(left) && SvOK(right)) || ((!SvOK(left) || \
b15aece3 1274 looks_like_number(left)) && SvPOKp(left) && *SvPVX_const(left) != '0')) \
e0ab1c0e 1275 && (!SvOK(right) || looks_like_number(right))))
8e9bbdb9 1276
a0d0e21e
LW
1277PP(pp_flop)
1278{
97aff369 1279 dVAR; dSP;
a0d0e21e
LW
1280
1281 if (GIMME == G_ARRAY) {
1282 dPOPPOPssrl;
86cb7173 1283
5b295bef
RD
1284 SvGETMAGIC(left);
1285 SvGETMAGIC(right);
a0d0e21e 1286
8e9bbdb9 1287 if (RANGE_IS_NUMERIC(left,right)) {
901017d6
AL
1288 register IV i, j;
1289 IV max;
4fe3f0fa
MHM
1290 if ((SvOK(left) && SvNV(left) < IV_MIN) ||
1291 (SvOK(right) && SvNV(right) > IV_MAX))
d470f89e 1292 DIE(aTHX_ "Range iterator outside integer range");
a0d0e21e
LW
1293 i = SvIV(left);
1294 max = SvIV(right);
bbce6d69 1295 if (max >= i) {
c1ab3db2
AK
1296 j = max - i + 1;
1297 EXTEND_MORTAL(j);
1298 EXTEND(SP, j);
bbce6d69 1299 }
c1ab3db2
AK
1300 else
1301 j = 0;
1302 while (j--) {
901017d6 1303 SV * const sv = sv_2mortal(newSViv(i++));
a0d0e21e
LW
1304 PUSHs(sv);
1305 }
1306 }
1307 else {
44f8325f 1308 SV * const final = sv_mortalcopy(right);
13c5b33c 1309 STRLEN len;
823a54a3 1310 const char * const tmps = SvPV_const(final, len);
a0d0e21e 1311
901017d6 1312 SV *sv = sv_mortalcopy(left);
13c5b33c 1313 SvPV_force_nolen(sv);
89ea2908 1314 while (!SvNIOKp(sv) && SvCUR(sv) <= len) {
a0d0e21e 1315 XPUSHs(sv);
b15aece3 1316 if (strEQ(SvPVX_const(sv),tmps))
89ea2908 1317 break;
a0d0e21e
LW
1318 sv = sv_2mortal(newSVsv(sv));
1319 sv_inc(sv);
1320 }
a0d0e21e
LW
1321 }
1322 }
1323 else {
1324 dTOPss;
901017d6 1325 SV * const targ = PAD_SV(cUNOP->op_first->op_targ);
4e3399f9 1326 int flop = 0;
a0d0e21e 1327 sv_inc(targ);
4e3399f9
YST
1328
1329 if (PL_op->op_private & OPpFLIP_LINENUM) {
1330 if (GvIO(PL_last_in_gv)) {
1331 flop = SvIV(sv) == (IV)IoLINES(GvIOp(PL_last_in_gv));
1332 }
1333 else {
fafc274c 1334 GV * const gv = gv_fetchpvs(".", GV_ADD|GV_NOTQUAL, SVt_PV);
4e3399f9
YST
1335 if (gv && GvSV(gv)) flop = SvIV(sv) == SvIV(GvSV(gv));
1336 }
1337 }
1338 else {
1339 flop = SvTRUE(sv);
1340 }
1341
1342 if (flop) {
a0d0e21e 1343 sv_setiv(PAD_SV(((UNOP*)cUNOP->op_first)->op_first->op_targ), 0);
396482e1 1344 sv_catpvs(targ, "E0");
a0d0e21e
LW
1345 }
1346 SETs(targ);
1347 }
1348
1349 RETURN;
1350}
1351
1352/* Control. */
1353
27da23d5 1354static const char * const context_name[] = {
515afda2 1355 "pseudo-block",
f31522f3 1356 NULL, /* CXt_WHEN never actually needs "block" */
76753e7f 1357 NULL, /* CXt_BLOCK never actually needs "block" */
f31522f3 1358 NULL, /* CXt_GIVEN never actually needs "block" */
76753e7f
NC
1359 NULL, /* CXt_LOOP_FOR never actually needs "loop" */
1360 NULL, /* CXt_LOOP_PLAIN never actually needs "loop" */
1361 NULL, /* CXt_LOOP_LAZYSV never actually needs "loop" */
1362 NULL, /* CXt_LOOP_LAZYIV never actually needs "loop" */
515afda2 1363 "subroutine",
76753e7f 1364 "format",
515afda2 1365 "eval",
515afda2 1366 "substitution",
515afda2
NC
1367};
1368
76e3520e 1369STATIC I32
06b5626a 1370S_dopoptolabel(pTHX_ const char *label)
a0d0e21e 1371{
97aff369 1372 dVAR;
a0d0e21e 1373 register I32 i;
a0d0e21e 1374
7918f24d
NC
1375 PERL_ARGS_ASSERT_DOPOPTOLABEL;
1376
a0d0e21e 1377 for (i = cxstack_ix; i >= 0; i--) {
901017d6 1378 register const PERL_CONTEXT * const cx = &cxstack[i];
6b35e009 1379 switch (CxTYPE(cx)) {
a0d0e21e 1380 case CXt_SUBST:
a0d0e21e 1381 case CXt_SUB:
7766f137 1382 case CXt_FORMAT:
a0d0e21e 1383 case CXt_EVAL:
0a753a76 1384 case CXt_NULL:
a2a5de95
NC
1385 Perl_ck_warner(aTHX_ packWARN(WARN_EXITING), "Exiting %s via %s",
1386 context_name[CxTYPE(cx)], OP_NAME(PL_op));
515afda2
NC
1387 if (CxTYPE(cx) == CXt_NULL)
1388 return -1;
1389 break;
c6fdafd0 1390 case CXt_LOOP_LAZYIV:
d01136d6 1391 case CXt_LOOP_LAZYSV:
3b719c58
NC
1392 case CXt_LOOP_FOR:
1393 case CXt_LOOP_PLAIN:
7e8f1eac
AD
1394 {
1395 const char *cx_label = CxLABEL(cx);
1396 if (!cx_label || strNE(label, cx_label) ) {
1c98cc53 1397 DEBUG_l(Perl_deb(aTHX_ "(poptolabel(): skipping label at cx=%ld %s)\n",
7e8f1eac 1398 (long)i, cx_label));
a0d0e21e
LW
1399 continue;
1400 }
1c98cc53 1401 DEBUG_l( Perl_deb(aTHX_ "(poptolabel(): found label at cx=%ld %s)\n", (long)i, label));
a0d0e21e 1402 return i;
7e8f1eac 1403 }
a0d0e21e
LW
1404 }
1405 }
1406 return i;
1407}
1408
0d863452
RH
1409
1410
e50aee73 1411I32
864dbfa3 1412Perl_dowantarray(pTHX)
e50aee73 1413{
97aff369 1414 dVAR;
f54cb97a 1415 const I32 gimme = block_gimme();
54310121
PP
1416 return (gimme == G_VOID) ? G_SCALAR : gimme;
1417}
1418
1419I32
864dbfa3 1420Perl_block_gimme(pTHX)
54310121 1421{
97aff369 1422 dVAR;
06b5626a 1423 const I32 cxix = dopoptosub(cxstack_ix);
e50aee73 1424 if (cxix < 0)
46fc3d4c 1425 return G_VOID;
e50aee73 1426
54310121 1427 switch (cxstack[cxix].blk_gimme) {
d2719217
GS
1428 case G_VOID:
1429 return G_VOID;
54310121 1430 case G_SCALAR:
e50aee73 1431 return G_SCALAR;
54310121
PP
1432 case G_ARRAY:
1433 return G_ARRAY;
1434 default:
cea2e8a9 1435 Perl_croak(aTHX_ "panic: bad gimme: %d\n", cxstack[cxix].blk_gimme);
d2719217
GS
1436 /* NOTREACHED */
1437 return 0;
54310121 1438 }
e50aee73
AD
1439}
1440
78f9721b
SM
1441I32
1442Perl_is_lvalue_sub(pTHX)
1443{
97aff369 1444 dVAR;
06b5626a 1445 const I32 cxix = dopoptosub(cxstack_ix);
78f9721b
SM
1446 assert(cxix >= 0); /* We should only be called from inside subs */
1447
bafb2adc
NC
1448 if (CxLVAL(cxstack + cxix) && CvLVALUE(cxstack[cxix].blk_sub.cv))
1449 return CxLVAL(cxstack + cxix);
78f9721b
SM
1450 else
1451 return 0;
1452}
1453
76e3520e 1454STATIC I32
901017d6 1455S_dopoptosub_at(pTHX_ const PERL_CONTEXT *cxstk, I32 startingblock)
2c375eb9 1456{
97aff369 1457 dVAR;
a0d0e21e 1458 I32 i;
7918f24d
NC
1459
1460 PERL_ARGS_ASSERT_DOPOPTOSUB_AT;
1461
a0d0e21e 1462 for (i = startingblock; i >= 0; i--) {
901017d6 1463 register const PERL_CONTEXT * const cx = &cxstk[i];
6b35e009 1464 switch (CxTYPE(cx)) {
a0d0e21e
LW
1465 default:
1466 continue;
1467 case CXt_EVAL:
1468 case CXt_SUB:
7766f137 1469 case CXt_FORMAT:
1c98cc53 1470 DEBUG_l( Perl_deb(aTHX_ "(dopoptosub_at(): found sub at cx=%ld)\n", (long)i));
a0d0e21e
LW
1471 return i;
1472 }
1473 }
1474 return i;
1475}
1476
76e3520e 1477STATIC I32
cea2e8a9 1478S_dopoptoeval(pTHX_ I32 startingblock)
a0d0e21e 1479{
97aff369 1480 dVAR;
a0d0e21e 1481 I32 i;
a0d0e21e 1482 for (i = startingblock; i >= 0; i--) {
06b5626a 1483 register const PERL_CONTEXT *cx = &cxstack[i];
6b35e009 1484 switch (CxTYPE(cx)) {
a0d0e21e
LW
1485 default:
1486 continue;
1487 case CXt_EVAL:
1c98cc53 1488 DEBUG_l( Perl_deb(aTHX_ "(dopoptoeval(): found eval at cx=%ld)\n", (long)i));
a0d0e21e
LW
1489 return i;
1490 }
1491 }
1492 return i;
1493}
1494
76e3520e 1495STATIC I32
cea2e8a9 1496S_dopoptoloop(pTHX_ I32 startingblock)
a0d0e21e 1497{
97aff369 1498 dVAR;
a0d0e21e 1499 I32 i;
a0d0e21e 1500 for (i = startingblock; i >= 0; i--) {
901017d6 1501 register const PERL_CONTEXT * const cx = &cxstack[i];
6b35e009 1502 switch (CxTYPE(cx)) {
a0d0e21e 1503 case CXt_SUBST:
a0d0e21e 1504 case CXt_SUB:
7766f137 1505 case CXt_FORMAT:
a0d0e21e 1506 case CXt_EVAL:
0a753a76 1507 case CXt_NULL:
a2a5de95
NC
1508 Perl_ck_warner(aTHX_ packWARN(WARN_EXITING), "Exiting %s via %s",
1509 context_name[CxTYPE(cx)], OP_NAME(PL_op));
515afda2
NC
1510 if ((CxTYPE(cx)) == CXt_NULL)
1511 return -1;
1512 break;
c6fdafd0 1513 case CXt_LOOP_LAZYIV:
d01136d6 1514 case CXt_LOOP_LAZYSV:
3b719c58
NC
1515 case CXt_LOOP_FOR:
1516 case CXt_LOOP_PLAIN:
1c98cc53 1517 DEBUG_l( Perl_deb(aTHX_ "(dopoptoloop(): found loop at cx=%ld)\n", (long)i));
a0d0e21e
LW
1518 return i;
1519 }
1520 }
1521 return i;
1522}
1523
0d863452
RH
1524STATIC I32
1525S_dopoptogiven(pTHX_ I32 startingblock)
1526{
97aff369 1527 dVAR;
0d863452
RH
1528 I32 i;
1529 for (i = startingblock; i >= 0; i--) {
1530 register const PERL_CONTEXT *cx = &cxstack[i];
1531 switch (CxTYPE(cx)) {
1532 default:
1533 continue;
1534 case CXt_GIVEN:
1c98cc53 1535 DEBUG_l( Perl_deb(aTHX_ "(dopoptogiven(): found given at cx=%ld)\n", (long)i));
0d863452 1536 return i;
3b719c58
NC
1537 case CXt_LOOP_PLAIN:
1538 assert(!CxFOREACHDEF(cx));
1539 break;
c6fdafd0 1540 case CXt_LOOP_LAZYIV:
d01136d6 1541 case CXt_LOOP_LAZYSV:
3b719c58 1542 case CXt_LOOP_FOR:
0d863452 1543 if (CxFOREACHDEF(cx)) {
1c98cc53 1544 DEBUG_l( Perl_deb(aTHX_ "(dopoptogiven(): found foreach at cx=%ld)\n", (long)i));
0d863452
RH
1545 return i;
1546 }
1547 }
1548 }
1549 return i;
1550}
1551
1552STATIC I32
1553S_dopoptowhen(pTHX_ I32 startingblock)
1554{
97aff369 1555 dVAR;
0d863452
RH
1556 I32 i;
1557 for (i = startingblock; i >= 0; i--) {
1558 register const PERL_CONTEXT *cx = &cxstack[i];
1559 switch (CxTYPE(cx)) {
1560 default:
1561 continue;
1562 case CXt_WHEN:
1c98cc53 1563 DEBUG_l( Perl_deb(aTHX_ "(dopoptowhen(): found when at cx=%ld)\n", (long)i));
0d863452
RH
1564 return i;
1565 }
1566 }
1567 return i;
1568}
1569
a0d0e21e 1570void
864dbfa3 1571Perl_dounwind(pTHX_ I32 cxix)
a0d0e21e 1572{
97aff369 1573 dVAR;
a0d0e21e
LW
1574 I32 optype;
1575
1576 while (cxstack_ix > cxix) {
b0d9ce38 1577 SV *sv;
06b5626a 1578 register PERL_CONTEXT *cx = &cxstack[cxstack_ix];
1c98cc53 1579 DEBUG_CX("UNWIND"); \
a0d0e21e 1580 /* Note: we don't need to restore the base context info till the end. */
6b35e009 1581 switch (CxTYPE(cx)) {
c90c0ff4
PP
1582 case CXt_SUBST:
1583 POPSUBST(cx);
1584 continue; /* not break */
a0d0e21e 1585 case CXt_SUB:
b0d9ce38
GS
1586 POPSUB(cx,sv);
1587 LEAVESUB(sv);
a0d0e21e
LW
1588 break;
1589 case CXt_EVAL:
1590 POPEVAL(cx);
1591 break;
c6fdafd0 1592 case CXt_LOOP_LAZYIV:
d01136d6 1593 case CXt_LOOP_LAZYSV:
3b719c58
NC
1594 case CXt_LOOP_FOR:
1595 case CXt_LOOP_PLAIN:
a0d0e21e
LW
1596 POPLOOP(cx);
1597 break;
0a753a76 1598 case CXt_NULL:
a0d0e21e 1599 break;
7766f137
GS
1600 case CXt_FORMAT:
1601 POPFORMAT(cx);
1602 break;
a0d0e21e 1603 }
c90c0ff4 1604 cxstack_ix--;
a0d0e21e 1605 }
1b6737cc 1606 PERL_UNUSED_VAR(optype);
a0d0e21e
LW
1607}
1608
5a844595
GS
1609void
1610Perl_qerror(pTHX_ SV *err)
1611{
97aff369 1612 dVAR;
7918f24d
NC
1613
1614 PERL_ARGS_ASSERT_QERROR;
1615
6b2fb389
DM
1616 if (PL_in_eval) {
1617 if (PL_in_eval & EVAL_KEEPERR) {
1618 Perl_ck_warner(aTHX_ packWARN(WARN_MISC), "\t(in cleanup) %s",
1619 SvPV_nolen_const(err));
1620 }
1621 else
1622 sv_catsv(ERRSV, err);
1623 }
5a844595
GS
1624 else if (PL_errors)
1625 sv_catsv(PL_errors, err);
1626 else
be2597df 1627 Perl_warn(aTHX_ "%"SVf, SVfARG(err));
13765c85
DM
1628 if (PL_parser)
1629 ++PL_parser->error_count;
5a844595
GS
1630}
1631
bb4c52e0 1632void
c5df3096 1633Perl_die_unwind(pTHX_ SV *msv)
a0d0e21e 1634{
27da23d5 1635 dVAR;
c5df3096 1636 SV *exceptsv = sv_mortalcopy(msv);
96d9b9cd 1637 U8 in_eval = PL_in_eval;
c5df3096 1638 PERL_ARGS_ASSERT_DIE_UNWIND;
87582a92 1639
96d9b9cd 1640 if (in_eval) {
a0d0e21e 1641 I32 cxix;
a0d0e21e 1642 I32 gimme;
a0d0e21e 1643
5a844595
GS
1644 while ((cxix = dopoptoeval(cxstack_ix)) < 0
1645 && PL_curstackinfo->si_prev)
1646 {
bac4b2ad 1647 dounwind(-1);
d3acc0f7 1648 POPSTACK;
bac4b2ad 1649 }
e336de0d 1650
a0d0e21e
LW
1651 if (cxix >= 0) {
1652 I32 optype;
b6494f15 1653 SV *namesv;
35a4481c 1654 register PERL_CONTEXT *cx;
901017d6 1655 SV **newsp;
8f89e5a9
Z
1656 COP *oldcop;
1657 JMPENV *restartjmpenv;
1658 OP *restartop;
a0d0e21e
LW
1659
1660 if (cxix < cxstack_ix)
1661 dounwind(cxix);
1662
3280af22 1663 POPBLOCK(cx,PL_curpm);
6b35e009 1664 if (CxTYPE(cx) != CXt_EVAL) {
7d0994e0 1665 STRLEN msglen;
96d9b9cd 1666 const char* message = SvPVx_const(exceptsv, msglen);
10edeb5d 1667 PerlIO_write(Perl_error_log, (const char *)"panic: die ", 11);
bf49b057 1668 PerlIO_write(Perl_error_log, message, msglen);
a0d0e21e
LW
1669 my_exit(1);
1670 }
1671 POPEVAL(cx);
b6494f15 1672 namesv = cx->blk_eval.old_namesv;
8f89e5a9
Z
1673 oldcop = cx->blk_oldcop;
1674 restartjmpenv = cx->blk_eval.cur_top_env;
1675 restartop = cx->blk_eval.retop;
a0d0e21e
LW
1676
1677 if (gimme == G_SCALAR)
3280af22
NIS
1678 *++newsp = &PL_sv_undef;
1679 PL_stack_sp = newsp;
a0d0e21e
LW
1680
1681 LEAVE;
748a9306 1682
7fb6a879
GS
1683 /* LEAVE could clobber PL_curcop (see save_re_context())
1684 * XXX it might be better to find a way to avoid messing with
1685 * PL_curcop in save_re_context() instead, but this is a more
1686 * minimal fix --GSAR */
8f89e5a9 1687 PL_curcop = oldcop;
7fb6a879 1688
7a2e2cd6 1689 if (optype == OP_REQUIRE) {
96d9b9cd 1690 const char* const msg = SvPVx_nolen_const(exceptsv);
b6494f15
VP
1691 (void)hv_store(GvHVn(PL_incgv),
1692 SvPVX_const(namesv), SvCUR(namesv),
27bcc0a7 1693 &PL_sv_undef, 0);
27e90453
DM
1694 /* note that unlike pp_entereval, pp_require isn't
1695 * supposed to trap errors. So now that we've popped the
1696 * EVAL that pp_require pushed, and processed the error
1697 * message, rethrow the error */
9fed9930
NC
1698 Perl_croak(aTHX_ "%sCompilation failed in require",
1699 *msg ? msg : "Unknown error\n");
7a2e2cd6 1700 }
c5df3096 1701 if (in_eval & EVAL_KEEPERR) {
7ce09284
Z
1702 Perl_ck_warner(aTHX_ packWARN(WARN_MISC), "\t(in cleanup) %s",
1703 SvPV_nolen_const(exceptsv));
96d9b9cd
Z
1704 }
1705 else {
1706 sv_setsv(ERRSV, exceptsv);
1707 }
8f89e5a9
Z
1708 PL_restartjmpenv = restartjmpenv;
1709 PL_restartop = restartop;
bb4c52e0
GG
1710 JMPENV_JUMP(3);
1711 /* NOTREACHED */
a0d0e21e
LW
1712 }
1713 }
87582a92 1714
96d9b9cd 1715 write_to_stderr(exceptsv);
f86702cc
PP
1716 my_failure_exit();
1717 /* NOTREACHED */
a0d0e21e
LW
1718}
1719
1720PP(pp_xor)
1721{
97aff369 1722 dVAR; dSP; dPOPTOPssrl;
a0d0e21e
LW
1723 if (SvTRUE(left) != SvTRUE(right))
1724 RETSETYES;
1725 else
1726 RETSETNO;
1727}
1728
8dff4fc5
BM
1729/*
1730=for apidoc caller_cx
1731
1732The XSUB-writer's equivalent of L<caller()|perlfunc/caller>. The
1733returned C<PERL_CONTEXT> structure can be interrogated to find all the
1734information returned to Perl by C<caller>. Note that XSUBs don't get a
1735stack frame, so C<caller_cx(0, NULL)> will return information for the
1736immediately-surrounding Perl code.
1737
1738This function skips over the automatic calls to C<&DB::sub> made on the
1739behalf of the debugger. If the stack frame requested was a sub called by
1740C<DB::sub>, the return value will be the frame for the call to
1741C<DB::sub>, since that has the correct line number/etc. for the call
1742site. If I<dbcxp> is non-C<NULL>, it will be set to a pointer to the
1743frame for the sub call itself.
1744
1745=cut
1746*/
1747
1748const PERL_CONTEXT *
1749Perl_caller_cx(pTHX_ I32 count, const PERL_CONTEXT **dbcxp)
a0d0e21e 1750{
a0d0e21e 1751 register I32 cxix = dopoptosub(cxstack_ix);
901017d6
AL
1752 register const PERL_CONTEXT *cx;
1753 register const PERL_CONTEXT *ccstack = cxstack;
1754 const PERL_SI *top_si = PL_curstackinfo;
27d41816 1755
a0d0e21e 1756 for (;;) {
2c375eb9
GS
1757 /* we may be in a higher stacklevel, so dig down deeper */
1758 while (cxix < 0 && top_si->si_type != PERLSI_MAIN) {
1759 top_si = top_si->si_prev;
1760 ccstack = top_si->si_cxstack;
1761 cxix = dopoptosub_at(ccstack, top_si->si_cxix);
1762 }
8dff4fc5
BM
1763 if (cxix < 0)
1764 return NULL;
f2a7f298 1765 /* caller() should not report the automatic calls to &DB::sub */
1766 if (PL_DBsub && GvCV(PL_DBsub) && cxix >= 0 &&
3280af22 1767 ccstack[cxix].blk_sub.cv == GvCV(PL_DBsub))
a0d0e21e
LW
1768 count++;
1769 if (!count--)
1770 break;
2c375eb9 1771 cxix = dopoptosub_at(ccstack, cxix - 1);
a0d0e21e 1772 }
2c375eb9
GS
1773
1774 cx = &ccstack[cxix];
8dff4fc5
BM
1775 if (dbcxp) *dbcxp = cx;
1776
7766f137 1777 if (CxTYPE(cx) == CXt_SUB || CxTYPE(cx) == CXt_FORMAT) {
f54cb97a 1778 const I32 dbcxix = dopoptosub_at(ccstack, cxix - 1);
2c375eb9 1779 /* We expect that ccstack[dbcxix] is CXt_SUB, anyway, the
06a5b730 1780 field below is defined for any cx. */
f2a7f298 1781 /* caller() should not report the automatic calls to &DB::sub */
1782 if (PL_DBsub && GvCV(PL_DBsub) && dbcxix >= 0 && ccstack[dbcxix].blk_sub.cv == GvCV(PL_DBsub))
2c375eb9 1783 cx = &ccstack[dbcxix];
06a5b730
PP
1784 }
1785
8dff4fc5
BM
1786 return cx;
1787}
1788
1789PP(pp_caller)
1790{
1791 dVAR;
1792 dSP;
1793 register const PERL_CONTEXT *cx;
1794 const PERL_CONTEXT *dbcx;
1795 I32 gimme;
1796 const char *stashname;
1797 I32 count = 0;
1798
1799 if (MAXARG)
1800 count = POPi;
1801
1802 cx = caller_cx(count, &dbcx);
1803 if (!cx) {
1804 if (GIMME != G_ARRAY) {
1805 EXTEND(SP, 1);
1806 RETPUSHUNDEF;
1807 }
1808 RETURN;
1809 }
1810
ed094faf 1811 stashname = CopSTASHPV(cx->blk_oldcop);
a0d0e21e 1812 if (GIMME != G_ARRAY) {
27d41816 1813 EXTEND(SP, 1);
ed094faf 1814 if (!stashname)
3280af22 1815 PUSHs(&PL_sv_undef);
49d8d3a1
MB
1816 else {
1817 dTARGET;
ed094faf 1818 sv_setpv(TARG, stashname);
49d8d3a1
MB
1819 PUSHs(TARG);
1820 }
a0d0e21e
LW
1821 RETURN;
1822 }
a0d0e21e 1823
b3ca2e83 1824 EXTEND(SP, 11);
27d41816 1825
ed094faf 1826 if (!stashname)
3280af22 1827 PUSHs(&PL_sv_undef);
49d8d3a1 1828 else
6e449a3a
MHM
1829 mPUSHs(newSVpv(stashname, 0));
1830 mPUSHs(newSVpv(OutCopFILE(cx->blk_oldcop), 0));
1831 mPUSHi((I32)CopLINE(cx->blk_oldcop));
a0d0e21e
LW
1832 if (!MAXARG)
1833 RETURN;
7766f137 1834 if (CxTYPE(cx) == CXt_SUB || CxTYPE(cx) == CXt_FORMAT) {
8dff4fc5 1835 GV * const cvgv = CvGV(dbcx->blk_sub.cv);
7766f137 1836 /* So is ccstack[dbcxix]. */
07b8c804 1837 if (isGV(cvgv)) {
561b68a9 1838 SV * const sv = newSV(0);
c445ea15 1839 gv_efullname3(sv, cvgv, NULL);
6e449a3a 1840 mPUSHs(sv);
bf38a478 1841 PUSHs(boolSV(CxHASARGS(cx)));
07b8c804
RGS
1842 }
1843 else {
84bafc02 1844 PUSHs(newSVpvs_flags("(unknown)", SVs_TEMP));
bf38a478 1845 PUSHs(boolSV(CxHASARGS(cx)));
07b8c804 1846 }
a0d0e21e
LW
1847 }
1848 else {
84bafc02 1849 PUSHs(newSVpvs_flags("(eval)", SVs_TEMP));
6e449a3a 1850 mPUSHi(0);
a0d0e21e 1851 }
54310121
PP
1852 gimme = (I32)cx->blk_gimme;
1853 if (gimme == G_VOID)
3280af22 1854 PUSHs(&PL_sv_undef);
54310121 1855 else
98625aca 1856 PUSHs(boolSV((gimme & G_WANT) == G_ARRAY));
6b35e009 1857 if (CxTYPE(cx) == CXt_EVAL) {
811a4de9 1858 /* eval STRING */
85a64632 1859 if (CxOLD_OP_TYPE(cx) == OP_ENTEREVAL) {
4633a7c4 1860 PUSHs(cx->blk_eval.cur_text);
3280af22 1861 PUSHs(&PL_sv_no);
0f79a09d 1862 }
811a4de9 1863 /* require */
0f79a09d 1864 else if (cx->blk_eval.old_namesv) {
6e449a3a 1865 mPUSHs(newSVsv(cx->blk_eval.old_namesv));
3280af22 1866 PUSHs(&PL_sv_yes);
06a5b730 1867 }
811a4de9
GS
1868 /* eval BLOCK (try blocks have old_namesv == 0) */
1869 else {
1870 PUSHs(&PL_sv_undef);
1871 PUSHs(&PL_sv_undef);
1872 }
4633a7c4 1873 }
a682de96
GS
1874 else {
1875 PUSHs(&PL_sv_undef);
1876 PUSHs(&PL_sv_undef);
1877 }
bafb2adc 1878 if (CxTYPE(cx) == CXt_SUB && CxHASARGS(cx)
ed094faf 1879 && CopSTASH_eq(PL_curcop, PL_debstash))
4633a7c4 1880 {
66a1b24b
AL
1881 AV * const ary = cx->blk_sub.argarray;
1882 const int off = AvARRAY(ary) - AvALLOC(ary);
a0d0e21e 1883
5b235299
NC
1884 if (!PL_dbargs)
1885 Perl_init_dbargs(aTHX);
a0d0e21e 1886
3280af22
NIS
1887 if (AvMAX(PL_dbargs) < AvFILLp(ary) + off)
1888 av_extend(PL_dbargs, AvFILLp(ary) + off);
1889 Copy(AvALLOC(ary), AvARRAY(PL_dbargs), AvFILLp(ary) + 1 + off, SV*);
1890 AvFILLp(PL_dbargs) = AvFILLp(ary) + off;
a0d0e21e 1891 }
f3aa04c2
GS
1892 /* XXX only hints propagated via op_private are currently
1893 * visible (others are not easily accessible, since they
1894 * use the global PL_hints) */
6e449a3a 1895 mPUSHi(CopHINTS_get(cx->blk_oldcop));
e476b1b5
GS
1896 {
1897 SV * mask ;
72dc9ed5 1898 STRLEN * const old_warnings = cx->blk_oldcop->cop_warnings ;
114bafba 1899
ac27b0f5 1900 if (old_warnings == pWARN_NONE ||
114bafba 1901 (old_warnings == pWARN_STD && (PL_dowarn & G_WARN_ON) == 0))
e476b1b5 1902 mask = newSVpvn(WARN_NONEstring, WARNsize) ;
ac27b0f5 1903 else if (old_warnings == pWARN_ALL ||
75b6c4ca
RGS
1904 (old_warnings == pWARN_STD && PL_dowarn & G_WARN_ON)) {
1905 /* Get the bit mask for $warnings::Bits{all}, because
1906 * it could have been extended by warnings::register */
1907 SV **bits_all;
6673a63c 1908 HV * const bits = get_hv("warnings::Bits", 0);
017a3ce5 1909 if (bits && (bits_all=hv_fetchs(bits, "all", FALSE))) {
75b6c4ca
RGS
1910 mask = newSVsv(*bits_all);
1911 }
1912 else {
1913 mask = newSVpvn(WARN_ALLstring, WARNsize) ;
1914 }
1915 }
e476b1b5 1916 else
72dc9ed5 1917 mask = newSVpvn((char *) (old_warnings + 1), old_warnings[0]);
6e449a3a 1918 mPUSHs(mask);
e476b1b5 1919 }
b3ca2e83 1920
c28fe1ec 1921 PUSHs(cx->blk_oldcop->cop_hints_hash ?
20439bc7 1922 sv_2mortal(newRV_noinc(MUTABLE_SV(cop_hints_2hv(cx->blk_oldcop, 0))))
b3ca2e83 1923 : &PL_sv_undef);
a0d0e21e
LW
1924 RETURN;
1925}
1926
a0d0e21e
LW
1927PP(pp_reset)
1928{
97aff369 1929 dVAR;
39644a26 1930 dSP;
10edeb5d 1931 const char * const tmps = (MAXARG < 1) ? (const char *)"" : POPpconstx;
11faa288 1932 sv_reset(tmps, CopSTASH(PL_curcop));
3280af22 1933 PUSHs(&PL_sv_yes);
a0d0e21e
LW
1934 RETURN;
1935}
1936
dd2155a4
DM
1937/* like pp_nextstate, but used instead when the debugger is active */
1938
a0d0e21e
LW
1939PP(pp_dbstate)
1940{
27da23d5 1941 dVAR;
533c011a 1942 PL_curcop = (COP*)PL_op;
a0d0e21e 1943 TAINT_NOT; /* Each statement is presumed innocent */
3280af22 1944 PL_stack_sp = PL_stack_base + cxstack[cxstack_ix].blk_oldsp;
a0d0e21e
LW
1945 FREETMPS;
1946
f410a211
NC
1947 PERL_ASYNC_CHECK();
1948
5df8de69
DM
1949 if (PL_op->op_flags & OPf_SPECIAL /* breakpoint */
1950 || SvIV(PL_DBsingle) || SvIV(PL_DBsignal) || SvIV(PL_DBtrace))
a0d0e21e 1951 {
39644a26 1952 dSP;
c09156bb 1953 register PERL_CONTEXT *cx;
f54cb97a 1954 const I32 gimme = G_ARRAY;
eb160463 1955 U8 hasargs;
0bd48802
AL
1956 GV * const gv = PL_DBgv;
1957 register CV * const cv = GvCV(gv);
a0d0e21e 1958
a0d0e21e 1959 if (!cv)
cea2e8a9 1960 DIE(aTHX_ "No DB::DB routine defined");
a0d0e21e 1961
aea4f609
DM
1962 if (CvDEPTH(cv) >= 1 && !(PL_debug & DEBUG_DB_RECURSE_FLAG))
1963 /* don't do recursive DB::DB call */
a0d0e21e 1964 return NORMAL;
748a9306 1965
a57c6685 1966 ENTER;
4633a7c4
LW
1967 SAVETMPS;
1968
3280af22 1969 SAVEI32(PL_debug);
55497cff 1970 SAVESTACK_POS();
3280af22 1971 PL_debug = 0;
748a9306 1972 hasargs = 0;
924508f0 1973 SPAGAIN;
748a9306 1974
aed2304a 1975 if (CvISXSUB(cv)) {
c127bd3a
SF
1976 CvDEPTH(cv)++;
1977 PUSHMARK(SP);
1978 (void)(*CvXSUB(cv))(aTHX_ cv);
1979 CvDEPTH(cv)--;
1980 FREETMPS;
a57c6685 1981 LEAVE;
c127bd3a
SF
1982 return NORMAL;
1983 }
1984 else {
1985 PUSHBLOCK(cx, CXt_SUB, SP);
1986 PUSHSUB_DB(cx);
1987 cx->blk_sub.retop = PL_op->op_next;
1988 CvDEPTH(cv)++;
1989 SAVECOMPPAD();
1990 PAD_SET_CUR_NOSAVE(CvPADLIST(cv), 1);
1991 RETURNOP(CvSTART(cv));
1992 }
a0d0e21e
LW
1993 }
1994 else
1995 return NORMAL;
1996}
1997
a0d0e21e
LW
1998PP(pp_enteriter)
1999{
27da23d5 2000 dVAR; dSP; dMARK;
c09156bb 2001 register PERL_CONTEXT *cx;
f54cb97a 2002 const I32 gimme = GIMME_V;
df530c37 2003 void *itervar; /* location of the iteration variable */
840fe433 2004 U8 cxtype = CXt_LOOP_FOR;
a0d0e21e 2005
d343c3ef 2006 ENTER_with_name("loop1");
4633a7c4
LW
2007 SAVETMPS;
2008
aafca525
DM
2009 if (PL_op->op_targ) { /* "my" variable */
2010 if (PL_op->op_private & OPpLVAL_INTRO) { /* for my $x (...) */
14f338dc
DM
2011 SvPADSTALE_off(PAD_SVl(PL_op->op_targ));
2012 SAVESETSVFLAGS(PAD_SVl(PL_op->op_targ),
2013 SVs_PADSTALE, SVs_PADSTALE);
2014 }
09edbca0 2015 SAVEPADSVANDMORTALIZE(PL_op->op_targ);
89e00a7c 2016#ifdef USE_ITHREADS
df530c37 2017 itervar = PL_comppad;
89e00a7c 2018#else
aafca525 2019 itervar = &PAD_SVl(PL_op->op_targ);
7766f137 2020#endif
54b9620d 2021 }
aafca525 2022 else { /* symbol table variable */
159b6efe 2023 GV * const gv = MUTABLE_GV(POPs);
f83b46a0
DM
2024 SV** svp = &GvSV(gv);
2025 save_pushptrptr(gv, SvREFCNT_inc(*svp), SAVEt_GVSV);
561b68a9 2026 *svp = newSV(0);
df530c37 2027 itervar = (void *)gv;
54b9620d 2028 }
4633a7c4 2029
0d863452
RH
2030 if (PL_op->op_private & OPpITER_DEF)
2031 cxtype |= CXp_FOR_DEF;
2032
d343c3ef 2033 ENTER_with_name("loop2");
a0d0e21e 2034
7766f137 2035 PUSHBLOCK(cx, cxtype, SP);
df530c37 2036 PUSHLOOP_FOR(cx, itervar, MARK);
533c011a 2037 if (PL_op->op_flags & OPf_STACKED) {
d01136d6
BS
2038 SV *maybe_ary = POPs;
2039 if (SvTYPE(maybe_ary) != SVt_PVAV) {
89ea2908 2040 dPOPss;
d01136d6 2041 SV * const right = maybe_ary;
984a4bea
RD
2042 SvGETMAGIC(sv);
2043 SvGETMAGIC(right);
4fe3f0fa 2044 if (RANGE_IS_NUMERIC(sv,right)) {
d01136d6 2045 cx->cx_type &= ~CXTYPEMASK;
c6fdafd0
NC
2046 cx->cx_type |= CXt_LOOP_LAZYIV;
2047 /* Make sure that no-one re-orders cop.h and breaks our
2048 assumptions */
2049 assert(CxTYPE(cx) == CXt_LOOP_LAZYIV);
a2309040
JH
2050#ifdef NV_PRESERVES_UV
2051 if ((SvOK(sv) && ((SvNV(sv) < (NV)IV_MIN) ||
2052 (SvNV(sv) > (NV)IV_MAX)))
2053 ||
2054 (SvOK(right) && ((SvNV(right) > (NV)IV_MAX) ||
2055 (SvNV(right) < (NV)IV_MIN))))
2056#else
2057 if ((SvOK(sv) && ((SvNV(sv) <= (NV)IV_MIN)
2058 ||
2059 ((SvNV(sv) > 0) &&
2060 ((SvUV(sv) > (UV)IV_MAX) ||
2061 (SvNV(sv) > (NV)UV_MAX)))))
2062 ||
2063 (SvOK(right) && ((SvNV(right) <= (NV)IV_MIN)
2064 ||
2065 ((SvNV(right) > 0) &&
2066 ((SvUV(right) > (UV)IV_MAX) ||
2067 (SvNV(right) > (NV)UV_MAX))))))
2068#endif
076d9a11 2069 DIE(aTHX_ "Range iterator outside integer range");
d01136d6
BS
2070 cx->blk_loop.state_u.lazyiv.cur = SvIV(sv);
2071 cx->blk_loop.state_u.lazyiv.end = SvIV(right);
d4665a05
DM
2072#ifdef DEBUGGING
2073 /* for correct -Dstv display */
2074 cx->blk_oldsp = sp - PL_stack_base;
2075#endif
89ea2908 2076 }
3f63a782 2077 else {
d01136d6
BS
2078 cx->cx_type &= ~CXTYPEMASK;
2079 cx->cx_type |= CXt_LOOP_LAZYSV;
2080 /* Make sure that no-one re-orders cop.h and breaks our
2081 assumptions */
2082 assert(CxTYPE(cx) == CXt_LOOP_LAZYSV);
2083 cx->blk_loop.state_u.lazysv.cur = newSVsv(sv);
2084 cx->blk_loop.state_u.lazysv.end = right;
2085 SvREFCNT_inc(right);
2086 (void) SvPV_force_nolen(cx->blk_loop.state_u.lazysv.cur);
267cc4a8
NC
2087 /* This will do the upgrade to SVt_PV, and warn if the value
2088 is uninitialised. */
10516c54 2089 (void) SvPV_nolen_const(right);
267cc4a8
NC
2090 /* Doing this avoids a check every time in pp_iter in pp_hot.c
2091 to replace !SvOK() with a pointer to "". */
2092 if (!SvOK(right)) {
2093 SvREFCNT_dec(right);
d01136d6 2094 cx->blk_loop.state_u.lazysv.end = &PL_sv_no;
267cc4a8 2095 }
3f63a782 2096 }
89ea2908 2097 }
d01136d6 2098 else /* SvTYPE(maybe_ary) == SVt_PVAV */ {
502c6561 2099 cx->blk_loop.state_u.ary.ary = MUTABLE_AV(maybe_ary);
d01136d6
BS
2100 SvREFCNT_inc(maybe_ary);
2101 cx->blk_loop.state_u.ary.ix =
2102 (PL_op->op_private & OPpITER_REVERSED) ?
2103 AvFILL(cx->blk_loop.state_u.ary.ary) + 1 :
2104 -1;
ef3e5ea9 2105 }
89ea2908 2106 }
d01136d6
BS
2107 else { /* iterating over items on the stack */
2108 cx->blk_loop.state_u.ary.ary = NULL; /* means to use the stack */
ef3e5ea9 2109 if (PL_op->op_private & OPpITER_REVERSED) {
d01136d6 2110 cx->blk_loop.state_u.ary.ix = cx->blk_oldsp + 1;
ef3e5ea9
NC
2111 }
2112 else {
d01136d6 2113 cx->blk_loop.state_u.ary.ix = MARK - PL_stack_base;
ef3e5ea9 2114 }
4633a7c4 2115 }
a0d0e21e
LW
2116
2117 RETURN;
2118}
2119
2120PP(pp_enterloop)
2121{
27da23d5 2122 dVAR; dSP;
c09156bb 2123 register PERL_CONTEXT *cx;
f54cb97a 2124 const I32 gimme = GIMME_V;
a0d0e21e 2125
d343c3ef 2126 ENTER_with_name("loop1");
a0d0e21e 2127 SAVETMPS;
d343c3ef 2128 ENTER_with_name("loop2");
a0d0e21e 2129
3b719c58
NC
2130 PUSHBLOCK(cx, CXt_LOOP_PLAIN, SP);
2131 PUSHLOOP_PLAIN(cx, SP);
a0d0e21e
LW
2132
2133 RETURN;
2134}
2135
2136PP(pp_leaveloop)
2137{
27da23d5 2138 dVAR; dSP;
c09156bb 2139 register PERL_CONTEXT *cx;
a0d0e21e
LW
2140 I32 gimme;
2141 SV **newsp;
2142 PMOP *newpm;
2143 SV **mark;
2144
2145 POPBLOCK(cx,newpm);
3b719c58 2146 assert(CxTYPE_is_LOOP(cx));
4fdae800 2147 mark = newsp;
a8bba7fa 2148 newsp = PL_stack_base + cx->blk_loop.resetsp;
f86702cc 2149
a1f49e72 2150 TAINT_NOT;
54310121 2151 if (gimme == G_VOID)
6f207bd3 2152 NOOP;
54310121
PP
2153 else if (gimme == G_SCALAR) {
2154 if (mark < SP)
2155 *++newsp = sv_mortalcopy(*SP);
2156 else
3280af22 2157 *++newsp = &PL_sv_undef;
a0d0e21e
LW
2158 }
2159 else {
a1f49e72 2160 while (mark < SP) {
a0d0e21e 2161 *++newsp = sv_mortalcopy(*++mark);
a1f49e72
CS
2162 TAINT_NOT; /* Each item is independent */
2163 }
a0d0e21e 2164 }
f86702cc
PP
2165 SP = newsp;
2166 PUTBACK;
2167
a8bba7fa 2168 POPLOOP(cx); /* Stack values are safe: release loop vars ... */
3280af22 2169 PL_curpm = newpm; /* ... and pop $1 et al */
f86702cc 2170
d343c3ef
GG
2171 LEAVE_with_name("loop2");
2172 LEAVE_with_name("loop1");
a0d0e21e 2173
f86702cc 2174 return NORMAL;
a0d0e21e
LW
2175}
2176
2177PP(pp_return)
2178{
27da23d5 2179 dVAR; dSP; dMARK;
c09156bb 2180 register PERL_CONTEXT *cx;
f86702cc 2181 bool popsub2 = FALSE;
b45de488 2182 bool clear_errsv = FALSE;
a0d0e21e
LW
2183 I32 gimme;
2184 SV **newsp;
2185 PMOP *newpm;
2186 I32 optype = 0;
b6494f15 2187 SV *namesv;
b0d9ce38 2188 SV *sv;
b263a1ad 2189 OP *retop = NULL;
a0d0e21e 2190
0bd48802
AL
2191 const I32 cxix = dopoptosub(cxstack_ix);
2192
9850bf21
RH
2193 if (cxix < 0) {
2194 if (CxMULTICALL(cxstack)) { /* In this case we must be in a
2195 * sort block, which is a CXt_NULL
2196 * not a CXt_SUB */
2197 dounwind(0);
d7507f74
RH
2198 PL_stack_base[1] = *PL_stack_sp;
2199 PL_stack_sp = PL_stack_base + 1;
a0d0e21e
LW
2200 return 0;
2201 }
9850bf21
RH
2202 else
2203 DIE(aTHX_ "Can't return outside a subroutine");
a0d0e21e 2204 }
a0d0e21e
LW
2205 if (cxix < cxstack_ix)
2206 dounwind(cxix);
2207
d7507f74
RH
2208 if (CxMULTICALL(&cxstack[cxix])) {
2209 gimme = cxstack[cxix].blk_gimme;
2210 if (gimme == G_VOID)
2211 PL_stack_sp = PL_stack_base;
2212 else if (gimme == G_SCALAR) {
2213 PL_stack_base[1] = *PL_stack_sp;
2214 PL_stack_sp = PL_stack_base + 1;
2215 }
9850bf21 2216 return 0;
d7507f74 2217 }
9850bf21 2218
a0d0e21e 2219 POPBLOCK(cx,newpm);
6b35e009 2220 switch (CxTYPE(cx)) {
a0d0e21e 2221 case CXt_SUB:
f86702cc 2222 popsub2 = TRUE;
f39bc417 2223 retop = cx->blk_sub.retop;
5dd42e15 2224 cxstack_ix++; /* preserve cx entry on stack for use by POPSUB */
a0d0e21e
LW
2225 break;
2226 case CXt_EVAL:
b45de488
GS
2227 if (!(PL_in_eval & EVAL_KEEPERR))
2228 clear_errsv = TRUE;
a0d0e21e 2229 POPEVAL(cx);
b6494f15 2230 namesv = cx->blk_eval.old_namesv;
f39bc417 2231 retop = cx->blk_eval.retop;
1d76a5c3
GS
2232 if (CxTRYBLOCK(cx))
2233 break;
748a9306
LW
2234 if (optype == OP_REQUIRE &&
2235 (MARK == SP || (gimme == G_SCALAR && !SvTRUE(*SP))) )
2236 {
54310121 2237 /* Unassume the success we assumed earlier. */
b6494f15
VP
2238 (void)hv_delete(GvHVn(PL_incgv),
2239 SvPVX_const(namesv), SvCUR(namesv),
2240 G_DISCARD);
2241 DIE(aTHX_ "%"SVf" did not return a true value", SVfARG(namesv));
748a9306 2242 }
a0d0e21e 2243 break;
7766f137
GS
2244 case CXt_FORMAT:
2245 POPFORMAT(cx);
f39bc417 2246 retop = cx->blk_sub.retop;
7766f137 2247 break;
a0d0e21e 2248 default:
cea2e8a9 2249 DIE(aTHX_ "panic: return");
a0d0e21e
LW
2250 }
2251
a1f49e72 2252 TAINT_NOT;
a0d0e21e 2253 if (gimme == G_SCALAR) {
a29cdaf0
IZ
2254 if (MARK < SP) {
2255 if (popsub2) {
a8bba7fa 2256 if (cx->blk_sub.cv && CvDEPTH(cx->blk_sub.cv) > 1) {
a29cdaf0
IZ
2257 if (SvTEMP(TOPs)) {
2258 *++newsp = SvREFCNT_inc(*SP);
2259 FREETMPS;
2260 sv_2mortal(*newsp);
959e3673
GS
2261 }
2262 else {
2263 sv = SvREFCNT_inc(*SP); /* FREETMPS could clobber it */
a29cdaf0 2264 FREETMPS;
959e3673
GS
2265 *++newsp = sv_mortalcopy(sv);
2266 SvREFCNT_dec(sv);
a29cdaf0 2267 }
959e3673
GS
2268 }
2269 else
a29cdaf0 2270 *++newsp = (SvTEMP(*SP)) ? *SP : sv_mortalcopy(*SP);
959e3673
GS
2271 }
2272 else
a29cdaf0 2273 *++newsp = sv_mortalcopy(*SP);
959e3673
GS
2274 }
2275 else
3280af22 2276 *++newsp = &PL_sv_undef;
a0d0e21e 2277 }
54310121 2278 else if (gimme == G_ARRAY) {
a1f49e72 2279 while (++MARK <= SP) {
f86702cc
PP
2280 *++newsp = (popsub2 && SvTEMP(*MARK))
2281 ? *MARK : sv_mortalcopy(*MARK);
a1f49e72
CS
2282 TAINT_NOT; /* Each item is independent */
2283 }
a0d0e21e 2284 }
3280af22 2285 PL_stack_sp = newsp;
a0d0e21e 2286
5dd42e15 2287 LEAVE;
f86702cc
PP
2288 /* Stack values are safe: */
2289 if (popsub2) {
5dd42e15 2290 cxstack_ix--;
b0d9ce38 2291 POPSUB(cx,sv); /* release CV and @_ ... */
f86702cc 2292 }
b0d9ce38 2293 else
c445ea15 2294 sv = NULL;
3280af22 2295 PL_curpm = newpm; /* ... and pop $1 et al */
f86702cc 2296
b0d9ce38 2297 LEAVESUB(sv);
8433848b 2298 if (clear_errsv) {
ab69dbc2 2299 CLEAR_ERRSV();
8433848b 2300 }
f39bc417 2301 return retop;
a0d0e21e
LW
2302}
2303
2304PP(pp_last)
2305{
27da23d5 2306 dVAR; dSP;
a0d0e21e 2307 I32 cxix;
c09156bb 2308 register PERL_CONTEXT *cx;
f86702cc 2309 I32 pop2 = 0;
a0d0e21e 2310 I32 gimme;
8772537c 2311 I32 optype;
b263a1ad 2312 OP *nextop = NULL;
a0d0e21e
LW
2313 SV **newsp;
2314 PMOP *newpm;
a8bba7fa 2315 SV **mark;
c445ea15 2316 SV *sv = NULL;
9d4ba2ae 2317
a0d0e21e 2318
533c011a 2319 if (PL_op->op_flags & OPf_SPECIAL) {
a0d0e21e
LW
2320 cxix = dopoptoloop(cxstack_ix);
2321 if (cxix < 0)
a651a37d 2322 DIE(aTHX_ "Can't \"last\" outside a loop block");
a0d0e21e
LW
2323 }
2324 else {
2325 cxix = dopoptolabel(cPVOP->op_pv);
2326 if (cxix < 0)
cea2e8a9 2327 DIE(aTHX_ "Label not found for \"last %s\"", cPVOP->op_pv);
a0d0e21e
LW
2328 }
2329 if (cxix < cxstack_ix)
2330 dounwind(cxix);
2331
2332 POPBLOCK(cx,newpm);
5dd42e15 2333 cxstack_ix++; /* temporarily protect top context */
a8bba7fa 2334 mark = newsp;
6b35e009 2335 switch (CxTYPE(cx)) {
c6fdafd0 2336 case CXt_LOOP_LAZYIV:
d01136d6 2337 case CXt_LOOP_LAZYSV:
3b719c58
NC
2338 case CXt_LOOP_FOR:
2339 case CXt_LOOP_PLAIN:
2340 pop2 = CxTYPE(cx);
a8bba7fa 2341 newsp = PL_stack_base + cx->blk_loop.resetsp;
022eaa24 2342 nextop = cx->blk_loop.my_op->op_lastop->op_next;
a0d0e21e 2343 break;
f86702cc 2344 case CXt_SUB:
f86702cc 2345 pop2 = CXt_SUB;
f39bc417 2346 nextop = cx->blk_sub.retop;
a0d0e21e 2347 break;
f86702cc
PP
2348 case CXt_EVAL:
2349 POPEVAL(cx);
f39bc417 2350 nextop = cx->blk_eval.retop;
a0d0e21e 2351 break;
7766f137
GS
2352 case CXt_FORMAT:
2353 POPFORMAT(cx);
f39bc417 2354 nextop = cx->blk_sub.retop;
7766f137 2355 break;
a0d0e21e 2356 default:
cea2e8a9 2357 DIE(aTHX_ "panic: last");
a0d0e21e
LW
2358 }
2359
a1f49e72 2360 TAINT_NOT;
a0d0e21e 2361 if (gimme == G_SCALAR) {
f86702cc
PP
2362 if (MARK < SP)
2363 *++newsp = ((pop2 == CXt_SUB) && SvTEMP(*SP))
2364 ? *SP : sv_mortalcopy(*SP);
a0d0e21e 2365 else
3280af22 2366 *++newsp = &PL_sv_undef;
a0d0e21e 2367 }
54310121 2368 else if (gimme == G_ARRAY) {
a1f49e72 2369 while (++MARK <= SP) {
f86702cc
PP
2370 *++newsp = ((pop2 == CXt_SUB) && SvTEMP(*MARK))
2371 ? *MARK : sv_mortalcopy(*MARK);
a1f49e72
CS
2372 TAINT_NOT; /* Each item is independent */
2373 }
f86702cc
PP
2374 }
2375 SP = newsp;
2376 PUTBACK;
2377
5dd42e15
DM
2378 LEAVE;
2379 cxstack_ix--;
f86702cc
PP
2380 /* Stack values are safe: */
2381 switch (pop2) {
c6fdafd0 2382 case CXt_LOOP_LAZYIV:
3b719c58 2383 case CXt_LOOP_PLAIN:
d01136d6 2384 case CXt_LOOP_LAZYSV:
3b719c58 2385 case CXt_LOOP_FOR:
a8bba7fa 2386 POPLOOP(cx); /* release loop vars ... */
4fdae800 2387 LEAVE;
f86702cc
PP
2388 break;
2389 case CXt_SUB:
b0d9ce38 2390 POPSUB(cx,sv); /* release CV and @_ ... */
f86702cc 2391 break;
a0d0e21e 2392 }
3280af22 2393 PL_curpm = newpm; /* ... and pop $1 et al */
a0d0e21e 2394
b0d9ce38 2395 LEAVESUB(sv);
9d4ba2ae
AL
2396 PERL_UNUSED_VAR(optype);
2397 PERL_UNUSED_VAR(gimme);
f86702cc 2398 return nextop;
a0d0e21e
LW
2399}
2400
2401PP(pp_next)
2402{
27da23d5 2403 dVAR;
a0d0e21e 2404 I32 cxix;
c09156bb 2405 register PERL_CONTEXT *cx;
85538317 2406 I32 inner;
a0d0e21e 2407
533c011a 2408 if (PL_op->op_flags & OPf_SPECIAL) {
a0d0e21e
LW
2409 cxix = dopoptoloop(cxstack_ix);
2410 if (cxix < 0)
a651a37d 2411 DIE(aTHX_ "Can't \"next\" outside a loop block");
a0d0e21e
LW
2412 }
2413 else {
2414 cxix = dopoptolabel(cPVOP->op_pv);
2415 if (cxix < 0)
cea2e8a9 2416 DIE(aTHX_ "Label not found for \"next %s\"", cPVOP->op_pv);
a0d0e21e
LW
2417 }
2418 if (cxix < cxstack_ix)
2419 dounwind(cxix);
2420
85538317
GS
2421 /* clear off anything above the scope we're re-entering, but
2422 * save the rest until after a possible continue block */
2423 inner = PL_scopestack_ix;
1ba6ee2b 2424 TOPBLOCK(cx);
85538317
GS
2425 if (PL_scopestack_ix < inner)
2426 leave_scope(PL_scopestack[PL_scopestack_ix]);
3a1b2b9e 2427 PL_curcop = cx->blk_oldcop;
d57ce4df 2428 return (cx)->blk_loop.my_op->op_nextop;
a0d0e21e
LW
2429}
2430
2431PP(pp_redo)
2432{
27da23d5 2433 dVAR;
a0d0e21e 2434 I32 cxix;
c09156bb 2435 register PERL_CONTEXT *cx;
a0d0e21e 2436 I32 oldsave;
a034e688 2437 OP* redo_op;
a0d0e21e 2438
533c011a 2439 if (PL_op->op_flags & OPf_SPECIAL) {
a0d0e21e
LW
2440 cxix = dopoptoloop(cxstack_ix);
2441 if (cxix < 0)
a651a37d 2442 DIE(aTHX_ "Can't \"redo\" outside a loop block");
a0d0e21e
LW
2443 }
2444 else {
2445 cxix = dopoptolabel(cPVOP->op_pv);
2446 if (cxix < 0)
cea2e8a9 2447 DIE(aTHX_ "Label not found for \"redo %s\"", cPVOP->op_pv);
a0d0e21e
LW
2448 }
2449 if (cxix < cxstack_ix)
2450 dounwind(cxix);
2451
022eaa24 2452 redo_op = cxstack[cxix].blk_loop.my_op->op_redoop;
a034e688
DM
2453 if (redo_op->op_type == OP_ENTER) {
2454 /* pop one less context to avoid $x being freed in while (my $x..) */
2455 cxstack_ix++;
2456 assert(CxTYPE(&cxstack[cxstack_ix]) == CXt_BLOCK);
2457 redo_op = redo_op->op_next;
2458 }
2459
a0d0e21e 2460 TOPBLOCK(cx);
3280af22 2461 oldsave = PL_scopestack[PL_scopestack_ix - 1];
a0d0e21e 2462 LEAVE_SCOPE(oldsave);
936c78b5 2463 FREETMPS;
3a1b2b9e 2464 PL_curcop = cx->blk_oldcop;
a034e688 2465 return redo_op;
a0d0e21e
LW
2466}
2467
0824fdcb 2468STATIC OP *
bfed75c6 2469S_dofindlabel(pTHX_ OP *o, const char *label, OP **opstack, OP **oplimit)
a0d0e21e 2470{
97aff369 2471 dVAR;
a0d0e21e 2472 OP **ops = opstack;
bfed75c6 2473 static const char too_deep[] = "Target of goto is too deeply nested";
a0d0e21e 2474
7918f24d
NC
2475 PERL_ARGS_ASSERT_DOFINDLABEL;
2476
fc36a67e 2477 if (ops >= oplimit)
cea2e8a9 2478 Perl_croak(aTHX_ too_deep);
11343788
MB
2479 if (o->op_type == OP_LEAVE ||
2480 o->op_type == OP_SCOPE ||
2481 o->op_type == OP_LEAVELOOP ||
33d34e4c 2482 o->op_type == OP_LEAVESUB ||
11343788 2483 o->op_type == OP_LEAVETRY)
fc36a67e 2484 {
5dc0d613 2485 *ops++ = cUNOPo->op_first;
fc36a67e 2486 if (ops >= oplimit)
cea2e8a9 2487 Perl_croak(aTHX_ too_deep);
fc36a67e 2488 }
c4aa4e48 2489 *ops = 0;
11343788 2490 if (o->op_flags & OPf_KIDS) {
aec46f14 2491 OP *kid;
a0d0e21e 2492 /* First try all the kids at this level, since that's likeliest. */
11343788 2493 for (kid = cUNOPo->op_first; kid; kid = kid->op_sibling) {
7e8f1eac
AD
2494 if (kid->op_type == OP_NEXTSTATE || kid->op_type == OP_DBSTATE) {
2495 const char *kid_label = CopLABEL(kCOP);
2496 if (kid_label && strEQ(kid_label, label))
2497 return kid;
2498 }
a0d0e21e 2499 }
11343788 2500 for (kid = cUNOPo->op_first; kid; kid = kid->op_sibling) {
3280af22 2501 if (kid == PL_lastgotoprobe)
a0d0e21e 2502 continue;
ed8d0fe2
SM
2503 if (kid->op_type == OP_NEXTSTATE || kid->op_type == OP_DBSTATE) {
2504 if (ops == opstack)
2505 *ops++ = kid;
2506 else if (ops[-1]->op_type == OP_NEXTSTATE ||
2507 ops[-1]->op_type == OP_DBSTATE)
2508 ops[-1] = kid;
2509 else
2510 *ops++ = kid;
2511 }
155aba94 2512 if ((o = dofindlabel(kid, label, ops, oplimit)))
11343788 2513 return o;
a0d0e21e
LW
2514 }
2515 }
c4aa4e48 2516 *ops = 0;
a0d0e21e
LW
2517 return 0;
2518}
2519
a0d0e21e
LW
2520PP(pp_goto)
2521{
27da23d5 2522 dVAR; dSP;
cbbf8932 2523 OP *retop = NULL;
a0d0e21e 2524 I32 ix;
c09156bb 2525 register PERL_CONTEXT *cx;
fc36a67e
PP
2526#define GOTO_DEPTH 64
2527 OP *enterops[GOTO_DEPTH];
cbbf8932 2528 const char *label = NULL;
bfed75c6
AL
2529 const bool do_dump = (PL_op->op_type == OP_DUMP);
2530 static const char must_have_label[] = "goto must have label";
a0d0e21e 2531
533c011a 2532 if (PL_op->op_flags & OPf_STACKED) {
9d4ba2ae 2533 SV * const sv = POPs;
a0d0e21e
LW
2534
2535 /* This egregious kludge implements goto &subroutine */
2536 if (SvROK(sv) && SvTYPE(SvRV(sv)) == SVt_PVCV) {
2537 I32 cxix;
c09156bb 2538 register PERL_CONTEXT *cx;
ea726b52 2539 CV *cv = MUTABLE_CV(SvRV(sv));
a0d0e21e
LW
2540 SV** mark;
2541 I32 items = 0;
2542 I32 oldsave;
b1464ded 2543 bool reified = 0;
a0d0e21e 2544
e8f7dd13 2545 retry:
4aa0a1f7 2546 if (!CvROOT(cv) && !CvXSUB(cv)) {
7fc63493 2547 const GV * const gv = CvGV(cv);
e8f7dd13 2548 if (gv) {
7fc63493 2549 GV *autogv;
e8f7dd13
GS
2550 SV *tmpstr;
2551 /* autoloaded stub? */
2552 if (cv != GvCV(gv) && (cv = GvCV(gv)))
2553 goto retry;
2554 autogv = gv_autoload4(GvSTASH(gv), GvNAME(gv),
2555 GvNAMELEN(gv), FALSE);
2556 if (autogv && (cv = GvCV(autogv)))
2557 goto retry;
2558 tmpstr = sv_newmortal();
c445ea15 2559 gv_efullname3(tmpstr, gv, NULL);
be2597df 2560 DIE(aTHX_ "Goto undefined subroutine &%"SVf"", SVfARG(tmpstr));
4aa0a1f7 2561 }
cea2e8a9 2562 DIE(aTHX_ "Goto undefined subroutine");
4aa0a1f7
AD
2563 }
2564
a0d0e21e 2565 /* First do some returnish stuff. */
b37c2d43 2566 SvREFCNT_inc_simple_void(cv); /* avoid premature free during unwind */
71fc2216 2567 FREETMPS;
a0d0e21e
LW
2568 cxix = dopoptosub(cxstack_ix);
2569 if (cxix < 0)
cea2e8a9 2570 DIE(aTHX_ "Can't goto subroutine outside a subroutine");
a0d0e21e
LW
2571 if (cxix < cxstack_ix)
2572 dounwind(cxix);
2573 TOPBLOCK(cx);
2d43a17f 2574 SPAGAIN;
564abe23 2575 /* ban goto in eval: see <20050521150056.GC20213@iabyn.com> */
2d43a17f 2576 if (CxTYPE(cx) == CXt_EVAL) {
c74ace89
DM
2577 if (CxREALEVAL(cx))
2578 DIE(aTHX_ "Can't goto subroutine from an eval-string");
2579 else
2580 DIE(aTHX_ "Can't goto subroutine from an eval-block");
2d43a17f 2581 }
9850bf21
RH
2582 else if (CxMULTICALL(cx))
2583 DIE(aTHX_ "Can't goto subroutine from a sort sub (or similar callback)");
bafb2adc 2584 if (CxTYPE(cx) == CXt_SUB && CxHASARGS(cx)) {
d8b46c1b 2585 /* put @_ back onto stack */
a0d0e21e 2586 AV* av = cx->blk_sub.argarray;
bfed75c6 2587
93965878 2588 items = AvFILLp(av) + 1;
a45cdc79
DM
2589 EXTEND(SP, items+1); /* @_ could have been extended. */
2590 Copy(AvARRAY(av), SP + 1, items, SV*);
3280af22
NIS
2591 SvREFCNT_dec(GvAV(PL_defgv));
2592 GvAV(PL_defgv) = cx->blk_sub.savearray;
b1464ded 2593 CLEAR_ARGARRAY(av);
d8b46c1b 2594 /* abandon @_ if it got reified */
62b1ebc2 2595 if (AvREAL(av)) {
b1464ded
DM
2596 reified = 1;
2597 SvREFCNT_dec(av);
d8b46c1b
GS
2598 av = newAV();
2599 av_extend(av, items-1);
11ca45c0 2600 AvREIFY_only(av);
ad64d0ec 2601 PAD_SVl(0) = MUTABLE_SV(cx->blk_sub.argarray = av);
62b1ebc2 2602 }
a0d0e21e 2603 }
aed2304a 2604 else if (CvISXSUB(cv)) { /* put GvAV(defgv) back onto stack */
890ce7af 2605 AV* const av = GvAV(PL_defgv);
1fa4e549 2606 items = AvFILLp(av) + 1;
a45cdc79
DM
2607 EXTEND(SP, items+1); /* @_ could have been extended. */
2608 Copy(AvARRAY(av), SP + 1, items, SV*);
1fa4e549 2609 }
a45cdc79
DM
2610 mark = SP;
2611 SP += items;
6b35e009 2612 if (CxTYPE(cx) == CXt_SUB &&
b150fb22 2613 !(CvDEPTH(cx->blk_sub.cv) = cx->blk_sub.olddepth))
a0d0e21e 2614 SvREFCNT_dec(cx->blk_sub.cv);
3280af22 2615 oldsave = PL_scopestack[PL_scopestack_ix - 1];
a0d0e21e
LW
2616 LEAVE_SCOPE(oldsave);
2617
2618 /* Now do some callish stuff. */
2619 SAVETMPS;
5023d17a 2620 SAVEFREESV(cv); /* later, undo the 'avoid premature free' hack */
aed2304a 2621 if (CvISXSUB(cv)) {
b37c2d43 2622 OP* const retop = cx->blk_sub.retop;
f73ef291
NC
2623 SV **newsp;
2624 I32 gimme;
b1464ded
DM
2625 if (reified) {
2626 I32 index;
2627 for (index=0; index<items; index++)
2628 sv_2mortal(SP[-index]);
2629 }
1fa4e549 2630
b37c2d43
AL
2631 /* XS subs don't have a CxSUB, so pop it */
2632 POPBLOCK(cx, PL_curpm);
2633 /* Push a mark for the start of arglist */
2634 PUSHMARK(mark);
2635 PUTBACK;
2636 (void)(*CvXSUB(cv))(aTHX_ cv);
a57c6685 2637 LEAVE;
5eff7df7 2638 return retop;
a0d0e21e
LW
2639 }
2640 else {
b37c2d43 2641 AV* const padlist = CvPADLIST(cv);
6b35e009 2642 if (CxTYPE(cx) == CXt_EVAL) {
85a64632 2643 PL_in_eval = CxOLD_IN_EVAL(cx);
3280af22 2644 PL_eval_root = cx->blk_eval.old_eval_root;
b150fb22 2645 cx->cx_type = CXt_SUB;
b150fb22 2646 }
a0d0e21e 2647 cx->blk_sub.cv = cv;
1a5b3db4 2648 cx->blk_sub.olddepth = CvDEPTH(cv);
dd2155a4 2649
a0d0e21e
LW
2650 CvDEPTH(cv)++;
2651 if (CvDEPTH(cv) < 2)
74c765eb 2652 SvREFCNT_inc_simple_void_NN(cv);
dd2155a4 2653 else {
2b9dff67 2654 if (CvDEPTH(cv) == PERL_SUB_DEPTH_WARN && ckWARN(WARN_RECURSION))
44a8e56a 2655 sub_crush_depth(cv);
26019298 2656 pad_push(padlist, CvDEPTH(cv));
a0d0e21e 2657 }
fd617465
DM
2658 SAVECOMPPAD();
2659 PAD_SET_CUR_NOSAVE(padlist, CvDEPTH(cv));
bafb2adc 2660 if (CxHASARGS(cx))
6d4ff0d2 2661 {
502c6561 2662 AV *const av = MUTABLE_AV(PAD_SVl(0));
a0d0e21e 2663
3280af22 2664 cx->blk_sub.savearray = GvAV(PL_defgv);
502c6561 2665 GvAV(PL_defgv) = MUTABLE_AV(SvREFCNT_inc_simple(av));
dd2155a4 2666 CX_CURPAD_SAVE(cx->blk_sub);
6d4ff0d2 2667 cx->blk_sub.argarray = av;
a0d0e21e
LW
2668
2669 if (items >= AvMAX(av) + 1) {
b37c2d43 2670 SV **ary = AvALLOC(av);
a0d0e21e
LW
2671 if (AvARRAY(av) != ary) {
2672 AvMAX(av) += AvARRAY(av) - AvALLOC(av);
9c6bc640 2673 AvARRAY(av) = ary;
a0d0e21e
LW
2674 }
2675 if (items >= AvMAX(av) + 1) {
2676 AvMAX(av) = items - 1;
2677 Renew(ary,items+1,SV*);
2678 AvALLOC(av) = ary;
9c6bc640 2679 AvARRAY(av) = ary;
a0d0e21e
LW
2680 }
2681 }
a45cdc79 2682 ++mark;
a0d0e21e 2683 Copy(mark,AvARRAY(av),items,SV*);
93965878 2684 AvFILLp(av) = items - 1;
d8b46c1b 2685 assert(!AvREAL(av));
b1464ded
DM
2686 if (reified) {
2687 /* transfer 'ownership' of refcnts to new @_ */
2688 AvREAL_on(av);
2689 AvREIFY_off(av);
2690 }
a0d0e21e
LW
2691 while (items--) {
2692 if (*mark)
2693 SvTEMP_off(*mark);
2694 mark++;
2695 }
2696 }
491527d0 2697 if (PERLDB_SUB) { /* Checking curstash breaks DProf. */
005a8a35 2698 Perl_get_db_sub(aTHX_ NULL, cv);
b37c2d43 2699 if (PERLDB_GOTO) {
b96d8cd9 2700 CV * const gotocv = get_cvs("DB::goto", 0);
b37c2d43
AL
2701 if (gotocv) {
2702 PUSHMARK( PL_stack_sp );
ad64d0ec 2703 call_sv(MUTABLE_SV(gotocv), G_SCALAR | G_NODEBUG);
b37c2d43
AL
2704 PL_stack_sp--;
2705 }
491527d0 2706 }
1ce6579f 2707 }
a0d0e21e
LW
2708 RETURNOP(CvSTART(cv));
2709 }
2710 }
1614b0e3 2711 else {
0510663f 2712 label = SvPV_nolen_const(sv);
1614b0e3 2713 if (!(do_dump || *label))
cea2e8a9 2714 DIE(aTHX_ must_have_label);
1614b0e3 2715 }
a0d0e21e 2716 }
533c011a 2717 else if (PL_op->op_flags & OPf_SPECIAL) {
a0d0e21e 2718 if (! do_dump)
cea2e8a9 2719 DIE(aTHX_ must_have_label);
a0d0e21e
LW
2720 }
2721 else
2722 label = cPVOP->op_pv;
2723
f410a211
NC
2724 PERL_ASYNC_CHECK();
2725
a0d0e21e 2726 if (label && *label) {
cbbf8932 2727 OP *gotoprobe = NULL;
3b2447bc 2728 bool leaving_eval = FALSE;
33d34e4c 2729 bool in_block = FALSE;
cbbf8932 2730 PERL_CONTEXT *last_eval_cx = NULL;
a0d0e21e
LW
2731
2732 /* find label */
2733
d4c19fe8 2734 PL_lastgotoprobe = NULL;
a0d0e21e
LW
2735 *enterops = 0;
2736 for (ix = cxstack_ix; ix >= 0; ix--) {
2737 cx = &cxstack[ix];
6b35e009 2738 switch (CxTYPE(cx)) {
a0d0e21e 2739 case CXt_EVAL:
3b2447bc 2740 leaving_eval = TRUE;
971ecbe6 2741 if (!CxTRYBLOCK(cx)) {
a4f3a277
RH
2742 gotoprobe = (last_eval_cx ?
2743 last_eval_cx->blk_eval.old_eval_root :
2744 PL_eval_root);
2745 last_eval_cx = cx;
9c5794fe
RH
2746 break;
2747 }
2748 /* else fall through */
c6fdafd0 2749 case CXt_LOOP_LAZYIV:
d01136d6 2750 case CXt_LOOP_LAZYSV:
3b719c58
NC
2751 case CXt_LOOP_FOR:
2752 case CXt_LOOP_PLAIN:
bb5aedc1
VP
2753 case CXt_GIVEN:
2754 case CXt_WHEN:
a0d0e21e
LW
2755 gotoprobe = cx->blk_oldcop->op_sibling;
2756 break;
2757 case CXt_SUBST:
2758 continue;
2759 case CXt_BLOCK:
33d34e4c 2760 if (ix) {
a0d0e21e 2761 gotoprobe = cx->blk_oldcop->op_sibling;
33d34e4c
AE
2762 in_block = TRUE;
2763 } else
3280af22 2764 gotoprobe = PL_main_root;
a0d0e21e 2765 break;
b3933176 2766 case CXt_SUB:
9850bf21 2767 if (CvDEPTH(cx->blk_sub.cv) && !CxMULTICALL(cx)) {
b3933176
CS
2768 gotoprobe = CvROOT(cx->blk_sub.cv);
2769 break;
2770 }
2771 /* FALL THROUGH */
7766f137 2772 case CXt_FORMAT:
0a753a76 2773 case CXt_NULL:
a651a37d 2774 DIE(aTHX_ "Can't \"goto\" out of a pseudo block");
a0d0e21e
LW
2775 default:
2776 if (ix)
cea2e8a9 2777 DIE(aTHX_ "panic: goto");
3280af22 2778 gotoprobe = PL_main_root;
a0d0e21e
LW
2779 break;
2780 }
2b597662
GS
2781 if (gotoprobe) {
2782 retop = dofindlabel(gotoprobe, label,
2783 enterops, enterops + GOTO_DEPTH);
2784 if (retop)
2785 break;
2786 }
3280af22 2787 PL_lastgotoprobe = gotoprobe;
a0d0e21e
LW
2788 }
2789 if (!retop)
cea2e8a9 2790 DIE(aTHX_ "Can't find label %s", label);
a0d0e21e 2791
3b2447bc
RH
2792 /* if we're leaving an eval, check before we pop any frames
2793 that we're not going to punt, otherwise the error
2794 won't be caught */
2795
2796 if (leaving_eval && *enterops && enterops[1]) {
2797 I32 i;
2798 for (i = 1; enterops[i]; i++)
2799 if (enterops[i]->op_type == OP_ENTERITER)
2800 DIE(aTHX_ "Can't \"goto\" into the middle of a foreach loop");
2801 }
2802
b500e03b
GG
2803 if (*enterops && enterops[1]) {
2804 I32 i = enterops[1]->op_type == OP_ENTER && in_block ? 2 : 1;
2805 if (enterops[i])
2806 deprecate("\"goto\" to jump into a construct");
2807 }
2808
a0d0e21e
LW
2809 /* pop unwanted frames */
2810
2811 if (ix < cxstack_ix) {
2812 I32 oldsave;
2813
2814 if (ix < 0)
2815 ix = 0;
2816 dounwind(ix);
2817 TOPBLOCK(cx);
3280af22 2818 oldsave = PL_scopestack[PL_scopestack_ix];
a0d0e21e
LW
2819 LEAVE_SCOPE(oldsave);
2820 }
2821
2822 /* push wanted frames */
2823
748a9306 2824 if (*enterops && enterops[1]) {
0bd48802 2825 OP * const oldop = PL_op;
33d34e4c
AE
2826 ix = enterops[1]->op_type == OP_ENTER && in_block ? 2 : 1;
2827 for (; enterops[ix]; ix++) {
533c011a 2828 PL_op = enterops[ix];
84902520
TB
2829 /* Eventually we may want to stack the needed arguments
2830 * for each op. For now, we punt on the hard ones. */
533c011a 2831 if (PL_op->op_type == OP_ENTERITER)
894356b3 2832 DIE(aTHX_ "Can't \"goto\" into the middle of a foreach loop");
16c91539 2833 PL_op->op_ppaddr(aTHX);
a0d0e21e 2834 }
533c011a 2835 PL_op = oldop;
a0d0e21e
LW
2836 }
2837 }
2838
2839 if (do_dump) {
a5f75d66 2840#ifdef VMS
6b88bc9c 2841 if (!retop) retop = PL_main_start;
a5f75d66 2842#endif
3280af22
NIS
2843 PL_restartop = retop;
2844 PL_do_undump = TRUE;
a0d0e21e
LW
2845
2846 my_unexec();
2847
3280af22
NIS
2848 PL_restartop = 0; /* hmm, must be GNU unexec().. */
2849 PL_do_undump = FALSE;
a0d0e21e
LW
2850 }
2851
2852 RETURNOP(retop);
2853}
2854
2855PP(pp_exit)
2856{
97aff369 2857 dVAR;
39644a26 2858 dSP;
a0d0e21e
LW
2859 I32 anum;
2860
2861 if (MAXARG < 1)
2862 anum = 0;
ff0cee69 2863 else {
a0d0e21e 2864 anum = SvIVx(POPs);
d98f61e7
GS
2865#ifdef VMS
2866 if (anum == 1 && (PL_op->op_private & OPpEXIT_VMSISH))
ff0cee69 2867 anum = 0;
96e176bf 2868 VMSISH_HUSHED = VMSISH_HUSHED || (PL_op->op_private & OPpHUSH_VMSISH);
ff0cee69
PP
2869#endif
2870 }
cc3604b1 2871 PL_exit_flags |= PERL_EXIT_EXPECTED;
81d86705
NC
2872#ifdef PERL_MAD
2873 /* KLUDGE: disable exit 0 in BEGIN blocks when we're just compiling */
2874 if (anum || !(PL_minus_c && PL_madskills))
2875 my_exit(anum);
2876#else
a0d0e21e 2877 my_exit(anum);
81d86705 2878#endif
3280af22 2879 PUSHs(&PL_sv_undef);
a0d0e21e
LW
2880 RETURN;
2881}
2882
a0d0e21e
LW
2883/* Eval. */
2884
0824fdcb 2885STATIC void
cea2e8a9 2886S_save_lines(pTHX_ AV *array, SV *sv)
a0d0e21e 2887{
504618e9 2888 const char *s = SvPVX_const(sv);
890ce7af 2889 const char * const send = SvPVX_const(sv) + SvCUR(sv);
504618e9 2890 I32 line = 1;
a0d0e21e 2891
7918f24d
NC
2892 PERL_ARGS_ASSERT_SAVE_LINES;
2893
a0d0e21e 2894 while (s && s < send) {
f54cb97a 2895 const char *t;
b9f83d2f 2896 SV * const tmpstr = newSV_type(SVt_PVMG);
a0d0e21e 2897
1d963ff3 2898 t = (const char *)memchr(s, '\n', send - s);
a0d0e21e
LW
2899 if (t)
2900 t++;
2901 else
2902 t = send;
2903
2904 sv_setpvn(tmpstr, s, t - s);
2905 av_store(array, line++, tmpstr);
2906 s = t;
2907 }
2908}
2909
22f16304
RU
2910/*
2911=for apidoc docatch
2912
2913Check for the cases 0 or 3 of cur_env.je_ret, only used inside an eval context.
2914
29150 is used as continue inside eval,
2916
29173 is used for a die caught by an inner eval - continue inner loop
2918
2919See cop.h: je_mustcatch, when set at any runlevel to TRUE, means eval ops must
2920establish a local jmpenv to handle exception traps.
2921
2922=cut
2923*/
0824fdcb 2924STATIC OP *
cea2e8a9 2925S_docatch(pTHX_ OP *o)
1e422769 2926{
97aff369 2927 dVAR;
6224f72b 2928 int ret;
06b5626a 2929 OP * const oldop = PL_op;
db36c5a1 2930 dJMPENV;
1e422769 2931
1e422769 2932#ifdef DEBUGGING
54310121 2933 assert(CATCH_GET == TRUE);
1e422769 2934#endif
312caa8e 2935 PL_op = o;
8bffa5f8 2936
14dd3ad8 2937 JMPENV_PUSH(ret);
6224f72b 2938 switch (ret) {
312caa8e 2939 case 0:
abd70938
DM
2940 assert(cxstack_ix >= 0);
2941 assert(CxTYPE(&cxstack[cxstack_ix]) == CXt_EVAL);
2942 cxstack[cxstack_ix].blk_eval.cur_top_env = PL_top_env;
14dd3ad8 2943 redo_body:
85aaa934 2944 CALLRUNOPS(aTHX);
312caa8e
CS
2945 break;
2946 case 3:
8bffa5f8 2947 /* die caught by an inner eval - continue inner loop */
febb3a6d
Z
2948 if (PL_restartop && PL_restartjmpenv == PL_top_env) {
2949 PL_restartjmpenv = NULL;
312caa8e
CS
2950 PL_op = PL_restartop;
2951 PL_restartop = 0;
2952 goto redo_body;
2953 }
2954 /* FALL THROUGH */
2955 default:
14dd3ad8 2956 JMPENV_POP;
533c011a 2957 PL_op = oldop;
6224f72b 2958 JMPENV_JUMP(ret);
1e422769 2959 /* NOTREACHED */
1e422769 2960 }
14dd3ad8 2961 JMPENV_POP;
533c011a 2962 PL_op = oldop;
5f66b61c 2963 return NULL;
1e422769
PP
2964}
2965
ee23ad3b
NC
2966/* James Bond: Do you expect me to talk?
2967 Auric Goldfinger: No, Mr. Bond. I expect you to die.
2968
2969 This code is an ugly hack, doesn't work with lexicals in subroutines that are
2970 called more than once, and is only used by regcomp.c, for (?{}) blocks.
2971
2972 Currently it is not used outside the core code. Best if it stays that way.
2973*/
c277df42 2974OP *
bfed75c6 2975Perl_sv_compile_2op(pTHX_ SV *sv, OP** startop, const char *code, PAD** padp)
c277df42
IZ
2976/* sv Text to convert to OP tree. */
2977/* startop op_free() this to undo. */
2978/* code Short string id of the caller. */
2979{
27da23d5 2980 dVAR; dSP; /* Make POPBLOCK work. */
c277df42
IZ
2981 PERL_CONTEXT *cx;
2982 SV **newsp;
b094c71d 2983 I32 gimme = G_VOID;
c277df42
IZ
2984 I32 optype;
2985 OP dummy;
83ee9e09
GS
2986 char tbuf[TYPE_DIGITS(long) + 12 + 10];
2987 char *tmpbuf = tbuf;
c277df42 2988 char *safestr;
a3985cdc 2989 int runtime;
601f1833 2990 CV* runcv = NULL; /* initialise to avoid compiler warnings */
f7997f86 2991 STRLEN len;
634d6919 2992 bool need_catch;
c277df42 2993
7918f24d
NC
2994 PERL_ARGS_ASSERT_SV_COMPILE_2OP;
2995
d343c3ef 2996 ENTER_with_name("eval");
8eaa0acf 2997 lex_start(sv, NULL, 0);
c277df42
IZ
2998 SAVETMPS;
2999 /* switch to eval mode */
3000
923e4eb5 3001 if (IN_PERL_COMPILETIME) {
f4dd75d9 3002 SAVECOPSTASH_FREE(&PL_compiling);
11faa288 3003 CopSTASH_set(&PL_compiling, PL_curstash);
cbce877f 3004 }
83ee9e09 3005 if (PERLDB_NAMEEVAL && CopLINE(PL_curcop)) {
9d4ba2ae 3006 SV * const sv = sv_newmortal();
83ee9e09
GS
3007 Perl_sv_setpvf(aTHX_ sv, "_<(%.10seval %lu)[%s:%"IVdf"]",
3008 code, (unsigned long)++PL_evalseq,
3009 CopFILE(PL_curcop), (IV)CopLINE(PL_curcop));
3010 tmpbuf = SvPVX(sv);
fc009855 3011 len = SvCUR(sv);
83ee9e09
GS
3012 }
3013 else
d9fad198
JH
3014 len = my_snprintf(tmpbuf, sizeof(tbuf), "_<(%.10s_eval %lu)", code,
3015 (unsigned long)++PL_evalseq);
f4dd75d9 3016 SAVECOPFILE_FREE(&PL_compiling);
57843af0 3017 CopFILE_set(&PL_compiling, tmpbuf+2);
f4dd75d9 3018 SAVECOPLINE(&PL_compiling);
57843af0 3019 CopLINE_set(&PL_compiling, 1);
c277df42
IZ
3020 /* XXX For C<eval "...">s within BEGIN {} blocks, this ends up
3021 deleting the eval's FILEGV from the stash before gv_check() runs
3022 (i.e. before run-time proper). To work around the coredump that
3023 ensues, we always turn GvMULTI_on for any globals that were
3024 introduced within evals. See force_ident(). GSAR 96-10-12 */
f7997f86
NC
3025 safestr = savepvn(tmpbuf, len);
3026 SAVEDELETE(PL_defstash, safestr, len);
b3ac6de7 3027 SAVEHINTS();
d1ca3daa 3028#ifdef OP_IN_REGISTER
6b88bc9c 3029 PL_opsave = op;
d1ca3daa 3030#else
7766f137 3031 SAVEVPTR(PL_op);
d1ca3daa 3032#endif
c277df42 3033
a3985cdc 3034 /* we get here either during compilation, or via pp_regcomp at runtime */
923e4eb5 3035 runtime = IN_PERL_RUNTIME;
a3985cdc 3036 if (runtime)
d819b83a 3037 runcv = find_runcv(NULL);
a3985cdc 3038
533c011a 3039 PL_op = &dummy;
13b51b79 3040 PL_op->op_type = OP_ENTEREVAL;
533c011a 3041 PL_op->op_flags = 0; /* Avoid uninit warning. */
923e4eb5 3042 PUSHBLOCK(cx, CXt_EVAL|(IN_PERL_COMPILETIME ? 0 : CXp_REAL), SP);
6b75f042 3043 PUSHEVAL(cx, 0);
634d6919
GG
3044 need_catch = CATCH_GET;
3045 CATCH_SET(TRUE);
a3985cdc
DM
3046
3047 if (runtime)
410be5db 3048 (void) doeval(G_SCALAR, startop, runcv, PL_curcop->cop_seq);
a3985cdc 3049 else
410be5db 3050 (void) doeval(G_SCALAR, startop, PL_compcv, PL_cop_seqmax);
634d6919 3051 CATCH_SET(need_catch);
13b51b79 3052 POPBLOCK(cx,PL_curpm);
e84b9f1f 3053 POPEVAL(cx);
c277df42
IZ
3054
3055 (*startop)->op_type = OP_NULL;
22c35a8c 3056 (*startop)->op_ppaddr = PL_ppaddr[OP_NULL];
f3548bdc 3057 /* XXX DAPM do this properly one year */
502c6561 3058 *padp = MUTABLE_AV(SvREFCNT_inc_simple(PL_comppad));
d343c3ef 3059 LEAVE_with_name("eval");
923e4eb5 3060 if (IN_PERL_COMPILETIME)
623e6609 3061 CopHINTS_set(&PL_compiling, PL_hints);
d1ca3daa 3062#ifdef OP_IN_REGISTER
6b88bc9c 3063 op = PL_opsave;
d1ca3daa 3064#endif
9d4ba2ae
AL
3065 PERL_UNUSED_VAR(newsp);
3066 PERL_UNUSED_VAR(optype);
3067
410be5db 3068 return PL_eval_start;
c277df42
IZ
3069}
3070
a3985cdc
DM
3071
3072/*
3073=for apidoc find_runcv
3074
3075Locate the CV corresponding to the currently executing sub or eval.
d819b83a
DM
3076If db_seqp is non_null, skip CVs that are in the DB package and populate
3077*db_seqp with the cop sequence number at the point that the DB:: code was
3078entered. (allows debuggers to eval in the scope of the breakpoint rather
cf525c36 3079than in the scope of the debugger itself).
a3985cdc
DM
3080
3081=cut
3082*/
3083
3084CV*
d819b83a 3085Perl_find_runcv(pTHX_ U32 *db_seqp)
a3985cdc 3086{
97aff369 3087 dVAR;
a3985cdc 3088 PERL_SI *si;
a3985cdc 3089
d819b83a
DM
3090 if (db_seqp)
3091 *db_seqp = PL_curcop->cop_seq;
a3985cdc 3092 for (si = PL_curstackinfo; si; si = si->si_prev) {
06b5626a 3093 I32 ix;
a3985cdc 3094 for (ix = si->si_cxix; ix >= 0; ix--) {
06b5626a 3095 const PERL_CONTEXT *cx = &(si->si_cxstack[ix]);
d819b83a 3096 if (CxTYPE(cx) == CXt_SUB || CxTYPE(cx) == CXt_FORMAT) {
1b6737cc 3097 CV * const cv = cx->blk_sub.cv;
d819b83a
DM
3098 /* skip DB:: code */
3099 if (db_seqp && PL_debstash && CvSTASH(cv) == PL_debstash) {
3100 *db_seqp = cx->blk_oldcop->cop_seq;
3101 continue;
3102 }
3103 return cv;
3104 }
a3985cdc
DM
3105 else if (CxTYPE(cx) == CXt_EVAL && !CxTRYBLOCK(cx))
3106 return PL_compcv;
3107 }
3108 }
3109 return PL_main_cv;
3110}
3111
3112
27e90453
DM
3113/* Run yyparse() in a setjmp wrapper. Returns:
3114 * 0: yyparse() successful
3115 * 1: yyparse() failed
3116 * 3: yyparse() died
3117 */
3118STATIC int
28ac2b49 3119S_try_yyparse(pTHX_ int gramtype)
27e90453
DM
3120{
3121 int ret;
3122 dJMPENV;
3123
3124 assert(CxTYPE(&cxstack[cxstack_ix]) == CXt_EVAL);
3125 JMPENV_PUSH(ret);
3126 switch (ret) {
3127 case 0:
28ac2b49 3128 ret = yyparse(gramtype) ? 1 : 0;
27e90453
DM
3129 break;
3130 case 3:
3131 break;
3132 default:
3133 JMPENV_POP;
3134 JMPENV_JUMP(ret);
3135 /* NOTREACHED */
3136 }
3137 JMPENV_POP;
3138 return ret;
3139}
3140
3141
a3985cdc
DM
3142/* Compile a require/do, an eval '', or a /(?{...})/.
3143 * In the last case, startop is non-null, and contains the address of
3144 * a pointer that should be set to the just-compiled code.
3145 * outside is the lexically enclosing CV (if any) that invoked us.
410be5db
DM
3146 * Returns a bool indicating whether the compile was successful; if so,
3147 * PL_eval_start contains the first op of the compiled ocde; otherwise,
3148 * pushes undef (also croaks if startop != NULL).
a3985cdc
DM
3149 */
3150
410be5db 3151STATIC bool
a3985cdc 3152S_doeval(pTHX_ int gimme, OP** startop, CV* outside, U32 seq)
a0d0e21e 3153{
27da23d5 3154 dVAR; dSP;
46c461b5 3155 OP * const saveop = PL_op;
27e90453
DM
3156 bool in_require = (saveop && saveop->op_type == OP_REQUIRE);
3157 int yystatus;
a0d0e21e 3158
27e90453 3159 PL_in_eval = (in_require
6dc8a9e4
IZ
3160 ? (EVAL_INREQUIRE | (PL_in_eval & EVAL_INEVAL))
3161 : EVAL_INEVAL);
a0d0e21e 3162
1ce6579f
PP
3163 PUSHMARK(SP);
3164
3280af22 3165 SAVESPTR(PL_compcv);
ea726b52 3166 PL_compcv = MUTABLE_CV(newSV_type(SVt_PVCV));
1aff0e91 3167 CvEVAL_on(PL_compcv);
2090ab20
JH
3168 assert(CxTYPE(&cxstack[cxstack_ix]) == CXt_EVAL);
3169 cxstack[cxstack_ix].blk_eval.cv = PL_compcv;
3170
a3985cdc 3171 CvOUTSIDE_SEQ(PL_compcv) = seq;
ea726b52 3172 CvOUTSIDE(PL_compcv) = MUTABLE_CV(SvREFCNT_inc_simple(outside));
a3985cdc 3173
dd2155a4 3174 /* set up a scratch pad */
a0d0e21e 3175
dd2155a4 3176 CvPADLIST(PL_compcv) = pad_new(padnew_SAVE);
cecbe010 3177 PL_op = NULL; /* avoid PL_op and PL_curpad referring to different CVs */
2c05e328 3178
07055b4c 3179
81d86705
NC
3180 if (!PL_madskills)
3181 SAVEMORTALIZESV(PL_compcv); /* must remain until end of current statement */
748a9306 3182
a0d0e21e
LW
3183 /* make sure we compile in the right package */
3184
ed094faf 3185 if (CopSTASH_ne(PL_curcop, PL_curstash)) {
3280af22 3186 SAVESPTR(PL_curstash);
ed094faf 3187 PL_curstash = CopSTASH(PL_curcop);
a0d0e21e 3188 }
3c10abe3 3189 /* XXX:ajgo do we really need to alloc an AV for begin/checkunit */
3280af22
NIS
3190 SAVESPTR(PL_beginav);
3191 PL_beginav = newAV();
3192 SAVEFREESV(PL_beginav);
3c10abe3
AG
3193 SAVESPTR(PL_unitcheckav);
3194 PL_unitcheckav = newAV();
3195 SAVEFREESV(PL_unitcheckav);
a0d0e21e 3196
81d86705 3197#ifdef PERL_MAD
9da243ce 3198 SAVEBOOL(PL_madskills);
81d86705
NC
3199 PL_madskills = 0;
3200#endif
3201
a0d0e21e
LW
3202 /* try to compile it */
3203
5f66b61c 3204 PL_eval_root = NULL;
3280af22 3205 PL_curcop = &PL_compiling;
fc15ae8f 3206 CopARYBASE_set(PL_curcop, 0);
5f66b61c 3207 if (saveop && (saveop->op_type != OP_REQUIRE) && (saveop->op_flags & OPf_SPECIAL))
faef0170 3208 PL_in_eval |= EVAL_KEEPERR;
ab69dbc2
RGS
3209 else
3210 CLEAR_ERRSV();
27e90453 3211
a88d97bf 3212 CALL_BLOCK_HOOKS(bhk_eval, saveop);
52db365a 3213
27e90453
DM
3214 /* note that yyparse() may raise an exception, e.g. C<BEGIN{die}>,
3215 * so honour CATCH_GET and trap it here if necessary */
3216
28ac2b49 3217 yystatus = (!in_require && CATCH_GET) ? S_try_yyparse(aTHX_ GRAMPROG) : yyparse(GRAMPROG);
27e90453
DM
3218
3219 if (yystatus || PL_parser->error_count || !PL_eval_root) {
0c58d367 3220 SV **newsp; /* Used by POPBLOCK. */
b6494f15 3221 PERL_CONTEXT *cx = NULL;
27e90453 3222 I32 optype; /* Used by POPEVAL. */
b6494f15 3223 SV *namesv = NULL;
9d4ba2ae 3224 const char *msg;
bfed75c6 3225
27e90453
DM
3226 PERL_UNUSED_VAR(newsp);
3227 PERL_UNUSED_VAR(optype);
3228
c86ffc32
DM
3229 /* note that if yystatus == 3, then the EVAL CX block has already
3230 * been popped, and various vars restored */
533c011a 3231 PL_op = saveop;
27e90453 3232 if (yystatus != 3) {
c86ffc32
DM
3233 if (PL_eval_root) {
3234 op_free(PL_eval_root);
3235 PL_eval_root = NULL;
3236 }
27e90453
DM
3237 SP = PL_stack_base + POPMARK; /* pop original mark */
3238 if (!startop) {
3239 POPBLOCK(cx,PL_curpm);
3240 POPEVAL(cx);
b6494f15 3241 namesv = cx->blk_eval.old_namesv;
27e90453 3242 }
c277df42 3243 }
27e90453
DM
3244 if (yystatus != 3)
3245 LEAVE_with_name("eval"); /* pp_entereval knows about this LEAVE. */
9d4ba2ae
AL
3246
3247 msg = SvPVx_nolen_const(ERRSV);
27e90453 3248 if (in_require) {
b6494f15
VP
3249 if (!cx) {
3250 /* If cx is still NULL, it means that we didn't go in the
3251 * POPEVAL branch. */
3252 cx = &cxstack[cxstack_ix];
3253 assert(CxTYPE(cx) == CXt_EVAL);
3254 namesv = cx->blk_eval.old_namesv;
3255 }
3256 (void)hv_store(GvHVn(PL_incgv),
3257 SvPVX_const(namesv), SvCUR(namesv),
3258 &PL_sv_undef, 0);
58d3fd3b
SH
3259 Perl_croak(aTHX_ "%sCompilation failed in require",
3260 *msg ? msg : "Unknown error\n");
5a844595
GS
3261 }
3262 else if (startop) {
27e90453
DM
3263 if (yystatus != 3) {
3264 POPBLOCK(cx,PL_curpm);
3265 POPEVAL(cx);
3266 }
5a844595
GS
3267 Perl_croak(aTHX_ "%sCompilation failed in regexp",
3268 (*msg ? msg : "Unknown error\n"));
7a2e2cd6 3269 }
9d7f88dd 3270 else {
9d7f88dd 3271 if (!*msg) {
6502358f 3272 sv_setpvs(ERRSV, "Compilation error");
9d7f88dd
SR
3273 }
3274 }
410be5db
DM
3275 PUSHs(&PL_sv_undef);
3276 PUTBACK;
3277 return FALSE;
a0d0e21e 3278 }
57843af0 3279 CopLINE_set(&PL_compiling, 0);
c277df42 3280 if (startop) {
3280af22 3281 *startop = PL_eval_root;
c277df42 3282 } else
3280af22 3283 SAVEFREEOP(PL_eval_root);
0c58d367
RGS
3284
3285 /* Set the context for this new optree.
021f53de
GG
3286 * Propagate the context from the eval(). */
3287 if ((gimme & G_WANT) == G_VOID)
3280af22 3288 scalarvoid(PL_eval_root);
7df0357e 3289 else if ((gimme & G_WANT) == G_ARRAY)
3280af22 3290 list(PL_eval_root);
a0d0e21e 3291 else
3280af22 3292 scalar(PL_eval_root);
a0d0e21e
LW
3293
3294 DEBUG_x(dump_eval());
3295
55497cff 3296 /* Register with debugger: */
6482a30d 3297 if (PERLDB_INTER && saveop && saveop->op_type == OP_REQUIRE) {
b96d8cd9 3298 CV * const cv = get_cvs("DB::postponed", 0);
55497cff
PP
3299 if (cv) {
3300 dSP;
924508f0 3301 PUSHMARK(SP);
ad64d0ec 3302 XPUSHs(MUTABLE_SV(CopFILEGV(&PL_compiling)));
55497cff 3303 PUTBACK;
ad64d0ec 3304 call_sv(MUTABLE_SV(cv), G_DISCARD);
55497cff
PP
3305 }
3306 }
3307
8ed49485
FC
3308 if (PL_unitcheckav) {
3309 OP *es = PL_eval_start;
3c10abe3 3310 call_list(PL_scopestack_ix, PL_unitcheckav);
8ed49485
FC
3311 PL_eval_start = es;
3312 }
3c10abe3 3313
a0d0e21e
LW
3314 /* compiled okay, so do it */
3315
3280af22
NIS
3316 CvDEPTH(PL_compcv) = 1;
3317 SP = PL_stack_base + POPMARK; /* pop original mark */
533c011a 3318 PL_op = saveop; /* The caller may need it. */
bc177e6b 3319 PL_parser->lex_state = LEX_NOTPARSING; /* $^S needs this. */
5dc0d613 3320
410be5db
DM
3321 PUTBACK;
3322 return TRUE;
a0d0e21e
LW
3323}
3324
a6c40364 3325STATIC PerlIO *
0786552a 3326S_check_type_and_open(pTHX_ const char *name)
ce8abf5f
SP
3327{
3328 Stat_t st;
c445ea15 3329 const int st_rc = PerlLIO_stat(name, &st);
df528165 3330
7918f24d
NC
3331 PERL_ARGS_ASSERT_CHECK_TYPE_AND_OPEN;
3332
6b845e56 3333 if (st_rc < 0 || S_ISDIR(st.st_mode) || S_ISBLK(st.st_mode)) {
4608196e 3334 return NULL;
ce8abf5f
SP
3335 }
3336
0786552a 3337 return PerlIO_open(name, PERL_SCRIPT_MODE);
ce8abf5f
SP
3338}
3339
75c20bac 3340#ifndef PERL_DISABLE_PMC
ce8abf5f 3341STATIC PerlIO *
0786552a 3342S_doopen_pm(pTHX_ const char *name, const STRLEN namelen)
b295d113 3343{
b295d113
TH
3344 PerlIO *fp;
3345
7918f24d
NC
3346 PERL_ARGS_ASSERT_DOOPEN_PM;
3347
ce9440c8 3348 if (namelen > 3 && memEQs(name + namelen - 3, 3, ".pm")) {
50b8ed39
NC
3349 SV *const pmcsv = newSV(namelen + 2);
3350 char *const pmc = SvPVX(pmcsv);
a6c40364 3351 Stat_t pmcstat;
50b8ed39
NC
3352
3353 memcpy(pmc, name, namelen);
3354 pmc[namelen] = 'c';
3355 pmc[namelen + 1] = '\0';
3356
a6c40364 3357 if (PerlLIO_stat(pmc, &pmcstat) < 0) {
0786552a 3358 fp = check_type_and_open(name);
a6c40364
GS
3359 }
3360 else {
0786552a 3361 fp = check_type_and_open(pmc);
b295d113 3362 }
a6c40364
GS
3363 SvREFCNT_dec(pmcsv);
3364 }
3365 else {
0786552a 3366 fp = check_type_and_open(name);
b295d113 3367 }
b295d113 3368 return fp;
75c20bac 3369}
7925835c 3370#else
75c20bac 3371# define doopen_pm(name, namelen) check_type_and_open(name)
7925835c 3372#endif /* !PERL_DISABLE_PMC */
b295d113 3373
a0d0e21e
LW
3374PP(pp_require)
3375{
27da23d5 3376 dVAR; dSP;
c09156bb 3377 register PERL_CONTEXT *cx;
a0d0e21e 3378 SV *sv;
5c144d81 3379 const char *name;
6132ea6c 3380 STRLEN len;
4492be7a
JM
3381 char * unixname;
3382 STRLEN unixlen;
62f5ad7a 3383#ifdef VMS
4492be7a 3384 int vms_unixname = 0;
62f5ad7a 3385#endif
c445ea15
AL
3386 const char *tryname = NULL;
3387 SV *namesv = NULL;
f54cb97a 3388 const I32 gimme = GIMME_V;
bbed91b5 3389 int filter_has_file = 0;
c445ea15 3390 PerlIO *tryrsfp = NULL;
34113e50 3391 SV *filter_cache = NULL;
c445ea15
AL
3392 SV *filter_state = NULL;
3393 SV *filter_sub = NULL;
3394 SV *hook_sv = NULL;
6ec9efec
JH
3395 SV *encoding;
3396 OP *op;
a0d0e21e
LW
3397
3398 sv = POPs;
d7aa5382 3399 if ( (SvNIOKp(sv) || SvVOK(sv)) && PL_op->op_type != OP_DOFILE) {
d086148c 3400 sv = sv_2mortal(new_version(sv));
d7aa5382 3401 if (!sv_derived_from(PL_patchlevel, "version"))
ac0e6a2f 3402 upg_version(PL_patchlevel, TRUE);
149c1637 3403 if (cUNOP->op_first->op_type == OP_CONST && cUNOP->op_first->op_private & OPpCONST_NOVER) {
3cacfbb9 3404 if ( vcmp(sv,PL_patchlevel) <= 0 )
468aa647 3405 DIE(aTHX_ "Perls since %"SVf" too modern--this is %"SVf", stopped",
be2597df