3 * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4 * 2000, 2001, 2002, 2003, 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!
20 #define PERL_IN_PP_HOT_C
34 PL_curcop = (COP*)PL_op;
35 TAINT_NOT; /* Each statement is presumed innocent */
36 PL_stack_sp = PL_stack_base + cxstack[cxstack_ix].blk_oldsp;
45 if (PL_op->op_private & OPpLVAL_INTRO)
46 PUSHs(save_scalar(cGVOP_gv));
48 PUSHs(GvSV(cGVOP_gv));
59 PL_curcop = (COP*)PL_op;
65 PUSHMARK(PL_stack_sp);
80 XPUSHs((SV*)cGVOP_gv);
91 RETURNOP(cLOGOP->op_other);
99 if (PL_op->op_private & OPpASSIGN_BACKWARDS) {
101 temp = left; left = right; right = temp;
103 if (PL_tainting && PL_tainted && !SvTAINTED(left))
105 SvSetMagicSV(right, left);
114 RETURNOP(cLOGOP->op_other);
116 RETURNOP(cLOGOP->op_next);
122 TAINT_NOT; /* Each statement is presumed innocent */
123 PL_stack_sp = PL_stack_base + cxstack[cxstack_ix].blk_oldsp;
125 oldsave = PL_scopestack[PL_scopestack_ix - 1];
126 LEAVE_SCOPE(oldsave);
132 dSP; dATARGET; tryAMAGICbin(concat,opASSIGN);
139 char* rpv = SvPV(right, rlen); /* mg_get(right) happens here */
140 bool rbyte = !SvUTF8(right), rcopied = FALSE;
142 if (TARG == right && right != left) {
143 right = sv_2mortal(newSVpvn(rpv, rlen));
144 rpv = SvPV(right, rlen); /* no point setting UTF-8 here */
149 lpv = SvPV(left, llen); /* mg_get(left) may happen here */
150 lbyte = !SvUTF8(left);
151 sv_setpvn(TARG, lpv, llen);
157 else { /* TARG == left */
158 if (SvGMAGICAL(left))
159 mg_get(left); /* or mg_get(left) may happen here */
162 lpv = SvPV_nomg(left, llen);
163 lbyte = !SvUTF8(left);
166 #if defined(PERL_Y2KWARN)
167 if ((SvIOK(right) || SvNOK(right)) && ckWARN(WARN_Y2K) && SvOK(TARG)) {
168 if (llen >= 2 && lpv[llen - 2] == '1' && lpv[llen - 1] == '9'
169 && (llen == 2 || !isDIGIT(lpv[llen - 3])))
171 Perl_warner(aTHX_ packWARN(WARN_Y2K), "Possible Y2K bug: %s",
172 "about to append an integer to '19'");
177 if (lbyte != rbyte) {
179 sv_utf8_upgrade_nomg(TARG);
182 right = sv_2mortal(newSVpvn(rpv, rlen));
183 sv_utf8_upgrade_nomg(right);
184 rpv = SvPV(right, rlen);
187 sv_catpvn_nomg(TARG, rpv, rlen);
198 if (PL_op->op_flags & OPf_MOD) {
199 if (PL_op->op_private & OPpLVAL_INTRO)
200 SAVECLEARSV(PAD_SVl(PL_op->op_targ));
201 else if (PL_op->op_private & OPpDEREF) {
203 vivify_ref(PAD_SVl(PL_op->op_targ), PL_op->op_private & OPpDEREF);
212 tryAMAGICunTARGET(iter, 0);
213 PL_last_in_gv = (GV*)(*PL_stack_sp--);
214 if (SvTYPE(PL_last_in_gv) != SVt_PVGV) {
215 if (SvROK(PL_last_in_gv) && SvTYPE(SvRV(PL_last_in_gv)) == SVt_PVGV)
216 PL_last_in_gv = (GV*)SvRV(PL_last_in_gv);
219 XPUSHs((SV*)PL_last_in_gv);
222 PL_last_in_gv = (GV*)(*PL_stack_sp--);
225 return do_readline();
230 dSP; tryAMAGICbinSET(eq,0);
231 #ifndef NV_PRESERVES_UV
232 if (SvROK(TOPs) && SvROK(TOPm1s)) {
234 SETs(boolSV(SvRV(TOPs) == SvRV(TOPp1s)));
238 #ifdef PERL_PRESERVE_IVUV
241 /* Unless the left argument is integer in range we are going
242 to have to use NV maths. Hence only attempt to coerce the
243 right argument if we know the left is integer. */
246 bool auvok = SvUOK(TOPm1s);
247 bool buvok = SvUOK(TOPs);
249 if (auvok == buvok) { /* ## IV == IV or UV == UV ## */
250 /* Casting IV to UV before comparison isn't going to matter
251 on 2s complement. On 1s complement or sign&magnitude
252 (if we have any of them) it could to make negative zero
253 differ from normal zero. As I understand it. (Need to
254 check - is negative zero implementation defined behaviour
256 UV buv = SvUVX(POPs);
257 UV auv = SvUVX(TOPs);
259 SETs(boolSV(auv == buv));
262 { /* ## Mixed IV,UV ## */
266 /* == is commutative so doesn't matter which is left or right */
268 /* top of stack (b) is the iv */
277 /* As uv is a UV, it's >0, so it cannot be == */
281 /* we know iv is >= 0 */
282 SETs(boolSV((UV)iv == SvUVX(uvp)));
290 SETs(boolSV(TOPn == value));
298 if (SvTYPE(TOPs) > SVt_PVLV)
299 DIE(aTHX_ PL_no_modify);
300 if (!SvREADONLY(TOPs) && SvIOK_notUV(TOPs) && !SvNOK(TOPs) && !SvPOK(TOPs)
301 && SvIVX(TOPs) != IV_MAX)
304 SvFLAGS(TOPs) &= ~(SVp_NOK|SVp_POK);
306 else /* Do all the PERL_PRESERVE_IVUV conditionals in sv_inc */
319 RETURNOP(cLOGOP->op_other);
325 /* Most of this is lifted straight from pp_defined */
330 if (!sv || !SvANY(sv)) {
332 RETURNOP(cLOGOP->op_other);
335 switch (SvTYPE(sv)) {
337 if (AvMAX(sv) >= 0 || SvGMAGICAL(sv) || (SvRMAGICAL(sv) && mg_find(sv, PERL_MAGIC_tied)))
341 if (HvARRAY(sv) || SvGMAGICAL(sv) || (SvRMAGICAL(sv) && mg_find(sv, PERL_MAGIC_tied)))
345 if (CvROOT(sv) || CvXSUB(sv))
356 RETURNOP(cLOGOP->op_other);
361 dSP; dATARGET; bool useleft; tryAMAGICbin(add,opASSIGN);
362 useleft = USE_LEFT(TOPm1s);
363 #ifdef PERL_PRESERVE_IVUV
364 /* We must see if we can perform the addition with integers if possible,
365 as the integer code detects overflow while the NV code doesn't.
366 If either argument hasn't had a numeric conversion yet attempt to get
367 the IV. It's important to do this now, rather than just assuming that
368 it's not IOK as a PV of "9223372036854775806" may not take well to NV
369 addition, and an SV which is NOK, NV=6.0 ought to be coerced to
370 integer in case the second argument is IV=9223372036854775806
371 We can (now) rely on sv_2iv to do the right thing, only setting the
372 public IOK flag if the value in the NV (or PV) slot is truly integer.
374 A side effect is that this also aggressively prefers integer maths over
375 fp maths for integer values.
377 How to detect overflow?
379 C 99 section 6.2.6.1 says
381 The range of nonnegative values of a signed integer type is a subrange
382 of the corresponding unsigned integer type, and the representation of
383 the same value in each type is the same. A computation involving
384 unsigned operands can never overflow, because a result that cannot be
385 represented by the resulting unsigned integer type is reduced modulo
386 the number that is one greater than the largest value that can be
387 represented by the resulting type.
391 which I read as "unsigned ints wrap."
393 signed integer overflow seems to be classed as "exception condition"
395 If an exceptional condition occurs during the evaluation of an
396 expression (that is, if the result is not mathematically defined or not
397 in the range of representable values for its type), the behavior is
400 (6.5, the 5th paragraph)
402 I had assumed that on 2s complement machines signed arithmetic would
403 wrap, hence coded pp_add and pp_subtract on the assumption that
404 everything perl builds on would be happy. After much wailing and
405 gnashing of teeth it would seem that irix64 knows its ANSI spec well,
406 knows that it doesn't need to, and doesn't. Bah. Anyway, the all-
407 unsigned code below is actually shorter than the old code. :-)
412 /* Unless the left argument is integer in range we are going to have to
413 use NV maths. Hence only attempt to coerce the right argument if
414 we know the left is integer. */
422 /* left operand is undef, treat as zero. + 0 is identity,
423 Could SETi or SETu right now, but space optimise by not adding
424 lots of code to speed up what is probably a rarish case. */
426 /* Left operand is defined, so is it IV? */
429 if ((auvok = SvUOK(TOPm1s)))
432 register IV aiv = SvIVX(TOPm1s);
435 auvok = 1; /* Now acting as a sign flag. */
436 } else { /* 2s complement assumption for IV_MIN */
444 bool result_good = 0;
447 bool buvok = SvUOK(TOPs);
452 register IV biv = SvIVX(TOPs);
459 /* ?uvok if value is >= 0. basically, flagged as UV if it's +ve,
460 else "IV" now, independent of how it came in.
461 if a, b represents positive, A, B negative, a maps to -A etc
466 all UV maths. negate result if A negative.
467 add if signs same, subtract if signs differ. */
473 /* Must get smaller */
479 /* result really should be -(auv-buv). as its negation
480 of true value, need to swap our result flag */
497 if (result <= (UV)IV_MIN)
500 /* result valid, but out of range for IV. */
505 } /* Overflow, drop through to NVs. */
512 /* left operand is undef, treat as zero. + 0.0 is identity. */
516 SETn( value + TOPn );
524 AV *av = GvAV(cGVOP_gv);
525 U32 lval = PL_op->op_flags & OPf_MOD;
526 SV** svp = av_fetch(av, PL_op->op_private, lval);
527 SV *sv = (svp ? *svp : &PL_sv_undef);
529 if (!lval && SvGMAGICAL(sv)) /* see note in pp_helem() */
530 sv = sv_mortalcopy(sv);
539 do_join(TARG, *MARK, MARK, SP);
550 * We ass_u_me that LvTARGOFF() comes first, and that two STRLENs
551 * will be enough to hold an OP*.
553 SV* sv = sv_newmortal();
554 sv_upgrade(sv, SVt_PVLV);
556 Copy(&PL_op, &LvTARGOFF(sv), 1, OP*);
564 /* Oversized hot code. */
568 dSP; dMARK; dORIGMARK;
574 if (PL_op->op_flags & OPf_STACKED)
579 if (gv && (io = GvIO(gv))
580 && (mg = SvTIED_mg((SV*)io, PERL_MAGIC_tiedscalar)))
583 if (MARK == ORIGMARK) {
584 /* If using default handle then we need to make space to
585 * pass object as 1st arg, so move other args up ...
589 Move(MARK, MARK + 1, (SP - MARK) + 1, SV*);
593 *MARK = SvTIED_obj((SV*)io, mg);
596 call_method("PRINT", G_SCALAR);
604 if (!(io = GvIO(gv))) {
605 if ((GvEGV(gv)) && (io = GvIO(GvEGV(gv)))
606 && (mg = SvTIED_mg((SV*)io, PERL_MAGIC_tiedscalar)))
608 if (ckWARN2(WARN_UNOPENED,WARN_CLOSED))
609 report_evil_fh(gv, io, PL_op->op_type);
610 SETERRNO(EBADF,RMS_IFI);
613 else if (!(fp = IoOFP(io))) {
614 if (ckWARN2(WARN_CLOSED, WARN_IO)) {
616 report_evil_fh(gv, io, OP_phoney_INPUT_ONLY);
617 else if (ckWARN2(WARN_UNOPENED,WARN_CLOSED))
618 report_evil_fh(gv, io, PL_op->op_type);
620 SETERRNO(EBADF,IoIFP(io)?RMS_FAC:RMS_IFI);
625 if (PL_ofs_sv && SvOK(PL_ofs_sv)) {
627 if (!do_print(*MARK, fp))
631 if (!do_print(PL_ofs_sv, fp)) { /* $, */
640 if (!do_print(*MARK, fp))
648 if (PL_ors_sv && SvOK(PL_ors_sv))
649 if (!do_print(PL_ors_sv, fp)) /* $\ */
652 if (IoFLAGS(io) & IOf_FLUSH)
653 if (PerlIO_flush(fp) == EOF)
674 tryAMAGICunDEREF(to_av);
677 if (SvTYPE(av) != SVt_PVAV)
678 DIE(aTHX_ "Not an ARRAY reference");
679 if (PL_op->op_flags & OPf_REF) {
684 if (GIMME == G_SCALAR)
685 Perl_croak(aTHX_ "Can't return array to lvalue scalar context");
689 else if (PL_op->op_flags & OPf_MOD
690 && PL_op->op_private & OPpLVAL_INTRO)
691 Perl_croak(aTHX_ PL_no_localize_ref);
694 if (SvTYPE(sv) == SVt_PVAV) {
696 if (PL_op->op_flags & OPf_REF) {
701 if (GIMME == G_SCALAR)
702 Perl_croak(aTHX_ "Can't return array to lvalue"
711 if (SvTYPE(sv) != SVt_PVGV) {
715 if (SvGMAGICAL(sv)) {
721 if (PL_op->op_flags & OPf_REF ||
722 PL_op->op_private & HINT_STRICT_REFS)
723 DIE(aTHX_ PL_no_usym, "an ARRAY");
724 if (ckWARN(WARN_UNINITIALIZED))
726 if (GIMME == G_ARRAY) {
733 if ((PL_op->op_flags & OPf_SPECIAL) &&
734 !(PL_op->op_flags & OPf_MOD))
736 gv = (GV*)gv_fetchpv(sym, FALSE, SVt_PVAV);
738 && (!is_gv_magical(sym,len,0)
739 || !(gv = (GV*)gv_fetchpv(sym, TRUE, SVt_PVAV))))
745 if (PL_op->op_private & HINT_STRICT_REFS)
746 DIE(aTHX_ PL_no_symref, sym, "an ARRAY");
747 gv = (GV*)gv_fetchpv(sym, TRUE, SVt_PVAV);
754 if (PL_op->op_private & OPpLVAL_INTRO)
756 if (PL_op->op_flags & OPf_REF) {
761 if (GIMME == G_SCALAR)
762 Perl_croak(aTHX_ "Can't return array to lvalue"
770 if (GIMME == G_ARRAY) {
771 I32 maxarg = AvFILL(av) + 1;
772 (void)POPs; /* XXXX May be optimized away? */
774 if (SvRMAGICAL(av)) {
776 for (i=0; i < (U32)maxarg; i++) {
777 SV **svp = av_fetch(av, i, FALSE);
778 SP[i+1] = (svp) ? *svp : &PL_sv_undef;
782 Copy(AvARRAY(av), SP+1, maxarg, SV*);
786 else if (GIMME_V == G_SCALAR) {
788 I32 maxarg = AvFILL(av) + 1;
801 tryAMAGICunDEREF(to_hv);
804 if (SvTYPE(hv) != SVt_PVHV)
805 DIE(aTHX_ "Not a HASH reference");
806 if (PL_op->op_flags & OPf_REF) {
811 if (GIMME != G_SCALAR)
812 Perl_croak(aTHX_ "Can't return hash to lvalue scalar context");
816 else if (PL_op->op_flags & OPf_MOD
817 && PL_op->op_private & OPpLVAL_INTRO)
818 Perl_croak(aTHX_ PL_no_localize_ref);
821 if (SvTYPE(sv) == SVt_PVHV) {
823 if (PL_op->op_flags & OPf_REF) {
828 if (GIMME == G_SCALAR)
829 Perl_croak(aTHX_ "Can't return hash to lvalue"
838 if (SvTYPE(sv) != SVt_PVGV) {
842 if (SvGMAGICAL(sv)) {
848 if (PL_op->op_flags & OPf_REF ||
849 PL_op->op_private & HINT_STRICT_REFS)
850 DIE(aTHX_ PL_no_usym, "a HASH");
851 if (ckWARN(WARN_UNINITIALIZED))
853 if (GIMME == G_ARRAY) {
860 if ((PL_op->op_flags & OPf_SPECIAL) &&
861 !(PL_op->op_flags & OPf_MOD))
863 gv = (GV*)gv_fetchpv(sym, FALSE, SVt_PVHV);
865 && (!is_gv_magical(sym,len,0)
866 || !(gv = (GV*)gv_fetchpv(sym, TRUE, SVt_PVHV))))
872 if (PL_op->op_private & HINT_STRICT_REFS)
873 DIE(aTHX_ PL_no_symref, sym, "a HASH");
874 gv = (GV*)gv_fetchpv(sym, TRUE, SVt_PVHV);
881 if (PL_op->op_private & OPpLVAL_INTRO)
883 if (PL_op->op_flags & OPf_REF) {
888 if (GIMME == G_SCALAR)
889 Perl_croak(aTHX_ "Can't return hash to lvalue"
897 if (GIMME == G_ARRAY) { /* array wanted */
898 *PL_stack_sp = (SV*)hv;
904 Perl_sv_setpvf(aTHX_ TARG, "%"IVdf"/%"IVdf,
905 (IV)HvFILL(hv), (IV)HvMAX(hv) + 1);
915 S_do_oddball(pTHX_ HV *hash, SV **relem, SV **firstrelem)
921 if (ckWARN(WARN_MISC)) {
922 if (relem == firstrelem &&
924 (SvTYPE(SvRV(*relem)) == SVt_PVAV ||
925 SvTYPE(SvRV(*relem)) == SVt_PVHV))
927 Perl_warner(aTHX_ packWARN(WARN_MISC),
928 "Reference found where even-sized list expected");
931 Perl_warner(aTHX_ packWARN(WARN_MISC),
932 "Odd number of elements in hash assignment");
935 tmpstr = NEWSV(29,0);
936 didstore = hv_store_ent(hash,*relem,tmpstr,0);
937 if (SvMAGICAL(hash)) {
938 if (SvSMAGICAL(tmpstr))
950 SV **lastlelem = PL_stack_sp;
951 SV **lastrelem = PL_stack_base + POPMARK;
952 SV **firstrelem = PL_stack_base + POPMARK + 1;
953 SV **firstlelem = lastrelem + 1;
966 PL_delaymagic = DM_DELAY; /* catch simultaneous items */
968 /* If there's a common identifier on both sides we have to take
969 * special care that assigning the identifier on the left doesn't
970 * clobber a value on the right that's used later in the list.
972 if (PL_op->op_private & (OPpASSIGN_COMMON)) {
973 EXTEND_MORTAL(lastrelem - firstrelem + 1);
974 for (relem = firstrelem; relem <= lastrelem; relem++) {
977 TAINT_NOT; /* Each item is independent */
978 *relem = sv_mortalcopy(sv);
988 while (lelem <= lastlelem) {
989 TAINT_NOT; /* Each item stands on its own, taintwise. */
991 switch (SvTYPE(sv)) {
994 magic = SvMAGICAL(ary) != 0;
996 av_extend(ary, lastrelem - relem);
998 while (relem <= lastrelem) { /* gobble up all the rest */
1002 sv_setsv(sv,*relem);
1004 didstore = av_store(ary,i++,sv);
1014 case SVt_PVHV: { /* normal hash */
1018 magic = SvMAGICAL(hash) != 0;
1021 while (relem < lastrelem) { /* gobble up all the rest */
1026 sv = &PL_sv_no, relem++;
1027 tmpstr = NEWSV(29,0);
1029 sv_setsv(tmpstr,*relem); /* value */
1030 *(relem++) = tmpstr;
1031 didstore = hv_store_ent(hash,sv,tmpstr,0);
1033 if (SvSMAGICAL(tmpstr))
1040 if (relem == lastrelem) {
1041 do_oddball(hash, relem, firstrelem);
1047 if (SvIMMORTAL(sv)) {
1048 if (relem <= lastrelem)
1052 if (relem <= lastrelem) {
1053 sv_setsv(sv, *relem);
1057 sv_setsv(sv, &PL_sv_undef);
1062 if (PL_delaymagic & ~DM_DELAY) {
1063 if (PL_delaymagic & DM_UID) {
1064 #ifdef HAS_SETRESUID
1065 (void)setresuid(PL_uid,PL_euid,(Uid_t)-1);
1067 # ifdef HAS_SETREUID
1068 (void)setreuid(PL_uid,PL_euid);
1071 if ((PL_delaymagic & DM_UID) == DM_RUID) {
1072 (void)setruid(PL_uid);
1073 PL_delaymagic &= ~DM_RUID;
1075 # endif /* HAS_SETRUID */
1077 if ((PL_delaymagic & DM_UID) == DM_EUID) {
1078 (void)seteuid(PL_uid);
1079 PL_delaymagic &= ~DM_EUID;
1081 # endif /* HAS_SETEUID */
1082 if (PL_delaymagic & DM_UID) {
1083 if (PL_uid != PL_euid)
1084 DIE(aTHX_ "No setreuid available");
1085 (void)PerlProc_setuid(PL_uid);
1087 # endif /* HAS_SETREUID */
1088 #endif /* HAS_SETRESUID */
1089 PL_uid = PerlProc_getuid();
1090 PL_euid = PerlProc_geteuid();
1092 if (PL_delaymagic & DM_GID) {
1093 #ifdef HAS_SETRESGID
1094 (void)setresgid(PL_gid,PL_egid,(Gid_t)-1);
1096 # ifdef HAS_SETREGID
1097 (void)setregid(PL_gid,PL_egid);
1100 if ((PL_delaymagic & DM_GID) == DM_RGID) {
1101 (void)setrgid(PL_gid);
1102 PL_delaymagic &= ~DM_RGID;
1104 # endif /* HAS_SETRGID */
1106 if ((PL_delaymagic & DM_GID) == DM_EGID) {
1107 (void)setegid(PL_gid);
1108 PL_delaymagic &= ~DM_EGID;
1110 # endif /* HAS_SETEGID */
1111 if (PL_delaymagic & DM_GID) {
1112 if (PL_gid != PL_egid)
1113 DIE(aTHX_ "No setregid available");
1114 (void)PerlProc_setgid(PL_gid);
1116 # endif /* HAS_SETREGID */
1117 #endif /* HAS_SETRESGID */
1118 PL_gid = PerlProc_getgid();
1119 PL_egid = PerlProc_getegid();
1121 PL_tainting |= (PL_uid && (PL_euid != PL_uid || PL_egid != PL_gid));
1126 if (gimme == G_VOID)
1127 SP = firstrelem - 1;
1128 else if (gimme == G_SCALAR) {
1131 SETi(lastrelem - firstrelem + 1);
1137 SP = firstrelem + (lastlelem - firstlelem);
1138 lelem = firstlelem + (relem - firstrelem);
1140 *relem++ = (lelem <= lastlelem) ? *lelem++ : &PL_sv_undef;
1148 register PMOP *pm = cPMOP;
1149 SV *rv = sv_newmortal();
1150 SV *sv = newSVrv(rv, "Regexp");
1151 if (pm->op_pmdynflags & PMdf_TAINTED)
1153 sv_magic(sv,(SV*)ReREFCNT_inc(PM_GETRE(pm)), PERL_MAGIC_qr,0,0);
1160 register PMOP *pm = cPMOP;
1166 I32 r_flags = REXEC_CHECKED;
1167 char *truebase; /* Start of string */
1168 register REGEXP *rx = PM_GETRE(pm);
1173 I32 oldsave = PL_savestack_ix;
1174 I32 update_minmatch = 1;
1175 I32 had_zerolen = 0;
1177 if (PL_op->op_flags & OPf_STACKED)
1184 PUTBACK; /* EVAL blocks need stack_sp. */
1185 s = SvPV(TARG, len);
1188 DIE(aTHX_ "panic: pp_match");
1189 rxtainted = ((pm->op_pmdynflags & PMdf_TAINTED) ||
1190 (PL_tainted && (pm->op_pmflags & PMf_RETAINT)));
1193 RX_MATCH_UTF8_set(rx, DO_UTF8(TARG));
1195 /* PMdf_USED is set after a ?? matches once */
1196 if (pm->op_pmdynflags & PMdf_USED) {
1198 if (gimme == G_ARRAY)
1203 /* empty pattern special-cased to use last successful pattern if possible */
1204 if (!rx->prelen && PL_curpm) {
1209 if (rx->minlen > (I32)len)
1214 /* XXXX What part of this is needed with true \G-support? */
1215 if ((global = dynpm->op_pmflags & PMf_GLOBAL)) {
1217 if (SvTYPE(TARG) >= SVt_PVMG && SvMAGIC(TARG)) {
1218 MAGIC* mg = mg_find(TARG, PERL_MAGIC_regex_global);
1219 if (mg && mg->mg_len >= 0) {
1220 if (!(rx->reganch & ROPT_GPOS_SEEN))
1221 rx->endp[0] = rx->startp[0] = mg->mg_len;
1222 else if (rx->reganch & ROPT_ANCH_GPOS) {
1223 r_flags |= REXEC_IGNOREPOS;
1224 rx->endp[0] = rx->startp[0] = mg->mg_len;
1226 minmatch = (mg->mg_flags & MGf_MINMATCH);
1227 update_minmatch = 0;
1231 if ((!global && rx->nparens)
1232 || SvTEMP(TARG) || PL_sawampersand)
1233 r_flags |= REXEC_COPY_STR;
1235 r_flags |= REXEC_SCREAM;
1237 if ((int)(pm->op_pmflags & PMf_MULTILINE) != PL_multiline) {
1238 SAVEINT(PL_multiline);
1239 PL_multiline = pm->op_pmflags & PMf_MULTILINE;
1243 if (global && rx->startp[0] != -1) {
1244 t = s = rx->endp[0] + truebase;
1245 if ((s + rx->minlen) > strend)
1247 if (update_minmatch++)
1248 minmatch = had_zerolen;
1250 if (rx->reganch & RE_USE_INTUIT &&
1251 DO_UTF8(TARG) == ((rx->reganch & ROPT_UTF8) != 0)) {
1252 PL_bostr = truebase;
1253 s = CALLREG_INTUIT_START(aTHX_ rx, TARG, s, strend, r_flags, NULL);
1257 if ( (rx->reganch & ROPT_CHECK_ALL)
1259 && ((rx->reganch & ROPT_NOSCAN)
1260 || !((rx->reganch & RE_INTUIT_TAIL)
1261 && (r_flags & REXEC_SCREAM)))
1262 && !SvROK(TARG)) /* Cannot trust since INTUIT cannot guess ^ */
1265 if (CALLREGEXEC(aTHX_ rx, s, strend, truebase, minmatch, TARG, NULL, r_flags))
1268 if (dynpm->op_pmflags & PMf_ONCE)
1269 dynpm->op_pmdynflags |= PMdf_USED;
1278 RX_MATCH_TAINTED_on(rx);
1279 TAINT_IF(RX_MATCH_TAINTED(rx));
1280 if (gimme == G_ARRAY) {
1281 I32 nparens, i, len;
1283 nparens = rx->nparens;
1284 if (global && !nparens)
1288 SPAGAIN; /* EVAL blocks could move the stack. */
1289 EXTEND(SP, nparens + i);
1290 EXTEND_MORTAL(nparens + i);
1291 for (i = !i; i <= nparens; i++) {
1292 PUSHs(sv_newmortal());
1294 if ((rx->startp[i] != -1) && rx->endp[i] != -1 ) {
1295 len = rx->endp[i] - rx->startp[i];
1296 if (rx->endp[i] < 0 || rx->startp[i] < 0 ||
1297 len < 0 || len > strend - s)
1298 DIE(aTHX_ "panic: pp_match start/end pointers");
1299 s = rx->startp[i] + truebase;
1300 sv_setpvn(*SP, s, len);
1301 if (DO_UTF8(TARG) && is_utf8_string((U8*)s, len))
1306 if (dynpm->op_pmflags & PMf_CONTINUE) {
1308 if (SvTYPE(TARG) >= SVt_PVMG && SvMAGIC(TARG))
1309 mg = mg_find(TARG, PERL_MAGIC_regex_global);
1311 sv_magic(TARG, (SV*)0, PERL_MAGIC_regex_global, Nullch, 0);
1312 mg = mg_find(TARG, PERL_MAGIC_regex_global);
1314 if (rx->startp[0] != -1) {
1315 mg->mg_len = rx->endp[0];
1316 if (rx->startp[0] == rx->endp[0])
1317 mg->mg_flags |= MGf_MINMATCH;
1319 mg->mg_flags &= ~MGf_MINMATCH;
1322 had_zerolen = (rx->startp[0] != -1
1323 && rx->startp[0] == rx->endp[0]);
1324 PUTBACK; /* EVAL blocks may use stack */
1325 r_flags |= REXEC_IGNOREPOS | REXEC_NOT_FIRST;
1330 LEAVE_SCOPE(oldsave);
1336 if (SvTYPE(TARG) >= SVt_PVMG && SvMAGIC(TARG))
1337 mg = mg_find(TARG, PERL_MAGIC_regex_global);
1339 sv_magic(TARG, (SV*)0, PERL_MAGIC_regex_global, Nullch, 0);
1340 mg = mg_find(TARG, PERL_MAGIC_regex_global);
1342 if (rx->startp[0] != -1) {
1343 mg->mg_len = rx->endp[0];
1344 if (rx->startp[0] == rx->endp[0])
1345 mg->mg_flags |= MGf_MINMATCH;
1347 mg->mg_flags &= ~MGf_MINMATCH;
1350 LEAVE_SCOPE(oldsave);
1354 yup: /* Confirmed by INTUIT */
1356 RX_MATCH_TAINTED_on(rx);
1357 TAINT_IF(RX_MATCH_TAINTED(rx));
1359 if (dynpm->op_pmflags & PMf_ONCE)
1360 dynpm->op_pmdynflags |= PMdf_USED;
1361 if (RX_MATCH_COPIED(rx))
1362 Safefree(rx->subbeg);
1363 RX_MATCH_COPIED_off(rx);
1364 rx->subbeg = Nullch;
1366 rx->subbeg = truebase;
1367 rx->startp[0] = s - truebase;
1368 if (RX_MATCH_UTF8(rx)) {
1369 char *t = (char*)utf8_hop((U8*)s, rx->minlen);
1370 rx->endp[0] = t - truebase;
1373 rx->endp[0] = s - truebase + rx->minlen;
1375 rx->sublen = strend - truebase;
1378 if (PL_sawampersand) {
1380 #ifdef PERL_COPY_ON_WRITE
1381 if (SvIsCOW(TARG) || (SvFLAGS(TARG) & CAN_COW_MASK) == CAN_COW_FLAGS) {
1383 PerlIO_printf(Perl_debug_log,
1384 "Copy on write: pp_match $& capture, type %d, truebase=%p, t=%p, difference %d\n",
1385 (int) SvTYPE(TARG), truebase, t,
1388 rx->saved_copy = sv_setsv_cow(rx->saved_copy, TARG);
1389 rx->subbeg = SvPVX(rx->saved_copy) + (t - truebase);
1390 assert (SvPOKp(rx->saved_copy));
1395 rx->subbeg = savepvn(t, strend - t);
1396 #ifdef PERL_COPY_ON_WRITE
1397 rx->saved_copy = Nullsv;
1400 rx->sublen = strend - t;
1401 RX_MATCH_COPIED_on(rx);
1402 off = rx->startp[0] = s - t;
1403 rx->endp[0] = off + rx->minlen;
1405 else { /* startp/endp are used by @- @+. */
1406 rx->startp[0] = s - truebase;
1407 rx->endp[0] = s - truebase + rx->minlen;
1409 rx->nparens = rx->lastparen = rx->lastcloseparen = 0; /* used by @-, @+, and $^N */
1410 LEAVE_SCOPE(oldsave);
1415 if (global && !(dynpm->op_pmflags & PMf_CONTINUE)) {
1416 if (SvTYPE(TARG) >= SVt_PVMG && SvMAGIC(TARG)) {
1417 MAGIC* mg = mg_find(TARG, PERL_MAGIC_regex_global);
1422 LEAVE_SCOPE(oldsave);
1423 if (gimme == G_ARRAY)
1429 Perl_do_readline(pTHX)
1431 dSP; dTARGETSTACKED;
1436 register IO *io = GvIO(PL_last_in_gv);
1437 register I32 type = PL_op->op_type;
1438 I32 gimme = GIMME_V;
1441 if (io && (mg = SvTIED_mg((SV*)io, PERL_MAGIC_tiedscalar))) {
1443 XPUSHs(SvTIED_obj((SV*)io, mg));
1446 call_method("READLINE", gimme);
1449 if (gimme == G_SCALAR) {
1451 SvSetSV_nosteal(TARG, result);
1460 if (IoFLAGS(io) & IOf_ARGV) {
1461 if (IoFLAGS(io) & IOf_START) {
1463 if (av_len(GvAVn(PL_last_in_gv)) < 0) {
1464 IoFLAGS(io) &= ~IOf_START;
1465 do_open(PL_last_in_gv,"-",1,FALSE,O_RDONLY,0,Nullfp);
1466 sv_setpvn(GvSV(PL_last_in_gv), "-", 1);
1467 SvSETMAGIC(GvSV(PL_last_in_gv));
1472 fp = nextargv(PL_last_in_gv);
1473 if (!fp) { /* Note: fp != IoIFP(io) */
1474 (void)do_close(PL_last_in_gv, FALSE); /* now it does*/
1477 else if (type == OP_GLOB)
1478 fp = Perl_start_glob(aTHX_ POPs, io);
1480 else if (type == OP_GLOB)
1482 else if (ckWARN(WARN_IO) && IoTYPE(io) == IoTYPE_WRONLY) {
1483 report_evil_fh(PL_last_in_gv, io, OP_phoney_OUTPUT_ONLY);
1487 if (ckWARN2(WARN_GLOB, WARN_CLOSED)
1488 && (!io || !(IoFLAGS(io) & IOf_START))) {
1489 if (type == OP_GLOB)
1490 Perl_warner(aTHX_ packWARN(WARN_GLOB),
1491 "glob failed (can't start child: %s)",
1494 report_evil_fh(PL_last_in_gv, io, PL_op->op_type);
1496 if (gimme == G_SCALAR) {
1497 /* undef TARG, and push that undefined value */
1498 if (type != OP_RCATLINE) {
1499 SV_CHECK_THINKFIRST_COW_DROP(TARG);
1500 (void)SvOK_off(TARG);
1507 if (gimme == G_SCALAR) {
1511 (void)SvUPGRADE(sv, SVt_PV);
1512 tmplen = SvLEN(sv); /* remember if already alloced */
1513 if (!tmplen && !SvREADONLY(sv))
1514 Sv_Grow(sv, 80); /* try short-buffering it */
1516 if (type == OP_RCATLINE && SvOK(sv)) {
1519 (void)SvPV_force(sv, n_a);
1525 sv = sv_2mortal(NEWSV(57, 80));
1529 /* This should not be marked tainted if the fp is marked clean */
1530 #define MAYBE_TAINT_LINE(io, sv) \
1531 if (!(IoFLAGS(io) & IOf_UNTAINT)) { \
1536 /* delay EOF state for a snarfed empty file */
1537 #define SNARF_EOF(gimme,rs,io,sv) \
1538 (gimme != G_SCALAR || SvCUR(sv) \
1539 || (IoFLAGS(io) & IOf_NOLINE) || !RsSNARF(rs))
1543 if (!sv_gets(sv, fp, offset)
1544 && (type == OP_GLOB || SNARF_EOF(gimme, PL_rs, io, sv)))
1546 PerlIO_clearerr(fp);
1547 if (IoFLAGS(io) & IOf_ARGV) {
1548 fp = nextargv(PL_last_in_gv);
1551 (void)do_close(PL_last_in_gv, FALSE);
1553 else if (type == OP_GLOB) {
1554 if (!do_close(PL_last_in_gv, FALSE) && ckWARN(WARN_GLOB)) {
1555 Perl_warner(aTHX_ packWARN(WARN_GLOB),
1556 "glob failed (child exited with status %d%s)",
1557 (int)(STATUS_CURRENT >> 8),
1558 (STATUS_CURRENT & 0x80) ? ", core dumped" : "");
1561 if (gimme == G_SCALAR) {
1562 if (type != OP_RCATLINE) {
1563 SV_CHECK_THINKFIRST_COW_DROP(TARG);
1564 (void)SvOK_off(TARG);
1569 MAYBE_TAINT_LINE(io, sv);
1572 MAYBE_TAINT_LINE(io, sv);
1574 IoFLAGS(io) |= IOf_NOLINE;
1578 if (type == OP_GLOB) {
1581 if (SvCUR(sv) > 0 && SvCUR(PL_rs) > 0) {
1582 tmps = SvEND(sv) - 1;
1583 if (*tmps == *SvPVX(PL_rs)) {
1588 for (tmps = SvPVX(sv); *tmps; tmps++)
1589 if (!isALPHA(*tmps) && !isDIGIT(*tmps) &&
1590 strchr("$&*(){}[]'\";\\|?<>~`", *tmps))
1592 if (*tmps && PerlLIO_lstat(SvPVX(sv), &PL_statbuf) < 0) {
1593 (void)POPs; /* Unmatched wildcard? Chuck it... */
1596 } else if (SvUTF8(sv)) { /* OP_READLINE, OP_RCATLINE */
1597 U8 *s = (U8*)SvPVX(sv) + offset;
1598 STRLEN len = SvCUR(sv) - offset;
1601 if (ckWARN(WARN_UTF8) &&
1602 !Perl_is_utf8_string_loc(aTHX_ s, len, &f))
1603 /* Emulate :encoding(utf8) warning in the same case. */
1604 Perl_warner(aTHX_ packWARN(WARN_UTF8),
1605 "utf8 \"\\x%02X\" does not map to Unicode",
1606 f < (U8*)SvEND(sv) ? *f : 0);
1608 if (gimme == G_ARRAY) {
1609 if (SvLEN(sv) - SvCUR(sv) > 20) {
1610 SvLEN_set(sv, SvCUR(sv)+1);
1611 Renew(SvPVX(sv), SvLEN(sv), char);
1613 sv = sv_2mortal(NEWSV(58, 80));
1616 else if (gimme == G_SCALAR && !tmplen && SvLEN(sv) - SvCUR(sv) > 80) {
1617 /* try to reclaim a bit of scalar space (only on 1st alloc) */
1621 SvLEN_set(sv, SvCUR(sv)+40); /* allow some slop */
1622 Renew(SvPVX(sv), SvLEN(sv), char);
1631 register PERL_CONTEXT *cx;
1632 I32 gimme = OP_GIMME(PL_op, -1);
1635 if (cxstack_ix >= 0)
1636 gimme = cxstack[cxstack_ix].blk_gimme;
1644 PUSHBLOCK(cx, CXt_BLOCK, SP);
1656 U32 lval = PL_op->op_flags & OPf_MOD || LVRET;
1657 U32 defer = PL_op->op_private & OPpLVAL_DEFER;
1659 #ifdef PERL_COPY_ON_WRITE
1660 U32 hash = (SvIsCOW_shared_hash(keysv)) ? SvUVX(keysv) : 0;
1662 U32 hash = (SvFAKE(keysv) && SvREADONLY(keysv)) ? SvUVX(keysv) : 0;
1666 if (SvTYPE(hv) == SVt_PVHV) {
1667 if (PL_op->op_private & OPpLVAL_INTRO) {
1670 /* does the element we're localizing already exist? */
1672 /* can we determine whether it exists? */
1674 || mg_find((SV*)hv, PERL_MAGIC_env)
1675 || ( (mg = mg_find((SV*)hv, PERL_MAGIC_tied))
1676 /* Try to preserve the existenceness of a tied hash
1677 * element by using EXISTS and DELETE if possible.
1678 * Fallback to FETCH and STORE otherwise */
1679 && (stash = SvSTASH(SvRV(SvTIED_obj((SV*)hv, mg))))
1680 && gv_fetchmethod_autoload(stash, "EXISTS", TRUE)
1681 && gv_fetchmethod_autoload(stash, "DELETE", TRUE)
1683 ) ? hv_exists_ent(hv, keysv, 0) : 1;
1686 he = hv_fetch_ent(hv, keysv, lval && !defer, hash);
1687 svp = he ? &HeVAL(he) : 0;
1693 if (!svp || *svp == &PL_sv_undef) {
1698 DIE(aTHX_ PL_no_helem, SvPV(keysv, n_a));
1700 lv = sv_newmortal();
1701 sv_upgrade(lv, SVt_PVLV);
1703 sv_magic(lv, key2 = newSVsv(keysv), PERL_MAGIC_defelem, Nullch, 0);
1704 SvREFCNT_dec(key2); /* sv_magic() increments refcount */
1705 LvTARG(lv) = SvREFCNT_inc(hv);
1710 if (PL_op->op_private & OPpLVAL_INTRO) {
1711 if (HvNAME(hv) && isGV(*svp))
1712 save_gp((GV*)*svp, !(PL_op->op_flags & OPf_SPECIAL));
1716 char *key = SvPV(keysv, keylen);
1717 SAVEDELETE(hv, savepvn(key,keylen), keylen);
1719 save_helem(hv, keysv, svp);
1722 else if (PL_op->op_private & OPpDEREF)
1723 vivify_ref(*svp, PL_op->op_private & OPpDEREF);
1725 sv = (svp ? *svp : &PL_sv_undef);
1726 /* This makes C<local $tied{foo} = $tied{foo}> possible.
1727 * Pushing the magical RHS on to the stack is useless, since
1728 * that magic is soon destined to be misled by the local(),
1729 * and thus the later pp_sassign() will fail to mg_get() the
1730 * old value. This should also cure problems with delayed
1731 * mg_get()s. GSAR 98-07-03 */
1732 if (!lval && SvGMAGICAL(sv))
1733 sv = sv_mortalcopy(sv);
1741 register PERL_CONTEXT *cx;
1747 if (PL_op->op_flags & OPf_SPECIAL) {
1748 cx = &cxstack[cxstack_ix];
1749 cx->blk_oldpm = PL_curpm; /* fake block should preserve $1 et al */
1754 gimme = OP_GIMME(PL_op, -1);
1756 if (cxstack_ix >= 0)
1757 gimme = cxstack[cxstack_ix].blk_gimme;
1763 if (gimme == G_VOID)
1765 else if (gimme == G_SCALAR) {
1768 if (SvFLAGS(TOPs) & (SVs_PADTMP|SVs_TEMP))
1771 *MARK = sv_mortalcopy(TOPs);
1774 *MARK = &PL_sv_undef;
1778 else if (gimme == G_ARRAY) {
1779 /* in case LEAVE wipes old return values */
1780 for (mark = newsp + 1; mark <= SP; mark++) {
1781 if (!(SvFLAGS(*mark) & (SVs_PADTMP|SVs_TEMP))) {
1782 *mark = sv_mortalcopy(*mark);
1783 TAINT_NOT; /* Each item is independent */
1787 PL_curpm = newpm; /* Don't pop $1 et al till now */
1797 register PERL_CONTEXT *cx;
1803 cx = &cxstack[cxstack_ix];
1804 if (CxTYPE(cx) != CXt_LOOP)
1805 DIE(aTHX_ "panic: pp_iter");
1807 itersvp = CxITERVAR(cx);
1808 av = cx->blk_loop.iterary;
1809 if (SvTYPE(av) != SVt_PVAV) {
1810 /* iterate ($min .. $max) */
1811 if (cx->blk_loop.iterlval) {
1812 /* string increment */
1813 register SV* cur = cx->blk_loop.iterlval;
1815 char *max = SvPV((SV*)av, maxlen);
1816 if (!SvNIOK(cur) && SvCUR(cur) <= maxlen) {
1817 if (SvREFCNT(*itersvp) == 1 && !SvMAGICAL(*itersvp)) {
1818 /* safe to reuse old SV */
1819 sv_setsv(*itersvp, cur);
1823 /* we need a fresh SV every time so that loop body sees a
1824 * completely new SV for closures/references to work as
1826 SvREFCNT_dec(*itersvp);
1827 *itersvp = newSVsv(cur);
1829 if (strEQ(SvPVX(cur), max))
1830 sv_setiv(cur, 0); /* terminate next time */
1837 /* integer increment */
1838 if (cx->blk_loop.iterix > cx->blk_loop.itermax)
1841 /* don't risk potential race */
1842 if (SvREFCNT(*itersvp) == 1 && !SvMAGICAL(*itersvp)) {
1843 /* safe to reuse old SV */
1844 sv_setiv(*itersvp, cx->blk_loop.iterix++);
1848 /* we need a fresh SV every time so that loop body sees a
1849 * completely new SV for closures/references to work as they
1851 SvREFCNT_dec(*itersvp);
1852 *itersvp = newSViv(cx->blk_loop.iterix++);
1858 if (cx->blk_loop.iterix >= (av == PL_curstack ? cx->blk_oldsp : AvFILL(av)))
1861 SvREFCNT_dec(*itersvp);
1863 if (SvMAGICAL(av) || AvREIFY(av)) {
1864 SV **svp = av_fetch(av, ++cx->blk_loop.iterix, FALSE);
1871 sv = AvARRAY(av)[++cx->blk_loop.iterix];
1873 if (sv && SvREFCNT(sv) == 0) {
1875 Perl_croak(aTHX_ "Use of freed value in iteration");
1882 if (av != PL_curstack && sv == &PL_sv_undef) {
1883 SV *lv = cx->blk_loop.iterlval;
1884 if (lv && SvREFCNT(lv) > 1) {
1889 SvREFCNT_dec(LvTARG(lv));
1891 lv = cx->blk_loop.iterlval = NEWSV(26, 0);
1892 sv_upgrade(lv, SVt_PVLV);
1894 sv_magic(lv, Nullsv, PERL_MAGIC_defelem, Nullch, 0);
1896 LvTARG(lv) = SvREFCNT_inc(av);
1897 LvTARGOFF(lv) = cx->blk_loop.iterix;
1898 LvTARGLEN(lv) = (STRLEN)UV_MAX;
1902 *itersvp = SvREFCNT_inc(sv);
1909 register PMOP *pm = cPMOP;
1925 register REGEXP *rx = PM_GETRE(pm);
1927 int force_on_match = 0;
1928 I32 oldsave = PL_savestack_ix;
1930 bool doutf8 = FALSE;
1931 #ifdef PERL_COPY_ON_WRITE
1936 /* known replacement string? */
1937 dstr = (pm->op_pmflags & PMf_CONST) ? POPs : Nullsv;
1938 if (PL_op->op_flags & OPf_STACKED)
1945 #ifdef PERL_COPY_ON_WRITE
1946 /* Awooga. Awooga. "bool" types that are actually char are dangerous,
1947 because they make integers such as 256 "false". */
1948 is_cow = SvIsCOW(TARG) ? TRUE : FALSE;
1951 sv_force_normal_flags(TARG,0);
1954 #ifdef PERL_COPY_ON_WRITE
1958 || (SvTYPE(TARG) > SVt_PVLV
1959 && !(SvTYPE(TARG) == SVt_PVGV && SvFAKE(TARG)))))
1960 DIE(aTHX_ PL_no_modify);
1963 s = SvPV(TARG, len);
1964 if (!SvPOKp(TARG) || SvTYPE(TARG) == SVt_PVGV)
1966 rxtainted = ((pm->op_pmdynflags & PMdf_TAINTED) ||
1967 (PL_tainted && (pm->op_pmflags & PMf_RETAINT)));
1972 RX_MATCH_UTF8_set(rx, DO_UTF8(TARG));
1976 DIE(aTHX_ "panic: pp_subst");
1979 slen = RX_MATCH_UTF8(rx) ? utf8_length((U8*)s, (U8*)strend) : len;
1980 maxiters = 2 * slen + 10; /* We can match twice at each
1981 position, once with zero-length,
1982 second time with non-zero. */
1984 if (!rx->prelen && PL_curpm) {
1988 r_flags = (rx->nparens || SvTEMP(TARG) || PL_sawampersand)
1989 ? REXEC_COPY_STR : 0;
1991 r_flags |= REXEC_SCREAM;
1992 if ((int)(pm->op_pmflags & PMf_MULTILINE) != PL_multiline) {
1993 SAVEINT(PL_multiline);
1994 PL_multiline = pm->op_pmflags & PMf_MULTILINE;
1997 if (rx->reganch & RE_USE_INTUIT) {
1999 s = CALLREG_INTUIT_START(aTHX_ rx, TARG, s, strend, r_flags, NULL);
2003 /* How to do it in subst? */
2004 /* if ( (rx->reganch & ROPT_CHECK_ALL)
2006 && ((rx->reganch & ROPT_NOSCAN)
2007 || !((rx->reganch & RE_INTUIT_TAIL)
2008 && (r_flags & REXEC_SCREAM))))
2013 /* only replace once? */
2014 once = !(rpm->op_pmflags & PMf_GLOBAL);
2016 /* known replacement string? */
2018 /* replacement needing upgrading? */
2019 if (DO_UTF8(TARG) && !doutf8) {
2020 nsv = sv_newmortal();
2023 sv_recode_to_utf8(nsv, PL_encoding);
2025 sv_utf8_upgrade(nsv);
2026 c = SvPV(nsv, clen);
2030 c = SvPV(dstr, clen);
2031 doutf8 = DO_UTF8(dstr);
2039 /* can do inplace substitution? */
2041 #ifdef PERL_COPY_ON_WRITE
2044 && (I32)clen <= rx->minlen && (once || !(r_flags & REXEC_COPY_STR))
2045 && !(rx->reganch & ROPT_LOOKBEHIND_SEEN)
2046 && (!doutf8 || SvUTF8(TARG))) {
2047 if (!CALLREGEXEC(aTHX_ rx, s, strend, orig, 0, TARG, NULL,
2048 r_flags | REXEC_CHECKED))
2052 LEAVE_SCOPE(oldsave);
2055 #ifdef PERL_COPY_ON_WRITE
2056 if (SvIsCOW(TARG)) {
2057 assert (!force_on_match);
2061 if (force_on_match) {
2063 s = SvPV_force(TARG, len);
2068 SvSCREAM_off(TARG); /* disable possible screamer */
2070 rxtainted |= RX_MATCH_TAINTED(rx);
2071 m = orig + rx->startp[0];
2072 d = orig + rx->endp[0];
2074 if (m - s > strend - d) { /* faster to shorten from end */
2076 Copy(c, m, clen, char);
2081 Move(d, m, i, char);
2085 SvCUR_set(TARG, m - s);
2088 else if ((i = m - s)) { /* faster from front */
2096 Copy(c, m, clen, char);
2101 Copy(c, d, clen, char);
2106 TAINT_IF(rxtainted & 1);
2112 if (iters++ > maxiters)
2113 DIE(aTHX_ "Substitution loop");
2114 rxtainted |= RX_MATCH_TAINTED(rx);
2115 m = rx->startp[0] + orig;
2119 Move(s, d, i, char);
2123 Copy(c, d, clen, char);
2126 s = rx->endp[0] + orig;
2127 } while (CALLREGEXEC(aTHX_ rx, s, strend, orig, s == m,
2129 /* don't match same null twice */
2130 REXEC_NOT_FIRST|REXEC_IGNOREPOS));
2133 SvCUR_set(TARG, d - SvPVX(TARG) + i);
2134 Move(s, d, i+1, char); /* include the NUL */
2136 TAINT_IF(rxtainted & 1);
2138 PUSHs(sv_2mortal(newSViv((I32)iters)));
2140 (void)SvPOK_only_UTF8(TARG);
2141 TAINT_IF(rxtainted);
2142 if (SvSMAGICAL(TARG)) {
2150 LEAVE_SCOPE(oldsave);
2154 if (CALLREGEXEC(aTHX_ rx, s, strend, orig, 0, TARG, NULL,
2155 r_flags | REXEC_CHECKED))
2157 if (force_on_match) {
2159 s = SvPV_force(TARG, len);
2162 #ifdef PERL_COPY_ON_WRITE
2165 rxtainted |= RX_MATCH_TAINTED(rx);
2166 dstr = NEWSV(25, len);
2167 sv_setpvn(dstr, m, s-m);
2172 register PERL_CONTEXT *cx;
2176 RETURNOP(cPMOP->op_pmreplroot);
2178 r_flags |= REXEC_IGNOREPOS | REXEC_NOT_FIRST;
2180 if (iters++ > maxiters)
2181 DIE(aTHX_ "Substitution loop");
2182 rxtainted |= RX_MATCH_TAINTED(rx);
2183 if (RX_MATCH_COPIED(rx) && rx->subbeg != orig) {
2188 strend = s + (strend - m);
2190 m = rx->startp[0] + orig;
2191 if (doutf8 && !SvUTF8(dstr))
2192 sv_catpvn_utf8_upgrade(dstr, s, m - s, nsv);
2194 sv_catpvn(dstr, s, m-s);
2195 s = rx->endp[0] + orig;
2197 sv_catpvn(dstr, c, clen);
2200 } while (CALLREGEXEC(aTHX_ rx, s, strend, orig, s == m,
2201 TARG, NULL, r_flags));
2202 if (doutf8 && !DO_UTF8(TARG))
2203 sv_catpvn_utf8_upgrade(dstr, s, strend - s, nsv);
2205 sv_catpvn(dstr, s, strend - s);
2207 #ifdef PERL_COPY_ON_WRITE
2208 /* The match may make the string COW. If so, brilliant, because that's
2209 just saved us one malloc, copy and free - the regexp has donated
2210 the old buffer, and we malloc an entirely new one, rather than the
2211 regexp malloc()ing a buffer and copying our original, only for
2212 us to throw it away here during the substitution. */
2213 if (SvIsCOW(TARG)) {
2214 sv_force_normal_flags(TARG, SV_COW_DROP_PV);
2218 (void)SvOOK_off(TARG);
2220 Safefree(SvPVX(TARG));
2222 SvPVX(TARG) = SvPVX(dstr);
2223 SvCUR_set(TARG, SvCUR(dstr));
2224 SvLEN_set(TARG, SvLEN(dstr));
2225 doutf8 |= DO_UTF8(dstr);
2229 TAINT_IF(rxtainted & 1);
2231 PUSHs(sv_2mortal(newSViv((I32)iters)));
2233 (void)SvPOK_only(TARG);
2236 TAINT_IF(rxtainted);
2239 LEAVE_SCOPE(oldsave);
2248 LEAVE_SCOPE(oldsave);
2257 PL_stack_base[PL_markstack_ptr[-1]++] = PL_stack_base[*PL_markstack_ptr];
2258 ++*PL_markstack_ptr;
2259 LEAVE; /* exit inner scope */
2262 if (PL_stack_base + *PL_markstack_ptr > SP) {
2264 I32 gimme = GIMME_V;
2266 LEAVE; /* exit outer scope */
2267 (void)POPMARK; /* pop src */
2268 items = --*PL_markstack_ptr - PL_markstack_ptr[-1];
2269 (void)POPMARK; /* pop dst */
2270 SP = PL_stack_base + POPMARK; /* pop original mark */
2271 if (gimme == G_SCALAR) {
2275 else if (gimme == G_ARRAY)
2282 ENTER; /* enter inner scope */
2285 src = PL_stack_base[*PL_markstack_ptr];
2289 RETURNOP(cLOGOP->op_other);
2300 register PERL_CONTEXT *cx;
2304 cxstack_ix++; /* temporarily protect top context */
2307 if (gimme == G_SCALAR) {
2310 if (cx->blk_sub.cv && CvDEPTH(cx->blk_sub.cv) > 1) {
2312 *MARK = SvREFCNT_inc(TOPs);
2317 sv = SvREFCNT_inc(TOPs); /* FREETMPS could clobber it */
2319 *MARK = sv_mortalcopy(sv);
2324 *MARK = SvTEMP(TOPs) ? TOPs : sv_mortalcopy(TOPs);
2328 *MARK = &PL_sv_undef;
2332 else if (gimme == G_ARRAY) {
2333 for (MARK = newsp + 1; MARK <= SP; MARK++) {
2334 if (!SvTEMP(*MARK)) {
2335 *MARK = sv_mortalcopy(*MARK);
2336 TAINT_NOT; /* Each item is independent */
2344 POPSUB(cx,sv); /* Stack values are safe: release CV and @_ ... */
2345 PL_curpm = newpm; /* ... and pop $1 et al */
2348 return pop_return();
2351 /* This duplicates the above code because the above code must not
2352 * get any slower by more conditions */
2360 register PERL_CONTEXT *cx;
2364 cxstack_ix++; /* temporarily protect top context */
2368 if (cx->blk_sub.lval & OPpENTERSUB_INARGS) {
2369 /* We are an argument to a function or grep().
2370 * This kind of lvalueness was legal before lvalue
2371 * subroutines too, so be backward compatible:
2372 * cannot report errors. */
2374 /* Scalar context *is* possible, on the LHS of -> only,
2375 * as in f()->meth(). But this is not an lvalue. */
2376 if (gimme == G_SCALAR)
2378 if (gimme == G_ARRAY) {
2379 if (!CvLVALUE(cx->blk_sub.cv))
2380 goto temporise_array;
2381 EXTEND_MORTAL(SP - newsp);
2382 for (mark = newsp + 1; mark <= SP; mark++) {
2385 else if (SvFLAGS(*mark) & (SVs_PADTMP | SVf_READONLY))
2386 *mark = sv_mortalcopy(*mark);
2388 /* Can be a localized value subject to deletion. */
2389 PL_tmps_stack[++PL_tmps_ix] = *mark;
2390 (void)SvREFCNT_inc(*mark);
2395 else if (cx->blk_sub.lval) { /* Leave it as it is if we can. */
2396 /* Here we go for robustness, not for speed, so we change all
2397 * the refcounts so the caller gets a live guy. Cannot set
2398 * TEMP, so sv_2mortal is out of question. */
2399 if (!CvLVALUE(cx->blk_sub.cv)) {
2405 DIE(aTHX_ "Can't modify non-lvalue subroutine call");
2407 if (gimme == G_SCALAR) {
2411 if (SvFLAGS(TOPs) & (SVs_TEMP | SVs_PADTMP | SVf_READONLY)) {
2417 DIE(aTHX_ "Can't return %s from lvalue subroutine",
2418 SvREADONLY(TOPs) ? (TOPs == &PL_sv_undef) ? "undef"
2419 : "a readonly value" : "a temporary");
2421 else { /* Can be a localized value
2422 * subject to deletion. */
2423 PL_tmps_stack[++PL_tmps_ix] = *mark;
2424 (void)SvREFCNT_inc(*mark);
2427 else { /* Should not happen? */
2433 DIE(aTHX_ "%s returned from lvalue subroutine in scalar context",
2434 (MARK > SP ? "Empty array" : "Array"));
2438 else if (gimme == G_ARRAY) {
2439 EXTEND_MORTAL(SP - newsp);
2440 for (mark = newsp + 1; mark <= SP; mark++) {
2441 if (*mark != &PL_sv_undef
2442 && SvFLAGS(*mark) & (SVs_TEMP | SVs_PADTMP | SVf_READONLY)) {
2443 /* Might be flattened array after $#array = */
2450 DIE(aTHX_ "Can't return a %s from lvalue subroutine",
2451 SvREADONLY(TOPs) ? "readonly value" : "temporary");
2454 /* Can be a localized value subject to deletion. */
2455 PL_tmps_stack[++PL_tmps_ix] = *mark;
2456 (void)SvREFCNT_inc(*mark);
2462 if (gimme == G_SCALAR) {
2466 if (cx->blk_sub.cv && CvDEPTH(cx->blk_sub.cv) > 1) {
2468 *MARK = SvREFCNT_inc(TOPs);
2473 sv = SvREFCNT_inc(TOPs); /* FREETMPS could clobber it */
2475 *MARK = sv_mortalcopy(sv);
2480 *MARK = SvTEMP(TOPs) ? TOPs : sv_mortalcopy(TOPs);
2484 *MARK = &PL_sv_undef;
2488 else if (gimme == G_ARRAY) {
2490 for (MARK = newsp + 1; MARK <= SP; MARK++) {
2491 if (!SvTEMP(*MARK)) {
2492 *MARK = sv_mortalcopy(*MARK);
2493 TAINT_NOT; /* Each item is independent */
2502 POPSUB(cx,sv); /* Stack values are safe: release CV and @_ ... */
2503 PL_curpm = newpm; /* ... and pop $1 et al */
2506 return pop_return();
2511 S_get_db_sub(pTHX_ SV **svp, CV *cv)
2513 SV *dbsv = GvSV(PL_DBsub);
2515 if (!PERLDB_SUB_NN) {
2519 if ( (CvFLAGS(cv) & (CVf_ANON | CVf_CLONED))
2520 || strEQ(GvNAME(gv), "END")
2521 || ((GvCV(gv) != cv) && /* Could be imported, and old sub redefined. */
2522 !( (SvTYPE(*svp) == SVt_PVGV) && (GvCV((GV*)*svp) == cv)
2523 && (gv = (GV*)*svp) ))) {
2524 /* Use GV from the stack as a fallback. */
2525 /* GV is potentially non-unique, or contain different CV. */
2526 SV *tmp = newRV((SV*)cv);
2527 sv_setsv(dbsv, tmp);
2531 gv_efullname3(dbsv, gv, Nullch);
2535 (void)SvUPGRADE(dbsv, SVt_PVIV);
2536 (void)SvIOK_on(dbsv);
2537 SAVEIV(SvIVX(dbsv));
2538 SvIVX(dbsv) = PTR2IV(cv); /* Do it the quickest way */
2542 PL_curcopdb = PL_curcop;
2543 cv = GvCV(PL_DBsub);
2553 register PERL_CONTEXT *cx;
2555 bool hasargs = (PL_op->op_flags & OPf_STACKED) != 0;
2558 DIE(aTHX_ "Not a CODE reference");
2559 switch (SvTYPE(sv)) {
2560 /* This is overwhelming the most common case: */
2562 if (!(cv = GvCVu((GV*)sv)))
2563 cv = sv_2cv(sv, &stash, &gv, FALSE);
2575 if (sv == &PL_sv_yes) { /* unfound import, ignore */
2577 SP = PL_stack_base + POPMARK;
2580 if (SvGMAGICAL(sv)) {
2584 sym = SvPOKp(sv) ? SvPVX(sv) : Nullch;
2587 sym = SvPV(sv, n_a);
2589 DIE(aTHX_ PL_no_usym, "a subroutine");
2590 if (PL_op->op_private & HINT_STRICT_REFS)
2591 DIE(aTHX_ PL_no_symref, sym, "a subroutine");
2592 cv = get_cv(sym, TRUE);
2597 SV **sp = &sv; /* Used in tryAMAGICunDEREF macro. */
2598 tryAMAGICunDEREF(to_cv);
2601 if (SvTYPE(cv) == SVt_PVCV)
2606 DIE(aTHX_ "Not a CODE reference");
2607 /* This is the second most common case: */
2617 if (!CvROOT(cv) && !CvXSUB(cv)) {
2622 if ((PL_op->op_private & OPpENTERSUB_DB) && GvCV(PL_DBsub) && !CvNODEBUG(cv)) {
2623 if (CvASSERTION(cv) && PL_DBassertion)
2624 sv_setiv(PL_DBassertion, 1);
2626 cv = get_db_sub(&sv, cv);
2628 DIE(aTHX_ "No DBsub routine");
2631 if (!(CvXSUB(cv))) {
2632 /* This path taken at least 75% of the time */
2634 register I32 items = SP - MARK;
2635 AV* padlist = CvPADLIST(cv);
2636 push_return(PL_op->op_next);
2637 PUSHBLOCK(cx, CXt_SUB, MARK);
2640 /* XXX This would be a natural place to set C<PL_compcv = cv> so
2641 * that eval'' ops within this sub know the correct lexical space.
2642 * Owing the speed considerations, we choose instead to search for
2643 * the cv using find_runcv() when calling doeval().
2645 if (CvDEPTH(cv) < 2)
2646 (void)SvREFCNT_inc(cv);
2648 PERL_STACK_OVERFLOW_CHECK();
2649 pad_push(padlist, CvDEPTH(cv), 1);
2651 PAD_SET_CUR(padlist, CvDEPTH(cv));
2658 DEBUG_S(PerlIO_printf(Perl_debug_log,
2659 "%p entersub preparing @_\n", thr));
2661 av = (AV*)PAD_SVl(0);
2663 /* @_ is normally not REAL--this should only ever
2664 * happen when DB::sub() calls things that modify @_ */
2669 cx->blk_sub.savearray = GvAV(PL_defgv);
2670 GvAV(PL_defgv) = (AV*)SvREFCNT_inc(av);
2671 CX_CURPAD_SAVE(cx->blk_sub);
2672 cx->blk_sub.argarray = av;
2675 if (items > AvMAX(av) + 1) {
2677 if (AvARRAY(av) != ary) {
2678 AvMAX(av) += AvARRAY(av) - AvALLOC(av);
2679 SvPVX(av) = (char*)ary;
2681 if (items > AvMAX(av) + 1) {
2682 AvMAX(av) = items - 1;
2683 Renew(ary,items,SV*);
2685 SvPVX(av) = (char*)ary;
2688 Copy(MARK,AvARRAY(av),items,SV*);
2689 AvFILLp(av) = items - 1;
2697 /* warning must come *after* we fully set up the context
2698 * stuff so that __WARN__ handlers can safely dounwind()
2701 if (CvDEPTH(cv) == 100 && ckWARN(WARN_RECURSION)
2702 && !(PERLDB_SUB && cv == GvCV(PL_DBsub)))
2703 sub_crush_depth(cv);
2705 DEBUG_S(PerlIO_printf(Perl_debug_log,
2706 "%p entersub returning %p\n", thr, CvSTART(cv)));
2708 RETURNOP(CvSTART(cv));
2711 #ifdef PERL_XSUB_OLDSTYLE
2712 if (CvOLDSTYLE(cv)) {
2713 I32 (*fp3)(int,int,int);
2715 register I32 items = SP - MARK;
2716 /* We dont worry to copy from @_. */
2721 PL_stack_sp = mark + 1;
2722 fp3 = (I32(*)(int,int,int))CvXSUB(cv);
2723 items = (*fp3)(CvXSUBANY(cv).any_i32,
2724 MARK - PL_stack_base + 1,
2726 PL_stack_sp = PL_stack_base + items;
2729 #endif /* PERL_XSUB_OLDSTYLE */
2731 I32 markix = TOPMARK;
2736 /* Need to copy @_ to stack. Alternative may be to
2737 * switch stack to @_, and copy return values
2738 * back. This would allow popping @_ in XSUB, e.g.. XXXX */
2741 av = GvAV(PL_defgv);
2742 items = AvFILLp(av) + 1; /* @_ is not tieable */
2745 /* Mark is at the end of the stack. */
2747 Copy(AvARRAY(av), SP + 1, items, SV*);
2752 /* We assume first XSUB in &DB::sub is the called one. */
2754 SAVEVPTR(PL_curcop);
2755 PL_curcop = PL_curcopdb;
2758 /* Do we need to open block here? XXXX */
2759 (void)(*CvXSUB(cv))(aTHX_ cv);
2761 /* Enforce some sanity in scalar context. */
2762 if (gimme == G_SCALAR && ++markix != PL_stack_sp - PL_stack_base ) {
2763 if (markix > PL_stack_sp - PL_stack_base)
2764 *(PL_stack_base + markix) = &PL_sv_undef;
2766 *(PL_stack_base + markix) = *PL_stack_sp;
2767 PL_stack_sp = PL_stack_base + markix;
2774 assert (0); /* Cannot get here. */
2775 /* This is deliberately moved here as spaghetti code to keep it out of the
2782 /* anonymous or undef'd function leaves us no recourse */
2783 if (CvANON(cv) || !(gv = CvGV(cv)))
2784 DIE(aTHX_ "Undefined subroutine called");
2786 /* autoloaded stub? */
2787 if (cv != GvCV(gv)) {
2790 /* should call AUTOLOAD now? */
2793 if ((autogv = gv_autoload4(GvSTASH(gv), GvNAME(gv), GvNAMELEN(gv),
2800 sub_name = sv_newmortal();
2801 gv_efullname3(sub_name, gv, Nullch);
2802 DIE(aTHX_ "Undefined subroutine &%"SVf" called", sub_name);
2806 DIE(aTHX_ "Not a CODE reference");
2812 Perl_sub_crush_depth(pTHX_ CV *cv)
2815 Perl_warner(aTHX_ packWARN(WARN_RECURSION), "Deep recursion on anonymous subroutine");
2817 SV* tmpstr = sv_newmortal();
2818 gv_efullname3(tmpstr, CvGV(cv), Nullch);
2819 Perl_warner(aTHX_ packWARN(WARN_RECURSION), "Deep recursion on subroutine \"%"SVf"\"",
2829 IV elem = SvIV(elemsv);
2831 U32 lval = PL_op->op_flags & OPf_MOD || LVRET;
2832 U32 defer = (PL_op->op_private & OPpLVAL_DEFER) && (elem > AvFILL(av));
2835 if (SvROK(elemsv) && !SvGAMAGIC(elemsv) && ckWARN(WARN_MISC))
2836 Perl_warner(aTHX_ packWARN(WARN_MISC), "Use of reference \"%"SVf"\" as array index", elemsv);
2838 elem -= PL_curcop->cop_arybase;
2839 if (SvTYPE(av) != SVt_PVAV)
2841 svp = av_fetch(av, elem, lval && !defer);
2843 if (!svp || *svp == &PL_sv_undef) {
2846 DIE(aTHX_ PL_no_aelem, elem);
2847 lv = sv_newmortal();
2848 sv_upgrade(lv, SVt_PVLV);
2850 sv_magic(lv, Nullsv, PERL_MAGIC_defelem, Nullch, 0);
2851 LvTARG(lv) = SvREFCNT_inc(av);
2852 LvTARGOFF(lv) = elem;
2857 if (PL_op->op_private & OPpLVAL_INTRO)
2858 save_aelem(av, elem, svp);
2859 else if (PL_op->op_private & OPpDEREF)
2860 vivify_ref(*svp, PL_op->op_private & OPpDEREF);
2862 sv = (svp ? *svp : &PL_sv_undef);
2863 if (!lval && SvGMAGICAL(sv)) /* see note in pp_helem() */
2864 sv = sv_mortalcopy(sv);
2870 Perl_vivify_ref(pTHX_ SV *sv, U32 to_what)
2876 Perl_croak(aTHX_ PL_no_modify);
2877 if (SvTYPE(sv) < SVt_RV)
2878 sv_upgrade(sv, SVt_RV);
2879 else if (SvTYPE(sv) >= SVt_PV) {
2880 (void)SvOOK_off(sv);
2881 Safefree(SvPVX(sv));
2882 SvLEN(sv) = SvCUR(sv) = 0;
2886 SvRV(sv) = NEWSV(355,0);
2889 SvRV(sv) = (SV*)newAV();
2892 SvRV(sv) = (SV*)newHV();
2907 if (SvTYPE(rsv) == SVt_PVCV) {
2913 SETs(method_common(sv, Null(U32*)));
2921 U32 hash = SvUVX(sv);
2923 XPUSHs(method_common(sv, &hash));
2928 S_method_common(pTHX_ SV* meth, U32* hashp)
2937 SV *packsv = Nullsv;
2940 name = SvPV(meth, namelen);
2941 sv = *(PL_stack_base + TOPMARK + 1);
2944 Perl_croak(aTHX_ "Can't call method \"%s\" on an undefined value", name);
2953 /* this isn't a reference */
2956 if(SvOK(sv) && (packname = SvPV(sv, packlen))) {
2958 he = hv_fetch_ent(PL_stashcache, sv, 0, 0);
2960 stash = INT2PTR(HV*,SvIV(HeVAL(he)));
2967 !(iogv = gv_fetchpv(packname, FALSE, SVt_PVIO)) ||
2968 !(ob=(SV*)GvIO(iogv)))
2970 /* this isn't the name of a filehandle either */
2972 ((UTF8_IS_START(*packname) && DO_UTF8(sv))
2973 ? !isIDFIRST_utf8((U8*)packname)
2974 : !isIDFIRST(*packname)
2977 Perl_croak(aTHX_ "Can't call method \"%s\" %s", name,
2978 SvOK(sv) ? "without a package or object reference"
2979 : "on an undefined value");
2981 /* assume it's a package name */
2982 stash = gv_stashpvn(packname, packlen, FALSE);
2986 SV* ref = newSViv(PTR2IV(stash));
2987 hv_store(PL_stashcache, packname, packlen, ref, 0);
2991 /* it _is_ a filehandle name -- replace with a reference */
2992 *(PL_stack_base + TOPMARK + 1) = sv_2mortal(newRV((SV*)iogv));
2995 /* if we got here, ob should be a reference or a glob */
2996 if (!ob || !(SvOBJECT(ob)
2997 || (SvTYPE(ob) == SVt_PVGV && (ob = (SV*)GvIO((GV*)ob))
3000 Perl_croak(aTHX_ "Can't call method \"%s\" on unblessed reference",
3004 stash = SvSTASH(ob);
3007 /* NOTE: stash may be null, hope hv_fetch_ent and
3008 gv_fetchmethod can cope (it seems they can) */
3010 /* shortcut for simple names */
3012 HE* he = hv_fetch_ent(stash, meth, 0, *hashp);
3014 gv = (GV*)HeVAL(he);
3015 if (isGV(gv) && GvCV(gv) &&
3016 (!GvCVGEN(gv) || GvCVGEN(gv) == PL_sub_generation))
3017 return (SV*)GvCV(gv);
3021 gv = gv_fetchmethod(stash ? stash : (HV*)packsv, name);
3024 /* This code tries to figure out just what went wrong with
3025 gv_fetchmethod. It therefore needs to duplicate a lot of
3026 the internals of that function. We can't move it inside
3027 Perl_gv_fetchmethod_autoload(), however, since that would
3028 cause UNIVERSAL->can("NoSuchPackage::foo") to croak, and we
3035 for (p = name; *p; p++) {
3037 sep = p, leaf = p + 1;
3038 else if (*p == ':' && *(p + 1) == ':')
3039 sep = p, leaf = p + 2;
3041 if (!sep || ((sep - name) == 5 && strnEQ(name, "SUPER", 5))) {
3042 /* the method name is unqualified or starts with SUPER:: */
3043 packname = sep ? CopSTASHPV(PL_curcop) :
3044 stash ? HvNAME(stash) : packname;
3047 "Can't use anonymous symbol table for method lookup");
3049 packlen = strlen(packname);
3052 /* the method name is qualified */
3054 packlen = sep - name;
3057 /* we're relying on gv_fetchmethod not autovivifying the stash */
3058 if (gv_stashpvn(packname, packlen, FALSE)) {
3060 "Can't locate object method \"%s\" via package \"%.*s\"",
3061 leaf, (int)packlen, packname);
3065 "Can't locate object method \"%s\" via package \"%.*s\""
3066 " (perhaps you forgot to load \"%.*s\"?)",
3067 leaf, (int)packlen, packname, (int)packlen, packname);
3070 return isGV(gv) ? (SV*)GvCV(gv) : (SV*)gv;