3 * Copyright (c) 1991-2002, Larry Wall
5 * You may distribute under the terms of either the GNU General Public
6 * License or the Artistic License, as specified in the README file.
11 * Then he heard Merry change the note, and up went the Horn-cry of Buckland,
14 * Awake! Awake! Fear, Fire, Foes! Awake!
19 #define PERL_IN_PP_HOT_C
33 PL_curcop = (COP*)PL_op;
34 TAINT_NOT; /* Each statement is presumed innocent */
35 PL_stack_sp = PL_stack_base + cxstack[cxstack_ix].blk_oldsp;
44 if (PL_op->op_private & OPpLVAL_INTRO)
45 PUSHs(save_scalar(cGVOP_gv));
47 PUSHs(GvSV(cGVOP_gv));
58 PL_curcop = (COP*)PL_op;
64 PUSHMARK(PL_stack_sp);
79 XPUSHs((SV*)cGVOP_gv);
90 RETURNOP(cLOGOP->op_other);
98 if (PL_op->op_private & OPpASSIGN_BACKWARDS) {
100 temp = left; left = right; right = temp;
102 if (PL_tainting && PL_tainted && !SvTAINTED(left))
104 SvSetMagicSV(right, left);
113 RETURNOP(cLOGOP->op_other);
115 RETURNOP(cLOGOP->op_next);
121 TAINT_NOT; /* Each statement is presumed innocent */
122 PL_stack_sp = PL_stack_base + cxstack[cxstack_ix].blk_oldsp;
124 oldsave = PL_scopestack[PL_scopestack_ix - 1];
125 LEAVE_SCOPE(oldsave);
131 dSP; dATARGET; tryAMAGICbin(concat,opASSIGN);
138 char* rpv = SvPV(right, rlen); /* mg_get(right) happens here */
139 bool rbyte = !SvUTF8(right), rcopied = FALSE;
141 if (TARG == right && right != left) {
142 right = sv_2mortal(newSVpvn(rpv, rlen));
143 rpv = SvPV(right, rlen); /* no point setting UTF8 here */
148 lpv = SvPV(left, llen); /* mg_get(left) may happen here */
149 lbyte = !SvUTF8(left);
150 sv_setpvn(TARG, lpv, llen);
156 else { /* TARG == left */
157 if (SvGMAGICAL(left))
158 mg_get(left); /* or mg_get(left) may happen here */
161 lpv = SvPV_nomg(left, llen);
162 lbyte = !SvUTF8(left);
165 #if defined(PERL_Y2KWARN)
166 if ((SvIOK(right) || SvNOK(right)) && ckWARN(WARN_Y2K) && SvOK(TARG)) {
167 if (llen >= 2 && lpv[llen - 2] == '1' && lpv[llen - 1] == '9'
168 && (llen == 2 || !isDIGIT(lpv[llen - 3])))
170 Perl_warner(aTHX_ packWARN(WARN_Y2K), "Possible Y2K bug: %s",
171 "about to append an integer to '19'");
176 if (lbyte != rbyte) {
178 sv_utf8_upgrade_nomg(TARG);
181 right = sv_2mortal(newSVpvn(rpv, rlen));
182 sv_utf8_upgrade_nomg(right);
183 rpv = SvPV(right, rlen);
186 sv_catpvn_nomg(TARG, rpv, rlen);
197 if (PL_op->op_flags & OPf_MOD) {
198 if (PL_op->op_private & OPpLVAL_INTRO)
199 SAVECLEARSV(PAD_SVl(PL_op->op_targ));
200 else if (PL_op->op_private & OPpDEREF) {
202 vivify_ref(PAD_SVl(PL_op->op_targ), PL_op->op_private & OPpDEREF);
211 tryAMAGICunTARGET(iter, 0);
212 PL_last_in_gv = (GV*)(*PL_stack_sp--);
213 if (SvTYPE(PL_last_in_gv) != SVt_PVGV) {
214 if (SvROK(PL_last_in_gv) && SvTYPE(SvRV(PL_last_in_gv)) == SVt_PVGV)
215 PL_last_in_gv = (GV*)SvRV(PL_last_in_gv);
218 XPUSHs((SV*)PL_last_in_gv);
221 PL_last_in_gv = (GV*)(*PL_stack_sp--);
224 return do_readline();
229 dSP; tryAMAGICbinSET(eq,0);
230 #ifndef NV_PRESERVES_UV
231 if (SvROK(TOPs) && SvROK(TOPm1s)) {
233 SETs(boolSV(SvRV(TOPs) == SvRV(TOPp1s)));
237 #ifdef PERL_PRESERVE_IVUV
240 /* Unless the left argument is integer in range we are going
241 to have to use NV maths. Hence only attempt to coerce the
242 right argument if we know the left is integer. */
245 bool auvok = SvUOK(TOPm1s);
246 bool buvok = SvUOK(TOPs);
248 if (auvok == buvok) { /* ## IV == IV or UV == UV ## */
249 /* Casting IV to UV before comparison isn't going to matter
250 on 2s complement. On 1s complement or sign&magnitude
251 (if we have any of them) it could to make negative zero
252 differ from normal zero. As I understand it. (Need to
253 check - is negative zero implementation defined behaviour
255 UV buv = SvUVX(POPs);
256 UV auv = SvUVX(TOPs);
258 SETs(boolSV(auv == buv));
261 { /* ## Mixed IV,UV ## */
265 /* == is commutative so doesn't matter which is left or right */
267 /* top of stack (b) is the iv */
276 /* As uv is a UV, it's >0, so it cannot be == */
280 /* we know iv is >= 0 */
281 SETs(boolSV((UV)iv == SvUVX(uvp)));
289 SETs(boolSV(TOPn == value));
297 if (SvTYPE(TOPs) > SVt_PVLV)
298 DIE(aTHX_ PL_no_modify);
299 if (!SvREADONLY(TOPs) && SvIOK_notUV(TOPs) && !SvNOK(TOPs) && !SvPOK(TOPs)
300 && SvIVX(TOPs) != IV_MAX)
303 SvFLAGS(TOPs) &= ~(SVp_NOK|SVp_POK);
305 else /* Do all the PERL_PRESERVE_IVUV conditionals in sv_inc */
318 RETURNOP(cLOGOP->op_other);
324 /* Most of this is lifted straight from pp_defined */
329 if (!sv || !SvANY(sv)) {
331 RETURNOP(cLOGOP->op_other);
334 switch (SvTYPE(sv)) {
336 if (AvMAX(sv) >= 0 || SvGMAGICAL(sv) || (SvRMAGICAL(sv) && mg_find(sv, PERL_MAGIC_tied)))
340 if (HvARRAY(sv) || SvGMAGICAL(sv) || (SvRMAGICAL(sv) && mg_find(sv, PERL_MAGIC_tied)))
344 if (CvROOT(sv) || CvXSUB(sv))
355 RETURNOP(cLOGOP->op_other);
360 dSP; dATARGET; bool useleft; tryAMAGICbin(add,opASSIGN);
361 useleft = USE_LEFT(TOPm1s);
362 #ifdef PERL_PRESERVE_IVUV
363 /* We must see if we can perform the addition with integers if possible,
364 as the integer code detects overflow while the NV code doesn't.
365 If either argument hasn't had a numeric conversion yet attempt to get
366 the IV. It's important to do this now, rather than just assuming that
367 it's not IOK as a PV of "9223372036854775806" may not take well to NV
368 addition, and an SV which is NOK, NV=6.0 ought to be coerced to
369 integer in case the second argument is IV=9223372036854775806
370 We can (now) rely on sv_2iv to do the right thing, only setting the
371 public IOK flag if the value in the NV (or PV) slot is truly integer.
373 A side effect is that this also aggressively prefers integer maths over
374 fp maths for integer values.
376 How to detect overflow?
378 C 99 section 6.2.6.1 says
380 The range of nonnegative values of a signed integer type is a subrange
381 of the corresponding unsigned integer type, and the representation of
382 the same value in each type is the same. A computation involving
383 unsigned operands can never overflow, because a result that cannot be
384 represented by the resulting unsigned integer type is reduced modulo
385 the number that is one greater than the largest value that can be
386 represented by the resulting type.
390 which I read as "unsigned ints wrap."
392 signed integer overflow seems to be classed as "exception condition"
394 If an exceptional condition occurs during the evaluation of an
395 expression (that is, if the result is not mathematically defined or not
396 in the range of representable values for its type), the behavior is
399 (6.5, the 5th paragraph)
401 I had assumed that on 2s complement machines signed arithmetic would
402 wrap, hence coded pp_add and pp_subtract on the assumption that
403 everything perl builds on would be happy. After much wailing and
404 gnashing of teeth it would seem that irix64 knows its ANSI spec well,
405 knows that it doesn't need to, and doesn't. Bah. Anyway, the all-
406 unsigned code below is actually shorter than the old code. :-)
411 /* Unless the left argument is integer in range we are going to have to
412 use NV maths. Hence only attempt to coerce the right argument if
413 we know the left is integer. */
421 /* left operand is undef, treat as zero. + 0 is identity,
422 Could SETi or SETu right now, but space optimise by not adding
423 lots of code to speed up what is probably a rarish case. */
425 /* Left operand is defined, so is it IV? */
428 if ((auvok = SvUOK(TOPm1s)))
431 register IV aiv = SvIVX(TOPm1s);
434 auvok = 1; /* Now acting as a sign flag. */
435 } else { /* 2s complement assumption for IV_MIN */
443 bool result_good = 0;
446 bool buvok = SvUOK(TOPs);
451 register IV biv = SvIVX(TOPs);
458 /* ?uvok if value is >= 0. basically, flagged as UV if it's +ve,
459 else "IV" now, independent of how it came in.
460 if a, b represents positive, A, B negative, a maps to -A etc
465 all UV maths. negate result if A negative.
466 add if signs same, subtract if signs differ. */
472 /* Must get smaller */
478 /* result really should be -(auv-buv). as its negation
479 of true value, need to swap our result flag */
496 if (result <= (UV)IV_MIN)
499 /* result valid, but out of range for IV. */
504 } /* Overflow, drop through to NVs. */
511 /* left operand is undef, treat as zero. + 0.0 is identity. */
515 SETn( value + TOPn );
523 AV *av = GvAV(cGVOP_gv);
524 U32 lval = PL_op->op_flags & OPf_MOD;
525 SV** svp = av_fetch(av, PL_op->op_private, lval);
526 SV *sv = (svp ? *svp : &PL_sv_undef);
528 if (!lval && SvGMAGICAL(sv)) /* see note in pp_helem() */
529 sv = sv_mortalcopy(sv);
538 do_join(TARG, *MARK, MARK, SP);
549 * We ass_u_me that LvTARGOFF() comes first, and that two STRLENs
550 * will be enough to hold an OP*.
552 SV* sv = sv_newmortal();
553 sv_upgrade(sv, SVt_PVLV);
555 Copy(&PL_op, &LvTARGOFF(sv), 1, OP*);
563 /* Oversized hot code. */
567 dSP; dMARK; dORIGMARK;
573 if (PL_op->op_flags & OPf_STACKED)
578 if (gv && (io = GvIO(gv))
579 && (mg = SvTIED_mg((SV*)io, PERL_MAGIC_tiedscalar)))
582 if (MARK == ORIGMARK) {
583 /* If using default handle then we need to make space to
584 * pass object as 1st arg, so move other args up ...
588 Move(MARK, MARK + 1, (SP - MARK) + 1, SV*);
592 *MARK = SvTIED_obj((SV*)io, mg);
595 call_method("PRINT", G_SCALAR);
603 if (!(io = GvIO(gv))) {
604 if ((GvEGV(gv)) && (io = GvIO(GvEGV(gv)))
605 && (mg = SvTIED_mg((SV*)io, PERL_MAGIC_tiedscalar)))
607 if (ckWARN2(WARN_UNOPENED,WARN_CLOSED))
608 report_evil_fh(gv, io, PL_op->op_type);
609 SETERRNO(EBADF,RMS_IFI);
612 else if (!(fp = IoOFP(io))) {
613 if (ckWARN2(WARN_CLOSED, WARN_IO)) {
615 report_evil_fh(gv, io, OP_phoney_INPUT_ONLY);
616 else if (ckWARN2(WARN_UNOPENED,WARN_CLOSED))
617 report_evil_fh(gv, io, PL_op->op_type);
619 SETERRNO(EBADF,IoIFP(io)?RMS_FAC:RMS_IFI);
624 if (PL_ofs_sv && SvOK(PL_ofs_sv)) {
626 if (!do_print(*MARK, fp))
630 if (!do_print(PL_ofs_sv, fp)) { /* $, */
639 if (!do_print(*MARK, fp))
647 if (PL_ors_sv && SvOK(PL_ors_sv))
648 if (!do_print(PL_ors_sv, fp)) /* $\ */
651 if (IoFLAGS(io) & IOf_FLUSH)
652 if (PerlIO_flush(fp) == EOF)
673 tryAMAGICunDEREF(to_av);
676 if (SvTYPE(av) != SVt_PVAV)
677 DIE(aTHX_ "Not an ARRAY reference");
678 if (PL_op->op_flags & OPf_REF) {
683 if (GIMME == G_SCALAR)
684 Perl_croak(aTHX_ "Can't return array to lvalue scalar context");
690 if (SvTYPE(sv) == SVt_PVAV) {
692 if (PL_op->op_flags & OPf_REF) {
697 if (GIMME == G_SCALAR)
698 Perl_croak(aTHX_ "Can't return array to lvalue"
707 if (SvTYPE(sv) != SVt_PVGV) {
711 if (SvGMAGICAL(sv)) {
717 if (PL_op->op_flags & OPf_REF ||
718 PL_op->op_private & HINT_STRICT_REFS)
719 DIE(aTHX_ PL_no_usym, "an ARRAY");
720 if (ckWARN(WARN_UNINITIALIZED))
722 if (GIMME == G_ARRAY) {
729 if ((PL_op->op_flags & OPf_SPECIAL) &&
730 !(PL_op->op_flags & OPf_MOD))
732 gv = (GV*)gv_fetchpv(sym, FALSE, SVt_PVAV);
734 && (!is_gv_magical(sym,len,0)
735 || !(gv = (GV*)gv_fetchpv(sym, TRUE, SVt_PVAV))))
741 if (PL_op->op_private & HINT_STRICT_REFS)
742 DIE(aTHX_ PL_no_symref, sym, "an ARRAY");
743 gv = (GV*)gv_fetchpv(sym, TRUE, SVt_PVAV);
750 if (PL_op->op_private & OPpLVAL_INTRO)
752 if (PL_op->op_flags & OPf_REF) {
757 if (GIMME == G_SCALAR)
758 Perl_croak(aTHX_ "Can't return array to lvalue"
766 if (GIMME == G_ARRAY) {
767 I32 maxarg = AvFILL(av) + 1;
768 (void)POPs; /* XXXX May be optimized away? */
770 if (SvRMAGICAL(av)) {
772 for (i=0; i < (U32)maxarg; i++) {
773 SV **svp = av_fetch(av, i, FALSE);
774 SP[i+1] = (svp) ? *svp : &PL_sv_undef;
778 Copy(AvARRAY(av), SP+1, maxarg, SV*);
782 else if (GIMME_V == G_SCALAR) {
784 I32 maxarg = AvFILL(av) + 1;
797 tryAMAGICunDEREF(to_hv);
800 if (SvTYPE(hv) != SVt_PVHV)
801 DIE(aTHX_ "Not a HASH reference");
802 if (PL_op->op_flags & OPf_REF) {
807 if (GIMME == G_SCALAR)
808 Perl_croak(aTHX_ "Can't return hash to lvalue scalar context");
814 if (SvTYPE(sv) == SVt_PVHV) {
816 if (PL_op->op_flags & OPf_REF) {
821 if (GIMME == G_SCALAR)
822 Perl_croak(aTHX_ "Can't return hash to lvalue"
831 if (SvTYPE(sv) != SVt_PVGV) {
835 if (SvGMAGICAL(sv)) {
841 if (PL_op->op_flags & OPf_REF ||
842 PL_op->op_private & HINT_STRICT_REFS)
843 DIE(aTHX_ PL_no_usym, "a HASH");
844 if (ckWARN(WARN_UNINITIALIZED))
846 if (GIMME == G_ARRAY) {
853 if ((PL_op->op_flags & OPf_SPECIAL) &&
854 !(PL_op->op_flags & OPf_MOD))
856 gv = (GV*)gv_fetchpv(sym, FALSE, SVt_PVHV);
858 && (!is_gv_magical(sym,len,0)
859 || !(gv = (GV*)gv_fetchpv(sym, TRUE, SVt_PVHV))))
865 if (PL_op->op_private & HINT_STRICT_REFS)
866 DIE(aTHX_ PL_no_symref, sym, "a HASH");
867 gv = (GV*)gv_fetchpv(sym, TRUE, SVt_PVHV);
874 if (PL_op->op_private & OPpLVAL_INTRO)
876 if (PL_op->op_flags & OPf_REF) {
881 if (GIMME == G_SCALAR)
882 Perl_croak(aTHX_ "Can't return hash to lvalue"
890 if (GIMME == G_ARRAY) { /* array wanted */
891 *PL_stack_sp = (SV*)hv;
897 Perl_sv_setpvf(aTHX_ TARG, "%"IVdf"/%"IVdf,
898 (IV)HvFILL(hv), (IV)HvMAX(hv) + 1);
908 S_do_oddball(pTHX_ HV *hash, SV **relem, SV **firstrelem)
914 if (ckWARN(WARN_MISC)) {
915 if (relem == firstrelem &&
917 (SvTYPE(SvRV(*relem)) == SVt_PVAV ||
918 SvTYPE(SvRV(*relem)) == SVt_PVHV))
920 Perl_warner(aTHX_ packWARN(WARN_MISC),
921 "Reference found where even-sized list expected");
924 Perl_warner(aTHX_ packWARN(WARN_MISC),
925 "Odd number of elements in hash assignment");
928 tmpstr = NEWSV(29,0);
929 didstore = hv_store_ent(hash,*relem,tmpstr,0);
930 if (SvMAGICAL(hash)) {
931 if (SvSMAGICAL(tmpstr))
943 SV **lastlelem = PL_stack_sp;
944 SV **lastrelem = PL_stack_base + POPMARK;
945 SV **firstrelem = PL_stack_base + POPMARK + 1;
946 SV **firstlelem = lastrelem + 1;
959 PL_delaymagic = DM_DELAY; /* catch simultaneous items */
961 /* If there's a common identifier on both sides we have to take
962 * special care that assigning the identifier on the left doesn't
963 * clobber a value on the right that's used later in the list.
965 if (PL_op->op_private & (OPpASSIGN_COMMON)) {
966 EXTEND_MORTAL(lastrelem - firstrelem + 1);
967 for (relem = firstrelem; relem <= lastrelem; relem++) {
970 TAINT_NOT; /* Each item is independent */
971 *relem = sv_mortalcopy(sv);
981 while (lelem <= lastlelem) {
982 TAINT_NOT; /* Each item stands on its own, taintwise. */
984 switch (SvTYPE(sv)) {
987 magic = SvMAGICAL(ary) != 0;
989 av_extend(ary, lastrelem - relem);
991 while (relem <= lastrelem) { /* gobble up all the rest */
997 didstore = av_store(ary,i++,sv);
1007 case SVt_PVHV: { /* normal hash */
1011 magic = SvMAGICAL(hash) != 0;
1014 while (relem < lastrelem) { /* gobble up all the rest */
1019 sv = &PL_sv_no, relem++;
1020 tmpstr = NEWSV(29,0);
1022 sv_setsv(tmpstr,*relem); /* value */
1023 *(relem++) = tmpstr;
1024 didstore = hv_store_ent(hash,sv,tmpstr,0);
1026 if (SvSMAGICAL(tmpstr))
1033 if (relem == lastrelem) {
1034 do_oddball(hash, relem, firstrelem);
1040 if (SvIMMORTAL(sv)) {
1041 if (relem <= lastrelem)
1045 if (relem <= lastrelem) {
1046 sv_setsv(sv, *relem);
1050 sv_setsv(sv, &PL_sv_undef);
1055 if (PL_delaymagic & ~DM_DELAY) {
1056 if (PL_delaymagic & DM_UID) {
1057 #ifdef HAS_SETRESUID
1058 (void)setresuid(PL_uid,PL_euid,(Uid_t)-1);
1060 # ifdef HAS_SETREUID
1061 (void)setreuid(PL_uid,PL_euid);
1064 if ((PL_delaymagic & DM_UID) == DM_RUID) {
1065 (void)setruid(PL_uid);
1066 PL_delaymagic &= ~DM_RUID;
1068 # endif /* HAS_SETRUID */
1070 if ((PL_delaymagic & DM_UID) == DM_EUID) {
1071 (void)seteuid(PL_uid);
1072 PL_delaymagic &= ~DM_EUID;
1074 # endif /* HAS_SETEUID */
1075 if (PL_delaymagic & DM_UID) {
1076 if (PL_uid != PL_euid)
1077 DIE(aTHX_ "No setreuid available");
1078 (void)PerlProc_setuid(PL_uid);
1080 # endif /* HAS_SETREUID */
1081 #endif /* HAS_SETRESUID */
1082 PL_uid = PerlProc_getuid();
1083 PL_euid = PerlProc_geteuid();
1085 if (PL_delaymagic & DM_GID) {
1086 #ifdef HAS_SETRESGID
1087 (void)setresgid(PL_gid,PL_egid,(Gid_t)-1);
1089 # ifdef HAS_SETREGID
1090 (void)setregid(PL_gid,PL_egid);
1093 if ((PL_delaymagic & DM_GID) == DM_RGID) {
1094 (void)setrgid(PL_gid);
1095 PL_delaymagic &= ~DM_RGID;
1097 # endif /* HAS_SETRGID */
1099 if ((PL_delaymagic & DM_GID) == DM_EGID) {
1100 (void)setegid(PL_gid);
1101 PL_delaymagic &= ~DM_EGID;
1103 # endif /* HAS_SETEGID */
1104 if (PL_delaymagic & DM_GID) {
1105 if (PL_gid != PL_egid)
1106 DIE(aTHX_ "No setregid available");
1107 (void)PerlProc_setgid(PL_gid);
1109 # endif /* HAS_SETREGID */
1110 #endif /* HAS_SETRESGID */
1111 PL_gid = PerlProc_getgid();
1112 PL_egid = PerlProc_getegid();
1114 PL_tainting |= (PL_uid && (PL_euid != PL_uid || PL_egid != PL_gid));
1119 if (gimme == G_VOID)
1120 SP = firstrelem - 1;
1121 else if (gimme == G_SCALAR) {
1124 SETi(lastrelem - firstrelem + 1);
1130 SP = firstrelem + (lastlelem - firstlelem);
1131 lelem = firstlelem + (relem - firstrelem);
1133 *relem++ = (lelem <= lastlelem) ? *lelem++ : &PL_sv_undef;
1141 register PMOP *pm = cPMOP;
1142 SV *rv = sv_newmortal();
1143 SV *sv = newSVrv(rv, "Regexp");
1144 if (pm->op_pmdynflags & PMdf_TAINTED)
1146 sv_magic(sv,(SV*)ReREFCNT_inc(PM_GETRE(pm)), PERL_MAGIC_qr,0,0);
1153 register PMOP *pm = cPMOP;
1159 I32 r_flags = REXEC_CHECKED;
1160 char *truebase; /* Start of string */
1161 register REGEXP *rx = PM_GETRE(pm);
1166 I32 oldsave = PL_savestack_ix;
1167 I32 update_minmatch = 1;
1168 I32 had_zerolen = 0;
1170 if (PL_op->op_flags & OPf_STACKED)
1177 PUTBACK; /* EVAL blocks need stack_sp. */
1178 s = SvPV(TARG, len);
1181 DIE(aTHX_ "panic: pp_match");
1182 rxtainted = ((pm->op_pmdynflags & PMdf_TAINTED) ||
1183 (PL_tainted && (pm->op_pmflags & PMf_RETAINT)));
1186 RX_MATCH_UTF8_set(rx, DO_UTF8(TARG));
1188 /* PMdf_USED is set after a ?? matches once */
1189 if (pm->op_pmdynflags & PMdf_USED) {
1191 if (gimme == G_ARRAY)
1196 /* empty pattern special-cased to use last successful pattern if possible */
1197 if (!rx->prelen && PL_curpm) {
1202 if (rx->minlen > (I32)len)
1207 /* XXXX What part of this is needed with true \G-support? */
1208 if ((global = dynpm->op_pmflags & PMf_GLOBAL)) {
1210 if (SvTYPE(TARG) >= SVt_PVMG && SvMAGIC(TARG)) {
1211 MAGIC* mg = mg_find(TARG, PERL_MAGIC_regex_global);
1212 if (mg && mg->mg_len >= 0) {
1213 if (!(rx->reganch & ROPT_GPOS_SEEN))
1214 rx->endp[0] = rx->startp[0] = mg->mg_len;
1215 else if (rx->reganch & ROPT_ANCH_GPOS) {
1216 r_flags |= REXEC_IGNOREPOS;
1217 rx->endp[0] = rx->startp[0] = mg->mg_len;
1219 minmatch = (mg->mg_flags & MGf_MINMATCH);
1220 update_minmatch = 0;
1224 if ((!global && rx->nparens)
1225 || SvTEMP(TARG) || PL_sawampersand)
1226 r_flags |= REXEC_COPY_STR;
1228 r_flags |= REXEC_SCREAM;
1230 if (pm->op_pmflags & (PMf_MULTILINE|PMf_SINGLELINE)) {
1231 SAVEINT(PL_multiline);
1232 PL_multiline = pm->op_pmflags & PMf_MULTILINE;
1236 if (global && rx->startp[0] != -1) {
1237 t = s = rx->endp[0] + truebase;
1238 if ((s + rx->minlen) > strend)
1240 if (update_minmatch++)
1241 minmatch = had_zerolen;
1243 if (rx->reganch & RE_USE_INTUIT &&
1244 DO_UTF8(TARG) == ((rx->reganch & ROPT_UTF8) != 0)) {
1245 PL_bostr = truebase;
1246 s = CALLREG_INTUIT_START(aTHX_ rx, TARG, s, strend, r_flags, NULL);
1250 if ( (rx->reganch & ROPT_CHECK_ALL)
1252 && ((rx->reganch & ROPT_NOSCAN)
1253 || !((rx->reganch & RE_INTUIT_TAIL)
1254 && (r_flags & REXEC_SCREAM)))
1255 && !SvROK(TARG)) /* Cannot trust since INTUIT cannot guess ^ */
1258 if (CALLREGEXEC(aTHX_ rx, s, strend, truebase, minmatch, TARG, NULL, r_flags))
1261 if (dynpm->op_pmflags & PMf_ONCE)
1262 dynpm->op_pmdynflags |= PMdf_USED;
1271 RX_MATCH_TAINTED_on(rx);
1272 TAINT_IF(RX_MATCH_TAINTED(rx));
1273 if (gimme == G_ARRAY) {
1274 I32 nparens, i, len;
1276 nparens = rx->nparens;
1277 if (global && !nparens)
1281 SPAGAIN; /* EVAL blocks could move the stack. */
1282 EXTEND(SP, nparens + i);
1283 EXTEND_MORTAL(nparens + i);
1284 for (i = !i; i <= nparens; i++) {
1285 PUSHs(sv_newmortal());
1287 if ((rx->startp[i] != -1) && rx->endp[i] != -1 ) {
1288 len = rx->endp[i] - rx->startp[i];
1289 if (rx->endp[i] < 0 || rx->startp[i] < 0 ||
1290 len < 0 || len > strend - s)
1291 DIE(aTHX_ "panic: pp_match start/end pointers");
1292 s = rx->startp[i] + truebase;
1293 sv_setpvn(*SP, s, len);
1294 if (DO_UTF8(TARG) && is_utf8_string((U8*)s, len))
1299 if (dynpm->op_pmflags & PMf_CONTINUE) {
1301 if (SvTYPE(TARG) >= SVt_PVMG && SvMAGIC(TARG))
1302 mg = mg_find(TARG, PERL_MAGIC_regex_global);
1304 sv_magic(TARG, (SV*)0, PERL_MAGIC_regex_global, Nullch, 0);
1305 mg = mg_find(TARG, PERL_MAGIC_regex_global);
1307 if (rx->startp[0] != -1) {
1308 mg->mg_len = rx->endp[0];
1309 if (rx->startp[0] == rx->endp[0])
1310 mg->mg_flags |= MGf_MINMATCH;
1312 mg->mg_flags &= ~MGf_MINMATCH;
1315 had_zerolen = (rx->startp[0] != -1
1316 && rx->startp[0] == rx->endp[0]);
1317 PUTBACK; /* EVAL blocks may use stack */
1318 r_flags |= REXEC_IGNOREPOS | REXEC_NOT_FIRST;
1323 LEAVE_SCOPE(oldsave);
1329 if (SvTYPE(TARG) >= SVt_PVMG && SvMAGIC(TARG))
1330 mg = mg_find(TARG, PERL_MAGIC_regex_global);
1332 sv_magic(TARG, (SV*)0, PERL_MAGIC_regex_global, Nullch, 0);
1333 mg = mg_find(TARG, PERL_MAGIC_regex_global);
1335 if (rx->startp[0] != -1) {
1336 mg->mg_len = rx->endp[0];
1337 if (rx->startp[0] == rx->endp[0])
1338 mg->mg_flags |= MGf_MINMATCH;
1340 mg->mg_flags &= ~MGf_MINMATCH;
1343 LEAVE_SCOPE(oldsave);
1347 yup: /* Confirmed by INTUIT */
1349 RX_MATCH_TAINTED_on(rx);
1350 TAINT_IF(RX_MATCH_TAINTED(rx));
1352 if (dynpm->op_pmflags & PMf_ONCE)
1353 dynpm->op_pmdynflags |= PMdf_USED;
1354 if (RX_MATCH_COPIED(rx))
1355 Safefree(rx->subbeg);
1356 RX_MATCH_COPIED_off(rx);
1357 rx->subbeg = Nullch;
1359 rx->subbeg = truebase;
1360 rx->startp[0] = s - truebase;
1361 if (RX_MATCH_UTF8(rx)) {
1362 char *t = (char*)utf8_hop((U8*)s, rx->minlen);
1363 rx->endp[0] = t - truebase;
1366 rx->endp[0] = s - truebase + rx->minlen;
1368 rx->sublen = strend - truebase;
1371 if (PL_sawampersand) {
1373 #ifdef PERL_COPY_ON_WRITE
1374 if (SvIsCOW(TARG) || (SvFLAGS(TARG) & CAN_COW_MASK) == CAN_COW_FLAGS) {
1376 PerlIO_printf(Perl_debug_log,
1377 "Copy on write: pp_match $& capture, type %d, truebase=%p, t=%p, difference %d\n",
1378 (int) SvTYPE(TARG), truebase, t,
1381 rx->saved_copy = sv_setsv_cow(rx->saved_copy, TARG);
1382 rx->subbeg = SvPVX(rx->saved_copy) + (t - truebase);
1383 assert (SvPOKp(rx->saved_copy));
1388 rx->subbeg = savepvn(t, strend - t);
1389 #ifdef PERL_COPY_ON_WRITE
1390 rx->saved_copy = Nullsv;
1393 rx->sublen = strend - t;
1394 RX_MATCH_COPIED_on(rx);
1395 off = rx->startp[0] = s - t;
1396 rx->endp[0] = off + rx->minlen;
1398 else { /* startp/endp are used by @- @+. */
1399 rx->startp[0] = s - truebase;
1400 rx->endp[0] = s - truebase + rx->minlen;
1402 rx->nparens = rx->lastparen = 0; /* used by @- and @+ */
1403 LEAVE_SCOPE(oldsave);
1408 if (global && !(dynpm->op_pmflags & PMf_CONTINUE)) {
1409 if (SvTYPE(TARG) >= SVt_PVMG && SvMAGIC(TARG)) {
1410 MAGIC* mg = mg_find(TARG, PERL_MAGIC_regex_global);
1415 LEAVE_SCOPE(oldsave);
1416 if (gimme == G_ARRAY)
1422 Perl_do_readline(pTHX)
1424 dSP; dTARGETSTACKED;
1429 register IO *io = GvIO(PL_last_in_gv);
1430 register I32 type = PL_op->op_type;
1431 I32 gimme = GIMME_V;
1434 if (io && (mg = SvTIED_mg((SV*)io, PERL_MAGIC_tiedscalar))) {
1436 XPUSHs(SvTIED_obj((SV*)io, mg));
1439 call_method("READLINE", gimme);
1442 if (gimme == G_SCALAR) {
1444 SvSetSV_nosteal(TARG, result);
1453 if (IoFLAGS(io) & IOf_ARGV) {
1454 if (IoFLAGS(io) & IOf_START) {
1456 if (av_len(GvAVn(PL_last_in_gv)) < 0) {
1457 IoFLAGS(io) &= ~IOf_START;
1458 do_open(PL_last_in_gv,"-",1,FALSE,O_RDONLY,0,Nullfp);
1459 sv_setpvn(GvSV(PL_last_in_gv), "-", 1);
1460 SvSETMAGIC(GvSV(PL_last_in_gv));
1465 fp = nextargv(PL_last_in_gv);
1466 if (!fp) { /* Note: fp != IoIFP(io) */
1467 (void)do_close(PL_last_in_gv, FALSE); /* now it does*/
1470 else if (type == OP_GLOB)
1471 fp = Perl_start_glob(aTHX_ POPs, io);
1473 else if (type == OP_GLOB)
1475 else if (ckWARN(WARN_IO) && IoTYPE(io) == IoTYPE_WRONLY) {
1476 report_evil_fh(PL_last_in_gv, io, OP_phoney_OUTPUT_ONLY);
1480 if (ckWARN2(WARN_GLOB, WARN_CLOSED)
1481 && (!io || !(IoFLAGS(io) & IOf_START))) {
1482 if (type == OP_GLOB)
1483 Perl_warner(aTHX_ packWARN(WARN_GLOB),
1484 "glob failed (can't start child: %s)",
1487 report_evil_fh(PL_last_in_gv, io, PL_op->op_type);
1489 if (gimme == G_SCALAR) {
1490 /* undef TARG, and push that undefined value */
1491 SV_CHECK_THINKFIRST_COW_DROP(TARG);
1492 (void)SvOK_off(TARG);
1498 if (gimme == G_SCALAR) {
1502 (void)SvUPGRADE(sv, SVt_PV);
1503 tmplen = SvLEN(sv); /* remember if already alloced */
1505 Sv_Grow(sv, 80); /* try short-buffering it */
1507 if (type == OP_RCATLINE && SvOK(sv)) {
1510 (void)SvPV_force(sv, n_a);
1516 sv = sv_2mortal(NEWSV(57, 80));
1520 /* This should not be marked tainted if the fp is marked clean */
1521 #define MAYBE_TAINT_LINE(io, sv) \
1522 if (!(IoFLAGS(io) & IOf_UNTAINT)) { \
1527 /* delay EOF state for a snarfed empty file */
1528 #define SNARF_EOF(gimme,rs,io,sv) \
1529 (gimme != G_SCALAR || SvCUR(sv) \
1530 || (IoFLAGS(io) & IOf_NOLINE) || !RsSNARF(rs))
1534 if (!sv_gets(sv, fp, offset)
1535 && (type == OP_GLOB || SNARF_EOF(gimme, PL_rs, io, sv)))
1537 PerlIO_clearerr(fp);
1538 if (IoFLAGS(io) & IOf_ARGV) {
1539 fp = nextargv(PL_last_in_gv);
1542 (void)do_close(PL_last_in_gv, FALSE);
1544 else if (type == OP_GLOB) {
1545 if (!do_close(PL_last_in_gv, FALSE) && ckWARN(WARN_GLOB)) {
1546 Perl_warner(aTHX_ packWARN(WARN_GLOB),
1547 "glob failed (child exited with status %d%s)",
1548 (int)(STATUS_CURRENT >> 8),
1549 (STATUS_CURRENT & 0x80) ? ", core dumped" : "");
1552 if (gimme == G_SCALAR) {
1553 SV_CHECK_THINKFIRST_COW_DROP(TARG);
1554 (void)SvOK_off(TARG);
1558 MAYBE_TAINT_LINE(io, sv);
1561 MAYBE_TAINT_LINE(io, sv);
1563 IoFLAGS(io) |= IOf_NOLINE;
1567 if (type == OP_GLOB) {
1570 if (SvCUR(sv) > 0 && SvCUR(PL_rs) > 0) {
1571 tmps = SvEND(sv) - 1;
1572 if (*tmps == *SvPVX(PL_rs)) {
1577 for (tmps = SvPVX(sv); *tmps; tmps++)
1578 if (!isALPHA(*tmps) && !isDIGIT(*tmps) &&
1579 strchr("$&*(){}[]'\";\\|?<>~`", *tmps))
1581 if (*tmps && PerlLIO_lstat(SvPVX(sv), &PL_statbuf) < 0) {
1582 (void)POPs; /* Unmatched wildcard? Chuck it... */
1586 if (gimme == G_ARRAY) {
1587 if (SvLEN(sv) - SvCUR(sv) > 20) {
1588 SvLEN_set(sv, SvCUR(sv)+1);
1589 Renew(SvPVX(sv), SvLEN(sv), char);
1591 sv = sv_2mortal(NEWSV(58, 80));
1594 else if (gimme == G_SCALAR && !tmplen && SvLEN(sv) - SvCUR(sv) > 80) {
1595 /* try to reclaim a bit of scalar space (only on 1st alloc) */
1599 SvLEN_set(sv, SvCUR(sv)+40); /* allow some slop */
1600 Renew(SvPVX(sv), SvLEN(sv), char);
1609 register PERL_CONTEXT *cx;
1610 I32 gimme = OP_GIMME(PL_op, -1);
1613 if (cxstack_ix >= 0)
1614 gimme = cxstack[cxstack_ix].blk_gimme;
1622 PUSHBLOCK(cx, CXt_BLOCK, SP);
1634 U32 lval = PL_op->op_flags & OPf_MOD || LVRET;
1635 U32 defer = PL_op->op_private & OPpLVAL_DEFER;
1637 #ifdef PERL_COPY_ON_WRITE
1638 U32 hash = (SvIsCOW_shared_hash(keysv)) ? SvUVX(keysv) : 0;
1640 U32 hash = (SvFAKE(keysv) && SvREADONLY(keysv)) ? SvUVX(keysv) : 0;
1644 if (SvTYPE(hv) == SVt_PVHV) {
1645 if (PL_op->op_private & OPpLVAL_INTRO) {
1648 /* does the element we're localizing already exist? */
1650 /* can we determine whether it exists? */
1652 || mg_find((SV*)hv, PERL_MAGIC_env)
1653 || ( (mg = mg_find((SV*)hv, PERL_MAGIC_tied))
1654 /* Try to preserve the existenceness of a tied hash
1655 * element by using EXISTS and DELETE if possible.
1656 * Fallback to FETCH and STORE otherwise */
1657 && (stash = SvSTASH(SvRV(SvTIED_obj((SV*)hv, mg))))
1658 && gv_fetchmethod_autoload(stash, "EXISTS", TRUE)
1659 && gv_fetchmethod_autoload(stash, "DELETE", TRUE)
1661 ) ? hv_exists_ent(hv, keysv, 0) : 1;
1664 he = hv_fetch_ent(hv, keysv, lval && !defer, hash);
1665 svp = he ? &HeVAL(he) : 0;
1671 if (!svp || *svp == &PL_sv_undef) {
1676 DIE(aTHX_ PL_no_helem, SvPV(keysv, n_a));
1678 lv = sv_newmortal();
1679 sv_upgrade(lv, SVt_PVLV);
1681 sv_magic(lv, key2 = newSVsv(keysv), PERL_MAGIC_defelem, Nullch, 0);
1682 SvREFCNT_dec(key2); /* sv_magic() increments refcount */
1683 LvTARG(lv) = SvREFCNT_inc(hv);
1688 if (PL_op->op_private & OPpLVAL_INTRO) {
1689 if (HvNAME(hv) && isGV(*svp))
1690 save_gp((GV*)*svp, !(PL_op->op_flags & OPf_SPECIAL));
1694 char *key = SvPV(keysv, keylen);
1695 SAVEDELETE(hv, savepvn(key,keylen), keylen);
1697 save_helem(hv, keysv, svp);
1700 else if (PL_op->op_private & OPpDEREF)
1701 vivify_ref(*svp, PL_op->op_private & OPpDEREF);
1703 sv = (svp ? *svp : &PL_sv_undef);
1704 /* This makes C<local $tied{foo} = $tied{foo}> possible.
1705 * Pushing the magical RHS on to the stack is useless, since
1706 * that magic is soon destined to be misled by the local(),
1707 * and thus the later pp_sassign() will fail to mg_get() the
1708 * old value. This should also cure problems with delayed
1709 * mg_get()s. GSAR 98-07-03 */
1710 if (!lval && SvGMAGICAL(sv))
1711 sv = sv_mortalcopy(sv);
1719 register PERL_CONTEXT *cx;
1725 if (PL_op->op_flags & OPf_SPECIAL) {
1726 cx = &cxstack[cxstack_ix];
1727 cx->blk_oldpm = PL_curpm; /* fake block should preserve $1 et al */
1732 gimme = OP_GIMME(PL_op, -1);
1734 if (cxstack_ix >= 0)
1735 gimme = cxstack[cxstack_ix].blk_gimme;
1741 if (gimme == G_VOID)
1743 else if (gimme == G_SCALAR) {
1746 if (SvFLAGS(TOPs) & (SVs_PADTMP|SVs_TEMP))
1749 *MARK = sv_mortalcopy(TOPs);
1752 *MARK = &PL_sv_undef;
1756 else if (gimme == G_ARRAY) {
1757 /* in case LEAVE wipes old return values */
1758 for (mark = newsp + 1; mark <= SP; mark++) {
1759 if (!(SvFLAGS(*mark) & (SVs_PADTMP|SVs_TEMP))) {
1760 *mark = sv_mortalcopy(*mark);
1761 TAINT_NOT; /* Each item is independent */
1765 PL_curpm = newpm; /* Don't pop $1 et al till now */
1775 register PERL_CONTEXT *cx;
1781 cx = &cxstack[cxstack_ix];
1782 if (CxTYPE(cx) != CXt_LOOP)
1783 DIE(aTHX_ "panic: pp_iter");
1785 itersvp = CxITERVAR(cx);
1786 av = cx->blk_loop.iterary;
1787 if (SvTYPE(av) != SVt_PVAV) {
1788 /* iterate ($min .. $max) */
1789 if (cx->blk_loop.iterlval) {
1790 /* string increment */
1791 register SV* cur = cx->blk_loop.iterlval;
1793 char *max = SvPV((SV*)av, maxlen);
1794 if (!SvNIOK(cur) && SvCUR(cur) <= maxlen) {
1795 if (SvREFCNT(*itersvp) == 1 && !SvMAGICAL(*itersvp)) {
1796 /* safe to reuse old SV */
1797 sv_setsv(*itersvp, cur);
1801 /* we need a fresh SV every time so that loop body sees a
1802 * completely new SV for closures/references to work as
1804 SvREFCNT_dec(*itersvp);
1805 *itersvp = newSVsv(cur);
1807 if (strEQ(SvPVX(cur), max))
1808 sv_setiv(cur, 0); /* terminate next time */
1815 /* integer increment */
1816 if (cx->blk_loop.iterix > cx->blk_loop.itermax)
1819 /* don't risk potential race */
1820 if (SvREFCNT(*itersvp) == 1 && !SvMAGICAL(*itersvp)) {
1821 /* safe to reuse old SV */
1822 sv_setiv(*itersvp, cx->blk_loop.iterix++);
1826 /* we need a fresh SV every time so that loop body sees a
1827 * completely new SV for closures/references to work as they
1829 SvREFCNT_dec(*itersvp);
1830 *itersvp = newSViv(cx->blk_loop.iterix++);
1836 if (cx->blk_loop.iterix >= (av == PL_curstack ? cx->blk_oldsp : AvFILL(av)))
1839 SvREFCNT_dec(*itersvp);
1841 if (SvMAGICAL(av) || AvREIFY(av)) {
1842 SV **svp = av_fetch(av, ++cx->blk_loop.iterix, FALSE);
1849 sv = AvARRAY(av)[++cx->blk_loop.iterix];
1855 if (av != PL_curstack && sv == &PL_sv_undef) {
1856 SV *lv = cx->blk_loop.iterlval;
1857 if (lv && SvREFCNT(lv) > 1) {
1862 SvREFCNT_dec(LvTARG(lv));
1864 lv = cx->blk_loop.iterlval = NEWSV(26, 0);
1865 sv_upgrade(lv, SVt_PVLV);
1867 sv_magic(lv, Nullsv, PERL_MAGIC_defelem, Nullch, 0);
1869 LvTARG(lv) = SvREFCNT_inc(av);
1870 LvTARGOFF(lv) = cx->blk_loop.iterix;
1871 LvTARGLEN(lv) = (STRLEN)UV_MAX;
1875 *itersvp = SvREFCNT_inc(sv);
1882 register PMOP *pm = cPMOP;
1898 register REGEXP *rx = PM_GETRE(pm);
1900 int force_on_match = 0;
1901 I32 oldsave = PL_savestack_ix;
1903 bool doutf8 = FALSE;
1904 #ifdef PERL_COPY_ON_WRITE
1909 /* known replacement string? */
1910 dstr = (pm->op_pmflags & PMf_CONST) ? POPs : Nullsv;
1911 if (PL_op->op_flags & OPf_STACKED)
1918 #ifdef PERL_COPY_ON_WRITE
1919 /* Awooga. Awooga. "bool" types that are actually char are dangerous,
1920 because they make integers such as 256 "false". */
1921 is_cow = SvIsCOW(TARG) ? TRUE : FALSE;
1924 sv_force_normal_flags(TARG,0);
1927 #ifdef PERL_COPY_ON_WRITE
1931 || (SvTYPE(TARG) > SVt_PVLV
1932 && !(SvTYPE(TARG) == SVt_PVGV && SvFAKE(TARG)))))
1933 DIE(aTHX_ PL_no_modify);
1936 s = SvPV(TARG, len);
1937 if (!SvPOKp(TARG) || SvTYPE(TARG) == SVt_PVGV)
1939 rxtainted = ((pm->op_pmdynflags & PMdf_TAINTED) ||
1940 (PL_tainted && (pm->op_pmflags & PMf_RETAINT)));
1945 RX_MATCH_UTF8_set(rx, DO_UTF8(TARG));
1949 DIE(aTHX_ "panic: pp_subst");
1952 slen = RX_MATCH_UTF8(rx) ? utf8_length((U8*)s, (U8*)strend) : len;
1953 maxiters = 2 * slen + 10; /* We can match twice at each
1954 position, once with zero-length,
1955 second time with non-zero. */
1957 if (!rx->prelen && PL_curpm) {
1961 r_flags = (rx->nparens || SvTEMP(TARG) || PL_sawampersand)
1962 ? REXEC_COPY_STR : 0;
1964 r_flags |= REXEC_SCREAM;
1965 if (pm->op_pmflags & (PMf_MULTILINE|PMf_SINGLELINE)) {
1966 SAVEINT(PL_multiline);
1967 PL_multiline = pm->op_pmflags & PMf_MULTILINE;
1970 if (rx->reganch & RE_USE_INTUIT) {
1972 s = CALLREG_INTUIT_START(aTHX_ rx, TARG, s, strend, r_flags, NULL);
1976 /* How to do it in subst? */
1977 /* if ( (rx->reganch & ROPT_CHECK_ALL)
1979 && ((rx->reganch & ROPT_NOSCAN)
1980 || !((rx->reganch & RE_INTUIT_TAIL)
1981 && (r_flags & REXEC_SCREAM))))
1986 /* only replace once? */
1987 once = !(rpm->op_pmflags & PMf_GLOBAL);
1989 /* known replacement string? */
1991 /* replacement needing upgrading? */
1992 if (DO_UTF8(TARG) && !doutf8) {
1993 nsv = sv_newmortal();
1996 sv_recode_to_utf8(nsv, PL_encoding);
1998 sv_utf8_upgrade(nsv);
1999 c = SvPV(nsv, clen);
2003 c = SvPV(dstr, clen);
2004 doutf8 = DO_UTF8(dstr);
2012 /* can do inplace substitution? */
2014 #ifdef PERL_COPY_ON_WRITE
2017 && (I32)clen <= rx->minlen && (once || !(r_flags & REXEC_COPY_STR))
2018 && !(rx->reganch & ROPT_LOOKBEHIND_SEEN)
2019 && (!doutf8 || SvUTF8(TARG))) {
2020 if (!CALLREGEXEC(aTHX_ rx, s, strend, orig, 0, TARG, NULL,
2021 r_flags | REXEC_CHECKED))
2025 LEAVE_SCOPE(oldsave);
2028 #ifdef PERL_COPY_ON_WRITE
2029 if (SvIsCOW(TARG)) {
2030 assert (!force_on_match);
2034 if (force_on_match) {
2036 s = SvPV_force(TARG, len);
2041 SvSCREAM_off(TARG); /* disable possible screamer */
2043 rxtainted |= RX_MATCH_TAINTED(rx);
2044 m = orig + rx->startp[0];
2045 d = orig + rx->endp[0];
2047 if (m - s > strend - d) { /* faster to shorten from end */
2049 Copy(c, m, clen, char);
2054 Move(d, m, i, char);
2058 SvCUR_set(TARG, m - s);
2061 else if ((i = m - s)) { /* faster from front */
2069 Copy(c, m, clen, char);
2074 Copy(c, d, clen, char);
2079 TAINT_IF(rxtainted & 1);
2085 if (iters++ > maxiters)
2086 DIE(aTHX_ "Substitution loop");
2087 rxtainted |= RX_MATCH_TAINTED(rx);
2088 m = rx->startp[0] + orig;
2092 Move(s, d, i, char);
2096 Copy(c, d, clen, char);
2099 s = rx->endp[0] + orig;
2100 } while (CALLREGEXEC(aTHX_ rx, s, strend, orig, s == m,
2102 /* don't match same null twice */
2103 REXEC_NOT_FIRST|REXEC_IGNOREPOS));
2106 SvCUR_set(TARG, d - SvPVX(TARG) + i);
2107 Move(s, d, i+1, char); /* include the NUL */
2109 TAINT_IF(rxtainted & 1);
2111 PUSHs(sv_2mortal(newSViv((I32)iters)));
2113 (void)SvPOK_only_UTF8(TARG);
2114 TAINT_IF(rxtainted);
2115 if (SvSMAGICAL(TARG)) {
2123 LEAVE_SCOPE(oldsave);
2127 if (CALLREGEXEC(aTHX_ rx, s, strend, orig, 0, TARG, NULL,
2128 r_flags | REXEC_CHECKED))
2130 if (force_on_match) {
2132 s = SvPV_force(TARG, len);
2135 #ifdef PERL_COPY_ON_WRITE
2138 rxtainted |= RX_MATCH_TAINTED(rx);
2139 dstr = NEWSV(25, len);
2140 sv_setpvn(dstr, m, s-m);
2145 register PERL_CONTEXT *cx;
2148 RETURNOP(cPMOP->op_pmreplroot);
2150 r_flags |= REXEC_IGNOREPOS | REXEC_NOT_FIRST;
2152 if (iters++ > maxiters)
2153 DIE(aTHX_ "Substitution loop");
2154 rxtainted |= RX_MATCH_TAINTED(rx);
2155 if (RX_MATCH_COPIED(rx) && rx->subbeg != orig) {
2160 strend = s + (strend - m);
2162 m = rx->startp[0] + orig;
2163 if (doutf8 && !SvUTF8(dstr))
2164 sv_catpvn_utf8_upgrade(dstr, s, m - s, nsv);
2166 sv_catpvn(dstr, s, m-s);
2167 s = rx->endp[0] + orig;
2169 sv_catpvn(dstr, c, clen);
2172 } while (CALLREGEXEC(aTHX_ rx, s, strend, orig, s == m,
2173 TARG, NULL, r_flags));
2174 if (doutf8 && !DO_UTF8(TARG))
2175 sv_catpvn_utf8_upgrade(dstr, s, strend - s, nsv);
2177 sv_catpvn(dstr, s, strend - s);
2179 #ifdef PERL_COPY_ON_WRITE
2180 /* The match may make the string COW. If so, brilliant, because that's
2181 just saved us one malloc, copy and free - the regexp has donated
2182 the old buffer, and we malloc an entirely new one, rather than the
2183 regexp malloc()ing a buffer and copying our original, only for
2184 us to throw it away here during the substitution. */
2185 if (SvIsCOW(TARG)) {
2186 sv_force_normal_flags(TARG, SV_COW_DROP_PV);
2190 (void)SvOOK_off(TARG);
2192 Safefree(SvPVX(TARG));
2194 SvPVX(TARG) = SvPVX(dstr);
2195 SvCUR_set(TARG, SvCUR(dstr));
2196 SvLEN_set(TARG, SvLEN(dstr));
2197 doutf8 |= DO_UTF8(dstr);
2201 TAINT_IF(rxtainted & 1);
2203 PUSHs(sv_2mortal(newSViv((I32)iters)));
2205 (void)SvPOK_only(TARG);
2208 TAINT_IF(rxtainted);
2211 LEAVE_SCOPE(oldsave);
2220 LEAVE_SCOPE(oldsave);
2229 PL_stack_base[PL_markstack_ptr[-1]++] = PL_stack_base[*PL_markstack_ptr];
2230 ++*PL_markstack_ptr;
2231 LEAVE; /* exit inner scope */
2234 if (PL_stack_base + *PL_markstack_ptr > SP) {
2236 I32 gimme = GIMME_V;
2238 LEAVE; /* exit outer scope */
2239 (void)POPMARK; /* pop src */
2240 items = --*PL_markstack_ptr - PL_markstack_ptr[-1];
2241 (void)POPMARK; /* pop dst */
2242 SP = PL_stack_base + POPMARK; /* pop original mark */
2243 if (gimme == G_SCALAR) {
2247 else if (gimme == G_ARRAY)
2254 ENTER; /* enter inner scope */
2257 src = PL_stack_base[*PL_markstack_ptr];
2261 RETURNOP(cLOGOP->op_other);
2272 register PERL_CONTEXT *cx;
2278 if (gimme == G_SCALAR) {
2281 if (cx->blk_sub.cv && CvDEPTH(cx->blk_sub.cv) > 1) {
2283 *MARK = SvREFCNT_inc(TOPs);
2288 sv = SvREFCNT_inc(TOPs); /* FREETMPS could clobber it */
2290 *MARK = sv_mortalcopy(sv);
2295 *MARK = SvTEMP(TOPs) ? TOPs : sv_mortalcopy(TOPs);
2299 *MARK = &PL_sv_undef;
2303 else if (gimme == G_ARRAY) {
2304 for (MARK = newsp + 1; MARK <= SP; MARK++) {
2305 if (!SvTEMP(*MARK)) {
2306 *MARK = sv_mortalcopy(*MARK);
2307 TAINT_NOT; /* Each item is independent */
2313 POPSUB(cx,sv); /* Stack values are safe: release CV and @_ ... */
2314 PL_curpm = newpm; /* ... and pop $1 et al */
2318 return pop_return();
2321 /* This duplicates the above code because the above code must not
2322 * get any slower by more conditions */
2330 register PERL_CONTEXT *cx;
2337 if (cx->blk_sub.lval & OPpENTERSUB_INARGS) {
2338 /* We are an argument to a function or grep().
2339 * This kind of lvalueness was legal before lvalue
2340 * subroutines too, so be backward compatible:
2341 * cannot report errors. */
2343 /* Scalar context *is* possible, on the LHS of -> only,
2344 * as in f()->meth(). But this is not an lvalue. */
2345 if (gimme == G_SCALAR)
2347 if (gimme == G_ARRAY) {
2348 if (!CvLVALUE(cx->blk_sub.cv))
2349 goto temporise_array;
2350 EXTEND_MORTAL(SP - newsp);
2351 for (mark = newsp + 1; mark <= SP; mark++) {
2354 else if (SvFLAGS(*mark) & (SVs_PADTMP | SVf_READONLY))
2355 *mark = sv_mortalcopy(*mark);
2357 /* Can be a localized value subject to deletion. */
2358 PL_tmps_stack[++PL_tmps_ix] = *mark;
2359 (void)SvREFCNT_inc(*mark);
2364 else if (cx->blk_sub.lval) { /* Leave it as it is if we can. */
2365 /* Here we go for robustness, not for speed, so we change all
2366 * the refcounts so the caller gets a live guy. Cannot set
2367 * TEMP, so sv_2mortal is out of question. */
2368 if (!CvLVALUE(cx->blk_sub.cv)) {
2373 DIE(aTHX_ "Can't modify non-lvalue subroutine call");
2375 if (gimme == G_SCALAR) {
2379 if (SvFLAGS(TOPs) & (SVs_TEMP | SVs_PADTMP | SVf_READONLY)) {
2384 DIE(aTHX_ "Can't return %s from lvalue subroutine",
2385 SvREADONLY(TOPs) ? (TOPs == &PL_sv_undef) ? "undef"
2386 : "a readonly value" : "a temporary");
2388 else { /* Can be a localized value
2389 * subject to deletion. */
2390 PL_tmps_stack[++PL_tmps_ix] = *mark;
2391 (void)SvREFCNT_inc(*mark);
2394 else { /* Should not happen? */
2399 DIE(aTHX_ "%s returned from lvalue subroutine in scalar context",
2400 (MARK > SP ? "Empty array" : "Array"));
2404 else if (gimme == G_ARRAY) {
2405 EXTEND_MORTAL(SP - newsp);
2406 for (mark = newsp + 1; mark <= SP; mark++) {
2407 if (*mark != &PL_sv_undef
2408 && SvFLAGS(*mark) & (SVs_TEMP | SVs_PADTMP | SVf_READONLY)) {
2409 /* Might be flattened array after $#array = */
2415 DIE(aTHX_ "Can't return a %s from lvalue subroutine",
2416 SvREADONLY(TOPs) ? "readonly value" : "temporary");
2419 /* Can be a localized value subject to deletion. */
2420 PL_tmps_stack[++PL_tmps_ix] = *mark;
2421 (void)SvREFCNT_inc(*mark);
2427 if (gimme == G_SCALAR) {
2431 if (cx->blk_sub.cv && CvDEPTH(cx->blk_sub.cv) > 1) {
2433 *MARK = SvREFCNT_inc(TOPs);
2438 sv = SvREFCNT_inc(TOPs); /* FREETMPS could clobber it */
2440 *MARK = sv_mortalcopy(sv);
2445 *MARK = SvTEMP(TOPs) ? TOPs : sv_mortalcopy(TOPs);
2449 *MARK = &PL_sv_undef;
2453 else if (gimme == G_ARRAY) {
2455 for (MARK = newsp + 1; MARK <= SP; MARK++) {
2456 if (!SvTEMP(*MARK)) {
2457 *MARK = sv_mortalcopy(*MARK);
2458 TAINT_NOT; /* Each item is independent */
2465 POPSUB(cx,sv); /* Stack values are safe: release CV and @_ ... */
2466 PL_curpm = newpm; /* ... and pop $1 et al */
2470 return pop_return();
2475 S_get_db_sub(pTHX_ SV **svp, CV *cv)
2477 SV *dbsv = GvSV(PL_DBsub);
2479 if (!PERLDB_SUB_NN) {
2483 if ( (CvFLAGS(cv) & (CVf_ANON | CVf_CLONED))
2484 || strEQ(GvNAME(gv), "END")
2485 || ((GvCV(gv) != cv) && /* Could be imported, and old sub redefined. */
2486 !( (SvTYPE(*svp) == SVt_PVGV) && (GvCV((GV*)*svp) == cv)
2487 && (gv = (GV*)*svp) ))) {
2488 /* Use GV from the stack as a fallback. */
2489 /* GV is potentially non-unique, or contain different CV. */
2490 SV *tmp = newRV((SV*)cv);
2491 sv_setsv(dbsv, tmp);
2495 gv_efullname3(dbsv, gv, Nullch);
2499 (void)SvUPGRADE(dbsv, SVt_PVIV);
2500 (void)SvIOK_on(dbsv);
2501 SAVEIV(SvIVX(dbsv));
2502 SvIVX(dbsv) = PTR2IV(cv); /* Do it the quickest way */
2506 PL_curcopdb = PL_curcop;
2507 cv = GvCV(PL_DBsub);
2517 register PERL_CONTEXT *cx;
2519 bool hasargs = (PL_op->op_flags & OPf_STACKED) != 0;
2522 DIE(aTHX_ "Not a CODE reference");
2523 switch (SvTYPE(sv)) {
2524 /* This is overwhelming the most common case: */
2526 if (!(cv = GvCVu((GV*)sv)))
2527 cv = sv_2cv(sv, &stash, &gv, FALSE);
2539 if (sv == &PL_sv_yes) { /* unfound import, ignore */
2541 SP = PL_stack_base + POPMARK;
2544 if (SvGMAGICAL(sv)) {
2548 sym = SvPOKp(sv) ? SvPVX(sv) : Nullch;
2551 sym = SvPV(sv, n_a);
2553 DIE(aTHX_ PL_no_usym, "a subroutine");
2554 if (PL_op->op_private & HINT_STRICT_REFS)
2555 DIE(aTHX_ PL_no_symref, sym, "a subroutine");
2556 cv = get_cv(sym, TRUE);
2561 SV **sp = &sv; /* Used in tryAMAGICunDEREF macro. */
2562 tryAMAGICunDEREF(to_cv);
2565 if (SvTYPE(cv) == SVt_PVCV)
2570 DIE(aTHX_ "Not a CODE reference");
2571 /* This is the second most common case: */
2581 if (!CvROOT(cv) && !CvXSUB(cv)) {
2586 if ((PL_op->op_private & OPpENTERSUB_DB) && GvCV(PL_DBsub) && !CvNODEBUG(cv)) {
2587 if (CvASSERTION(cv) && PL_DBassertion)
2588 sv_setiv(PL_DBassertion, 1);
2590 cv = get_db_sub(&sv, cv);
2592 DIE(aTHX_ "No DBsub routine");
2595 if (!(CvXSUB(cv))) {
2596 /* This path taken at least 75% of the time */
2598 register I32 items = SP - MARK;
2599 AV* padlist = CvPADLIST(cv);
2600 push_return(PL_op->op_next);
2601 PUSHBLOCK(cx, CXt_SUB, MARK);
2604 /* XXX This would be a natural place to set C<PL_compcv = cv> so
2605 * that eval'' ops within this sub know the correct lexical space.
2606 * Owing the speed considerations, we choose instead to search for
2607 * the cv using find_runcv() when calling doeval().
2609 if (CvDEPTH(cv) < 2)
2610 (void)SvREFCNT_inc(cv);
2612 PERL_STACK_OVERFLOW_CHECK();
2613 pad_push(padlist, CvDEPTH(cv), 1);
2615 PAD_SET_CUR(padlist, CvDEPTH(cv));
2622 DEBUG_S(PerlIO_printf(Perl_debug_log,
2623 "%p entersub preparing @_\n", thr));
2625 av = (AV*)PAD_SVl(0);
2627 /* @_ is normally not REAL--this should only ever
2628 * happen when DB::sub() calls things that modify @_ */
2633 cx->blk_sub.savearray = GvAV(PL_defgv);
2634 GvAV(PL_defgv) = (AV*)SvREFCNT_inc(av);
2635 CX_CURPAD_SAVE(cx->blk_sub);
2636 cx->blk_sub.argarray = av;
2639 if (items > AvMAX(av) + 1) {
2641 if (AvARRAY(av) != ary) {
2642 AvMAX(av) += AvARRAY(av) - AvALLOC(av);
2643 SvPVX(av) = (char*)ary;
2645 if (items > AvMAX(av) + 1) {
2646 AvMAX(av) = items - 1;
2647 Renew(ary,items,SV*);
2649 SvPVX(av) = (char*)ary;
2652 Copy(MARK,AvARRAY(av),items,SV*);
2653 AvFILLp(av) = items - 1;
2661 /* warning must come *after* we fully set up the context
2662 * stuff so that __WARN__ handlers can safely dounwind()
2665 if (CvDEPTH(cv) == 100 && ckWARN(WARN_RECURSION)
2666 && !(PERLDB_SUB && cv == GvCV(PL_DBsub)))
2667 sub_crush_depth(cv);
2669 DEBUG_S(PerlIO_printf(Perl_debug_log,
2670 "%p entersub returning %p\n", thr, CvSTART(cv)));
2672 RETURNOP(CvSTART(cv));
2675 #ifdef PERL_XSUB_OLDSTYLE
2676 if (CvOLDSTYLE(cv)) {
2677 I32 (*fp3)(int,int,int);
2679 register I32 items = SP - MARK;
2680 /* We dont worry to copy from @_. */
2685 PL_stack_sp = mark + 1;
2686 fp3 = (I32(*)(int,int,int))CvXSUB(cv);
2687 items = (*fp3)(CvXSUBANY(cv).any_i32,
2688 MARK - PL_stack_base + 1,
2690 PL_stack_sp = PL_stack_base + items;
2693 #endif /* PERL_XSUB_OLDSTYLE */
2695 I32 markix = TOPMARK;
2700 /* Need to copy @_ to stack. Alternative may be to
2701 * switch stack to @_, and copy return values
2702 * back. This would allow popping @_ in XSUB, e.g.. XXXX */
2705 av = GvAV(PL_defgv);
2706 items = AvFILLp(av) + 1; /* @_ is not tieable */
2709 /* Mark is at the end of the stack. */
2711 Copy(AvARRAY(av), SP + 1, items, SV*);
2716 /* We assume first XSUB in &DB::sub is the called one. */
2718 SAVEVPTR(PL_curcop);
2719 PL_curcop = PL_curcopdb;
2722 /* Do we need to open block here? XXXX */
2723 (void)(*CvXSUB(cv))(aTHX_ cv);
2725 /* Enforce some sanity in scalar context. */
2726 if (gimme == G_SCALAR && ++markix != PL_stack_sp - PL_stack_base ) {
2727 if (markix > PL_stack_sp - PL_stack_base)
2728 *(PL_stack_base + markix) = &PL_sv_undef;
2730 *(PL_stack_base + markix) = *PL_stack_sp;
2731 PL_stack_sp = PL_stack_base + markix;
2738 assert (0); /* Cannot get here. */
2739 /* This is deliberately moved here as spaghetti code to keep it out of the
2746 /* anonymous or undef'd function leaves us no recourse */
2747 if (CvANON(cv) || !(gv = CvGV(cv)))
2748 DIE(aTHX_ "Undefined subroutine called");
2750 /* autoloaded stub? */
2751 if (cv != GvCV(gv)) {
2754 /* should call AUTOLOAD now? */
2757 if ((autogv = gv_autoload4(GvSTASH(gv), GvNAME(gv), GvNAMELEN(gv),
2764 sub_name = sv_newmortal();
2765 gv_efullname3(sub_name, gv, Nullch);
2766 DIE(aTHX_ "Undefined subroutine &%"SVf" called", sub_name);
2770 DIE(aTHX_ "Not a CODE reference");
2776 Perl_sub_crush_depth(pTHX_ CV *cv)
2779 Perl_warner(aTHX_ packWARN(WARN_RECURSION), "Deep recursion on anonymous subroutine");
2781 SV* tmpstr = sv_newmortal();
2782 gv_efullname3(tmpstr, CvGV(cv), Nullch);
2783 Perl_warner(aTHX_ packWARN(WARN_RECURSION), "Deep recursion on subroutine \"%"SVf"\"",
2793 IV elem = SvIV(elemsv);
2795 U32 lval = PL_op->op_flags & OPf_MOD || LVRET;
2796 U32 defer = (PL_op->op_private & OPpLVAL_DEFER) && (elem > AvFILL(av));
2799 if (SvROK(elemsv) && !SvGAMAGIC(elemsv) && ckWARN(WARN_MISC))
2800 Perl_warner(aTHX_ packWARN(WARN_MISC), "Use of reference \"%"SVf"\" as array index", elemsv);
2802 elem -= PL_curcop->cop_arybase;
2803 if (SvTYPE(av) != SVt_PVAV)
2805 svp = av_fetch(av, elem, lval && !defer);
2807 if (!svp || *svp == &PL_sv_undef) {
2810 DIE(aTHX_ PL_no_aelem, elem);
2811 lv = sv_newmortal();
2812 sv_upgrade(lv, SVt_PVLV);
2814 sv_magic(lv, Nullsv, PERL_MAGIC_defelem, Nullch, 0);
2815 LvTARG(lv) = SvREFCNT_inc(av);
2816 LvTARGOFF(lv) = elem;
2821 if (PL_op->op_private & OPpLVAL_INTRO)
2822 save_aelem(av, elem, svp);
2823 else if (PL_op->op_private & OPpDEREF)
2824 vivify_ref(*svp, PL_op->op_private & OPpDEREF);
2826 sv = (svp ? *svp : &PL_sv_undef);
2827 if (!lval && SvGMAGICAL(sv)) /* see note in pp_helem() */
2828 sv = sv_mortalcopy(sv);
2834 Perl_vivify_ref(pTHX_ SV *sv, U32 to_what)
2840 Perl_croak(aTHX_ PL_no_modify);
2841 if (SvTYPE(sv) < SVt_RV)
2842 sv_upgrade(sv, SVt_RV);
2843 else if (SvTYPE(sv) >= SVt_PV) {
2844 (void)SvOOK_off(sv);
2845 Safefree(SvPVX(sv));
2846 SvLEN(sv) = SvCUR(sv) = 0;
2850 SvRV(sv) = NEWSV(355,0);
2853 SvRV(sv) = (SV*)newAV();
2856 SvRV(sv) = (SV*)newHV();
2871 if (SvTYPE(rsv) == SVt_PVCV) {
2877 SETs(method_common(sv, Null(U32*)));
2885 U32 hash = SvUVX(sv);
2887 XPUSHs(method_common(sv, &hash));
2892 S_method_common(pTHX_ SV* meth, U32* hashp)
2901 SV *packsv = Nullsv;
2904 name = SvPV(meth, namelen);
2905 sv = *(PL_stack_base + TOPMARK + 1);
2908 Perl_croak(aTHX_ "Can't call method \"%s\" on an undefined value", name);
2917 /* this isn't a reference */
2920 !(packname = SvPV(sv, packlen)) ||
2921 !(iogv = gv_fetchpv(packname, FALSE, SVt_PVIO)) ||
2922 !(ob=(SV*)GvIO(iogv)))
2924 /* this isn't the name of a filehandle either */
2926 ((UTF8_IS_START(*packname) && DO_UTF8(sv))
2927 ? !isIDFIRST_utf8((U8*)packname)
2928 : !isIDFIRST(*packname)
2931 Perl_croak(aTHX_ "Can't call method \"%s\" %s", name,
2932 SvOK(sv) ? "without a package or object reference"
2933 : "on an undefined value");
2935 /* assume it's a package name */
2936 stash = gv_stashpvn(packname, packlen, FALSE);
2941 /* it _is_ a filehandle name -- replace with a reference */
2942 *(PL_stack_base + TOPMARK + 1) = sv_2mortal(newRV((SV*)iogv));
2945 /* if we got here, ob should be a reference or a glob */
2946 if (!ob || !(SvOBJECT(ob)
2947 || (SvTYPE(ob) == SVt_PVGV && (ob = (SV*)GvIO((GV*)ob))
2950 Perl_croak(aTHX_ "Can't call method \"%s\" on unblessed reference",
2954 stash = SvSTASH(ob);
2957 /* NOTE: stash may be null, hope hv_fetch_ent and
2958 gv_fetchmethod can cope (it seems they can) */
2960 /* shortcut for simple names */
2962 HE* he = hv_fetch_ent(stash, meth, 0, *hashp);
2964 gv = (GV*)HeVAL(he);
2965 if (isGV(gv) && GvCV(gv) &&
2966 (!GvCVGEN(gv) || GvCVGEN(gv) == PL_sub_generation))
2967 return (SV*)GvCV(gv);
2971 gv = gv_fetchmethod(stash ? stash : (HV*)packsv, name);
2974 /* This code tries to figure out just what went wrong with
2975 gv_fetchmethod. It therefore needs to duplicate a lot of
2976 the internals of that function. We can't move it inside
2977 Perl_gv_fetchmethod_autoload(), however, since that would
2978 cause UNIVERSAL->can("NoSuchPackage::foo") to croak, and we
2985 for (p = name; *p; p++) {
2987 sep = p, leaf = p + 1;
2988 else if (*p == ':' && *(p + 1) == ':')
2989 sep = p, leaf = p + 2;
2991 if (!sep || ((sep - name) == 5 && strnEQ(name, "SUPER", 5))) {
2992 /* the method name is unqualified or starts with SUPER:: */
2993 packname = sep ? CopSTASHPV(PL_curcop) :
2994 stash ? HvNAME(stash) : packname;
2995 packlen = strlen(packname);
2998 /* the method name is qualified */
3000 packlen = sep - name;
3003 /* we're relying on gv_fetchmethod not autovivifying the stash */
3004 if (gv_stashpvn(packname, packlen, FALSE)) {
3006 "Can't locate object method \"%s\" via package \"%.*s\"",
3007 leaf, (int)packlen, packname);
3011 "Can't locate object method \"%s\" via package \"%.*s\""
3012 " (perhaps you forgot to load \"%.*s\"?)",
3013 leaf, (int)packlen, packname, (int)packlen, packname);
3016 return isGV(gv) ? (SV*)GvCV(gv) : (SV*)gv;