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));
77 /* This is sometimes called directly by pp_coreargs and pp_grepstart. */
81 PUSHMARK(PL_stack_sp);
92 /* no PUTBACK, SETs doesn't inc/dec SP */
99 XPUSHs(MUTABLE_SV(cGVOP_gv));
108 /* SP is not used to remove a variable that is saved across the
109 sv_2bool_flags call in SvTRUE_NN, if a RISC/CISC or low/high machine
110 register or load/store vs direct mem ops macro is introduced, this
111 should be a define block between direct PL_stack_sp and dSP operations,
112 presently, using PL_stack_sp is bias towards CISC cpus */
113 SV * const sv = *PL_stack_sp;
117 if (PL_op->op_type == OP_AND)
119 return cLOGOP->op_other;
127 /* sassign keeps its args in the optree traditionally backwards.
128 So we pop them differently.
130 SV *left = POPs; SV *right = TOPs;
132 if (PL_op->op_private & OPpASSIGN_BACKWARDS) {
133 SV * const temp = left;
134 left = right; right = temp;
136 if (TAINTING_get && TAINT_get && !SvTAINTED(right))
138 if (PL_op->op_private & OPpASSIGN_CV_TO_GV) {
139 SV * const cv = SvRV(right);
140 const U32 cv_type = SvTYPE(cv);
141 const bool is_gv = isGV_with_GP(left);
142 const bool got_coderef = cv_type == SVt_PVCV || cv_type == SVt_PVFM;
148 /* Can do the optimisation if left (LVALUE) is not a typeglob,
149 right (RVALUE) is a reference to something, and we're in void
151 if (!got_coderef && !is_gv && GIMME_V == G_VOID) {
152 /* Is the target symbol table currently empty? */
153 GV * const gv = gv_fetchsv_nomg(left, GV_NOINIT, SVt_PVGV);
154 if (SvTYPE(gv) != SVt_PVGV && !SvOK(gv)) {
155 /* Good. Create a new proxy constant subroutine in the target.
156 The gv becomes a(nother) reference to the constant. */
157 SV *const value = SvRV(cv);
159 SvUPGRADE(MUTABLE_SV(gv), SVt_IV);
160 SvPCS_IMPORTED_on(gv);
162 SvREFCNT_inc_simple_void(value);
168 /* Need to fix things up. */
170 /* Need to fix GV. */
171 left = MUTABLE_SV(gv_fetchsv_nomg(left,GV_ADD, SVt_PVGV));
175 /* We've been returned a constant rather than a full subroutine,
176 but they expect a subroutine reference to apply. */
178 ENTER_with_name("sassign_coderef");
179 SvREFCNT_inc_void(SvRV(cv));
180 /* newCONSTSUB takes a reference count on the passed in SV
181 from us. We set the name to NULL, otherwise we get into
182 all sorts of fun as the reference to our new sub is
183 donated to the GV that we're about to assign to.
185 SvRV_set(right, MUTABLE_SV(newCONSTSUB(GvSTASH(left), NULL,
188 LEAVE_with_name("sassign_coderef");
190 /* What can happen for the corner case *{"BONK"} = \&{"BONK"};
192 First: ops for \&{"BONK"}; return us the constant in the
194 Second: ops for *{"BONK"} cause that symbol table entry
195 (and our reference to it) to be upgraded from RV
197 Thirdly: We get here. cv is actually PVGV now, and its
198 GvCV() is actually the subroutine we're looking for
200 So change the reference so that it points to the subroutine
201 of that typeglob, as that's what they were after all along.
203 GV *const upgraded = MUTABLE_GV(cv);
204 CV *const source = GvCV(upgraded);
207 assert(CvFLAGS(source) & CVf_CONST);
209 SvREFCNT_inc_void(source);
210 SvREFCNT_dec(upgraded);
211 SvRV_set(right, MUTABLE_SV(source));
217 SvTEMP(left) && !SvSMAGICAL(left) && SvREFCNT(left) == 1 &&
218 (!isGV_with_GP(left) || SvFAKE(left)) && ckWARN(WARN_MISC)
221 packWARN(WARN_MISC), "Useless assignment to a temporary"
223 SvSetMagicSV(left, right);
233 RETURNOP(cLOGOP->op_other);
235 RETURNOP(cLOGOP->op_next);
242 TAINT_NOT; /* Each statement is presumed innocent */
243 PL_stack_sp = PL_stack_base + cxstack[cxstack_ix].blk_oldsp;
245 if (!(PL_op->op_flags & OPf_SPECIAL)) {
246 I32 oldsave = PL_scopestack[PL_scopestack_ix - 1];
247 LEAVE_SCOPE(oldsave);
254 dVAR; dSP; dATARGET; tryAMAGICbin_MG(concat_amg, AMGf_assign);
259 const char *rpv = NULL;
261 bool rcopied = FALSE;
263 if (TARG == right && right != left) { /* $r = $l.$r */
264 rpv = SvPV_nomg_const(right, rlen);
265 rbyte = !DO_UTF8(right);
266 right = newSVpvn_flags(rpv, rlen, SVs_TEMP);
267 rpv = SvPV_const(right, rlen); /* no point setting UTF-8 here */
271 if (TARG != left) { /* not $l .= $r */
273 const char* const lpv = SvPV_nomg_const(left, llen);
274 lbyte = !DO_UTF8(left);
275 sv_setpvn(TARG, lpv, llen);
281 else { /* $l .= $r */
283 if (left == right && ckWARN(WARN_UNINITIALIZED)) /* $l .= $l */
284 report_uninit(right);
287 SvPV_force_nomg_nolen(left);
288 lbyte = !DO_UTF8(left);
295 /* $r.$r: do magic twice: tied might return different 2nd time */
297 rpv = SvPV_nomg_const(right, rlen);
298 rbyte = !DO_UTF8(right);
300 if (lbyte != rbyte) {
301 /* sv_utf8_upgrade_nomg() may reallocate the stack */
304 sv_utf8_upgrade_nomg(TARG);
307 right = newSVpvn_flags(rpv, rlen, SVs_TEMP);
308 sv_utf8_upgrade_nomg(right);
309 rpv = SvPV_nomg_const(right, rlen);
313 sv_catpvn_nomg(TARG, rpv, rlen);
320 /* push the elements of av onto the stack.
321 * XXX Note that padav has similar code but without the mg_get().
322 * I suspect that the mg_get is no longer needed, but while padav
323 * differs, it can't share this function */
326 S_pushav(pTHX_ AV* const av)
329 const I32 maxarg = AvFILL(av) + 1;
331 if (SvRMAGICAL(av)) {
333 for (i=0; i < (U32)maxarg; i++) {
334 SV ** const svp = av_fetch(av, i, FALSE);
335 /* See note in pp_helem, and bug id #27839 */
337 ? SvGMAGICAL(*svp) ? (mg_get(*svp), *svp) : *svp
342 Copy(AvARRAY(av), SP+1, maxarg, SV*);
349 /* ($lex1,@lex2,...) or my ($lex1,@lex2,...) */
354 PADOFFSET base = PL_op->op_targ;
355 int count = (int)(PL_op->op_private) & OPpPADRANGE_COUNTMASK;
357 if (PL_op->op_flags & OPf_SPECIAL) {
358 /* fake the RHS of my ($x,$y,..) = @_ */
360 S_pushav(aTHX_ GvAVn(PL_defgv));
364 /* note, this is only skipped for compile-time-known void cxt */
365 if ((PL_op->op_flags & OPf_WANT) != OPf_WANT_VOID) {
368 for (i = 0; i <count; i++)
369 *++SP = PAD_SV(base+i);
371 if (PL_op->op_private & OPpLVAL_INTRO) {
372 SV **svp = &(PAD_SVl(base));
373 const UV payload = (UV)(
374 (base << (OPpPADRANGE_COUNTSHIFT + SAVE_TIGHT_SHIFT))
375 | (count << SAVE_TIGHT_SHIFT)
376 | SAVEt_CLEARPADRANGE);
377 assert(OPpPADRANGE_COUNTMASK + 1 == (1 <<OPpPADRANGE_COUNTSHIFT));
378 assert((payload >> (OPpPADRANGE_COUNTSHIFT+SAVE_TIGHT_SHIFT)) == base);
385 for (i = 0; i <count; i++)
386 SvPADSTALE_off(*svp++); /* mark lexical as active */
397 OP * const op = PL_op;
398 /* access PL_curpad once */
399 SV ** const padentry = &(PAD_SVl(op->op_targ));
404 PUTBACK; /* no pop/push after this, TOPs ok */
406 if (op->op_flags & OPf_MOD) {
407 if (op->op_private & OPpLVAL_INTRO)
408 if (!(op->op_private & OPpPAD_STATE))
409 save_clearsv(padentry);
410 if (op->op_private & OPpDEREF) {
411 /* TOPs is equivalent to TARG here. Using TOPs (SP) rather
412 than TARG reduces the scope of TARG, so it does not
413 span the call to save_clearsv, resulting in smaller
415 TOPs = vivify_ref(TOPs, op->op_private & OPpDEREF);
428 tryAMAGICunTARGETlist(iter_amg, 0, 0);
429 PL_last_in_gv = MUTABLE_GV(*PL_stack_sp--);
431 else PL_last_in_gv = PL_argvgv, PL_stack_sp--;
432 if (!isGV_with_GP(PL_last_in_gv)) {
433 if (SvROK(PL_last_in_gv) && isGV_with_GP(SvRV(PL_last_in_gv)))
434 PL_last_in_gv = MUTABLE_GV(SvRV(PL_last_in_gv));
437 XPUSHs(MUTABLE_SV(PL_last_in_gv));
440 PL_last_in_gv = MUTABLE_GV(*PL_stack_sp--);
443 return do_readline();
451 tryAMAGICbin_MG(eq_amg, AMGf_set|AMGf_numeric);
455 (SvIOK_notUV(left) && SvIOK_notUV(right))
456 ? (SvIVX(left) == SvIVX(right))
457 : ( do_ncmp(left, right) == 0)
466 PL_op->op_type == OP_PREINC || PL_op->op_type == OP_I_PREINC;
467 if (SvTYPE(TOPs) >= SVt_PVAV || (isGV_with_GP(TOPs) && !SvFAKE(TOPs)))
468 Perl_croak_no_modify();
469 if (!SvREADONLY(TOPs) && !SvGMAGICAL(TOPs) && SvIOK_notUV(TOPs) && !SvNOK(TOPs) && !SvPOK(TOPs)
470 && SvIVX(TOPs) != (inc ? IV_MAX : IV_MIN))
472 SvIV_set(TOPs, SvIVX(TOPs) + (inc ? 1 : -1));
473 SvFLAGS(TOPs) &= ~(SVp_NOK|SVp_POK);
475 else /* Do all the PERL_PRESERVE_IVUV conditionals in sv_inc */
476 if (inc) sv_inc(TOPs);
489 if (PL_op->op_type == OP_OR)
491 RETURNOP(cLOGOP->op_other);
500 const int op_type = PL_op->op_type;
501 const bool is_dor = (op_type == OP_DOR || op_type == OP_DORASSIGN);
506 if (!sv || !SvANY(sv)) {
507 if (op_type == OP_DOR)
509 RETURNOP(cLOGOP->op_other);
515 if (!sv || !SvANY(sv))
520 switch (SvTYPE(sv)) {
522 if (AvMAX(sv) >= 0 || SvGMAGICAL(sv) || (SvRMAGICAL(sv) && mg_find(sv, PERL_MAGIC_tied)))
526 if (HvARRAY(sv) || SvGMAGICAL(sv) || (SvRMAGICAL(sv) && mg_find(sv, PERL_MAGIC_tied)))
530 if (CvROOT(sv) || CvXSUB(sv))
543 if(op_type == OP_DOR)
545 RETURNOP(cLOGOP->op_other);
547 /* assuming OP_DEFINED */
555 dVAR; dSP; dATARGET; bool useleft; SV *svl, *svr;
556 tryAMAGICbin_MG(add_amg, AMGf_assign|AMGf_numeric);
560 useleft = USE_LEFT(svl);
561 #ifdef PERL_PRESERVE_IVUV
562 /* We must see if we can perform the addition with integers if possible,
563 as the integer code detects overflow while the NV code doesn't.
564 If either argument hasn't had a numeric conversion yet attempt to get
565 the IV. It's important to do this now, rather than just assuming that
566 it's not IOK as a PV of "9223372036854775806" may not take well to NV
567 addition, and an SV which is NOK, NV=6.0 ought to be coerced to
568 integer in case the second argument is IV=9223372036854775806
569 We can (now) rely on sv_2iv to do the right thing, only setting the
570 public IOK flag if the value in the NV (or PV) slot is truly integer.
572 A side effect is that this also aggressively prefers integer maths over
573 fp maths for integer values.
575 How to detect overflow?
577 C 99 section 6.2.6.1 says
579 The range of nonnegative values of a signed integer type is a subrange
580 of the corresponding unsigned integer type, and the representation of
581 the same value in each type is the same. A computation involving
582 unsigned operands can never overflow, because a result that cannot be
583 represented by the resulting unsigned integer type is reduced modulo
584 the number that is one greater than the largest value that can be
585 represented by the resulting type.
589 which I read as "unsigned ints wrap."
591 signed integer overflow seems to be classed as "exception condition"
593 If an exceptional condition occurs during the evaluation of an
594 expression (that is, if the result is not mathematically defined or not
595 in the range of representable values for its type), the behavior is
598 (6.5, the 5th paragraph)
600 I had assumed that on 2s complement machines signed arithmetic would
601 wrap, hence coded pp_add and pp_subtract on the assumption that
602 everything perl builds on would be happy. After much wailing and
603 gnashing of teeth it would seem that irix64 knows its ANSI spec well,
604 knows that it doesn't need to, and doesn't. Bah. Anyway, the all-
605 unsigned code below is actually shorter than the old code. :-)
608 if (SvIV_please_nomg(svr)) {
609 /* Unless the left argument is integer in range we are going to have to
610 use NV maths. Hence only attempt to coerce the right argument if
611 we know the left is integer. */
619 /* left operand is undef, treat as zero. + 0 is identity,
620 Could SETi or SETu right now, but space optimise by not adding
621 lots of code to speed up what is probably a rarish case. */
623 /* Left operand is defined, so is it IV? */
624 if (SvIV_please_nomg(svl)) {
625 if ((auvok = SvUOK(svl)))
628 const IV aiv = SvIVX(svl);
631 auvok = 1; /* Now acting as a sign flag. */
632 } else { /* 2s complement assumption for IV_MIN */
640 bool result_good = 0;
643 bool buvok = SvUOK(svr);
648 const IV biv = SvIVX(svr);
655 /* ?uvok if value is >= 0. basically, flagged as UV if it's +ve,
656 else "IV" now, independent of how it came in.
657 if a, b represents positive, A, B negative, a maps to -A etc
662 all UV maths. negate result if A negative.
663 add if signs same, subtract if signs differ. */
669 /* Must get smaller */
675 /* result really should be -(auv-buv). as its negation
676 of true value, need to swap our result flag */
693 if (result <= (UV)IV_MIN)
696 /* result valid, but out of range for IV. */
701 } /* Overflow, drop through to NVs. */
706 NV value = SvNV_nomg(svr);
709 /* left operand is undef, treat as zero. + 0.0 is identity. */
713 SETn( value + SvNV_nomg(svl) );
721 AV * const av = PL_op->op_type == OP_AELEMFAST_LEX
722 ? MUTABLE_AV(PAD_SV(PL_op->op_targ)) : GvAVn(cGVOP_gv);
723 const U32 lval = PL_op->op_flags & OPf_MOD;
724 SV** const svp = av_fetch(av, PL_op->op_private, lval);
725 SV *sv = (svp ? *svp : &PL_sv_undef);
727 if (!lval && SvRMAGICAL(av) && SvGMAGICAL(sv)) /* see note in pp_helem() */
735 dVAR; dSP; dMARK; dTARGET;
737 do_join(TARG, *MARK, MARK, SP);
748 * We ass_u_me that LvTARGOFF() comes first, and that two STRLENs
749 * will be enough to hold an OP*.
751 SV* const sv = sv_newmortal();
752 sv_upgrade(sv, SVt_PVLV);
754 Copy(&PL_op, &LvTARGOFF(sv), 1, OP*);
757 XPUSHs(MUTABLE_SV(PL_op));
762 /* Oversized hot code. */
766 dVAR; dSP; dMARK; dORIGMARK;
770 = (PL_op->op_flags & OPf_STACKED) ? MUTABLE_GV(*++MARK) : PL_defoutgv;
774 && (mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar)))
777 if (MARK == ORIGMARK) {
778 /* If using default handle then we need to make space to
779 * pass object as 1st arg, so move other args up ...
783 Move(MARK, MARK + 1, (SP - MARK) + 1, SV*);
786 return Perl_tied_method(aTHX_ "PRINT", mark - 1, MUTABLE_SV(io),
788 (G_SCALAR | TIED_METHOD_ARGUMENTS_ON_STACK
789 | (PL_op->op_type == OP_SAY
790 ? TIED_METHOD_SAY : 0)), sp - mark);
793 if ( gv && GvEGVx(gv) && (io = GvIO(GvEGV(gv)))
794 && (mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar)))
797 SETERRNO(EBADF,RMS_IFI);
800 else if (!(fp = IoOFP(io))) {
802 report_wrongway_fh(gv, '<');
805 SETERRNO(EBADF,IoIFP(io)?RMS_FAC:RMS_IFI);
809 SV * const ofs = GvSV(PL_ofsgv); /* $, */
811 if (ofs && (SvGMAGICAL(ofs) || SvOK(ofs))) {
813 if (!do_print(*MARK, fp))
817 /* don't use 'ofs' here - it may be invalidated by magic callbacks */
818 if (!do_print(GvSV(PL_ofsgv), fp)) {
827 if (!do_print(*MARK, fp))
835 if (PL_op->op_type == OP_SAY) {
836 if (PerlIO_write(fp, "\n", 1) == 0 || PerlIO_error(fp))
839 else if (PL_ors_sv && SvOK(PL_ors_sv))
840 if (!do_print(PL_ors_sv, fp)) /* $\ */
843 if (IoFLAGS(io) & IOf_FLUSH)
844 if (PerlIO_flush(fp) == EOF)
854 XPUSHs(&PL_sv_undef);
861 const I32 gimme = GIMME_V;
862 static const char an_array[] = "an ARRAY";
863 static const char a_hash[] = "a HASH";
864 const bool is_pp_rv2av = PL_op->op_type == OP_RV2AV;
865 const svtype type = is_pp_rv2av ? SVt_PVAV : SVt_PVHV;
870 sv = amagic_deref_call(sv, is_pp_rv2av ? to_av_amg : to_hv_amg);
873 if (SvTYPE(sv) != type)
874 /* diag_listed_as: Not an ARRAY reference */
875 DIE(aTHX_ "Not %s reference", is_pp_rv2av ? an_array : a_hash);
876 else if (PL_op->op_flags & OPf_MOD
877 && PL_op->op_private & OPpLVAL_INTRO)
878 Perl_croak(aTHX_ "%s", PL_no_localize_ref);
880 else if (SvTYPE(sv) != type) {
883 if (!isGV_with_GP(sv)) {
884 gv = Perl_softref2xv(aTHX_ sv, is_pp_rv2av ? an_array : a_hash,
892 sv = is_pp_rv2av ? MUTABLE_SV(GvAVn(gv)) : MUTABLE_SV(GvHVn(gv));
893 if (PL_op->op_private & OPpLVAL_INTRO)
894 sv = is_pp_rv2av ? MUTABLE_SV(save_ary(gv)) : MUTABLE_SV(save_hash(gv));
896 if (PL_op->op_flags & OPf_REF) {
900 else if (PL_op->op_private & OPpMAYBE_LVSUB) {
901 const I32 flags = is_lvalue_sub();
902 if (flags && !(flags & OPpENTERSUB_INARGS)) {
903 if (gimme != G_ARRAY)
904 goto croak_cant_return;
911 AV *const av = MUTABLE_AV(sv);
912 /* The guts of pp_rv2av, with no intending change to preserve history
913 (until such time as we get tools that can do blame annotation across
914 whitespace changes. */
915 if (gimme == G_ARRAY) {
921 else if (gimme == G_SCALAR) {
923 const I32 maxarg = AvFILL(av) + 1;
927 /* The guts of pp_rv2hv */
928 if (gimme == G_ARRAY) { /* array wanted */
930 return Perl_do_kv(aTHX);
932 else if ((PL_op->op_private & OPpTRUEBOOL
933 || ( PL_op->op_private & OPpMAYBE_TRUEBOOL
934 && block_gimme() == G_VOID ))
935 && (!SvRMAGICAL(sv) || !mg_find(sv, PERL_MAGIC_tied)))
936 SETs(HvUSEDKEYS(sv) ? &PL_sv_yes : sv_2mortal(newSViv(0)));
937 else if (gimme == G_SCALAR) {
939 TARG = Perl_hv_scalar(aTHX_ MUTABLE_HV(sv));
947 Perl_croak(aTHX_ "Can't return %s to lvalue scalar context",
948 is_pp_rv2av ? "array" : "hash");
953 S_do_oddball(pTHX_ HV *hash, SV **relem, SV **firstrelem)
957 PERL_ARGS_ASSERT_DO_ODDBALL;
963 if (ckWARN(WARN_MISC)) {
965 if (relem == firstrelem &&
967 (SvTYPE(SvRV(*relem)) == SVt_PVAV ||
968 SvTYPE(SvRV(*relem)) == SVt_PVHV))
970 err = "Reference found where even-sized list expected";
973 err = "Odd number of elements in hash assignment";
974 Perl_warner(aTHX_ packWARN(WARN_MISC), "%s", err);
978 didstore = hv_store_ent(hash,*relem,tmpstr,0);
979 if (SvMAGICAL(hash)) {
980 if (SvSMAGICAL(tmpstr))
992 SV **lastlelem = PL_stack_sp;
993 SV **lastrelem = PL_stack_base + POPMARK;
994 SV **firstrelem = PL_stack_base + POPMARK + 1;
995 SV **firstlelem = lastrelem + 1;
1008 SV **firsthashrelem = NULL; /* "= 0" keeps gcc 2.95 quiet */
1010 PL_delaymagic = DM_DELAY; /* catch simultaneous items */
1013 /* If there's a common identifier on both sides we have to take
1014 * special care that assigning the identifier on the left doesn't
1015 * clobber a value on the right that's used later in the list.
1016 * Don't bother if LHS is just an empty hash or array.
1019 if ( (PL_op->op_private & OPpASSIGN_COMMON)
1021 firstlelem != lastlelem
1022 || ! ((sv = *firstlelem))
1024 || ! (SvTYPE(sv) == SVt_PVAV || SvTYPE(sv) == SVt_PVHV)
1025 || (SvTYPE(sv) == SVt_PVAV && AvFILL((AV*)sv) != -1)
1026 || (SvTYPE(sv) == SVt_PVHV && HvUSEDKEYS((HV*)sv) != 0)
1029 EXTEND_MORTAL(lastrelem - firstrelem + 1);
1030 for (relem = firstrelem; relem <= lastrelem; relem++) {
1031 if ((sv = *relem)) {
1032 TAINT_NOT; /* Each item is independent */
1034 /* Dear TODO test in t/op/sort.t, I love you.
1035 (It's relying on a panic, not a "semi-panic" from newSVsv()
1036 and then an assertion failure below.) */
1037 if (SvIS_FREED(sv)) {
1038 Perl_croak(aTHX_ "panic: attempt to copy freed scalar %p",
1041 /* Not newSVsv(), as it does not allow copy-on-write,
1042 resulting in wasteful copies. We need a second copy of
1043 a temp here, hence the SV_NOSTEAL. */
1044 *relem = sv_mortalcopy_flags(sv,SV_GMAGIC|SV_DO_COW_SVSETSV
1055 while (lelem <= lastlelem) {
1056 TAINT_NOT; /* Each item stands on its own, taintwise. */
1058 switch (SvTYPE(sv)) {
1060 ary = MUTABLE_AV(sv);
1061 magic = SvMAGICAL(ary) != 0;
1063 SAVEFREESV(SvREFCNT_inc_simple_NN(sv));
1065 av_extend(ary, lastrelem - relem);
1067 while (relem <= lastrelem) { /* gobble up all the rest */
1070 SvGETMAGIC(*relem); /* before newSV, in case it dies */
1072 sv_setsv_nomg(sv, *relem);
1074 didstore = av_store(ary,i++,sv);
1083 if (PL_delaymagic & DM_ARRAY_ISA)
1084 SvSETMAGIC(MUTABLE_SV(ary));
1087 case SVt_PVHV: { /* normal hash */
1089 SV** topelem = relem;
1091 hash = MUTABLE_HV(sv);
1092 magic = SvMAGICAL(hash) != 0;
1094 SAVEFREESV(SvREFCNT_inc_simple_NN(sv));
1096 firsthashrelem = relem;
1098 while (relem < lastrelem) { /* gobble up all the rest */
1100 sv = *relem ? *relem : &PL_sv_no;
1102 tmpstr = sv_newmortal();
1104 sv_setsv(tmpstr,*relem); /* value */
1106 if (gimme != G_VOID) {
1107 if (hv_exists_ent(hash, sv, 0))
1108 /* key overwrites an existing entry */
1111 if (gimme == G_ARRAY) {
1112 /* copy element back: possibly to an earlier
1113 * stack location if we encountered dups earlier */
1115 *topelem++ = tmpstr;
1118 didstore = hv_store_ent(hash,sv,tmpstr,0);
1119 if (didstore) SvREFCNT_inc_simple_void_NN(tmpstr);
1121 if (SvSMAGICAL(tmpstr))
1126 if (relem == lastrelem) {
1127 do_oddball(hash, relem, firstrelem);
1134 if (SvIMMORTAL(sv)) {
1135 if (relem <= lastrelem)
1139 if (relem <= lastrelem) {
1141 SvTEMP(sv) && !SvSMAGICAL(sv) && SvREFCNT(sv) == 1 &&
1142 (!isGV_with_GP(sv) || SvFAKE(sv)) && ckWARN(WARN_MISC)
1145 packWARN(WARN_MISC),
1146 "Useless assignment to a temporary"
1148 sv_setsv(sv, *relem);
1152 sv_setsv(sv, &PL_sv_undef);
1157 if (PL_delaymagic & ~DM_DELAY) {
1158 /* Will be used to set PL_tainting below */
1159 UV tmp_uid = PerlProc_getuid();
1160 UV tmp_euid = PerlProc_geteuid();
1161 UV tmp_gid = PerlProc_getgid();
1162 UV tmp_egid = PerlProc_getegid();
1164 if (PL_delaymagic & DM_UID) {
1165 #ifdef HAS_SETRESUID
1166 (void)setresuid((PL_delaymagic & DM_RUID) ? PL_delaymagic_uid : (Uid_t)-1,
1167 (PL_delaymagic & DM_EUID) ? PL_delaymagic_euid : (Uid_t)-1,
1170 # ifdef HAS_SETREUID
1171 (void)setreuid((PL_delaymagic & DM_RUID) ? PL_delaymagic_uid : (Uid_t)-1,
1172 (PL_delaymagic & DM_EUID) ? PL_delaymagic_euid : (Uid_t)-1);
1175 if ((PL_delaymagic & DM_UID) == DM_RUID) {
1176 (void)setruid(PL_delaymagic_uid);
1177 PL_delaymagic &= ~DM_RUID;
1179 # endif /* HAS_SETRUID */
1181 if ((PL_delaymagic & DM_UID) == DM_EUID) {
1182 (void)seteuid(PL_delaymagic_euid);
1183 PL_delaymagic &= ~DM_EUID;
1185 # endif /* HAS_SETEUID */
1186 if (PL_delaymagic & DM_UID) {
1187 if (PL_delaymagic_uid != PL_delaymagic_euid)
1188 DIE(aTHX_ "No setreuid available");
1189 (void)PerlProc_setuid(PL_delaymagic_uid);
1191 # endif /* HAS_SETREUID */
1192 #endif /* HAS_SETRESUID */
1193 tmp_uid = PerlProc_getuid();
1194 tmp_euid = PerlProc_geteuid();
1196 if (PL_delaymagic & DM_GID) {
1197 #ifdef HAS_SETRESGID
1198 (void)setresgid((PL_delaymagic & DM_RGID) ? PL_delaymagic_gid : (Gid_t)-1,
1199 (PL_delaymagic & DM_EGID) ? PL_delaymagic_egid : (Gid_t)-1,
1202 # ifdef HAS_SETREGID
1203 (void)setregid((PL_delaymagic & DM_RGID) ? PL_delaymagic_gid : (Gid_t)-1,
1204 (PL_delaymagic & DM_EGID) ? PL_delaymagic_egid : (Gid_t)-1);
1207 if ((PL_delaymagic & DM_GID) == DM_RGID) {
1208 (void)setrgid(PL_delaymagic_gid);
1209 PL_delaymagic &= ~DM_RGID;
1211 # endif /* HAS_SETRGID */
1213 if ((PL_delaymagic & DM_GID) == DM_EGID) {
1214 (void)setegid(PL_delaymagic_egid);
1215 PL_delaymagic &= ~DM_EGID;
1217 # endif /* HAS_SETEGID */
1218 if (PL_delaymagic & DM_GID) {
1219 if (PL_delaymagic_gid != PL_delaymagic_egid)
1220 DIE(aTHX_ "No setregid available");
1221 (void)PerlProc_setgid(PL_delaymagic_gid);
1223 # endif /* HAS_SETREGID */
1224 #endif /* HAS_SETRESGID */
1225 tmp_gid = PerlProc_getgid();
1226 tmp_egid = PerlProc_getegid();
1228 TAINTING_set( TAINTING_get | (tmp_uid && (tmp_euid != tmp_uid || tmp_egid != tmp_gid)) );
1232 if (gimme == G_VOID)
1233 SP = firstrelem - 1;
1234 else if (gimme == G_SCALAR) {
1237 SETi(lastrelem - firstrelem + 1 - duplicates);
1244 /* at this point we have removed the duplicate key/value
1245 * pairs from the stack, but the remaining values may be
1246 * wrong; i.e. with (a 1 a 2 b 3) on the stack we've removed
1247 * the (a 2), but the stack now probably contains
1248 * (a <freed> b 3), because { hv_save(a,1); hv_save(a,2) }
1249 * obliterates the earlier key. So refresh all values. */
1250 lastrelem -= duplicates;
1251 relem = firsthashrelem;
1252 while (relem < lastrelem) {
1255 he = hv_fetch_ent(hash, sv, 0, 0);
1256 *relem++ = (he ? HeVAL(he) : &PL_sv_undef);
1262 SP = firstrelem + (lastlelem - firstlelem);
1263 lelem = firstlelem + (relem - firstrelem);
1265 *relem++ = (lelem <= lastlelem) ? *lelem++ : &PL_sv_undef;
1274 PMOP * const pm = cPMOP;
1275 REGEXP * rx = PM_GETRE(pm);
1276 SV * const pkg = rx ? CALLREG_PACKAGE(rx) : NULL;
1277 SV * const rv = sv_newmortal();
1281 SvUPGRADE(rv, SVt_IV);
1282 /* For a subroutine describing itself as "This is a hacky workaround" I'm
1283 loathe to use it here, but it seems to be the right fix. Or close.
1284 The key part appears to be that it's essential for pp_qr to return a new
1285 object (SV), which implies that there needs to be an effective way to
1286 generate a new SV from the existing SV that is pre-compiled in the
1288 SvRV_set(rv, MUTABLE_SV(reg_temp_copy(NULL, rx)));
1291 cvp = &( ReANY((REGEXP *)SvRV(rv))->qr_anoncv);
1292 if ((cv = *cvp) && CvCLONE(*cvp)) {
1293 *cvp = cv_clone(cv);
1298 HV *const stash = gv_stashsv(pkg, GV_ADD);
1300 (void)sv_bless(rv, stash);
1303 if (RX_ISTAINTED(rx)) {
1305 SvTAINTED_on(SvRV(rv));
1320 U8 r_flags = REXEC_CHECKED;
1321 const char *truebase; /* Start of string */
1322 REGEXP *rx = PM_GETRE(pm);
1324 const I32 gimme = GIMME;
1327 const I32 oldsave = PL_savestack_ix;
1328 I32 update_minmatch = 1;
1329 I32 had_zerolen = 0;
1332 if (PL_op->op_flags & OPf_STACKED)
1334 else if (PL_op->op_private & OPpTARGET_MY)
1341 PUTBACK; /* EVAL blocks need stack_sp. */
1342 /* Skip get-magic if this is a qr// clone, because regcomp has
1344 s = ReANY(rx)->mother_re
1345 ? SvPV_nomg_const(TARG, len)
1346 : SvPV_const(TARG, len);
1348 DIE(aTHX_ "panic: pp_match");
1350 rxtainted = (RX_ISTAINTED(rx) ||
1351 (TAINT_get && (pm->op_pmflags & PMf_RETAINT)));
1354 RX_MATCH_UTF8_set(rx, DO_UTF8(TARG));
1356 /* We need to know this in case we fail out early - pos() must be reset */
1357 global = dynpm->op_pmflags & PMf_GLOBAL;
1359 /* PMdf_USED is set after a ?? matches once */
1362 SvREADONLY(PL_regex_pad[pm->op_pmoffset])
1364 pm->op_pmflags & PMf_USED
1367 DEBUG_r(PerlIO_printf(Perl_debug_log, "?? already matched once"));
1371 /* empty pattern special-cased to use last successful pattern if
1372 possible, except for qr// */
1373 if (!ReANY(rx)->mother_re && !RX_PRELEN(rx)
1379 if (RX_MINLEN(rx) > (I32)len) {
1380 DEBUG_r(PerlIO_printf(Perl_debug_log, "String shorter than min possible regex match\n"));
1386 /* XXXX What part of this is needed with true \G-support? */
1388 RX_OFFS(rx)[0].start = -1;
1389 if (SvTYPE(TARG) >= SVt_PVMG && SvMAGIC(TARG)) {
1390 MAGIC* const mg = mg_find(TARG, PERL_MAGIC_regex_global);
1391 if (mg && mg->mg_len >= 0) {
1392 if (!(RX_EXTFLAGS(rx) & RXf_GPOS_SEEN))
1393 RX_OFFS(rx)[0].end = RX_OFFS(rx)[0].start = mg->mg_len;
1394 else if (RX_EXTFLAGS(rx) & RXf_ANCH_GPOS) {
1395 r_flags |= REXEC_IGNOREPOS;
1396 RX_OFFS(rx)[0].end = RX_OFFS(rx)[0].start = mg->mg_len;
1397 } else if (RX_EXTFLAGS(rx) & RXf_GPOS_FLOAT)
1400 RX_OFFS(rx)[0].end = RX_OFFS(rx)[0].start = mg->mg_len;
1401 minmatch = (mg->mg_flags & MGf_MINMATCH) ? RX_GOFS(rx) + 1 : 0;
1402 update_minmatch = 0;
1406 #ifdef PERL_SAWAMPERSAND
1409 || (RX_EXTFLAGS(rx) & (RXf_EVAL_SEEN|RXf_PMf_KEEPCOPY))
1413 r_flags |= (REXEC_COPY_STR|REXEC_COPY_SKIP_PRE);
1414 /* in @a =~ /(.)/g, we iterate multiple times, but copy the buffer
1415 * only on the first iteration. Therefore we need to copy $' as well
1416 * as $&, to make the rest of the string available for captures in
1417 * subsequent iterations */
1418 if (! (global && gimme == G_ARRAY))
1419 r_flags |= REXEC_COPY_SKIP_POST;
1423 if (global && RX_OFFS(rx)[0].start != -1) {
1424 t = s = RX_OFFS(rx)[0].end + truebase - RX_GOFS(rx);
1425 if ((s + RX_MINLEN(rx)) > strend || s < truebase) {
1426 DEBUG_r(PerlIO_printf(Perl_debug_log, "Regex match can't succeed, so not even tried\n"));
1429 if (update_minmatch++)
1430 minmatch = had_zerolen;
1432 if (RX_EXTFLAGS(rx) & RXf_USE_INTUIT &&
1433 DO_UTF8(TARG) == (RX_UTF8(rx) != 0)) {
1434 /* FIXME - can PL_bostr be made const char *? */
1435 PL_bostr = (char *)truebase;
1436 s = CALLREG_INTUIT_START(rx, TARG, (char *)s, (char *)strend, r_flags, NULL);
1440 #ifdef PERL_SAWAMPERSAND
1441 if ( (RX_EXTFLAGS(rx) & RXf_CHECK_ALL)
1443 && !(RX_EXTFLAGS(rx) & RXf_PMf_KEEPCOPY)
1444 && !SvROK(TARG)) /* Cannot trust since INTUIT cannot guess ^ */
1448 if (!CALLREGEXEC(rx, (char*)s, (char *)strend, (char*)truebase,
1449 minmatch, TARG, NUM2PTR(void*, gpos), r_flags))
1453 if (dynpm->op_pmflags & PMf_ONCE) {
1455 SvREADONLY_on(PL_regex_pad[dynpm->op_pmoffset]);
1457 dynpm->op_pmflags |= PMf_USED;
1463 RX_MATCH_TAINTED_on(rx);
1464 TAINT_IF(RX_MATCH_TAINTED(rx));
1465 if (gimme == G_ARRAY) {
1466 const I32 nparens = RX_NPARENS(rx);
1467 I32 i = (global && !nparens) ? 1 : 0;
1469 SPAGAIN; /* EVAL blocks could move the stack. */
1470 EXTEND(SP, nparens + i);
1471 EXTEND_MORTAL(nparens + i);
1472 for (i = !i; i <= nparens; i++) {
1473 PUSHs(sv_newmortal());
1474 if ((RX_OFFS(rx)[i].start != -1) && RX_OFFS(rx)[i].end != -1 ) {
1475 const I32 len = RX_OFFS(rx)[i].end - RX_OFFS(rx)[i].start;
1476 s = RX_OFFS(rx)[i].start + truebase;
1477 if (RX_OFFS(rx)[i].end < 0 || RX_OFFS(rx)[i].start < 0 ||
1478 len < 0 || len > strend - s)
1479 DIE(aTHX_ "panic: pp_match start/end pointers, i=%ld, "
1480 "start=%ld, end=%ld, s=%p, strend=%p, len=%"UVuf,
1481 (long) i, (long) RX_OFFS(rx)[i].start,
1482 (long)RX_OFFS(rx)[i].end, s, strend, (UV) len);
1483 sv_setpvn(*SP, s, len);
1484 if (DO_UTF8(TARG) && is_utf8_string((U8*)s, len))
1489 if (dynpm->op_pmflags & PMf_CONTINUE) {
1491 if (SvTYPE(TARG) >= SVt_PVMG && SvMAGIC(TARG))
1492 mg = mg_find(TARG, PERL_MAGIC_regex_global);
1494 #ifdef PERL_OLD_COPY_ON_WRITE
1496 sv_force_normal_flags(TARG, 0);
1498 mg = sv_magicext(TARG, NULL, PERL_MAGIC_regex_global,
1499 &PL_vtbl_mglob, NULL, 0);
1501 if (RX_OFFS(rx)[0].start != -1) {
1502 mg->mg_len = RX_OFFS(rx)[0].end;
1503 if (RX_OFFS(rx)[0].start + RX_GOFS(rx) == (UV)RX_OFFS(rx)[0].end)
1504 mg->mg_flags |= MGf_MINMATCH;
1506 mg->mg_flags &= ~MGf_MINMATCH;
1509 had_zerolen = (RX_OFFS(rx)[0].start != -1
1510 && (RX_OFFS(rx)[0].start + RX_GOFS(rx)
1511 == (UV)RX_OFFS(rx)[0].end));
1512 PUTBACK; /* EVAL blocks may use stack */
1513 r_flags |= REXEC_IGNOREPOS | REXEC_NOT_FIRST;
1518 LEAVE_SCOPE(oldsave);
1524 if (SvTYPE(TARG) >= SVt_PVMG && SvMAGIC(TARG))
1525 mg = mg_find(TARG, PERL_MAGIC_regex_global);
1529 #ifdef PERL_OLD_COPY_ON_WRITE
1531 sv_force_normal_flags(TARG, 0);
1533 mg = sv_magicext(TARG, NULL, PERL_MAGIC_regex_global,
1534 &PL_vtbl_mglob, NULL, 0);
1536 if (RX_OFFS(rx)[0].start != -1) {
1537 mg->mg_len = RX_OFFS(rx)[0].end;
1538 if (RX_OFFS(rx)[0].start + RX_GOFS(rx) == (UV)RX_OFFS(rx)[0].end)
1539 mg->mg_flags |= MGf_MINMATCH;
1541 mg->mg_flags &= ~MGf_MINMATCH;
1544 LEAVE_SCOPE(oldsave);
1548 #ifdef PERL_SAWAMPERSAND
1549 yup: /* Confirmed by INTUIT */
1552 RX_MATCH_TAINTED_on(rx);
1553 TAINT_IF(RX_MATCH_TAINTED(rx));
1555 if (dynpm->op_pmflags & PMf_ONCE) {
1557 SvREADONLY_on(PL_regex_pad[dynpm->op_pmoffset]);
1559 dynpm->op_pmflags |= PMf_USED;
1562 if (RX_MATCH_COPIED(rx))
1563 Safefree(RX_SUBBEG(rx));
1564 RX_MATCH_COPIED_off(rx);
1565 RX_SUBBEG(rx) = NULL;
1567 /* FIXME - should rx->subbeg be const char *? */
1568 RX_SUBBEG(rx) = (char *) truebase;
1569 RX_SUBOFFSET(rx) = 0;
1570 RX_SUBCOFFSET(rx) = 0;
1571 RX_OFFS(rx)[0].start = s - truebase;
1572 if (RX_MATCH_UTF8(rx)) {
1573 char * const t = (char*)utf8_hop((U8*)s, RX_MINLENRET(rx));
1574 RX_OFFS(rx)[0].end = t - truebase;
1577 RX_OFFS(rx)[0].end = s - truebase + RX_MINLENRET(rx);
1579 RX_SUBLEN(rx) = strend - truebase;
1582 #ifdef PERL_SAWAMPERSAND
1583 if (PL_sawampersand || RX_EXTFLAGS(rx) & RXf_PMf_KEEPCOPY)
1588 if (SvCANCOW(TARG)) {
1590 PerlIO_printf(Perl_debug_log,
1591 "Copy on write: pp_match $& capture, type %d, truebase=%p, t=%p, difference %d\n",
1592 (int) SvTYPE(TARG), (void*)truebase, (void*)t,
1595 RX_SAVED_COPY(rx) = sv_setsv_cow(RX_SAVED_COPY(rx), TARG);
1597 = (char *) SvPVX_const(RX_SAVED_COPY(rx)) + (t - truebase);
1598 assert (SvPOKp(RX_SAVED_COPY(rx)));
1603 RX_SUBBEG(rx) = savepvn(t, strend - t);
1605 RX_SAVED_COPY(rx) = NULL;
1608 RX_SUBLEN(rx) = strend - t;
1609 RX_SUBOFFSET(rx) = 0;
1610 RX_SUBCOFFSET(rx) = 0;
1611 RX_MATCH_COPIED_on(rx);
1612 off = RX_OFFS(rx)[0].start = s - t;
1613 RX_OFFS(rx)[0].end = off + RX_MINLENRET(rx);
1615 #ifdef PERL_SAWAMPERSAND
1616 else { /* startp/endp are used by @- @+. */
1617 RX_OFFS(rx)[0].start = s - truebase;
1618 RX_OFFS(rx)[0].end = s - truebase + RX_MINLENRET(rx);
1621 /* match via INTUIT shouldn't have any captures. Let @-, @+, $^N know */
1622 assert(!RX_NPARENS(rx));
1623 RX_LASTPAREN(rx) = RX_LASTCLOSEPAREN(rx) = 0;
1624 LEAVE_SCOPE(oldsave);
1629 if (global && !(dynpm->op_pmflags & PMf_CONTINUE)) {
1630 if (SvTYPE(TARG) >= SVt_PVMG && SvMAGIC(TARG)) {
1631 MAGIC* const mg = mg_find(TARG, PERL_MAGIC_regex_global);
1636 LEAVE_SCOPE(oldsave);
1637 if (gimme == G_ARRAY)
1643 Perl_do_readline(pTHX)
1645 dVAR; dSP; dTARGETSTACKED;
1650 IO * const io = GvIO(PL_last_in_gv);
1651 const I32 type = PL_op->op_type;
1652 const I32 gimme = GIMME_V;
1655 const MAGIC *const mg = SvTIED_mg((const SV *)io, PERL_MAGIC_tiedscalar);
1657 Perl_tied_method(aTHX_ "READLINE", SP, MUTABLE_SV(io), mg, gimme, 0);
1658 if (gimme == G_SCALAR) {
1660 SvSetSV_nosteal(TARG, TOPs);
1670 if (IoFLAGS(io) & IOf_ARGV) {
1671 if (IoFLAGS(io) & IOf_START) {
1673 if (av_len(GvAVn(PL_last_in_gv)) < 0) {
1674 IoFLAGS(io) &= ~IOf_START;
1675 do_open(PL_last_in_gv,"-",1,FALSE,O_RDONLY,0,NULL);
1676 SvTAINTED_off(GvSVn(PL_last_in_gv)); /* previous tainting irrelevant */
1677 sv_setpvs(GvSVn(PL_last_in_gv), "-");
1678 SvSETMAGIC(GvSV(PL_last_in_gv));
1683 fp = nextargv(PL_last_in_gv);
1684 if (!fp) { /* Note: fp != IoIFP(io) */
1685 (void)do_close(PL_last_in_gv, FALSE); /* now it does*/
1688 else if (type == OP_GLOB)
1689 fp = Perl_start_glob(aTHX_ POPs, io);
1691 else if (type == OP_GLOB)
1693 else if (IoTYPE(io) == IoTYPE_WRONLY) {
1694 report_wrongway_fh(PL_last_in_gv, '>');
1698 if ((!io || !(IoFLAGS(io) & IOf_START))
1699 && ckWARN2(WARN_GLOB, WARN_CLOSED))
1701 if (type == OP_GLOB)
1702 Perl_ck_warner_d(aTHX_ packWARN(WARN_GLOB),
1703 "glob failed (can't start child: %s)",
1706 report_evil_fh(PL_last_in_gv);
1708 if (gimme == G_SCALAR) {
1709 /* undef TARG, and push that undefined value */
1710 if (type != OP_RCATLINE) {
1711 SV_CHECK_THINKFIRST_COW_DROP(TARG);
1719 if (gimme == G_SCALAR) {
1721 if (type == OP_RCATLINE && SvGMAGICAL(sv))
1724 if (type == OP_RCATLINE)
1725 SvPV_force_nomg_nolen(sv);
1729 else if (isGV_with_GP(sv)) {
1730 SvPV_force_nomg_nolen(sv);
1732 SvUPGRADE(sv, SVt_PV);
1733 tmplen = SvLEN(sv); /* remember if already alloced */
1734 if (!tmplen && !SvREADONLY(sv) && !SvIsCOW(sv)) {
1735 /* try short-buffering it. Please update t/op/readline.t
1736 * if you change the growth length.
1741 if (type == OP_RCATLINE && SvOK(sv)) {
1743 SvPV_force_nomg_nolen(sv);
1749 sv = sv_2mortal(newSV(80));
1753 /* This should not be marked tainted if the fp is marked clean */
1754 #define MAYBE_TAINT_LINE(io, sv) \
1755 if (!(IoFLAGS(io) & IOf_UNTAINT)) { \
1760 /* delay EOF state for a snarfed empty file */
1761 #define SNARF_EOF(gimme,rs,io,sv) \
1762 (gimme != G_SCALAR || SvCUR(sv) \
1763 || (IoFLAGS(io) & IOf_NOLINE) || !RsSNARF(rs))
1767 if (!sv_gets(sv, fp, offset)
1769 || SNARF_EOF(gimme, PL_rs, io, sv)
1770 || PerlIO_error(fp)))
1772 PerlIO_clearerr(fp);
1773 if (IoFLAGS(io) & IOf_ARGV) {
1774 fp = nextargv(PL_last_in_gv);
1777 (void)do_close(PL_last_in_gv, FALSE);
1779 else if (type == OP_GLOB) {
1780 if (!do_close(PL_last_in_gv, FALSE)) {
1781 Perl_ck_warner(aTHX_ packWARN(WARN_GLOB),
1782 "glob failed (child exited with status %d%s)",
1783 (int)(STATUS_CURRENT >> 8),
1784 (STATUS_CURRENT & 0x80) ? ", core dumped" : "");
1787 if (gimme == G_SCALAR) {
1788 if (type != OP_RCATLINE) {
1789 SV_CHECK_THINKFIRST_COW_DROP(TARG);
1795 MAYBE_TAINT_LINE(io, sv);
1798 MAYBE_TAINT_LINE(io, sv);
1800 IoFLAGS(io) |= IOf_NOLINE;
1804 if (type == OP_GLOB) {
1807 if (SvCUR(sv) > 0 && SvCUR(PL_rs) > 0) {
1808 char * const tmps = SvEND(sv) - 1;
1809 if (*tmps == *SvPVX_const(PL_rs)) {
1811 SvCUR_set(sv, SvCUR(sv) - 1);
1814 for (t1 = SvPVX_const(sv); *t1; t1++)
1815 if (!isALNUMC(*t1) &&
1816 strchr("$&*(){}[]'\";\\|?<>~`", *t1))
1818 if (*t1 && PerlLIO_lstat(SvPVX_const(sv), &PL_statbuf) < 0) {
1819 (void)POPs; /* Unmatched wildcard? Chuck it... */
1822 } else if (SvUTF8(sv)) { /* OP_READLINE, OP_RCATLINE */
1823 if (ckWARN(WARN_UTF8)) {
1824 const U8 * const s = (const U8*)SvPVX_const(sv) + offset;
1825 const STRLEN len = SvCUR(sv) - offset;
1828 if (!is_utf8_string_loc(s, len, &f))
1829 /* Emulate :encoding(utf8) warning in the same case. */
1830 Perl_warner(aTHX_ packWARN(WARN_UTF8),
1831 "utf8 \"\\x%02X\" does not map to Unicode",
1832 f < (U8*)SvEND(sv) ? *f : 0);
1835 if (gimme == G_ARRAY) {
1836 if (SvLEN(sv) - SvCUR(sv) > 20) {
1837 SvPV_shrink_to_cur(sv);
1839 sv = sv_2mortal(newSV(80));
1842 else if (gimme == G_SCALAR && !tmplen && SvLEN(sv) - SvCUR(sv) > 80) {
1843 /* try to reclaim a bit of scalar space (only on 1st alloc) */
1844 const STRLEN new_len
1845 = SvCUR(sv) < 60 ? 80 : SvCUR(sv)+40; /* allow some slop */
1846 SvPV_renew(sv, new_len);
1857 SV * const keysv = POPs;
1858 HV * const hv = MUTABLE_HV(POPs);
1859 const U32 lval = PL_op->op_flags & OPf_MOD || LVRET;
1860 const U32 defer = PL_op->op_private & OPpLVAL_DEFER;
1862 const bool localizing = PL_op->op_private & OPpLVAL_INTRO;
1863 bool preeminent = TRUE;
1865 if (SvTYPE(hv) != SVt_PVHV)
1872 /* If we can determine whether the element exist,
1873 * Try to preserve the existenceness of a tied hash
1874 * element by using EXISTS and DELETE if possible.
1875 * Fallback to FETCH and STORE otherwise. */
1876 if (SvCANEXISTDELETE(hv))
1877 preeminent = hv_exists_ent(hv, keysv, 0);
1880 he = hv_fetch_ent(hv, keysv, lval && !defer, 0);
1881 svp = he ? &HeVAL(he) : NULL;
1883 if (!svp || !*svp || *svp == &PL_sv_undef) {
1887 DIE(aTHX_ PL_no_helem_sv, SVfARG(keysv));
1889 lv = sv_newmortal();
1890 sv_upgrade(lv, SVt_PVLV);
1892 sv_magic(lv, key2 = newSVsv(keysv), PERL_MAGIC_defelem, NULL, 0);
1893 SvREFCNT_dec(key2); /* sv_magic() increments refcount */
1894 LvTARG(lv) = SvREFCNT_inc_simple(hv);
1900 if (HvNAME_get(hv) && isGV(*svp))
1901 save_gp(MUTABLE_GV(*svp), !(PL_op->op_flags & OPf_SPECIAL));
1902 else if (preeminent)
1903 save_helem_flags(hv, keysv, svp,
1904 (PL_op->op_flags & OPf_SPECIAL) ? 0 : SAVEf_SETMAGIC);
1906 SAVEHDELETE(hv, keysv);
1908 else if (PL_op->op_private & OPpDEREF) {
1909 PUSHs(vivify_ref(*svp, PL_op->op_private & OPpDEREF));
1913 sv = (svp && *svp ? *svp : &PL_sv_undef);
1914 /* Originally this did a conditional C<sv = sv_mortalcopy(sv)>; this
1915 * was to make C<local $tied{foo} = $tied{foo}> possible.
1916 * However, it seems no longer to be needed for that purpose, and
1917 * introduced a new bug: stuff like C<while ($hash{taintedval} =~ /.../g>
1918 * would loop endlessly since the pos magic is getting set on the
1919 * mortal copy and lost. However, the copy has the effect of
1920 * triggering the get magic, and losing it altogether made things like
1921 * c<$tied{foo};> in void context no longer do get magic, which some
1922 * code relied on. Also, delayed triggering of magic on @+ and friends
1923 * meant the original regex may be out of scope by now. So as a
1924 * compromise, do the get magic here. (The MGf_GSKIP flag will stop it
1925 * being called too many times). */
1926 if (!lval && SvRMAGICAL(hv) && SvGMAGICAL(sv))
1940 cx = &cxstack[cxstack_ix];
1941 itersvp = CxITERVAR(cx);
1943 switch (CxTYPE(cx)) {
1945 case CXt_LOOP_LAZYSV: /* string increment */
1947 SV* cur = cx->blk_loop.state_u.lazysv.cur;
1948 SV *end = cx->blk_loop.state_u.lazysv.end;
1949 /* If the maximum is !SvOK(), pp_enteriter substitutes PL_sv_no.
1950 It has SvPVX of "" and SvCUR of 0, which is what we want. */
1952 const char *max = SvPV_const(end, maxlen);
1953 if (SvNIOK(cur) || SvCUR(cur) > maxlen)
1957 if (SvREFCNT(oldsv) == 1 && !SvMAGICAL(oldsv)) {
1958 /* safe to reuse old SV */
1959 sv_setsv(oldsv, cur);
1963 /* we need a fresh SV every time so that loop body sees a
1964 * completely new SV for closures/references to work as
1966 *itersvp = newSVsv(cur);
1967 SvREFCNT_dec(oldsv);
1969 if (strEQ(SvPVX_const(cur), max))
1970 sv_setiv(cur, 0); /* terminate next time */
1976 case CXt_LOOP_LAZYIV: /* integer increment */
1978 IV cur = cx->blk_loop.state_u.lazyiv.cur;
1979 if (cur > cx->blk_loop.state_u.lazyiv.end)
1983 /* don't risk potential race */
1984 if (SvREFCNT(oldsv) == 1 && !SvMAGICAL(oldsv)) {
1985 /* safe to reuse old SV */
1986 sv_setiv(oldsv, cur);
1990 /* we need a fresh SV every time so that loop body sees a
1991 * completely new SV for closures/references to work as they
1993 *itersvp = newSViv(cur);
1994 SvREFCNT_dec(oldsv);
1997 if (cur == IV_MAX) {
1998 /* Handle end of range at IV_MAX */
1999 cx->blk_loop.state_u.lazyiv.end = IV_MIN;
2001 ++cx->blk_loop.state_u.lazyiv.cur;
2005 case CXt_LOOP_FOR: /* iterate array */
2008 AV *av = cx->blk_loop.state_u.ary.ary;
2010 bool av_is_stack = FALSE;
2017 if (PL_op->op_private & OPpITER_REVERSED) {
2018 ix = --cx->blk_loop.state_u.ary.ix;
2019 if (ix <= (av_is_stack ? cx->blk_loop.resetsp : -1))
2023 ix = ++cx->blk_loop.state_u.ary.ix;
2024 if (ix > (av_is_stack ? cx->blk_oldsp : AvFILL(av)))
2028 if (SvMAGICAL(av) || AvREIFY(av)) {
2029 SV * const * const svp = av_fetch(av, ix, FALSE);
2030 sv = svp ? *svp : NULL;
2033 sv = AvARRAY(av)[ix];
2037 if (SvIS_FREED(sv)) {
2039 Perl_croak(aTHX_ "Use of freed value in iteration");
2042 SvREFCNT_inc_simple_void_NN(sv);
2047 if (!av_is_stack && sv == &PL_sv_undef) {
2048 SV *lv = newSV_type(SVt_PVLV);
2050 sv_magic(lv, NULL, PERL_MAGIC_defelem, NULL, 0);
2051 LvTARG(lv) = SvREFCNT_inc_simple(av);
2053 LvTARGLEN(lv) = (STRLEN)UV_MAX;
2059 SvREFCNT_dec(oldsv);
2064 DIE(aTHX_ "panic: pp_iter, type=%u", CxTYPE(cx));
2070 A description of how taint works in pattern matching and substitution.
2072 This is all conditional on NO_TAINT_SUPPORT not being defined. Under
2073 NO_TAINT_SUPPORT, taint-related operations should become no-ops.
2075 While the pattern is being assembled/concatenated and then compiled,
2076 PL_tainted will get set (via TAINT_set) if any component of the pattern
2077 is tainted, e.g. /.*$tainted/. At the end of pattern compilation,
2078 the RXf_TAINTED flag is set on the pattern if PL_tainted is set (via
2081 When the pattern is copied, e.g. $r = qr/..../, the SV holding the ref to
2082 the pattern is marked as tainted. This means that subsequent usage, such
2083 as /x$r/, will set PL_tainted using TAINT_set, and thus RXf_TAINTED,
2084 on the new pattern too.
2086 During execution of a pattern, locale-variant ops such as ALNUML set the
2087 local flag RF_tainted. At the end of execution, the engine sets the
2088 RXf_TAINTED_SEEN on the pattern if RF_tainted got set, or clears it
2091 In addition, RXf_TAINTED_SEEN is used post-execution by the get magic code
2092 of $1 et al to indicate whether the returned value should be tainted.
2093 It is the responsibility of the caller of the pattern (i.e. pp_match,
2094 pp_subst etc) to set this flag for any other circumstances where $1 needs
2097 The taint behaviour of pp_subst (and pp_substcont) is quite complex.
2099 There are three possible sources of taint
2101 * the pattern (both compile- and run-time, RXf_TAINTED / RXf_TAINTED_SEEN)
2102 * the replacement string (or expression under /e)
2104 There are four destinations of taint and they are affected by the sources
2105 according to the rules below:
2107 * the return value (not including /r):
2108 tainted by the source string and pattern, but only for the
2109 number-of-iterations case; boolean returns aren't tainted;
2110 * the modified string (or modified copy under /r):
2111 tainted by the source string, pattern, and replacement strings;
2113 tainted by the pattern, and under 'use re "taint"', by the source
2115 * PL_taint - i.e. whether subsequent code (e.g. in a /e block) is tainted:
2116 should always be unset before executing subsequent code.
2118 The overall action of pp_subst is:
2120 * at the start, set bits in rxtainted indicating the taint status of
2121 the various sources.
2123 * After each pattern execution, update the SUBST_TAINT_PAT bit in
2124 rxtainted if RXf_TAINTED_SEEN has been set, to indicate that the
2125 pattern has subsequently become tainted via locale ops.
2127 * If control is being passed to pp_substcont to execute a /e block,
2128 save rxtainted in the CXt_SUBST block, for future use by
2131 * Whenever control is being returned to perl code (either by falling
2132 off the "end" of pp_subst/pp_substcont, or by entering a /e block),
2133 use the flag bits in rxtainted to make all the appropriate types of
2134 destination taint visible; e.g. set RXf_TAINTED_SEEN so that $1
2135 et al will appear tainted.
2137 pp_match is just a simpler version of the above.
2156 U8 rxtainted = 0; /* holds various SUBST_TAINT_* flag bits.
2157 See "how taint works" above */
2160 REGEXP *rx = PM_GETRE(pm);
2162 int force_on_match = 0;
2163 const I32 oldsave = PL_savestack_ix;
2165 bool doutf8 = FALSE; /* whether replacement is in utf8 */
2170 /* known replacement string? */
2171 SV *dstr = (pm->op_pmflags & PMf_CONST) ? POPs : NULL;
2175 if (PL_op->op_flags & OPf_STACKED)
2177 else if (PL_op->op_private & OPpTARGET_MY)
2184 SvGETMAGIC(TARG); /* must come before cow check */
2186 /* Awooga. Awooga. "bool" types that are actually char are dangerous,
2187 because they make integers such as 256 "false". */
2188 is_cow = SvIsCOW(TARG) ? TRUE : FALSE;
2191 sv_force_normal_flags(TARG,0);
2193 if (!(rpm->op_pmflags & PMf_NONDESTRUCT)
2197 && (SvREADONLY(TARG)
2198 || ( ((SvTYPE(TARG) == SVt_PVGV && isGV_with_GP(TARG))
2199 || SvTYPE(TARG) > SVt_PVLV)
2200 && !(SvTYPE(TARG) == SVt_PVGV && SvFAKE(TARG)))))
2201 Perl_croak_no_modify();
2204 s = SvPV_nomg(TARG, len);
2205 if (!SvPOKp(TARG) || SvTYPE(TARG) == SVt_PVGV || SvVOK(TARG))
2208 /* only replace once? */
2209 once = !(rpm->op_pmflags & PMf_GLOBAL);
2211 /* See "how taint works" above */
2214 (SvTAINTED(TARG) ? SUBST_TAINT_STR : 0)
2215 | (RX_ISTAINTED(rx) ? SUBST_TAINT_PAT : 0)
2216 | ((pm->op_pmflags & PMf_RETAINT) ? SUBST_TAINT_RETAINT : 0)
2217 | ((once && !(rpm->op_pmflags & PMf_NONDESTRUCT))
2218 ? SUBST_TAINT_BOOLRET : 0));
2222 RX_MATCH_UTF8_set(rx, DO_UTF8(TARG));
2226 DIE(aTHX_ "panic: pp_subst, pm=%p, s=%p", pm, s);
2229 slen = RX_MATCH_UTF8(rx) ? utf8_length((U8*)s, (U8*)strend) : len;
2230 maxiters = 2 * slen + 10; /* We can match twice at each
2231 position, once with zero-length,
2232 second time with non-zero. */
2234 if (!RX_PRELEN(rx) && PL_curpm
2235 && !ReANY(rx)->mother_re) {
2240 #ifdef PERL_SAWAMPERSAND
2241 r_flags = ( RX_NPARENS(rx)
2243 || (RX_EXTFLAGS(rx) & (RXf_EVAL_SEEN|RXf_PMf_KEEPCOPY))
2248 r_flags = REXEC_COPY_STR;
2252 if (RX_EXTFLAGS(rx) & RXf_USE_INTUIT) {
2254 s = CALLREG_INTUIT_START(rx, TARG, s, strend, r_flags, NULL);
2258 /* How to do it in subst? */
2259 /* if ( (RX_EXTFLAGS(rx) & RXf_CHECK_ALL)
2261 && !(RX_EXTFLAGS(rx) & RXf_KEEPCOPY))
2266 if (!CALLREGEXEC(rx, s, strend, orig, 0, TARG, NULL,
2267 r_flags | REXEC_CHECKED))
2271 PUSHs(rpm->op_pmflags & PMf_NONDESTRUCT ? TARG : &PL_sv_no);
2272 LEAVE_SCOPE(oldsave);
2278 /* known replacement string? */
2280 /* replacement needing upgrading? */
2281 if (DO_UTF8(TARG) && !doutf8) {
2282 nsv = sv_newmortal();
2285 sv_recode_to_utf8(nsv, PL_encoding);
2287 sv_utf8_upgrade(nsv);
2288 c = SvPV_const(nsv, clen);
2292 c = SvPV_const(dstr, clen);
2293 doutf8 = DO_UTF8(dstr);
2296 if (SvTAINTED(dstr))
2297 rxtainted |= SUBST_TAINT_REPL;
2304 /* can do inplace substitution? */
2309 && (I32)clen <= RX_MINLENRET(rx)
2310 && (once || !(r_flags & REXEC_COPY_STR))
2311 && !(RX_EXTFLAGS(rx) & (RXf_LOOKBEHIND_SEEN|RXf_MODIFIES_VARS))
2312 && (!doutf8 || SvUTF8(TARG))
2313 && !(rpm->op_pmflags & PMf_NONDESTRUCT))
2317 if (SvIsCOW(TARG)) {
2318 if (!force_on_match)
2320 assert(SvVOK(TARG));
2323 if (force_on_match) {
2325 s = SvPV_force_nomg(TARG, len);
2330 if (RX_MATCH_TAINTED(rx)) /* run time pattern taint, eg locale */
2331 rxtainted |= SUBST_TAINT_PAT;
2332 m = orig + RX_OFFS(rx)[0].start;
2333 d = orig + RX_OFFS(rx)[0].end;
2335 if (m - s > strend - d) { /* faster to shorten from end */
2337 Copy(c, m, clen, char);
2342 Move(d, m, i, char);
2346 SvCUR_set(TARG, m - s);
2348 else if ((i = m - s)) { /* faster from front */
2351 Move(s, d - i, i, char);
2354 Copy(c, m, clen, char);
2359 Copy(c, d, clen, char);
2369 if (iters++ > maxiters)
2370 DIE(aTHX_ "Substitution loop");
2371 if (RX_MATCH_TAINTED(rx)) /* run time pattern taint, eg locale */
2372 rxtainted |= SUBST_TAINT_PAT;
2373 m = RX_OFFS(rx)[0].start + orig;
2376 Move(s, d, i, char);
2380 Copy(c, d, clen, char);
2383 s = RX_OFFS(rx)[0].end + orig;
2384 } while (CALLREGEXEC(rx, s, strend, orig, s == m,
2386 /* don't match same null twice */
2387 REXEC_NOT_FIRST|REXEC_IGNOREPOS));
2390 SvCUR_set(TARG, d - SvPVX_const(TARG) + i);
2391 Move(s, d, i+1, char); /* include the NUL */
2400 if (force_on_match) {
2402 if (rpm->op_pmflags & PMf_NONDESTRUCT) {
2403 /* I feel that it should be possible to avoid this mortal copy
2404 given that the code below copies into a new destination.
2405 However, I suspect it isn't worth the complexity of
2406 unravelling the C<goto force_it> for the small number of
2407 cases where it would be viable to drop into the copy code. */
2408 TARG = sv_2mortal(newSVsv(TARG));
2410 s = SvPV_force_nomg(TARG, len);
2416 if (RX_MATCH_TAINTED(rx)) /* run time pattern taint, eg locale */
2417 rxtainted |= SUBST_TAINT_PAT;
2419 dstr = newSVpvn_flags(m, s-m, SVs_TEMP | (DO_UTF8(TARG) ? SVf_UTF8 : 0));
2423 /* note that a whole bunch of local vars are saved here for
2424 * use by pp_substcont: here's a list of them in case you're
2425 * searching for places in this sub that uses a particular var:
2426 * iters maxiters r_flags oldsave rxtainted orig dstr targ
2427 * s m strend rx once */
2429 RETURNOP(cPMOP->op_pmreplrootu.op_pmreplroot);
2431 r_flags |= REXEC_IGNOREPOS | REXEC_NOT_FIRST;
2434 if (iters++ > maxiters)
2435 DIE(aTHX_ "Substitution loop");
2436 if (RX_MATCH_TAINTED(rx))
2437 rxtainted |= SUBST_TAINT_PAT;
2438 if (RX_MATCH_COPIED(rx) && RX_SUBBEG(rx) != orig) {
2441 assert(RX_SUBOFFSET(rx) == 0);
2442 orig = RX_SUBBEG(rx);
2444 strend = s + (strend - m);
2446 m = RX_OFFS(rx)[0].start + orig;
2447 sv_catpvn_nomg_maybeutf8(dstr, s, m - s, DO_UTF8(TARG));
2448 s = RX_OFFS(rx)[0].end + orig;
2450 /* replacement already stringified */
2452 sv_catpvn_nomg_maybeutf8(dstr, c, clen, doutf8);
2457 if (!nsv) nsv = sv_newmortal();
2458 sv_copypv(nsv, repl);
2459 if (!DO_UTF8(nsv)) sv_recode_to_utf8(nsv, PL_encoding);
2460 sv_catsv(dstr, nsv);
2462 else sv_catsv(dstr, repl);
2463 if (SvTAINTED(repl))
2464 rxtainted |= SUBST_TAINT_REPL;
2468 } while (CALLREGEXEC(rx, s, strend, orig, s == m,
2469 TARG, NULL, r_flags));
2470 sv_catpvn_nomg_maybeutf8(dstr, s, strend - s, DO_UTF8(TARG));
2472 if (rpm->op_pmflags & PMf_NONDESTRUCT) {
2473 /* From here on down we're using the copy, and leaving the original
2480 /* The match may make the string COW. If so, brilliant, because
2481 that's just saved us one malloc, copy and free - the regexp has
2482 donated the old buffer, and we malloc an entirely new one, rather
2483 than the regexp malloc()ing a buffer and copying our original,
2484 only for us to throw it away here during the substitution. */
2485 if (SvIsCOW(TARG)) {
2486 sv_force_normal_flags(TARG, SV_COW_DROP_PV);
2492 SvPV_set(TARG, SvPVX(dstr));
2493 SvCUR_set(TARG, SvCUR(dstr));
2494 SvLEN_set(TARG, SvLEN(dstr));
2495 SvFLAGS(TARG) |= SvUTF8(dstr);
2496 SvPV_set(dstr, NULL);
2503 if (!(rpm->op_pmflags & PMf_NONDESTRUCT)) {
2504 (void)SvPOK_only_UTF8(TARG);
2507 /* See "how taint works" above */
2509 if ((rxtainted & SUBST_TAINT_PAT) ||
2510 ((rxtainted & (SUBST_TAINT_STR|SUBST_TAINT_RETAINT)) ==
2511 (SUBST_TAINT_STR|SUBST_TAINT_RETAINT))
2513 (RX_MATCH_TAINTED_on(rx)); /* taint $1 et al */
2515 if (!(rxtainted & SUBST_TAINT_BOOLRET)
2516 && (rxtainted & (SUBST_TAINT_STR|SUBST_TAINT_PAT))
2518 SvTAINTED_on(TOPs); /* taint return value */
2520 SvTAINTED_off(TOPs); /* may have got tainted earlier */
2522 /* needed for mg_set below */
2524 cBOOL(rxtainted & (SUBST_TAINT_STR|SUBST_TAINT_PAT|SUBST_TAINT_REPL))
2528 SvSETMAGIC(TARG); /* PL_tainted must be correctly set for this mg_set */
2530 LEAVE_SCOPE(oldsave);
2539 PL_stack_base[PL_markstack_ptr[-1]++] = PL_stack_base[*PL_markstack_ptr];
2540 ++*PL_markstack_ptr;
2542 LEAVE_with_name("grep_item"); /* exit inner scope */
2545 if (PL_stack_base + *PL_markstack_ptr > SP) {
2547 const I32 gimme = GIMME_V;
2549 LEAVE_with_name("grep"); /* exit outer scope */
2550 (void)POPMARK; /* pop src */
2551 items = --*PL_markstack_ptr - PL_markstack_ptr[-1];
2552 (void)POPMARK; /* pop dst */
2553 SP = PL_stack_base + POPMARK; /* pop original mark */
2554 if (gimme == G_SCALAR) {
2555 if (PL_op->op_private & OPpGREP_LEX) {
2556 SV* const sv = sv_newmortal();
2557 sv_setiv(sv, items);
2565 else if (gimme == G_ARRAY)
2572 ENTER_with_name("grep_item"); /* enter inner scope */
2575 src = PL_stack_base[*PL_markstack_ptr];
2577 if (PL_op->op_private & OPpGREP_LEX)
2578 PAD_SVl(PL_op->op_targ) = src;
2582 RETURNOP(cLOGOP->op_other);
2596 if (CxMULTICALL(&cxstack[cxstack_ix]))
2600 cxstack_ix++; /* temporarily protect top context */
2603 if (gimme == G_SCALAR) {
2606 if (cx->blk_sub.cv && CvDEPTH(cx->blk_sub.cv) > 1) {
2607 if (SvTEMP(TOPs) && SvREFCNT(TOPs) == 1
2608 && !SvMAGICAL(TOPs)) {
2609 *MARK = SvREFCNT_inc(TOPs);
2614 sv = SvREFCNT_inc(TOPs); /* FREETMPS could clobber it */
2616 *MARK = sv_mortalcopy(sv);
2620 else if (SvTEMP(TOPs) && SvREFCNT(TOPs) == 1
2621 && !SvMAGICAL(TOPs)) {
2625 *MARK = sv_mortalcopy(TOPs);
2629 *MARK = &PL_sv_undef;
2633 else if (gimme == G_ARRAY) {
2634 for (MARK = newsp + 1; MARK <= SP; MARK++) {
2635 if (!SvTEMP(*MARK) || SvREFCNT(*MARK) != 1
2636 || SvMAGICAL(*MARK)) {
2637 *MARK = sv_mortalcopy(*MARK);
2638 TAINT_NOT; /* Each item is independent */
2646 POPSUB(cx,sv); /* Stack values are safe: release CV and @_ ... */
2647 PL_curpm = newpm; /* ... and pop $1 et al */
2650 return cx->blk_sub.retop;
2660 const bool hasargs = (PL_op->op_flags & OPf_STACKED) != 0;
2663 DIE(aTHX_ "Not a CODE reference");
2664 switch (SvTYPE(sv)) {
2665 /* This is overwhelming the most common case: */
2668 if (!(cv = GvCVu((const GV *)sv))) {
2670 cv = sv_2cv(sv, &stash, &gv, 0);
2679 if(isGV_with_GP(sv)) goto we_have_a_glob;
2682 if (sv == &PL_sv_yes) { /* unfound import, ignore */
2684 SP = PL_stack_base + POPMARK;
2692 sv = amagic_deref_call(sv, to_cv_amg);
2693 /* Don't SPAGAIN here. */
2700 DIE(aTHX_ PL_no_usym, "a subroutine");
2701 sym = SvPV_nomg_const(sv, len);
2702 if (PL_op->op_private & HINT_STRICT_REFS)
2703 DIE(aTHX_ "Can't use string (\"%" SVf32 "\"%s) as a subroutine ref while \"strict refs\" in use", sv, len>32 ? "..." : "");
2704 cv = get_cvn_flags(sym, len, GV_ADD|SvUTF8(sv));
2707 cv = MUTABLE_CV(SvRV(sv));
2708 if (SvTYPE(cv) == SVt_PVCV)
2713 DIE(aTHX_ "Not a CODE reference");
2714 /* This is the second most common case: */
2716 cv = MUTABLE_CV(sv);
2724 if (CvCLONE(cv) && ! CvCLONED(cv))
2725 DIE(aTHX_ "Closure prototype called");
2726 if (!CvROOT(cv) && !CvXSUB(cv)) {
2730 /* anonymous or undef'd function leaves us no recourse */
2731 if (CvANON(cv) || !(gv = CvGV(cv))) {
2733 DIE(aTHX_ "Undefined subroutine &%"HEKf" called",
2734 HEKfARG(CvNAME_HEK(cv)));
2735 DIE(aTHX_ "Undefined subroutine called");
2738 /* autoloaded stub? */
2739 if (cv != GvCV(gv)) {
2742 /* should call AUTOLOAD now? */
2745 if ((autogv = gv_autoload_pvn(GvSTASH(gv), GvNAME(gv), GvNAMELEN(gv),
2746 GvNAMEUTF8(gv) ? SVf_UTF8 : 0)))
2752 sub_name = sv_newmortal();
2753 gv_efullname3(sub_name, gv, NULL);
2754 DIE(aTHX_ "Undefined subroutine &%"SVf" called", SVfARG(sub_name));
2763 if ((PL_op->op_private & OPpENTERSUB_DB) && GvCV(PL_DBsub) && !CvNODEBUG(cv)) {
2764 Perl_get_db_sub(aTHX_ &sv, cv);
2766 PL_curcopdb = PL_curcop;
2768 /* check for lsub that handles lvalue subroutines */
2769 cv = GvCV(gv_HVadd(gv_fetchpvs("DB::lsub", GV_ADDMULTI, SVt_PVHV)));
2770 /* if lsub not found then fall back to DB::sub */
2771 if (!cv) cv = GvCV(PL_DBsub);
2773 cv = GvCV(PL_DBsub);
2776 if (!cv || (!CvXSUB(cv) && !CvSTART(cv)))
2777 DIE(aTHX_ "No DB::sub routine defined");
2780 if (!(CvISXSUB(cv))) {
2781 /* This path taken at least 75% of the time */
2783 I32 items = SP - MARK;
2784 PADLIST * const padlist = CvPADLIST(cv);
2785 PUSHBLOCK(cx, CXt_SUB, MARK);
2787 cx->blk_sub.retop = PL_op->op_next;
2789 if (CvDEPTH(cv) >= 2) {
2790 PERL_STACK_OVERFLOW_CHECK();
2791 pad_push(padlist, CvDEPTH(cv));
2794 PAD_SET_CUR_NOSAVE(padlist, CvDEPTH(cv));
2796 AV *const av = MUTABLE_AV(PAD_SVl(0));
2798 /* @_ is normally not REAL--this should only ever
2799 * happen when DB::sub() calls things that modify @_ */
2804 cx->blk_sub.savearray = GvAV(PL_defgv);
2805 GvAV(PL_defgv) = MUTABLE_AV(SvREFCNT_inc_simple(av));
2806 CX_CURPAD_SAVE(cx->blk_sub);
2807 cx->blk_sub.argarray = av;
2810 if (items > AvMAX(av) + 1) {
2811 SV **ary = AvALLOC(av);
2812 if (AvARRAY(av) != ary) {
2813 AvMAX(av) += AvARRAY(av) - AvALLOC(av);
2816 if (items > AvMAX(av) + 1) {
2817 AvMAX(av) = items - 1;
2818 Renew(ary,items,SV*);
2823 Copy(MARK,AvARRAY(av),items,SV*);
2824 AvFILLp(av) = items - 1;
2832 if ((cx->blk_u16 & OPpENTERSUB_LVAL_MASK) == OPpLVAL_INTRO &&
2834 DIE(aTHX_ "Can't modify non-lvalue subroutine call");
2835 /* warning must come *after* we fully set up the context
2836 * stuff so that __WARN__ handlers can safely dounwind()
2839 if (CvDEPTH(cv) == PERL_SUB_DEPTH_WARN && ckWARN(WARN_RECURSION)
2840 && !(PERLDB_SUB && cv == GvCV(PL_DBsub)))
2841 sub_crush_depth(cv);
2842 RETURNOP(CvSTART(cv));
2845 I32 markix = TOPMARK;
2850 /* Need to copy @_ to stack. Alternative may be to
2851 * switch stack to @_, and copy return values
2852 * back. This would allow popping @_ in XSUB, e.g.. XXXX */
2853 AV * const av = GvAV(PL_defgv);
2854 const I32 items = AvFILLp(av) + 1; /* @_ is not tieable */
2857 /* Mark is at the end of the stack. */
2859 Copy(AvARRAY(av), SP + 1, items, SV*);
2864 /* We assume first XSUB in &DB::sub is the called one. */
2866 SAVEVPTR(PL_curcop);
2867 PL_curcop = PL_curcopdb;
2870 /* Do we need to open block here? XXXX */
2872 /* CvXSUB(cv) must not be NULL because newXS() refuses NULL xsub address */
2874 CvXSUB(cv)(aTHX_ cv);
2876 /* Enforce some sanity in scalar context. */
2877 if (gimme == G_SCALAR && ++markix != PL_stack_sp - PL_stack_base ) {
2878 if (markix > PL_stack_sp - PL_stack_base)
2879 *(PL_stack_base + markix) = &PL_sv_undef;
2881 *(PL_stack_base + markix) = *PL_stack_sp;
2882 PL_stack_sp = PL_stack_base + markix;
2890 Perl_sub_crush_depth(pTHX_ CV *cv)
2892 PERL_ARGS_ASSERT_SUB_CRUSH_DEPTH;
2895 Perl_warner(aTHX_ packWARN(WARN_RECURSION), "Deep recursion on anonymous subroutine");
2897 SV* const tmpstr = sv_newmortal();
2898 gv_efullname3(tmpstr, CvGV(cv), NULL);
2899 Perl_warner(aTHX_ packWARN(WARN_RECURSION), "Deep recursion on subroutine \"%"SVf"\"",
2908 SV* const elemsv = POPs;
2909 IV elem = SvIV(elemsv);
2910 AV *const av = MUTABLE_AV(POPs);
2911 const U32 lval = PL_op->op_flags & OPf_MOD || LVRET;
2912 const U32 defer = (PL_op->op_private & OPpLVAL_DEFER) && (elem > av_len(av));
2913 const bool localizing = PL_op->op_private & OPpLVAL_INTRO;
2914 bool preeminent = TRUE;
2917 if (SvROK(elemsv) && !SvGAMAGIC(elemsv) && ckWARN(WARN_MISC))
2918 Perl_warner(aTHX_ packWARN(WARN_MISC),
2919 "Use of reference \"%"SVf"\" as array index",
2921 if (SvTYPE(av) != SVt_PVAV)
2928 /* If we can determine whether the element exist,
2929 * Try to preserve the existenceness of a tied array
2930 * element by using EXISTS and DELETE if possible.
2931 * Fallback to FETCH and STORE otherwise. */
2932 if (SvCANEXISTDELETE(av))
2933 preeminent = av_exists(av, elem);
2936 svp = av_fetch(av, elem, lval && !defer);
2938 #ifdef PERL_MALLOC_WRAP
2939 if (SvUOK(elemsv)) {
2940 const UV uv = SvUV(elemsv);
2941 elem = uv > IV_MAX ? IV_MAX : uv;
2943 else if (SvNOK(elemsv))
2944 elem = (IV)SvNV(elemsv);
2946 static const char oom_array_extend[] =
2947 "Out of memory during array extend"; /* Duplicated in av.c */
2948 MEM_WRAP_CHECK_1(elem,SV*,oom_array_extend);
2951 if (!svp || *svp == &PL_sv_undef) {
2954 DIE(aTHX_ PL_no_aelem, elem);
2955 lv = sv_newmortal();
2956 sv_upgrade(lv, SVt_PVLV);
2958 sv_magic(lv, NULL, PERL_MAGIC_defelem, NULL, 0);
2959 LvTARG(lv) = SvREFCNT_inc_simple(av);
2960 LvTARGOFF(lv) = elem;
2967 save_aelem(av, elem, svp);
2969 SAVEADELETE(av, elem);
2971 else if (PL_op->op_private & OPpDEREF) {
2972 PUSHs(vivify_ref(*svp, PL_op->op_private & OPpDEREF));
2976 sv = (svp ? *svp : &PL_sv_undef);
2977 if (!lval && SvRMAGICAL(av) && SvGMAGICAL(sv)) /* see note in pp_helem() */
2984 Perl_vivify_ref(pTHX_ SV *sv, U32 to_what)
2986 PERL_ARGS_ASSERT_VIVIFY_REF;
2991 Perl_croak_no_modify();
2992 prepare_SV_for_RV(sv);
2995 SvRV_set(sv, newSV(0));
2998 SvRV_set(sv, MUTABLE_SV(newAV()));
3001 SvRV_set(sv, MUTABLE_SV(newHV()));
3008 if (SvGMAGICAL(sv)) {
3009 /* copy the sv without magic to prevent magic from being
3011 SV* msv = sv_newmortal();
3012 sv_setsv_nomg(msv, sv);
3021 SV* const sv = TOPs;
3024 SV* const rsv = SvRV(sv);
3025 if (SvTYPE(rsv) == SVt_PVCV) {
3031 SETs(method_common(sv, NULL));
3038 SV* const sv = cSVOP_sv;
3039 U32 hash = SvSHARED_HASH(sv);
3041 XPUSHs(method_common(sv, &hash));
3046 S_method_common(pTHX_ SV* meth, U32* hashp)
3053 SV * const sv = PL_stack_base + TOPMARK == PL_stack_sp
3054 ? (Perl_croak(aTHX_ "Can't call method \"%"SVf"\" without a "
3055 "package or object reference", SVfARG(meth)),
3057 : *(PL_stack_base + TOPMARK + 1);
3059 PERL_ARGS_ASSERT_METHOD_COMMON;
3063 Perl_croak(aTHX_ "Can't call method \"%"SVf"\" on an undefined value",
3068 ob = MUTABLE_SV(SvRV(sv));
3069 else if (!SvOK(sv)) goto undefined;
3071 /* this isn't a reference */
3074 const char * const packname = SvPV_nomg_const(sv, packlen);
3075 const bool packname_is_utf8 = !!SvUTF8(sv);
3076 const HE* const he =
3077 (const HE *)hv_common(
3078 PL_stashcache, NULL, packname, packlen,
3079 packname_is_utf8 ? HVhek_UTF8 : 0, 0, NULL, 0
3083 stash = INT2PTR(HV*,SvIV(HeVAL(he)));
3084 DEBUG_o(Perl_deb(aTHX_ "PL_stashcache hit %p for '%"SVf"'\n",
3089 if (!(iogv = gv_fetchpvn_flags(
3090 packname, packlen, SVf_UTF8 * packname_is_utf8, SVt_PVIO
3092 !(ob=MUTABLE_SV(GvIO(iogv))))
3094 /* this isn't the name of a filehandle either */
3097 Perl_croak(aTHX_ "Can't call method \"%"SVf"\" "
3098 "without a package or object reference",
3101 /* assume it's a package name */
3102 stash = gv_stashpvn(packname, packlen, packname_is_utf8 ? SVf_UTF8 : 0);
3106 SV* const ref = newSViv(PTR2IV(stash));
3107 (void)hv_store(PL_stashcache, packname,
3108 packname_is_utf8 ? -(I32)packlen : (I32)packlen, ref, 0);
3109 DEBUG_o(Perl_deb(aTHX_ "PL_stashcache caching %p for '%"SVf"'\n",
3114 /* it _is_ a filehandle name -- replace with a reference */
3115 *(PL_stack_base + TOPMARK + 1) = sv_2mortal(newRV(MUTABLE_SV(iogv)));
3118 /* if we got here, ob should be a reference or a glob */
3119 if (!ob || !(SvOBJECT(ob)
3120 || (SvTYPE(ob) == SVt_PVGV
3122 && (ob = MUTABLE_SV(GvIO((const GV *)ob)))
3125 Perl_croak(aTHX_ "Can't call method \"%"SVf"\" on unblessed reference",
3126 SVfARG((SvSCREAM(meth) && strEQ(SvPV_nolen_const(meth),"isa"))
3127 ? newSVpvs_flags("DOES", SVs_TEMP)
3131 stash = SvSTASH(ob);
3134 /* NOTE: stash may be null, hope hv_fetch_ent and
3135 gv_fetchmethod can cope (it seems they can) */
3137 /* shortcut for simple names */
3139 const HE* const he = hv_fetch_ent(stash, meth, 0, *hashp);
3141 gv = MUTABLE_GV(HeVAL(he));
3142 if (isGV(gv) && GvCV(gv) &&
3143 (!GvCVGEN(gv) || GvCVGEN(gv)
3144 == (PL_sub_generation + HvMROMETA(stash)->cache_gen)))
3145 return MUTABLE_SV(GvCV(gv));
3149 gv = gv_fetchmethod_sv_flags(stash ? stash : MUTABLE_HV(packsv),
3150 meth, GV_AUTOLOAD | GV_CROAK);
3154 return isGV(gv) ? MUTABLE_SV(GvCV(gv)) : MUTABLE_SV(gv);
3159 * c-indentation-style: bsd
3161 * indent-tabs-mode: nil
3164 * ex: set ts=8 sts=4 sw=4 et: