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
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.
12 * Then he heard Merry change the note, and up went the Horn-cry of Buckland,
15 * Awake! Awake! Fear, Fire, Foes! Awake!
18 * [p.1007 of _The Lord of the Rings_, VI/viii: "The Scouring of the Shire"]
21 /* This file contains 'hot' pp ("push/pop") functions that
22 * execute the opcodes that make up a perl program. A typical pp function
23 * expects to find its arguments on the stack, and usually pushes its
24 * results onto the stack, hence the 'pp' terminology. Each OP structure
25 * contains a pointer to the relevant pp_foo() function.
27 * By 'hot', we mean common ops whose execution speed is critical.
28 * By gathering them together into a single file, we encourage
29 * CPU cache hits on hot code. Also it could be taken as a warning not to
30 * change any code in this file unless you're sure it won't affect
35 #define PERL_IN_PP_HOT_C
51 PL_curcop = (COP*)PL_op;
52 TAINT_NOT; /* Each statement is presumed innocent */
53 PL_stack_sp = PL_stack_base + cxstack[cxstack_ix].blk_oldsp;
64 if (PL_op->op_private & OPpLVAL_INTRO)
65 PUSHs(save_scalar(cGVOP_gv));
67 PUSHs(GvSVn(cGVOP_gv));
80 PUSHMARK(PL_stack_sp);
95 XPUSHs(MUTABLE_SV(cGVOP_gv));
106 if (PL_op->op_type == OP_AND)
108 RETURNOP(cLOGOP->op_other);
114 dVAR; dSP; dPOPTOPssrl;
116 if (PL_op->op_private & OPpASSIGN_BACKWARDS) {
117 SV * const temp = left;
118 left = right; right = temp;
120 if (PL_tainting && PL_tainted && !SvTAINTED(left))
122 if (PL_op->op_private & OPpASSIGN_CV_TO_GV) {
123 SV * const cv = SvRV(left);
124 const U32 cv_type = SvTYPE(cv);
125 const bool is_gv = isGV_with_GP(right);
126 const bool got_coderef = cv_type == SVt_PVCV || cv_type == SVt_PVFM;
132 /* Can do the optimisation if right (LVALUE) is not a typeglob,
133 left (RVALUE) is a reference to something, and we're in void
135 if (!got_coderef && !is_gv && GIMME_V == G_VOID) {
136 /* Is the target symbol table currently empty? */
137 GV * const gv = gv_fetchsv(right, GV_NOINIT, SVt_PVGV);
138 if (SvTYPE(gv) != SVt_PVGV && !SvOK(gv)) {
139 /* Good. Create a new proxy constant subroutine in the target.
140 The gv becomes a(nother) reference to the constant. */
141 SV *const value = SvRV(cv);
143 SvUPGRADE(MUTABLE_SV(gv), SVt_IV);
144 SvPCS_IMPORTED_on(gv);
146 SvREFCNT_inc_simple_void(value);
152 /* Need to fix things up. */
154 /* Need to fix GV. */
155 right = MUTABLE_SV(gv_fetchsv(right, GV_ADD, SVt_PVGV));
159 /* We've been returned a constant rather than a full subroutine,
160 but they expect a subroutine reference to apply. */
162 ENTER_with_name("sassign_coderef");
163 SvREFCNT_inc_void(SvRV(cv));
164 /* newCONSTSUB takes a reference count on the passed in SV
165 from us. We set the name to NULL, otherwise we get into
166 all sorts of fun as the reference to our new sub is
167 donated to the GV that we're about to assign to.
169 SvRV_set(left, MUTABLE_SV(newCONSTSUB(GvSTASH(right), NULL,
172 LEAVE_with_name("sassign_coderef");
174 /* What can happen for the corner case *{"BONK"} = \&{"BONK"};
176 First: ops for \&{"BONK"}; return us the constant in the
178 Second: ops for *{"BONK"} cause that symbol table entry
179 (and our reference to it) to be upgraded from RV
181 Thirdly: We get here. cv is actually PVGV now, and its
182 GvCV() is actually the subroutine we're looking for
184 So change the reference so that it points to the subroutine
185 of that typeglob, as that's what they were after all along.
187 GV *const upgraded = MUTABLE_GV(cv);
188 CV *const source = GvCV(upgraded);
191 assert(CvFLAGS(source) & CVf_CONST);
193 SvREFCNT_inc_void(source);
194 SvREFCNT_dec(upgraded);
195 SvRV_set(left, MUTABLE_SV(source));
200 SvSetMagicSV(right, left);
210 RETURNOP(cLOGOP->op_other);
212 RETURNOP(cLOGOP->op_next);
219 TAINT_NOT; /* Each statement is presumed innocent */
220 PL_stack_sp = PL_stack_base + cxstack[cxstack_ix].blk_oldsp;
222 if (!(PL_op->op_flags & OPf_SPECIAL)) {
223 I32 oldsave = PL_scopestack[PL_scopestack_ix - 1];
224 LEAVE_SCOPE(oldsave);
231 dVAR; dSP; dATARGET; tryAMAGICbin_MG(concat_amg, AMGf_assign);
236 const char *rpv = NULL;
238 bool rcopied = FALSE;
240 if (TARG == right && right != left) { /* $r = $l.$r */
241 rpv = SvPV_nomg_const(right, rlen);
242 rbyte = !DO_UTF8(right);
243 right = newSVpvn_flags(rpv, rlen, SVs_TEMP);
244 rpv = SvPV_const(right, rlen); /* no point setting UTF-8 here */
248 if (TARG != left) { /* not $l .= $r */
250 const char* const lpv = SvPV_nomg_const(left, llen);
251 lbyte = !DO_UTF8(left);
252 sv_setpvn(TARG, lpv, llen);
258 else { /* $l .= $r */
260 if (left == right && ckWARN(WARN_UNINITIALIZED)) /* $l .= $l */
261 report_uninit(right);
264 lbyte = (SvROK(left) && SvTYPE(SvRV(left)) == SVt_REGEXP)
265 ? !DO_UTF8(SvRV(left)) : !DO_UTF8(left);
272 /* $r.$r: do magic twice: tied might return different 2nd time */
274 rpv = SvPV_nomg_const(right, rlen);
275 rbyte = !DO_UTF8(right);
277 if (lbyte != rbyte) {
278 /* sv_utf8_upgrade_nomg() may reallocate the stack */
281 sv_utf8_upgrade_nomg(TARG);
284 right = newSVpvn_flags(rpv, rlen, SVs_TEMP);
285 sv_utf8_upgrade_nomg(right);
286 rpv = SvPV_nomg_const(right, rlen);
290 sv_catpvn_nomg(TARG, rpv, rlen);
301 if (PL_op->op_flags & OPf_MOD) {
302 if (PL_op->op_private & OPpLVAL_INTRO)
303 if (!(PL_op->op_private & OPpPAD_STATE))
304 SAVECLEARSV(PAD_SVl(PL_op->op_targ));
305 if (PL_op->op_private & OPpDEREF) {
307 vivify_ref(PAD_SVl(PL_op->op_targ), PL_op->op_private & OPpDEREF);
317 dSP; SvGETMAGIC(TOPs);
318 tryAMAGICunTARGET(iter, 0);
319 PL_last_in_gv = MUTABLE_GV(*PL_stack_sp--);
320 if (!isGV_with_GP(PL_last_in_gv)) {
321 if (SvROK(PL_last_in_gv) && isGV_with_GP(SvRV(PL_last_in_gv)))
322 PL_last_in_gv = MUTABLE_GV(SvRV(PL_last_in_gv));
325 XPUSHs(MUTABLE_SV(PL_last_in_gv));
328 PL_last_in_gv = MUTABLE_GV(*PL_stack_sp--);
331 return do_readline();
337 tryAMAGICbin_MG(eq_amg, AMGf_set);
338 #ifndef NV_PRESERVES_UV
339 if (SvROK(TOPs) && !SvAMAGIC(TOPs) && SvROK(TOPm1s) && !SvAMAGIC(TOPm1s)) {
341 SETs(boolSV(SvRV(TOPs) == SvRV(TOPp1s)));
345 #ifdef PERL_PRESERVE_IVUV
346 SvIV_please_nomg(TOPs);
348 /* Unless the left argument is integer in range we are going
349 to have to use NV maths. Hence only attempt to coerce the
350 right argument if we know the left is integer. */
351 SvIV_please_nomg(TOPm1s);
353 const bool auvok = SvUOK(TOPm1s);
354 const bool buvok = SvUOK(TOPs);
356 if (auvok == buvok) { /* ## IV == IV or UV == UV ## */
357 /* Casting IV to UV before comparison isn't going to matter
358 on 2s complement. On 1s complement or sign&magnitude
359 (if we have any of them) it could to make negative zero
360 differ from normal zero. As I understand it. (Need to
361 check - is negative zero implementation defined behaviour
363 const UV buv = SvUVX(POPs);
364 const UV auv = SvUVX(TOPs);
366 SETs(boolSV(auv == buv));
369 { /* ## Mixed IV,UV ## */
373 /* == is commutative so doesn't matter which is left or right */
375 /* top of stack (b) is the iv */
384 /* As uv is a UV, it's >0, so it cannot be == */
387 /* we know iv is >= 0 */
388 SETs(boolSV((UV)iv == SvUVX(uvp)));
395 #if defined(NAN_COMPARE_BROKEN) && defined(Perl_isnan)
397 if (Perl_isnan(left) || Perl_isnan(right))
399 SETs(boolSV(left == right));
402 SETs(boolSV(SvNV_nomg(TOPs) == value));
411 if (SvTYPE(TOPs) >= SVt_PVAV || isGV_with_GP(TOPs))
412 Perl_croak_no_modify(aTHX);
413 if (!SvREADONLY(TOPs) && SvIOK_notUV(TOPs) && !SvNOK(TOPs) && !SvPOK(TOPs)
414 && SvIVX(TOPs) != IV_MAX)
416 SvIV_set(TOPs, SvIVX(TOPs) + 1);
417 SvFLAGS(TOPs) &= ~(SVp_NOK|SVp_POK);
419 else /* Do all the PERL_PRESERVE_IVUV conditionals in sv_inc */
432 if (PL_op->op_type == OP_OR)
434 RETURNOP(cLOGOP->op_other);
443 const int op_type = PL_op->op_type;
444 const bool is_dor = (op_type == OP_DOR || op_type == OP_DORASSIGN);
449 if (!sv || !SvANY(sv)) {
450 if (op_type == OP_DOR)
452 RETURNOP(cLOGOP->op_other);
458 if (!sv || !SvANY(sv))
463 switch (SvTYPE(sv)) {
465 if (AvMAX(sv) >= 0 || SvGMAGICAL(sv) || (SvRMAGICAL(sv) && mg_find(sv, PERL_MAGIC_tied)))
469 if (HvARRAY(sv) || SvGMAGICAL(sv) || (SvRMAGICAL(sv) && mg_find(sv, PERL_MAGIC_tied)))
473 if (CvROOT(sv) || CvXSUB(sv))
486 if(op_type == OP_DOR)
488 RETURNOP(cLOGOP->op_other);
490 /* assuming OP_DEFINED */
498 dVAR; dSP; dATARGET; bool useleft; SV *svl, *svr;
499 tryAMAGICbin_MG(add_amg, AMGf_assign|AMGf_numeric);
503 useleft = USE_LEFT(svl);
504 #ifdef PERL_PRESERVE_IVUV
505 /* We must see if we can perform the addition with integers if possible,
506 as the integer code detects overflow while the NV code doesn't.
507 If either argument hasn't had a numeric conversion yet attempt to get
508 the IV. It's important to do this now, rather than just assuming that
509 it's not IOK as a PV of "9223372036854775806" may not take well to NV
510 addition, and an SV which is NOK, NV=6.0 ought to be coerced to
511 integer in case the second argument is IV=9223372036854775806
512 We can (now) rely on sv_2iv to do the right thing, only setting the
513 public IOK flag if the value in the NV (or PV) slot is truly integer.
515 A side effect is that this also aggressively prefers integer maths over
516 fp maths for integer values.
518 How to detect overflow?
520 C 99 section 6.2.6.1 says
522 The range of nonnegative values of a signed integer type is a subrange
523 of the corresponding unsigned integer type, and the representation of
524 the same value in each type is the same. A computation involving
525 unsigned operands can never overflow, because a result that cannot be
526 represented by the resulting unsigned integer type is reduced modulo
527 the number that is one greater than the largest value that can be
528 represented by the resulting type.
532 which I read as "unsigned ints wrap."
534 signed integer overflow seems to be classed as "exception condition"
536 If an exceptional condition occurs during the evaluation of an
537 expression (that is, if the result is not mathematically defined or not
538 in the range of representable values for its type), the behavior is
541 (6.5, the 5th paragraph)
543 I had assumed that on 2s complement machines signed arithmetic would
544 wrap, hence coded pp_add and pp_subtract on the assumption that
545 everything perl builds on would be happy. After much wailing and
546 gnashing of teeth it would seem that irix64 knows its ANSI spec well,
547 knows that it doesn't need to, and doesn't. Bah. Anyway, the all-
548 unsigned code below is actually shorter than the old code. :-)
551 SvIV_please_nomg(svr);
554 /* Unless the left argument is integer in range we are going to have to
555 use NV maths. Hence only attempt to coerce the right argument if
556 we know the left is integer. */
564 /* left operand is undef, treat as zero. + 0 is identity,
565 Could SETi or SETu right now, but space optimise by not adding
566 lots of code to speed up what is probably a rarish case. */
568 /* Left operand is defined, so is it IV? */
569 SvIV_please_nomg(svl);
571 if ((auvok = SvUOK(svl)))
574 register const IV aiv = SvIVX(svl);
577 auvok = 1; /* Now acting as a sign flag. */
578 } else { /* 2s complement assumption for IV_MIN */
586 bool result_good = 0;
589 bool buvok = SvUOK(svr);
594 register const IV biv = SvIVX(svr);
601 /* ?uvok if value is >= 0. basically, flagged as UV if it's +ve,
602 else "IV" now, independent of how it came in.
603 if a, b represents positive, A, B negative, a maps to -A etc
608 all UV maths. negate result if A negative.
609 add if signs same, subtract if signs differ. */
615 /* Must get smaller */
621 /* result really should be -(auv-buv). as its negation
622 of true value, need to swap our result flag */
639 if (result <= (UV)IV_MIN)
642 /* result valid, but out of range for IV. */
647 } /* Overflow, drop through to NVs. */
652 NV value = SvNV_nomg(svr);
655 /* left operand is undef, treat as zero. + 0.0 is identity. */
659 SETn( value + SvNV_nomg(svl) );
667 AV * const av = PL_op->op_flags & OPf_SPECIAL
668 ? MUTABLE_AV(PAD_SV(PL_op->op_targ)) : GvAV(cGVOP_gv);
669 const U32 lval = PL_op->op_flags & OPf_MOD;
670 SV** const svp = av_fetch(av, PL_op->op_private, lval);
671 SV *sv = (svp ? *svp : &PL_sv_undef);
673 if (!lval && SvRMAGICAL(av) && SvGMAGICAL(sv)) /* see note in pp_helem() */
681 dVAR; dSP; dMARK; dTARGET;
683 do_join(TARG, *MARK, MARK, SP);
694 * We ass_u_me that LvTARGOFF() comes first, and that two STRLENs
695 * will be enough to hold an OP*.
697 SV* const sv = sv_newmortal();
698 sv_upgrade(sv, SVt_PVLV);
700 Copy(&PL_op, &LvTARGOFF(sv), 1, OP*);
703 XPUSHs(MUTABLE_SV(PL_op));
708 /* Oversized hot code. */
712 dVAR; dSP; dMARK; dORIGMARK;
717 = (PL_op->op_flags & OPf_STACKED) ? MUTABLE_GV(*++MARK) : PL_defoutgv;
719 if (gv && (io = GvIO(gv))
720 && (mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar)))
723 if (MARK == ORIGMARK) {
724 /* If using default handle then we need to make space to
725 * pass object as 1st arg, so move other args up ...
729 Move(MARK, MARK + 1, (SP - MARK) + 1, SV*);
733 *MARK = SvTIED_obj(MUTABLE_SV(io), mg);
735 ENTER_with_name("call_PRINT");
736 if( PL_op->op_type == OP_SAY ) {
737 /* local $\ = "\n" */
738 SAVEGENERICSV(PL_ors_sv);
739 PL_ors_sv = newSVpvs("\n");
741 call_method("PRINT", G_SCALAR);
742 LEAVE_with_name("call_PRINT");
749 if (!(io = GvIO(gv))) {
750 if ( gv && GvEGVx(gv) && (io = GvIO(GvEGV(gv)))
751 && (mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar)))
753 if (ckWARN2(WARN_UNOPENED,WARN_CLOSED))
754 report_evil_fh(gv, io, PL_op->op_type);
755 SETERRNO(EBADF,RMS_IFI);
758 else if (!(fp = IoOFP(io))) {
759 if (ckWARN2(WARN_CLOSED, WARN_IO)) {
761 report_evil_fh(gv, io, OP_phoney_INPUT_ONLY);
762 else if (ckWARN2(WARN_UNOPENED,WARN_CLOSED))
763 report_evil_fh(gv, io, PL_op->op_type);
765 SETERRNO(EBADF,IoIFP(io)?RMS_FAC:RMS_IFI);
769 SV * const ofs = GvSV(PL_ofsgv); /* $, */
771 if (ofs && (SvGMAGICAL(ofs) || SvOK(ofs))) {
773 if (!do_print(*MARK, fp))
777 /* don't use 'ofs' here - it may be invalidated by magic callbacks */
778 if (!do_print(GvSV(PL_ofsgv), fp)) {
787 if (!do_print(*MARK, fp))
795 if (PL_op->op_type == OP_SAY) {
796 if (PerlIO_write(fp, "\n", 1) == 0 || PerlIO_error(fp))
799 else if (PL_ors_sv && SvOK(PL_ors_sv))
800 if (!do_print(PL_ors_sv, fp)) /* $\ */
803 if (IoFLAGS(io) & IOf_FLUSH)
804 if (PerlIO_flush(fp) == EOF)
814 XPUSHs(&PL_sv_undef);
821 const I32 gimme = GIMME_V;
822 static const char an_array[] = "an ARRAY";
823 static const char a_hash[] = "a HASH";
824 const bool is_pp_rv2av = PL_op->op_type == OP_RV2AV;
825 const svtype type = is_pp_rv2av ? SVt_PVAV : SVt_PVHV;
827 if (!(PL_op->op_private & OPpDEREFed))
830 tryAMAGICunDEREF_var(is_pp_rv2av ? to_av_amg : to_hv_amg);
833 if (SvTYPE(sv) != type)
834 DIE(aTHX_ "Not %s reference", is_pp_rv2av ? an_array : a_hash);
835 if (PL_op->op_flags & OPf_REF) {
840 if (gimme != G_ARRAY)
841 goto croak_cant_return;
845 else if (PL_op->op_flags & OPf_MOD
846 && PL_op->op_private & OPpLVAL_INTRO)
847 Perl_croak(aTHX_ "%s", PL_no_localize_ref);
850 if (SvTYPE(sv) == type) {
851 if (PL_op->op_flags & OPf_REF) {
856 if (gimme != G_ARRAY)
857 goto croak_cant_return;
865 if (!isGV_with_GP(sv)) {
866 gv = Perl_softref2xv(aTHX_ sv, is_pp_rv2av ? an_array : a_hash,
874 sv = is_pp_rv2av ? MUTABLE_SV(GvAVn(gv)) : MUTABLE_SV(GvHVn(gv));
875 if (PL_op->op_private & OPpLVAL_INTRO)
876 sv = is_pp_rv2av ? MUTABLE_SV(save_ary(gv)) : MUTABLE_SV(save_hash(gv));
877 if (PL_op->op_flags & OPf_REF) {
882 if (gimme != G_ARRAY)
883 goto croak_cant_return;
891 AV *const av = MUTABLE_AV(sv);
892 /* The guts of pp_rv2av, with no intenting change to preserve history
893 (until such time as we get tools that can do blame annotation across
894 whitespace changes. */
895 if (gimme == G_ARRAY) {
896 const I32 maxarg = AvFILL(av) + 1;
897 (void)POPs; /* XXXX May be optimized away? */
899 if (SvRMAGICAL(av)) {
901 for (i=0; i < (U32)maxarg; i++) {
902 SV ** const svp = av_fetch(av, i, FALSE);
903 /* See note in pp_helem, and bug id #27839 */
905 ? SvGMAGICAL(*svp) ? (mg_get(*svp), *svp) : *svp
910 Copy(AvARRAY(av), SP+1, maxarg, SV*);
914 else if (gimme == G_SCALAR) {
916 const I32 maxarg = AvFILL(av) + 1;
920 /* The guts of pp_rv2hv */
921 if (gimme == G_ARRAY) { /* array wanted */
925 else if (gimme == G_SCALAR) {
927 TARG = Perl_hv_scalar(aTHX_ MUTABLE_HV(sv));
935 Perl_croak(aTHX_ "Can't return %s to lvalue scalar context",
936 is_pp_rv2av ? "array" : "hash");
941 S_do_oddball(pTHX_ HV *hash, SV **relem, SV **firstrelem)
945 PERL_ARGS_ASSERT_DO_ODDBALL;
951 if (ckWARN(WARN_MISC)) {
953 if (relem == firstrelem &&
955 (SvTYPE(SvRV(*relem)) == SVt_PVAV ||
956 SvTYPE(SvRV(*relem)) == SVt_PVHV))
958 err = "Reference found where even-sized list expected";
961 err = "Odd number of elements in hash assignment";
962 Perl_warner(aTHX_ packWARN(WARN_MISC), "%s", err);
966 didstore = hv_store_ent(hash,*relem,tmpstr,0);
967 if (SvMAGICAL(hash)) {
968 if (SvSMAGICAL(tmpstr))
980 SV **lastlelem = PL_stack_sp;
981 SV **lastrelem = PL_stack_base + POPMARK;
982 SV **firstrelem = PL_stack_base + POPMARK + 1;
983 SV **firstlelem = lastrelem + 1;
996 SV **firsthashrelem = NULL; /* "= 0" keeps gcc 2.95 quiet */
998 PL_delaymagic = DM_DELAY; /* catch simultaneous items */
1001 /* If there's a common identifier on both sides we have to take
1002 * special care that assigning the identifier on the left doesn't
1003 * clobber a value on the right that's used later in the list.
1005 if (PL_op->op_private & (OPpASSIGN_COMMON)) {
1006 EXTEND_MORTAL(lastrelem - firstrelem + 1);
1007 for (relem = firstrelem; relem <= lastrelem; relem++) {
1008 if ((sv = *relem)) {
1009 TAINT_NOT; /* Each item is independent */
1011 /* Dear TODO test in t/op/sort.t, I love you.
1012 (It's relying on a panic, not a "semi-panic" from newSVsv()
1013 and then an assertion failure below.) */
1014 if (SvIS_FREED(sv)) {
1015 Perl_croak(aTHX_ "panic: attempt to copy freed scalar %p",
1018 /* Specifically *not* sv_mortalcopy(), as that will steal TEMPs,
1019 and we need a second copy of a temp here. */
1020 *relem = sv_2mortal(newSVsv(sv));
1030 while (lelem <= lastlelem) {
1031 TAINT_NOT; /* Each item stands on its own, taintwise. */
1033 switch (SvTYPE(sv)) {
1035 ary = MUTABLE_AV(sv);
1036 magic = SvMAGICAL(ary) != 0;
1038 av_extend(ary, lastrelem - relem);
1040 while (relem <= lastrelem) { /* gobble up all the rest */
1044 sv_setsv(sv, *relem);
1046 didstore = av_store(ary,i++,sv);
1055 if (PL_delaymagic & DM_ARRAY_ISA)
1056 SvSETMAGIC(MUTABLE_SV(ary));
1058 case SVt_PVHV: { /* normal hash */
1060 SV** topelem = relem;
1062 hash = MUTABLE_HV(sv);
1063 magic = SvMAGICAL(hash) != 0;
1065 firsthashrelem = relem;
1067 while (relem < lastrelem) { /* gobble up all the rest */
1069 sv = *relem ? *relem : &PL_sv_no;
1073 sv_setsv(tmpstr,*relem); /* value */
1075 if (gimme != G_VOID) {
1076 if (hv_exists_ent(hash, sv, 0))
1077 /* key overwrites an existing entry */
1080 if (gimme == G_ARRAY) {
1081 /* copy element back: possibly to an earlier
1082 * stack location if we encountered dups earlier */
1084 *topelem++ = tmpstr;
1087 didstore = hv_store_ent(hash,sv,tmpstr,0);
1089 if (SvSMAGICAL(tmpstr))
1096 if (relem == lastrelem) {
1097 do_oddball(hash, relem, firstrelem);
1103 if (SvIMMORTAL(sv)) {
1104 if (relem <= lastrelem)
1108 if (relem <= lastrelem) {
1109 sv_setsv(sv, *relem);
1113 sv_setsv(sv, &PL_sv_undef);
1118 if (PL_delaymagic & ~DM_DELAY) {
1119 if (PL_delaymagic & DM_UID) {
1120 #ifdef HAS_SETRESUID
1121 (void)setresuid((PL_delaymagic & DM_RUID) ? PL_uid : (Uid_t)-1,
1122 (PL_delaymagic & DM_EUID) ? PL_euid : (Uid_t)-1,
1125 # ifdef HAS_SETREUID
1126 (void)setreuid((PL_delaymagic & DM_RUID) ? PL_uid : (Uid_t)-1,
1127 (PL_delaymagic & DM_EUID) ? PL_euid : (Uid_t)-1);
1130 if ((PL_delaymagic & DM_UID) == DM_RUID) {
1131 (void)setruid(PL_uid);
1132 PL_delaymagic &= ~DM_RUID;
1134 # endif /* HAS_SETRUID */
1136 if ((PL_delaymagic & DM_UID) == DM_EUID) {
1137 (void)seteuid(PL_euid);
1138 PL_delaymagic &= ~DM_EUID;
1140 # endif /* HAS_SETEUID */
1141 if (PL_delaymagic & DM_UID) {
1142 if (PL_uid != PL_euid)
1143 DIE(aTHX_ "No setreuid available");
1144 (void)PerlProc_setuid(PL_uid);
1146 # endif /* HAS_SETREUID */
1147 #endif /* HAS_SETRESUID */
1148 PL_uid = PerlProc_getuid();
1149 PL_euid = PerlProc_geteuid();
1151 if (PL_delaymagic & DM_GID) {
1152 #ifdef HAS_SETRESGID
1153 (void)setresgid((PL_delaymagic & DM_RGID) ? PL_gid : (Gid_t)-1,
1154 (PL_delaymagic & DM_EGID) ? PL_egid : (Gid_t)-1,
1157 # ifdef HAS_SETREGID
1158 (void)setregid((PL_delaymagic & DM_RGID) ? PL_gid : (Gid_t)-1,
1159 (PL_delaymagic & DM_EGID) ? PL_egid : (Gid_t)-1);
1162 if ((PL_delaymagic & DM_GID) == DM_RGID) {
1163 (void)setrgid(PL_gid);
1164 PL_delaymagic &= ~DM_RGID;
1166 # endif /* HAS_SETRGID */
1168 if ((PL_delaymagic & DM_GID) == DM_EGID) {
1169 (void)setegid(PL_egid);
1170 PL_delaymagic &= ~DM_EGID;
1172 # endif /* HAS_SETEGID */
1173 if (PL_delaymagic & DM_GID) {
1174 if (PL_gid != PL_egid)
1175 DIE(aTHX_ "No setregid available");
1176 (void)PerlProc_setgid(PL_gid);
1178 # endif /* HAS_SETREGID */
1179 #endif /* HAS_SETRESGID */
1180 PL_gid = PerlProc_getgid();
1181 PL_egid = PerlProc_getegid();
1183 PL_tainting |= (PL_uid && (PL_euid != PL_uid || PL_egid != PL_gid));
1187 if (gimme == G_VOID)
1188 SP = firstrelem - 1;
1189 else if (gimme == G_SCALAR) {
1192 SETi(lastrelem - firstrelem + 1 - duplicates);
1199 /* at this point we have removed the duplicate key/value
1200 * pairs from the stack, but the remaining values may be
1201 * wrong; i.e. with (a 1 a 2 b 3) on the stack we've removed
1202 * the (a 2), but the stack now probably contains
1203 * (a <freed> b 3), because { hv_save(a,1); hv_save(a,2) }
1204 * obliterates the earlier key. So refresh all values. */
1205 lastrelem -= duplicates;
1206 relem = firsthashrelem;
1207 while (relem < lastrelem) {
1210 he = hv_fetch_ent(hash, sv, 0, 0);
1211 *relem++ = (he ? HeVAL(he) : &PL_sv_undef);
1217 SP = firstrelem + (lastlelem - firstlelem);
1218 lelem = firstlelem + (relem - firstrelem);
1220 *relem++ = (lelem <= lastlelem) ? *lelem++ : &PL_sv_undef;
1229 register PMOP * const pm = cPMOP;
1230 REGEXP * rx = PM_GETRE(pm);
1231 SV * const pkg = rx ? CALLREG_PACKAGE(rx) : NULL;
1232 SV * const rv = sv_newmortal();
1234 SvUPGRADE(rv, SVt_IV);
1235 /* For a subroutine describing itself as "This is a hacky workaround" I'm
1236 loathe to use it here, but it seems to be the right fix. Or close.
1237 The key part appears to be that it's essential for pp_qr to return a new
1238 object (SV), which implies that there needs to be an effective way to
1239 generate a new SV from the existing SV that is pre-compiled in the
1241 SvRV_set(rv, MUTABLE_SV(reg_temp_copy(NULL, rx)));
1245 HV *const stash = gv_stashsv(pkg, GV_ADD);
1247 (void)sv_bless(rv, stash);
1250 if (RX_EXTFLAGS(rx) & RXf_TAINTED)
1259 register PMOP *pm = cPMOP;
1261 register const char *t;
1262 register const char *s;
1265 U8 r_flags = REXEC_CHECKED;
1266 const char *truebase; /* Start of string */
1267 register REGEXP *rx = PM_GETRE(pm);
1269 const I32 gimme = GIMME;
1272 const I32 oldsave = PL_savestack_ix;
1273 I32 update_minmatch = 1;
1274 I32 had_zerolen = 0;
1277 if (PL_op->op_flags & OPf_STACKED)
1279 else if (PL_op->op_private & OPpTARGET_MY)
1286 PUTBACK; /* EVAL blocks need stack_sp. */
1287 /* Skip get-magic if this is a qr// clone, because regcomp has
1289 s = ((struct regexp *)SvANY(rx))->mother_re
1290 ? SvPV_nomg_const(TARG, len)
1291 : SvPV_const(TARG, len);
1293 DIE(aTHX_ "panic: pp_match");
1295 rxtainted = ((RX_EXTFLAGS(rx) & RXf_TAINTED) ||
1296 (PL_tainted && (pm->op_pmflags & PMf_RETAINT)));
1299 RX_MATCH_UTF8_set(rx, DO_UTF8(TARG));
1301 /* PMdf_USED is set after a ?? matches once */
1304 SvREADONLY(PL_regex_pad[pm->op_pmoffset])
1306 pm->op_pmflags & PMf_USED
1310 if (gimme == G_ARRAY)
1317 /* empty pattern special-cased to use last successful pattern if possible */
1318 if (!RX_PRELEN(rx) && PL_curpm) {
1323 if (RX_MINLEN(rx) > (I32)len)
1328 /* XXXX What part of this is needed with true \G-support? */
1329 if ((global = dynpm->op_pmflags & PMf_GLOBAL)) {
1330 RX_OFFS(rx)[0].start = -1;
1331 if (SvTYPE(TARG) >= SVt_PVMG && SvMAGIC(TARG)) {
1332 MAGIC* const mg = mg_find(TARG, PERL_MAGIC_regex_global);
1333 if (mg && mg->mg_len >= 0) {
1334 if (!(RX_EXTFLAGS(rx) & RXf_GPOS_SEEN))
1335 RX_OFFS(rx)[0].end = RX_OFFS(rx)[0].start = mg->mg_len;
1336 else if (RX_EXTFLAGS(rx) & RXf_ANCH_GPOS) {
1337 r_flags |= REXEC_IGNOREPOS;
1338 RX_OFFS(rx)[0].end = RX_OFFS(rx)[0].start = mg->mg_len;
1339 } else if (RX_EXTFLAGS(rx) & RXf_GPOS_FLOAT)
1342 RX_OFFS(rx)[0].end = RX_OFFS(rx)[0].start = mg->mg_len;
1343 minmatch = (mg->mg_flags & MGf_MINMATCH) ? RX_GOFS(rx) + 1 : 0;
1344 update_minmatch = 0;
1348 /* XXX: comment out !global get safe $1 vars after a
1349 match, BUT be aware that this leads to dramatic slowdowns on
1350 /g matches against large strings. So far a solution to this problem
1351 appears to be quite tricky.
1352 Test for the unsafe vars are TODO for now. */
1353 if ( (!global && RX_NPARENS(rx))
1354 || SvTEMP(TARG) || SvAMAGIC(TARG) || PL_sawampersand
1355 || (RX_EXTFLAGS(rx) & (RXf_EVAL_SEEN|RXf_PMf_KEEPCOPY)))
1356 r_flags |= REXEC_COPY_STR;
1358 r_flags |= REXEC_SCREAM;
1361 if (global && RX_OFFS(rx)[0].start != -1) {
1362 t = s = RX_OFFS(rx)[0].end + truebase - RX_GOFS(rx);
1363 if ((s + RX_MINLEN(rx)) > strend || s < truebase)
1365 if (update_minmatch++)
1366 minmatch = had_zerolen;
1368 if (RX_EXTFLAGS(rx) & RXf_USE_INTUIT &&
1369 DO_UTF8(TARG) == (RX_UTF8(rx) != 0)) {
1370 /* FIXME - can PL_bostr be made const char *? */
1371 PL_bostr = (char *)truebase;
1372 s = CALLREG_INTUIT_START(rx, TARG, (char *)s, (char *)strend, r_flags, NULL);
1376 if ( (RX_EXTFLAGS(rx) & RXf_CHECK_ALL)
1378 && !(RX_EXTFLAGS(rx) & RXf_PMf_KEEPCOPY)
1379 && ((RX_EXTFLAGS(rx) & RXf_NOSCAN)
1380 || !((RX_EXTFLAGS(rx) & RXf_INTUIT_TAIL)
1381 && (r_flags & REXEC_SCREAM)))
1382 && !SvROK(TARG)) /* Cannot trust since INTUIT cannot guess ^ */
1385 if (CALLREGEXEC(rx, (char*)s, (char *)strend, (char*)truebase,
1386 minmatch, TARG, NUM2PTR(void*, gpos), r_flags))
1389 if (dynpm->op_pmflags & PMf_ONCE) {
1391 SvREADONLY_on(PL_regex_pad[dynpm->op_pmoffset]);
1393 dynpm->op_pmflags |= PMf_USED;
1404 RX_MATCH_TAINTED_on(rx);
1405 TAINT_IF(RX_MATCH_TAINTED(rx));
1406 if (gimme == G_ARRAY) {
1407 const I32 nparens = RX_NPARENS(rx);
1408 I32 i = (global && !nparens) ? 1 : 0;
1410 SPAGAIN; /* EVAL blocks could move the stack. */
1411 EXTEND(SP, nparens + i);
1412 EXTEND_MORTAL(nparens + i);
1413 for (i = !i; i <= nparens; i++) {
1414 PUSHs(sv_newmortal());
1415 if ((RX_OFFS(rx)[i].start != -1) && RX_OFFS(rx)[i].end != -1 ) {
1416 const I32 len = RX_OFFS(rx)[i].end - RX_OFFS(rx)[i].start;
1417 s = RX_OFFS(rx)[i].start + truebase;
1418 if (RX_OFFS(rx)[i].end < 0 || RX_OFFS(rx)[i].start < 0 ||
1419 len < 0 || len > strend - s)
1420 DIE(aTHX_ "panic: pp_match start/end pointers");
1421 sv_setpvn(*SP, s, len);
1422 if (DO_UTF8(TARG) && is_utf8_string((U8*)s, len))
1427 if (dynpm->op_pmflags & PMf_CONTINUE) {
1429 if (SvTYPE(TARG) >= SVt_PVMG && SvMAGIC(TARG))
1430 mg = mg_find(TARG, PERL_MAGIC_regex_global);
1432 #ifdef PERL_OLD_COPY_ON_WRITE
1434 sv_force_normal_flags(TARG, 0);
1436 mg = sv_magicext(TARG, NULL, PERL_MAGIC_regex_global,
1437 &PL_vtbl_mglob, NULL, 0);
1439 if (RX_OFFS(rx)[0].start != -1) {
1440 mg->mg_len = RX_OFFS(rx)[0].end;
1441 if (RX_OFFS(rx)[0].start + RX_GOFS(rx) == (UV)RX_OFFS(rx)[0].end)
1442 mg->mg_flags |= MGf_MINMATCH;
1444 mg->mg_flags &= ~MGf_MINMATCH;
1447 had_zerolen = (RX_OFFS(rx)[0].start != -1
1448 && (RX_OFFS(rx)[0].start + RX_GOFS(rx)
1449 == (UV)RX_OFFS(rx)[0].end));
1450 PUTBACK; /* EVAL blocks may use stack */
1451 r_flags |= REXEC_IGNOREPOS | REXEC_NOT_FIRST;
1456 LEAVE_SCOPE(oldsave);
1462 if (SvTYPE(TARG) >= SVt_PVMG && SvMAGIC(TARG))
1463 mg = mg_find(TARG, PERL_MAGIC_regex_global);
1467 #ifdef PERL_OLD_COPY_ON_WRITE
1469 sv_force_normal_flags(TARG, 0);
1471 mg = sv_magicext(TARG, NULL, PERL_MAGIC_regex_global,
1472 &PL_vtbl_mglob, NULL, 0);
1474 if (RX_OFFS(rx)[0].start != -1) {
1475 mg->mg_len = RX_OFFS(rx)[0].end;
1476 if (RX_OFFS(rx)[0].start + RX_GOFS(rx) == (UV)RX_OFFS(rx)[0].end)
1477 mg->mg_flags |= MGf_MINMATCH;
1479 mg->mg_flags &= ~MGf_MINMATCH;
1482 LEAVE_SCOPE(oldsave);
1486 yup: /* Confirmed by INTUIT */
1488 RX_MATCH_TAINTED_on(rx);
1489 TAINT_IF(RX_MATCH_TAINTED(rx));
1491 if (dynpm->op_pmflags & PMf_ONCE) {
1493 SvREADONLY_on(PL_regex_pad[dynpm->op_pmoffset]);
1495 dynpm->op_pmflags |= PMf_USED;
1498 if (RX_MATCH_COPIED(rx))
1499 Safefree(RX_SUBBEG(rx));
1500 RX_MATCH_COPIED_off(rx);
1501 RX_SUBBEG(rx) = NULL;
1503 /* FIXME - should rx->subbeg be const char *? */
1504 RX_SUBBEG(rx) = (char *) truebase;
1505 RX_OFFS(rx)[0].start = s - truebase;
1506 if (RX_MATCH_UTF8(rx)) {
1507 char * const t = (char*)utf8_hop((U8*)s, RX_MINLENRET(rx));
1508 RX_OFFS(rx)[0].end = t - truebase;
1511 RX_OFFS(rx)[0].end = s - truebase + RX_MINLENRET(rx);
1513 RX_SUBLEN(rx) = strend - truebase;
1516 if (PL_sawampersand || RX_EXTFLAGS(rx) & RXf_PMf_KEEPCOPY) {
1518 #ifdef PERL_OLD_COPY_ON_WRITE
1519 if (SvIsCOW(TARG) || (SvFLAGS(TARG) & CAN_COW_MASK) == CAN_COW_FLAGS) {
1521 PerlIO_printf(Perl_debug_log,
1522 "Copy on write: pp_match $& capture, type %d, truebase=%p, t=%p, difference %d\n",
1523 (int) SvTYPE(TARG), (void*)truebase, (void*)t,
1526 RX_SAVED_COPY(rx) = sv_setsv_cow(RX_SAVED_COPY(rx), TARG);
1528 = (char *) SvPVX_const(RX_SAVED_COPY(rx)) + (t - truebase);
1529 assert (SvPOKp(RX_SAVED_COPY(rx)));
1534 RX_SUBBEG(rx) = savepvn(t, strend - t);
1535 #ifdef PERL_OLD_COPY_ON_WRITE
1536 RX_SAVED_COPY(rx) = NULL;
1539 RX_SUBLEN(rx) = strend - t;
1540 RX_MATCH_COPIED_on(rx);
1541 off = RX_OFFS(rx)[0].start = s - t;
1542 RX_OFFS(rx)[0].end = off + RX_MINLENRET(rx);
1544 else { /* startp/endp are used by @- @+. */
1545 RX_OFFS(rx)[0].start = s - truebase;
1546 RX_OFFS(rx)[0].end = s - truebase + RX_MINLENRET(rx);
1548 /* including RX_NPARENS(rx) in the below code seems highly suspicious.
1550 RX_NPARENS(rx) = RX_LASTPAREN(rx) = RX_LASTCLOSEPAREN(rx) = 0; /* used by @-, @+, and $^N */
1551 LEAVE_SCOPE(oldsave);
1556 if (global && !(dynpm->op_pmflags & PMf_CONTINUE)) {
1557 if (SvTYPE(TARG) >= SVt_PVMG && SvMAGIC(TARG)) {
1558 MAGIC* const mg = mg_find(TARG, PERL_MAGIC_regex_global);
1563 LEAVE_SCOPE(oldsave);
1564 if (gimme == G_ARRAY)
1570 Perl_do_readline(pTHX)
1572 dVAR; dSP; dTARGETSTACKED;
1577 register IO * const io = GvIO(PL_last_in_gv);
1578 register const I32 type = PL_op->op_type;
1579 const I32 gimme = GIMME_V;
1582 MAGIC * const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
1585 XPUSHs(SvTIED_obj(MUTABLE_SV(io), mg));
1587 ENTER_with_name("call_READLINE");
1588 call_method("READLINE", gimme);
1589 LEAVE_with_name("call_READLINE");
1591 if (gimme == G_SCALAR) {
1592 SV* const result = POPs;
1593 SvSetSV_nosteal(TARG, result);
1603 if (IoFLAGS(io) & IOf_ARGV) {
1604 if (IoFLAGS(io) & IOf_START) {
1606 if (av_len(GvAVn(PL_last_in_gv)) < 0) {
1607 IoFLAGS(io) &= ~IOf_START;
1608 do_open(PL_last_in_gv,"-",1,FALSE,O_RDONLY,0,NULL);
1609 sv_setpvs(GvSVn(PL_last_in_gv), "-");
1610 SvSETMAGIC(GvSV(PL_last_in_gv));
1615 fp = nextargv(PL_last_in_gv);
1616 if (!fp) { /* Note: fp != IoIFP(io) */
1617 (void)do_close(PL_last_in_gv, FALSE); /* now it does*/
1620 else if (type == OP_GLOB)
1621 fp = Perl_start_glob(aTHX_ POPs, io);
1623 else if (type == OP_GLOB)
1625 else if (ckWARN(WARN_IO) && IoTYPE(io) == IoTYPE_WRONLY) {
1626 report_evil_fh(PL_last_in_gv, io, OP_phoney_OUTPUT_ONLY);
1630 if ((!io || !(IoFLAGS(io) & IOf_START))
1631 && ckWARN2(WARN_GLOB, WARN_CLOSED))
1633 if (type == OP_GLOB)
1634 Perl_warner(aTHX_ packWARN(WARN_GLOB),
1635 "glob failed (can't start child: %s)",
1638 report_evil_fh(PL_last_in_gv, io, PL_op->op_type);
1640 if (gimme == G_SCALAR) {
1641 /* undef TARG, and push that undefined value */
1642 if (type != OP_RCATLINE) {
1643 SV_CHECK_THINKFIRST_COW_DROP(TARG);
1651 if (gimme == G_SCALAR) {
1653 if (type == OP_RCATLINE && SvGMAGICAL(sv))
1656 if (type == OP_RCATLINE)
1657 SvPV_force_nolen(sv);
1661 else if (isGV_with_GP(sv)) {
1662 SvPV_force_nolen(sv);
1664 SvUPGRADE(sv, SVt_PV);
1665 tmplen = SvLEN(sv); /* remember if already alloced */
1666 if (!tmplen && !SvREADONLY(sv)) {
1667 /* try short-buffering it. Please update t/op/readline.t
1668 * if you change the growth length.
1673 if (type == OP_RCATLINE && SvOK(sv)) {
1675 SvPV_force_nolen(sv);
1681 sv = sv_2mortal(newSV(80));
1685 /* This should not be marked tainted if the fp is marked clean */
1686 #define MAYBE_TAINT_LINE(io, sv) \
1687 if (!(IoFLAGS(io) & IOf_UNTAINT)) { \
1692 /* delay EOF state for a snarfed empty file */
1693 #define SNARF_EOF(gimme,rs,io,sv) \
1694 (gimme != G_SCALAR || SvCUR(sv) \
1695 || (IoFLAGS(io) & IOf_NOLINE) || !RsSNARF(rs))
1699 if (!sv_gets(sv, fp, offset)
1701 || SNARF_EOF(gimme, PL_rs, io, sv)
1702 || PerlIO_error(fp)))
1704 PerlIO_clearerr(fp);
1705 if (IoFLAGS(io) & IOf_ARGV) {
1706 fp = nextargv(PL_last_in_gv);
1709 (void)do_close(PL_last_in_gv, FALSE);
1711 else if (type == OP_GLOB) {
1712 if (!do_close(PL_last_in_gv, FALSE)) {
1713 Perl_ck_warner(aTHX_ packWARN(WARN_GLOB),
1714 "glob failed (child exited with status %d%s)",
1715 (int)(STATUS_CURRENT >> 8),
1716 (STATUS_CURRENT & 0x80) ? ", core dumped" : "");
1719 if (gimme == G_SCALAR) {
1720 if (type != OP_RCATLINE) {
1721 SV_CHECK_THINKFIRST_COW_DROP(TARG);
1727 MAYBE_TAINT_LINE(io, sv);
1730 MAYBE_TAINT_LINE(io, sv);
1732 IoFLAGS(io) |= IOf_NOLINE;
1736 if (type == OP_GLOB) {
1739 if (SvCUR(sv) > 0 && SvCUR(PL_rs) > 0) {
1740 char * const tmps = SvEND(sv) - 1;
1741 if (*tmps == *SvPVX_const(PL_rs)) {
1743 SvCUR_set(sv, SvCUR(sv) - 1);
1746 for (t1 = SvPVX_const(sv); *t1; t1++)
1747 if (!isALPHA(*t1) && !isDIGIT(*t1) &&
1748 strchr("$&*(){}[]'\";\\|?<>~`", *t1))
1750 if (*t1 && PerlLIO_lstat(SvPVX_const(sv), &PL_statbuf) < 0) {
1751 (void)POPs; /* Unmatched wildcard? Chuck it... */
1754 } else if (SvUTF8(sv)) { /* OP_READLINE, OP_RCATLINE */
1755 if (ckWARN(WARN_UTF8)) {
1756 const U8 * const s = (const U8*)SvPVX_const(sv) + offset;
1757 const STRLEN len = SvCUR(sv) - offset;
1760 if (!is_utf8_string_loc(s, len, &f))
1761 /* Emulate :encoding(utf8) warning in the same case. */
1762 Perl_warner(aTHX_ packWARN(WARN_UTF8),
1763 "utf8 \"\\x%02X\" does not map to Unicode",
1764 f < (U8*)SvEND(sv) ? *f : 0);
1767 if (gimme == G_ARRAY) {
1768 if (SvLEN(sv) - SvCUR(sv) > 20) {
1769 SvPV_shrink_to_cur(sv);
1771 sv = sv_2mortal(newSV(80));
1774 else if (gimme == G_SCALAR && !tmplen && SvLEN(sv) - SvCUR(sv) > 80) {
1775 /* try to reclaim a bit of scalar space (only on 1st alloc) */
1776 const STRLEN new_len
1777 = SvCUR(sv) < 60 ? 80 : SvCUR(sv)+40; /* allow some slop */
1778 SvPV_renew(sv, new_len);
1787 register PERL_CONTEXT *cx;
1788 I32 gimme = OP_GIMME(PL_op, -1);
1791 if (cxstack_ix >= 0) {
1792 /* If this flag is set, we're just inside a return, so we should
1793 * store the caller's context */
1794 gimme = (PL_op->op_flags & OPf_SPECIAL)
1796 : cxstack[cxstack_ix].blk_gimme;
1801 ENTER_with_name("block");
1804 PUSHBLOCK(cx, CXt_BLOCK, SP);
1814 SV * const keysv = POPs;
1815 HV * const hv = MUTABLE_HV(POPs);
1816 const U32 lval = PL_op->op_flags & OPf_MOD || LVRET;
1817 const U32 defer = PL_op->op_private & OPpLVAL_DEFER;
1819 const U32 hash = (SvIsCOW_shared_hash(keysv)) ? SvSHARED_HASH(keysv) : 0;
1820 const bool localizing = PL_op->op_private & OPpLVAL_INTRO;
1821 bool preeminent = TRUE;
1823 if (SvTYPE(hv) != SVt_PVHV)
1830 /* If we can determine whether the element exist,
1831 * Try to preserve the existenceness of a tied hash
1832 * element by using EXISTS and DELETE if possible.
1833 * Fallback to FETCH and STORE otherwise. */
1834 if (SvCANEXISTDELETE(hv) || mg_find((const SV *)hv, PERL_MAGIC_env))
1835 preeminent = hv_exists_ent(hv, keysv, 0);
1838 he = hv_fetch_ent(hv, keysv, lval && !defer, hash);
1839 svp = he ? &HeVAL(he) : NULL;
1841 if (!svp || *svp == &PL_sv_undef) {
1845 DIE(aTHX_ PL_no_helem_sv, SVfARG(keysv));
1847 lv = sv_newmortal();
1848 sv_upgrade(lv, SVt_PVLV);
1850 sv_magic(lv, key2 = newSVsv(keysv), PERL_MAGIC_defelem, NULL, 0);
1851 SvREFCNT_dec(key2); /* sv_magic() increments refcount */
1852 LvTARG(lv) = SvREFCNT_inc_simple(hv);
1858 if (HvNAME_get(hv) && isGV(*svp))
1859 save_gp(MUTABLE_GV(*svp), !(PL_op->op_flags & OPf_SPECIAL));
1860 else if (preeminent)
1861 save_helem_flags(hv, keysv, svp,
1862 (PL_op->op_flags & OPf_SPECIAL) ? 0 : SAVEf_SETMAGIC);
1864 SAVEHDELETE(hv, keysv);
1866 else if (PL_op->op_private & OPpDEREF)
1867 vivify_ref(*svp, PL_op->op_private & OPpDEREF);
1869 sv = (svp ? *svp : &PL_sv_undef);
1870 /* Originally this did a conditional C<sv = sv_mortalcopy(sv)>; this
1871 * was to make C<local $tied{foo} = $tied{foo}> possible.
1872 * However, it seems no longer to be needed for that purpose, and
1873 * introduced a new bug: stuff like C<while ($hash{taintedval} =~ /.../g>
1874 * would loop endlessly since the pos magic is getting set on the
1875 * mortal copy and lost. However, the copy has the effect of
1876 * triggering the get magic, and losing it altogether made things like
1877 * c<$tied{foo};> in void context no longer do get magic, which some
1878 * code relied on. Also, delayed triggering of magic on @+ and friends
1879 * meant the original regex may be out of scope by now. So as a
1880 * compromise, do the get magic here. (The MGf_GSKIP flag will stop it
1881 * being called too many times). */
1882 if (!lval && SvRMAGICAL(hv) && SvGMAGICAL(sv))
1891 register PERL_CONTEXT *cx;
1896 if (PL_op->op_flags & OPf_SPECIAL) {
1897 cx = &cxstack[cxstack_ix];
1898 cx->blk_oldpm = PL_curpm; /* fake block should preserve $1 et al */
1903 gimme = OP_GIMME(PL_op, (cxstack_ix >= 0) ? gimme : G_SCALAR);
1906 if (gimme == G_VOID)
1908 else if (gimme == G_SCALAR) {
1912 if (SvFLAGS(TOPs) & (SVs_PADTMP|SVs_TEMP))
1915 *MARK = sv_mortalcopy(TOPs);
1918 *MARK = &PL_sv_undef;
1922 else if (gimme == G_ARRAY) {
1923 /* in case LEAVE wipes old return values */
1925 for (mark = newsp + 1; mark <= SP; mark++) {
1926 if (!(SvFLAGS(*mark) & (SVs_PADTMP|SVs_TEMP))) {
1927 *mark = sv_mortalcopy(*mark);
1928 TAINT_NOT; /* Each item is independent */
1932 PL_curpm = newpm; /* Don't pop $1 et al till now */
1934 LEAVE_with_name("block");
1942 register PERL_CONTEXT *cx;
1945 AV *av = NULL; /* used for LOOP_FOR on arrays and the stack */
1946 bool av_is_stack = FALSE;
1949 cx = &cxstack[cxstack_ix];
1950 if (!CxTYPE_is_LOOP(cx))
1951 DIE(aTHX_ "panic: pp_iter");
1953 itersvp = CxITERVAR(cx);
1954 if (CxTYPE(cx) == CXt_LOOP_LAZYSV) {
1955 /* string increment */
1956 SV* cur = cx->blk_loop.state_u.lazysv.cur;
1957 SV *end = cx->blk_loop.state_u.lazysv.end;
1958 /* If the maximum is !SvOK(), pp_enteriter substitutes PL_sv_no.
1959 It has SvPVX of "" and SvCUR of 0, which is what we want. */
1961 const char *max = SvPV_const(end, maxlen);
1962 if (!SvNIOK(cur) && SvCUR(cur) <= maxlen) {
1963 if (SvREFCNT(*itersvp) == 1 && !SvMAGICAL(*itersvp)) {
1964 /* safe to reuse old SV */
1965 sv_setsv(*itersvp, cur);
1969 /* we need a fresh SV every time so that loop body sees a
1970 * completely new SV for closures/references to work as
1973 *itersvp = newSVsv(cur);
1974 SvREFCNT_dec(oldsv);
1976 if (strEQ(SvPVX_const(cur), max))
1977 sv_setiv(cur, 0); /* terminate next time */
1984 else if (CxTYPE(cx) == CXt_LOOP_LAZYIV) {
1985 /* integer increment */
1986 if (cx->blk_loop.state_u.lazyiv.cur > cx->blk_loop.state_u.lazyiv.end)
1989 /* don't risk potential race */
1990 if (SvREFCNT(*itersvp) == 1 && !SvMAGICAL(*itersvp)) {
1991 /* safe to reuse old SV */
1992 sv_setiv(*itersvp, cx->blk_loop.state_u.lazyiv.cur++);
1996 /* we need a fresh SV every time so that loop body sees a
1997 * completely new SV for closures/references to work as they
2000 *itersvp = newSViv(cx->blk_loop.state_u.lazyiv.cur++);
2001 SvREFCNT_dec(oldsv);
2004 /* Handle end of range at IV_MAX */
2005 if ((cx->blk_loop.state_u.lazyiv.cur == IV_MIN) &&
2006 (cx->blk_loop.state_u.lazyiv.end == IV_MAX))
2008 cx->blk_loop.state_u.lazyiv.cur++;
2009 cx->blk_loop.state_u.lazyiv.end++;
2016 assert(CxTYPE(cx) == CXt_LOOP_FOR);
2017 av = cx->blk_loop.state_u.ary.ary;
2022 if (PL_op->op_private & OPpITER_REVERSED) {
2023 if (cx->blk_loop.state_u.ary.ix <= (av_is_stack
2024 ? cx->blk_loop.resetsp + 1 : 0))
2027 if (SvMAGICAL(av) || AvREIFY(av)) {
2028 SV * const * const svp = av_fetch(av, --cx->blk_loop.state_u.ary.ix, FALSE);
2029 sv = svp ? *svp : NULL;
2032 sv = AvARRAY(av)[--cx->blk_loop.state_u.ary.ix];
2036 if (cx->blk_loop.state_u.ary.ix >= (av_is_stack ? cx->blk_oldsp :
2040 if (SvMAGICAL(av) || AvREIFY(av)) {
2041 SV * const * const svp = av_fetch(av, ++cx->blk_loop.state_u.ary.ix, FALSE);
2042 sv = svp ? *svp : NULL;
2045 sv = AvARRAY(av)[++cx->blk_loop.state_u.ary.ix];
2049 if (sv && SvIS_FREED(sv)) {
2051 Perl_croak(aTHX_ "Use of freed value in iteration");
2056 SvREFCNT_inc_simple_void_NN(sv);
2060 if (!av_is_stack && sv == &PL_sv_undef) {
2061 SV *lv = newSV_type(SVt_PVLV);
2063 sv_magic(lv, NULL, PERL_MAGIC_defelem, NULL, 0);
2064 LvTARG(lv) = SvREFCNT_inc_simple(av);
2065 LvTARGOFF(lv) = cx->blk_loop.state_u.ary.ix;
2066 LvTARGLEN(lv) = (STRLEN)UV_MAX;
2072 SvREFCNT_dec(oldsv);
2080 register PMOP *pm = cPMOP;
2095 register REGEXP *rx = PM_GETRE(pm);
2097 int force_on_match = 0;
2098 const I32 oldsave = PL_savestack_ix;
2100 bool doutf8 = FALSE;
2102 #ifdef PERL_OLD_COPY_ON_WRITE
2106 /* known replacement string? */
2107 register SV *dstr = (pm->op_pmflags & PMf_CONST) ? POPs : NULL;
2111 if (PL_op->op_flags & OPf_STACKED)
2113 else if (PL_op->op_private & OPpTARGET_MY)
2120 /* In non-destructive replacement mode, duplicate target scalar so it
2121 * remains unchanged. */
2122 if (rpm->op_pmflags & PMf_NONDESTRUCT)
2123 TARG = newSVsv(TARG);
2125 #ifdef PERL_OLD_COPY_ON_WRITE
2126 /* Awooga. Awooga. "bool" types that are actually char are dangerous,
2127 because they make integers such as 256 "false". */
2128 is_cow = SvIsCOW(TARG) ? TRUE : FALSE;
2131 sv_force_normal_flags(TARG,0);
2134 #ifdef PERL_OLD_COPY_ON_WRITE
2138 || ( ((SvTYPE(TARG) == SVt_PVGV && isGV_with_GP(TARG))
2139 || SvTYPE(TARG) > SVt_PVLV)
2140 && !(SvTYPE(TARG) == SVt_PVGV && SvFAKE(TARG)))))
2141 Perl_croak_no_modify(aTHX);
2145 s = SvPV_mutable(TARG, len);
2146 if (!SvPOKp(TARG) || SvTYPE(TARG) == SVt_PVGV)
2148 rxtainted = ((RX_EXTFLAGS(rx) & RXf_TAINTED) ||
2149 (PL_tainted && (pm->op_pmflags & PMf_RETAINT)));
2154 RX_MATCH_UTF8_set(rx, DO_UTF8(TARG));
2158 DIE(aTHX_ "panic: pp_subst");
2161 slen = RX_MATCH_UTF8(rx) ? utf8_length((U8*)s, (U8*)strend) : len;
2162 maxiters = 2 * slen + 10; /* We can match twice at each
2163 position, once with zero-length,
2164 second time with non-zero. */
2166 if (!RX_PRELEN(rx) && PL_curpm) {
2170 r_flags = (RX_NPARENS(rx) || SvTEMP(TARG) || PL_sawampersand
2171 || (RX_EXTFLAGS(rx) & (RXf_EVAL_SEEN|RXf_PMf_KEEPCOPY)) )
2172 ? REXEC_COPY_STR : 0;
2174 r_flags |= REXEC_SCREAM;
2177 if (RX_EXTFLAGS(rx) & RXf_USE_INTUIT) {
2179 s = CALLREG_INTUIT_START(rx, TARG, s, strend, r_flags, NULL);
2183 /* How to do it in subst? */
2184 /* if ( (RX_EXTFLAGS(rx) & RXf_CHECK_ALL)
2186 && !(RX_EXTFLAGS(rx) & RXf_KEEPCOPY)
2187 && ((RX_EXTFLAGS(rx) & RXf_NOSCAN)
2188 || !((RX_EXTFLAGS(rx) & RXf_INTUIT_TAIL)
2189 && (r_flags & REXEC_SCREAM))))
2194 /* only replace once? */
2195 once = !(rpm->op_pmflags & PMf_GLOBAL);
2196 matched = CALLREGEXEC(rx, s, strend, orig, 0, TARG, NULL,
2197 r_flags | REXEC_CHECKED);
2198 /* known replacement string? */
2201 /* Upgrade the source if the replacement is utf8 but the source is not,
2202 * but only if it matched; see
2203 * http://www.nntp.perl.org/group/perl.perl5.porters/2010/04/msg158809.html
2205 if (matched && DO_UTF8(dstr) && ! DO_UTF8(TARG)) {
2206 const STRLEN new_len = sv_utf8_upgrade(TARG);
2208 /* If the lengths are the same, the pattern contains only
2209 * invariants, can keep going; otherwise, various internal markers
2210 * could be off, so redo */
2211 if (new_len != len) {
2216 /* replacement needing upgrading? */
2217 if (DO_UTF8(TARG) && !doutf8) {
2218 nsv = sv_newmortal();
2221 sv_recode_to_utf8(nsv, PL_encoding);
2223 sv_utf8_upgrade(nsv);
2224 c = SvPV_const(nsv, clen);
2228 c = SvPV_const(dstr, clen);
2229 doutf8 = DO_UTF8(dstr);
2237 /* can do inplace substitution? */
2239 #ifdef PERL_OLD_COPY_ON_WRITE
2242 && (I32)clen <= RX_MINLENRET(rx) && (once || !(r_flags & REXEC_COPY_STR))
2243 && !(RX_EXTFLAGS(rx) & RXf_LOOKBEHIND_SEEN)
2244 && (!doutf8 || SvUTF8(TARG))) {
2248 if (rpm->op_pmflags & PMf_NONDESTRUCT)
2252 LEAVE_SCOPE(oldsave);
2255 #ifdef PERL_OLD_COPY_ON_WRITE
2256 if (SvIsCOW(TARG)) {
2257 assert (!force_on_match);
2261 if (force_on_match) {
2263 s = SvPV_force(TARG, len);
2268 SvSCREAM_off(TARG); /* disable possible screamer */
2270 rxtainted |= RX_MATCH_TAINTED(rx);
2271 m = orig + RX_OFFS(rx)[0].start;
2272 d = orig + RX_OFFS(rx)[0].end;
2274 if (m - s > strend - d) { /* faster to shorten from end */
2276 Copy(c, m, clen, char);
2281 Move(d, m, i, char);
2285 SvCUR_set(TARG, m - s);
2287 else if ((i = m - s)) { /* faster from front */
2290 Move(s, d - i, i, char);
2293 Copy(c, m, clen, char);
2298 Copy(c, d, clen, char);
2303 TAINT_IF(rxtainted & 1);
2305 if (rpm->op_pmflags & PMf_NONDESTRUCT)
2312 if (iters++ > maxiters)
2313 DIE(aTHX_ "Substitution loop");
2314 rxtainted |= RX_MATCH_TAINTED(rx);
2315 m = RX_OFFS(rx)[0].start + orig;
2318 Move(s, d, i, char);
2322 Copy(c, d, clen, char);
2325 s = RX_OFFS(rx)[0].end + orig;
2326 } while (CALLREGEXEC(rx, s, strend, orig, s == m,
2328 /* don't match same null twice */
2329 REXEC_NOT_FIRST|REXEC_IGNOREPOS));
2332 SvCUR_set(TARG, d - SvPVX_const(TARG) + i);
2333 Move(s, d, i+1, char); /* include the NUL */
2335 TAINT_IF(rxtainted & 1);
2337 if (rpm->op_pmflags & PMf_NONDESTRUCT)
2342 (void)SvPOK_only_UTF8(TARG);
2343 TAINT_IF(rxtainted);
2344 if (SvSMAGICAL(TARG)) {
2352 LEAVE_SCOPE(oldsave);
2358 if (force_on_match) {
2360 s = SvPV_force(TARG, len);
2363 #ifdef PERL_OLD_COPY_ON_WRITE
2366 rxtainted |= RX_MATCH_TAINTED(rx);
2367 dstr = newSVpvn_utf8(m, s-m, DO_UTF8(TARG));
2371 register PERL_CONTEXT *cx;
2374 RETURNOP(cPMOP->op_pmreplrootu.op_pmreplroot);
2376 r_flags |= REXEC_IGNOREPOS | REXEC_NOT_FIRST;
2378 if (iters++ > maxiters)
2379 DIE(aTHX_ "Substitution loop");
2380 rxtainted |= RX_MATCH_TAINTED(rx);
2381 if (RX_MATCH_COPIED(rx) && RX_SUBBEG(rx) != orig) {
2384 orig = RX_SUBBEG(rx);
2386 strend = s + (strend - m);
2388 m = RX_OFFS(rx)[0].start + orig;
2389 if (doutf8 && !SvUTF8(dstr))
2390 sv_catpvn_utf8_upgrade(dstr, s, m - s, nsv);
2392 sv_catpvn(dstr, s, m-s);
2393 s = RX_OFFS(rx)[0].end + orig;
2395 sv_catpvn(dstr, c, clen);
2398 } while (CALLREGEXEC(rx, s, strend, orig, s == m,
2399 TARG, NULL, r_flags));
2400 if (doutf8 && !DO_UTF8(TARG))
2401 sv_catpvn_utf8_upgrade(dstr, s, strend - s, nsv);
2403 sv_catpvn(dstr, s, strend - s);
2405 #ifdef PERL_OLD_COPY_ON_WRITE
2406 /* The match may make the string COW. If so, brilliant, because that's
2407 just saved us one malloc, copy and free - the regexp has donated
2408 the old buffer, and we malloc an entirely new one, rather than the
2409 regexp malloc()ing a buffer and copying our original, only for
2410 us to throw it away here during the substitution. */
2411 if (SvIsCOW(TARG)) {
2412 sv_force_normal_flags(TARG, SV_COW_DROP_PV);
2418 SvPV_set(TARG, SvPVX(dstr));
2419 SvCUR_set(TARG, SvCUR(dstr));
2420 SvLEN_set(TARG, SvLEN(dstr));
2421 doutf8 |= DO_UTF8(dstr);
2422 SvPV_set(dstr, NULL);
2424 TAINT_IF(rxtainted & 1);
2426 if (rpm->op_pmflags & PMf_NONDESTRUCT)
2431 (void)SvPOK_only(TARG);
2434 TAINT_IF(rxtainted);
2437 LEAVE_SCOPE(oldsave);
2445 if (rpm->op_pmflags & PMf_NONDESTRUCT)
2449 LEAVE_SCOPE(oldsave);
2458 PL_stack_base[PL_markstack_ptr[-1]++] = PL_stack_base[*PL_markstack_ptr];
2459 ++*PL_markstack_ptr;
2461 LEAVE_with_name("grep_item"); /* exit inner scope */
2464 if (PL_stack_base + *PL_markstack_ptr > SP) {
2466 const I32 gimme = GIMME_V;
2468 LEAVE_with_name("grep"); /* exit outer scope */
2469 (void)POPMARK; /* pop src */
2470 items = --*PL_markstack_ptr - PL_markstack_ptr[-1];
2471 (void)POPMARK; /* pop dst */
2472 SP = PL_stack_base + POPMARK; /* pop original mark */
2473 if (gimme == G_SCALAR) {
2474 if (PL_op->op_private & OPpGREP_LEX) {
2475 SV* const sv = sv_newmortal();
2476 sv_setiv(sv, items);
2484 else if (gimme == G_ARRAY)
2491 ENTER_with_name("grep_item"); /* enter inner scope */
2494 src = PL_stack_base[*PL_markstack_ptr];
2496 if (PL_op->op_private & OPpGREP_LEX)
2497 PAD_SVl(PL_op->op_targ) = src;
2501 RETURNOP(cLOGOP->op_other);
2512 register PERL_CONTEXT *cx;
2515 if (CxMULTICALL(&cxstack[cxstack_ix]))
2519 cxstack_ix++; /* temporarily protect top context */
2522 if (gimme == G_SCALAR) {
2525 if (cx->blk_sub.cv && CvDEPTH(cx->blk_sub.cv) > 1) {
2527 *MARK = SvREFCNT_inc(TOPs);
2532 sv = SvREFCNT_inc(TOPs); /* FREETMPS could clobber it */
2534 *MARK = sv_mortalcopy(sv);
2539 *MARK = SvTEMP(TOPs) ? TOPs : sv_mortalcopy(TOPs);
2543 *MARK = &PL_sv_undef;
2547 else if (gimme == G_ARRAY) {
2548 for (MARK = newsp + 1; MARK <= SP; MARK++) {
2549 if (!SvTEMP(*MARK)) {
2550 *MARK = sv_mortalcopy(*MARK);
2551 TAINT_NOT; /* Each item is independent */
2559 POPSUB(cx,sv); /* Stack values are safe: release CV and @_ ... */
2560 PL_curpm = newpm; /* ... and pop $1 et al */
2563 return cx->blk_sub.retop;
2566 /* This duplicates the above code because the above code must not
2567 * get any slower by more conditions */
2575 register PERL_CONTEXT *cx;
2578 if (CxMULTICALL(&cxstack[cxstack_ix]))
2582 cxstack_ix++; /* temporarily protect top context */
2586 if (CxLVAL(cx) & OPpENTERSUB_INARGS) {
2587 /* We are an argument to a function or grep().
2588 * This kind of lvalueness was legal before lvalue
2589 * subroutines too, so be backward compatible:
2590 * cannot report errors. */
2592 /* Scalar context *is* possible, on the LHS of -> only,
2593 * as in f()->meth(). But this is not an lvalue. */
2594 if (gimme == G_SCALAR)
2596 if (gimme == G_ARRAY) {
2597 if (!CvLVALUE(cx->blk_sub.cv))
2598 goto temporise_array;
2599 EXTEND_MORTAL(SP - newsp);
2600 for (mark = newsp + 1; mark <= SP; mark++) {
2603 else if (SvFLAGS(*mark) & (SVs_PADTMP | SVf_READONLY))
2604 *mark = sv_mortalcopy(*mark);
2606 /* Can be a localized value subject to deletion. */
2607 PL_tmps_stack[++PL_tmps_ix] = *mark;
2608 SvREFCNT_inc_void(*mark);
2613 else if (CxLVAL(cx)) { /* Leave it as it is if we can. */
2614 /* Here we go for robustness, not for speed, so we change all
2615 * the refcounts so the caller gets a live guy. Cannot set
2616 * TEMP, so sv_2mortal is out of question. */
2617 if (!CvLVALUE(cx->blk_sub.cv)) {
2623 DIE(aTHX_ "Can't modify non-lvalue subroutine call");
2625 if (gimme == G_SCALAR) {
2629 /* Temporaries are bad unless they happen to have set magic
2630 * attached, such as the elements of a tied hash or array */
2631 if ((SvFLAGS(TOPs) & (SVs_TEMP | SVs_PADTMP) ||
2632 (SvFLAGS(TOPs) & (SVf_READONLY | SVf_FAKE))
2635 !SvSMAGICAL(TOPs)) {
2641 DIE(aTHX_ "Can't return %s from lvalue subroutine",
2642 SvREADONLY(TOPs) ? (TOPs == &PL_sv_undef) ? "undef"
2643 : "a readonly value" : "a temporary");
2645 else { /* Can be a localized value
2646 * subject to deletion. */
2647 PL_tmps_stack[++PL_tmps_ix] = *mark;
2648 SvREFCNT_inc_void(*mark);
2651 else { /* Should not happen? */
2657 DIE(aTHX_ "%s returned from lvalue subroutine in scalar context",
2658 (MARK > SP ? "Empty array" : "Array"));
2662 else if (gimme == G_ARRAY) {
2663 EXTEND_MORTAL(SP - newsp);
2664 for (mark = newsp + 1; mark <= SP; mark++) {
2665 if (*mark != &PL_sv_undef
2666 && SvFLAGS(*mark) & (SVs_TEMP | SVs_PADTMP | SVf_READONLY)) {
2667 /* Might be flattened array after $#array = */
2674 DIE(aTHX_ "Can't return a %s from lvalue subroutine",
2675 SvREADONLY(TOPs) ? "readonly value" : "temporary");
2678 /* Can be a localized value subject to deletion. */
2679 PL_tmps_stack[++PL_tmps_ix] = *mark;
2680 SvREFCNT_inc_void(*mark);
2686 if (gimme == G_SCALAR) {
2690 if (cx->blk_sub.cv && CvDEPTH(cx->blk_sub.cv) > 1) {
2692 *MARK = SvREFCNT_inc(TOPs);
2697 sv = SvREFCNT_inc(TOPs); /* FREETMPS could clobber it */
2699 *MARK = sv_mortalcopy(sv);
2704 *MARK = SvTEMP(TOPs) ? TOPs : sv_mortalcopy(TOPs);
2708 *MARK = &PL_sv_undef;
2712 else if (gimme == G_ARRAY) {
2714 for (MARK = newsp + 1; MARK <= SP; MARK++) {
2715 if (!SvTEMP(*MARK)) {
2716 *MARK = sv_mortalcopy(*MARK);
2717 TAINT_NOT; /* Each item is independent */
2726 POPSUB(cx,sv); /* Stack values are safe: release CV and @_ ... */
2727 PL_curpm = newpm; /* ... and pop $1 et al */
2730 return cx->blk_sub.retop;
2738 register PERL_CONTEXT *cx;
2740 const bool hasargs = (PL_op->op_flags & OPf_STACKED) != 0;
2743 DIE(aTHX_ "Not a CODE reference");
2744 switch (SvTYPE(sv)) {
2745 /* This is overwhelming the most common case: */
2747 if (!isGV_with_GP(sv))
2748 DIE(aTHX_ "Not a CODE reference");
2750 if (!(cv = GvCVu((const GV *)sv))) {
2752 cv = sv_2cv(sv, &stash, &gv, 0);
2761 if(isGV_with_GP(sv)) goto we_have_a_glob;
2764 if (sv == &PL_sv_yes) { /* unfound import, ignore */
2766 SP = PL_stack_base + POPMARK;
2773 SV * const * sp = &sv; /* Used in tryAMAGICunDEREF macro. */
2774 tryAMAGICunDEREF(to_cv);
2779 sym = SvPV_nomg_const(sv, len);
2781 DIE(aTHX_ PL_no_usym, "a subroutine");
2782 if (PL_op->op_private & HINT_STRICT_REFS)
2783 DIE(aTHX_ "Can't use string (\"%.32s\"%s) as a subroutine ref while \"strict refs\" in use", sym, len>32 ? "..." : "");
2784 cv = get_cvn_flags(sym, len, GV_ADD|SvUTF8(sv));
2787 cv = MUTABLE_CV(SvRV(sv));
2788 if (SvTYPE(cv) == SVt_PVCV)
2793 DIE(aTHX_ "Not a CODE reference");
2794 /* This is the second most common case: */
2796 cv = MUTABLE_CV(sv);
2804 if (!CvROOT(cv) && !CvXSUB(cv)) {
2808 /* anonymous or undef'd function leaves us no recourse */
2809 if (CvANON(cv) || !(gv = CvGV(cv)))
2810 DIE(aTHX_ "Undefined subroutine called");
2812 /* autoloaded stub? */
2813 if (cv != GvCV(gv)) {
2816 /* should call AUTOLOAD now? */
2819 if ((autogv = gv_autoload4(GvSTASH(gv), GvNAME(gv), GvNAMELEN(gv),
2826 sub_name = sv_newmortal();
2827 gv_efullname3(sub_name, gv, NULL);
2828 DIE(aTHX_ "Undefined subroutine &%"SVf" called", SVfARG(sub_name));
2832 DIE(aTHX_ "Not a CODE reference");
2837 if ((PL_op->op_private & OPpENTERSUB_DB) && GvCV(PL_DBsub) && !CvNODEBUG(cv)) {
2838 Perl_get_db_sub(aTHX_ &sv, cv);
2840 PL_curcopdb = PL_curcop;
2842 /* check for lsub that handles lvalue subroutines */
2843 cv = GvCV(gv_HVadd(gv_fetchpvs("DB::lsub", GV_ADDMULTI, SVt_PVHV)));
2844 /* if lsub not found then fall back to DB::sub */
2845 if (!cv) cv = GvCV(PL_DBsub);
2847 cv = GvCV(PL_DBsub);
2850 if (!cv || (!CvXSUB(cv) && !CvSTART(cv)))
2851 DIE(aTHX_ "No DB::sub routine defined");
2854 if (!(CvISXSUB(cv))) {
2855 /* This path taken at least 75% of the time */
2857 register I32 items = SP - MARK;
2858 AV* const padlist = CvPADLIST(cv);
2859 PUSHBLOCK(cx, CXt_SUB, MARK);
2861 cx->blk_sub.retop = PL_op->op_next;
2863 /* XXX This would be a natural place to set C<PL_compcv = cv> so
2864 * that eval'' ops within this sub know the correct lexical space.
2865 * Owing the speed considerations, we choose instead to search for
2866 * the cv using find_runcv() when calling doeval().
2868 if (CvDEPTH(cv) >= 2) {
2869 PERL_STACK_OVERFLOW_CHECK();
2870 pad_push(padlist, CvDEPTH(cv));
2873 PAD_SET_CUR_NOSAVE(padlist, CvDEPTH(cv));
2875 AV *const av = MUTABLE_AV(PAD_SVl(0));
2877 /* @_ is normally not REAL--this should only ever
2878 * happen when DB::sub() calls things that modify @_ */
2883 cx->blk_sub.savearray = GvAV(PL_defgv);
2884 GvAV(PL_defgv) = MUTABLE_AV(SvREFCNT_inc_simple(av));
2885 CX_CURPAD_SAVE(cx->blk_sub);
2886 cx->blk_sub.argarray = av;
2889 if (items > AvMAX(av) + 1) {
2890 SV **ary = AvALLOC(av);
2891 if (AvARRAY(av) != ary) {
2892 AvMAX(av) += AvARRAY(av) - AvALLOC(av);
2895 if (items > AvMAX(av) + 1) {
2896 AvMAX(av) = items - 1;
2897 Renew(ary,items,SV*);
2902 Copy(MARK,AvARRAY(av),items,SV*);
2903 AvFILLp(av) = items - 1;
2911 /* warning must come *after* we fully set up the context
2912 * stuff so that __WARN__ handlers can safely dounwind()
2915 if (CvDEPTH(cv) == PERL_SUB_DEPTH_WARN && ckWARN(WARN_RECURSION)
2916 && !(PERLDB_SUB && cv == GvCV(PL_DBsub)))
2917 sub_crush_depth(cv);
2918 RETURNOP(CvSTART(cv));
2921 I32 markix = TOPMARK;
2926 /* Need to copy @_ to stack. Alternative may be to
2927 * switch stack to @_, and copy return values
2928 * back. This would allow popping @_ in XSUB, e.g.. XXXX */
2929 AV * const av = GvAV(PL_defgv);
2930 const I32 items = AvFILLp(av) + 1; /* @_ is not tieable */
2933 /* Mark is at the end of the stack. */
2935 Copy(AvARRAY(av), SP + 1, items, SV*);
2940 /* We assume first XSUB in &DB::sub is the called one. */
2942 SAVEVPTR(PL_curcop);
2943 PL_curcop = PL_curcopdb;
2946 /* Do we need to open block here? XXXX */
2948 /* CvXSUB(cv) must not be NULL because newXS() refuses NULL xsub address */
2950 CvXSUB(cv)(aTHX_ cv);
2952 /* Enforce some sanity in scalar context. */
2953 if (gimme == G_SCALAR && ++markix != PL_stack_sp - PL_stack_base ) {
2954 if (markix > PL_stack_sp - PL_stack_base)
2955 *(PL_stack_base + markix) = &PL_sv_undef;
2957 *(PL_stack_base + markix) = *PL_stack_sp;
2958 PL_stack_sp = PL_stack_base + markix;
2966 Perl_sub_crush_depth(pTHX_ CV *cv)
2968 PERL_ARGS_ASSERT_SUB_CRUSH_DEPTH;
2971 Perl_warner(aTHX_ packWARN(WARN_RECURSION), "Deep recursion on anonymous subroutine");
2973 SV* const tmpstr = sv_newmortal();
2974 gv_efullname3(tmpstr, CvGV(cv), NULL);
2975 Perl_warner(aTHX_ packWARN(WARN_RECURSION), "Deep recursion on subroutine \"%"SVf"\"",
2984 SV* const elemsv = POPs;
2985 IV elem = SvIV(elemsv);
2986 AV *const av = MUTABLE_AV(POPs);
2987 const U32 lval = PL_op->op_flags & OPf_MOD || LVRET;
2988 const U32 defer = (PL_op->op_private & OPpLVAL_DEFER) && (elem > av_len(av));
2989 const bool localizing = PL_op->op_private & OPpLVAL_INTRO;
2990 bool preeminent = TRUE;
2993 if (SvROK(elemsv) && !SvGAMAGIC(elemsv) && ckWARN(WARN_MISC))
2994 Perl_warner(aTHX_ packWARN(WARN_MISC),
2995 "Use of reference \"%"SVf"\" as array index",
2998 elem -= CopARYBASE_get(PL_curcop);
2999 if (SvTYPE(av) != SVt_PVAV)
3006 /* If we can determine whether the element exist,
3007 * Try to preserve the existenceness of a tied array
3008 * element by using EXISTS and DELETE if possible.
3009 * Fallback to FETCH and STORE otherwise. */
3010 if (SvCANEXISTDELETE(av))
3011 preeminent = av_exists(av, elem);
3014 svp = av_fetch(av, elem, lval && !defer);
3016 #ifdef PERL_MALLOC_WRAP
3017 if (SvUOK(elemsv)) {
3018 const UV uv = SvUV(elemsv);
3019 elem = uv > IV_MAX ? IV_MAX : uv;
3021 else if (SvNOK(elemsv))
3022 elem = (IV)SvNV(elemsv);
3024 static const char oom_array_extend[] =
3025 "Out of memory during array extend"; /* Duplicated in av.c */
3026 MEM_WRAP_CHECK_1(elem,SV*,oom_array_extend);
3029 if (!svp || *svp == &PL_sv_undef) {
3032 DIE(aTHX_ PL_no_aelem, elem);
3033 lv = sv_newmortal();
3034 sv_upgrade(lv, SVt_PVLV);
3036 sv_magic(lv, NULL, PERL_MAGIC_defelem, NULL, 0);
3037 LvTARG(lv) = SvREFCNT_inc_simple(av);
3038 LvTARGOFF(lv) = elem;
3045 save_aelem(av, elem, svp);
3047 SAVEADELETE(av, elem);
3049 else if (PL_op->op_private & OPpDEREF)
3050 vivify_ref(*svp, PL_op->op_private & OPpDEREF);
3052 sv = (svp ? *svp : &PL_sv_undef);
3053 if (!lval && SvRMAGICAL(av) && SvGMAGICAL(sv)) /* see note in pp_helem() */
3060 Perl_vivify_ref(pTHX_ SV *sv, U32 to_what)
3062 PERL_ARGS_ASSERT_VIVIFY_REF;
3067 Perl_croak_no_modify(aTHX);
3068 prepare_SV_for_RV(sv);
3071 SvRV_set(sv, newSV(0));
3074 SvRV_set(sv, MUTABLE_SV(newAV()));
3077 SvRV_set(sv, MUTABLE_SV(newHV()));
3088 SV* const sv = TOPs;
3091 SV* const rsv = SvRV(sv);
3092 if (SvTYPE(rsv) == SVt_PVCV) {
3098 SETs(method_common(sv, NULL));
3105 SV* const sv = cSVOP_sv;
3106 U32 hash = SvSHARED_HASH(sv);
3108 XPUSHs(method_common(sv, &hash));
3113 S_method_common(pTHX_ SV* meth, U32* hashp)
3119 const char* packname = NULL;
3122 SV * const sv = *(PL_stack_base + TOPMARK + 1);
3124 PERL_ARGS_ASSERT_METHOD_COMMON;
3127 Perl_croak(aTHX_ "Can't call method \"%"SVf"\" on an undefined value",
3132 ob = MUTABLE_SV(SvRV(sv));
3136 /* this isn't a reference */
3137 if(SvOK(sv) && (packname = SvPV_const(sv, packlen))) {
3138 const HE* const he = hv_fetch_ent(PL_stashcache, sv, 0, 0);
3140 stash = INT2PTR(HV*,SvIV(HeVAL(he)));
3147 !(iogv = gv_fetchsv(sv, 0, SVt_PVIO)) ||
3148 !(ob=MUTABLE_SV(GvIO(iogv))))
3150 /* this isn't the name of a filehandle either */
3152 ((UTF8_IS_START(*packname) && DO_UTF8(sv))
3153 ? !isIDFIRST_utf8((U8*)packname)
3154 : !isIDFIRST(*packname)
3157 Perl_croak(aTHX_ "Can't call method \"%"SVf"\" %s",
3159 SvOK(sv) ? "without a package or object reference"
3160 : "on an undefined value");
3162 /* assume it's a package name */
3163 stash = gv_stashpvn(packname, packlen, 0);
3167 SV* const ref = newSViv(PTR2IV(stash));
3168 (void)hv_store(PL_stashcache, packname, packlen, ref, 0);
3172 /* it _is_ a filehandle name -- replace with a reference */
3173 *(PL_stack_base + TOPMARK + 1) = sv_2mortal(newRV(MUTABLE_SV(iogv)));
3176 /* if we got here, ob should be a reference or a glob */
3177 if (!ob || !(SvOBJECT(ob)
3178 || (SvTYPE(ob) == SVt_PVGV
3180 && (ob = MUTABLE_SV(GvIO((const GV *)ob)))
3183 const char * const name = SvPV_nolen_const(meth);
3184 Perl_croak(aTHX_ "Can't call method \"%s\" on unblessed reference",
3185 (SvSCREAM(meth) && strEQ(name,"isa")) ? "DOES" :
3189 stash = SvSTASH(ob);
3192 /* NOTE: stash may be null, hope hv_fetch_ent and
3193 gv_fetchmethod can cope (it seems they can) */
3195 /* shortcut for simple names */
3197 const HE* const he = hv_fetch_ent(stash, meth, 0, *hashp);
3199 gv = MUTABLE_GV(HeVAL(he));
3200 if (isGV(gv) && GvCV(gv) &&
3201 (!GvCVGEN(gv) || GvCVGEN(gv)
3202 == (PL_sub_generation + HvMROMETA(stash)->cache_gen)))
3203 return MUTABLE_SV(GvCV(gv));
3207 gv = gv_fetchmethod_flags(stash ? stash : MUTABLE_HV(packsv),
3208 SvPV_nolen_const(meth),
3209 GV_AUTOLOAD | GV_CROAK);
3213 return isGV(gv) ? MUTABLE_SV(GvCV(gv)) : MUTABLE_SV(gv);
3218 * c-indentation-style: bsd
3220 * indent-tabs-mode: t
3223 * ex: set ts=8 sts=4 sw=4 noet: