3 * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
4 * 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by Larry Wall and others
6 * You may distribute under the terms of either the GNU General Public
7 * License or the Artistic License, as specified in the README file.
12 * 'It's a big house this, and very peculiar. Always a bit more
13 * to discover, and no knowing what you'll find round a corner.
14 * And Elves, sir!' --Samwise Gamgee
16 * [p.225 of _The Lord of the Rings_, II/i: "Many Meetings"]
19 /* This file contains general pp ("push/pop") functions that execute the
20 * opcodes that make up a perl program. A typical pp function expects to
21 * find its arguments on the stack, and usually pushes its results onto
22 * the stack, hence the 'pp' terminology. Each OP structure contains
23 * a pointer to the relevant pp_foo() function.
32 #include "regcharclass.h"
34 /* XXX I can't imagine anyone who doesn't have this actually _needs_
35 it, since pid_t is an integral type.
38 #ifdef NEED_GETPID_PROTO
39 extern Pid_t getpid (void);
43 * Some BSDs and Cygwin default to POSIX math instead of IEEE.
44 * This switches them over to IEEE.
46 #if defined(LIBM_LIB_VERSION)
47 _LIB_VERSION_TYPE _LIB_VERSION = _IEEE_;
50 static const STRLEN small_mu_len = sizeof(GREEK_SMALL_LETTER_MU_UTF8) - 1;
51 static const STRLEN capital_iota_len = sizeof(GREEK_CAPITAL_LETTER_IOTA_UTF8) - 1;
53 /* variations on pp_null */
58 if (GIMME_V == G_SCALAR)
65 /* This is also called directly by pp_lvavref. */
70 assert(SvTYPE(TARG) == SVt_PVAV);
71 if (UNLIKELY( PL_op->op_private & OPpLVAL_INTRO ))
72 if (LIKELY( !(PL_op->op_private & OPpPAD_STATE) ))
73 SAVECLEARSV(PAD_SVl(PL_op->op_targ));
75 if (PL_op->op_flags & OPf_REF) {
78 } else if (PL_op->op_private & OPpMAYBE_LVSUB) {
79 const I32 flags = is_lvalue_sub();
80 if (flags && !(flags & OPpENTERSUB_INARGS)) {
81 if (GIMME_V == G_SCALAR)
82 /* diag_listed_as: Can't return %s to lvalue scalar context */
83 Perl_croak(aTHX_ "Can't return array to lvalue scalar context");
89 if (gimme == G_ARRAY) {
90 /* XXX see also S_pushav in pp_hot.c */
91 const Size_t maxarg = AvFILL(MUTABLE_AV(TARG)) + 1;
93 if (SvMAGICAL(TARG)) {
95 for (i=0; i < maxarg; i++) {
96 SV * const * const svp = av_fetch(MUTABLE_AV(TARG), i, FALSE);
97 SP[i+1] = (svp) ? *svp : &PL_sv_undef;
102 for (i=0; i < (PADOFFSET)maxarg; i++) {
103 SV * const sv = AvARRAY((const AV *)TARG)[i];
104 SP[i+1] = sv ? sv : &PL_sv_undef;
109 else if (gimme == G_SCALAR) {
110 SV* const sv = sv_newmortal();
111 const SSize_t maxarg = AvFILL(MUTABLE_AV(TARG)) + 1;
112 sv_setiv(sv, maxarg);
123 assert(SvTYPE(TARG) == SVt_PVHV);
125 if (UNLIKELY( PL_op->op_private & OPpLVAL_INTRO ))
126 if (LIKELY( !(PL_op->op_private & OPpPAD_STATE) ))
127 SAVECLEARSV(PAD_SVl(PL_op->op_targ));
128 if (PL_op->op_flags & OPf_REF)
130 else if (PL_op->op_private & OPpMAYBE_LVSUB) {
131 const I32 flags = is_lvalue_sub();
132 if (flags && !(flags & OPpENTERSUB_INARGS)) {
133 if (GIMME_V == G_SCALAR)
134 /* diag_listed_as: Can't return %s to lvalue scalar context */
135 Perl_croak(aTHX_ "Can't return hash to lvalue scalar context");
140 if (gimme == G_ARRAY) {
141 RETURNOP(Perl_do_kv(aTHX));
143 else if ((PL_op->op_private & OPpTRUEBOOL
144 || ( PL_op->op_private & OPpMAYBE_TRUEBOOL
145 && block_gimme() == G_VOID ))
146 && (!SvRMAGICAL(TARG) || !mg_find(TARG, PERL_MAGIC_tied)))
147 SETs(HvUSEDKEYS(TARG) ? &PL_sv_yes : sv_2mortal(newSViv(0)));
148 else if (gimme == G_SCALAR) {
149 SV* const sv = Perl_hv_scalar(aTHX_ MUTABLE_HV(TARG));
158 assert(SvTYPE(TARG) == SVt_PVCV);
166 SvPADSTALE_off(TARG);
173 CV * const protocv = PadnamePROTOCV(
174 PadlistNAMESARRAY(CvPADLIST(find_runcv(NULL)))[ARGTARG]
176 assert(SvTYPE(TARG) == SVt_PVCV);
178 if (CvISXSUB(protocv)) { /* constant */
179 /* XXX Should we clone it here? */
180 /* If this changes to use SAVECLEARSV, we can move the SAVECLEARSV
181 to introcv and remove the SvPADSTALE_off. */
182 SAVEPADSVANDMORTALIZE(ARGTARG);
183 PAD_SVl(ARGTARG) = SvREFCNT_inc_simple_NN(protocv);
186 if (CvROOT(protocv)) {
187 assert(CvCLONE(protocv));
188 assert(!CvCLONED(protocv));
190 cv_clone_into(protocv,(CV *)TARG);
191 SAVECLEARSV(PAD_SVl(ARGTARG));
198 /* In some cases this function inspects PL_op. If this function is called
199 for new op types, more bool parameters may need to be added in place of
202 When noinit is true, the absence of a gv will cause a retval of undef.
203 This is unrelated to the cv-to-gv assignment case.
207 S_rv2gv(pTHX_ SV *sv, const bool vivify_sv, const bool strict,
210 if (!isGV(sv) || SvFAKE(sv)) SvGETMAGIC(sv);
213 sv = amagic_deref_call(sv, to_gv_amg);
217 if (SvTYPE(sv) == SVt_PVIO) {
218 GV * const gv = MUTABLE_GV(sv_newmortal());
219 gv_init(gv, 0, "__ANONIO__", 10, 0);
220 GvIOp(gv) = MUTABLE_IO(sv);
221 SvREFCNT_inc_void_NN(sv);
224 else if (!isGV_with_GP(sv)) {
225 Perl_die(aTHX_ "Not a GLOB reference");
229 if (!isGV_with_GP(sv)) {
231 /* If this is a 'my' scalar and flag is set then vivify
234 if (vivify_sv && sv != &PL_sv_undef) {
237 Perl_croak_no_modify();
238 if (cUNOP->op_targ) {
239 SV * const namesv = PAD_SV(cUNOP->op_targ);
240 HV *stash = CopSTASH(PL_curcop);
241 if (SvTYPE(stash) != SVt_PVHV) stash = NULL;
242 gv = MUTABLE_GV(newSV(0));
243 gv_init_sv(gv, stash, namesv, 0);
246 const char * const name = CopSTASHPV(PL_curcop);
247 gv = newGVgen_flags(name,
248 HvNAMEUTF8(CopSTASH(PL_curcop)) ? SVf_UTF8 : 0 );
249 SvREFCNT_inc_simple_void_NN(gv);
251 prepare_SV_for_RV(sv);
252 SvRV_set(sv, MUTABLE_SV(gv));
257 if (PL_op->op_flags & OPf_REF || strict) {
258 Perl_die(aTHX_ PL_no_usym, "a symbol");
260 if (ckWARN(WARN_UNINITIALIZED))
266 if (!(sv = MUTABLE_SV(gv_fetchsv_nomg(
267 sv, GV_ADDMG, SVt_PVGV
276 (SvPOKp(sv) && SvCUR(sv)>32 ? "..." : ""),
280 if ((PL_op->op_private & (OPpLVAL_INTRO|OPpDONT_INIT_GV))
281 == OPpDONT_INIT_GV) {
282 /* We are the target of a coderef assignment. Return
283 the scalar unchanged, and let pp_sasssign deal with
287 sv = MUTABLE_SV(gv_fetchsv_nomg(sv, GV_ADD, SVt_PVGV));
289 /* FAKE globs in the symbol table cause weird bugs (#77810) */
293 if (SvFAKE(sv) && !(PL_op->op_private & OPpALLOW_FAKE)) {
294 SV *newsv = sv_newmortal();
295 sv_setsv_flags(newsv, sv, 0);
307 sv, PL_op->op_private & OPpDEREF,
308 PL_op->op_private & HINT_STRICT_REFS,
309 ((PL_op->op_flags & OPf_SPECIAL) && !(PL_op->op_flags & OPf_MOD))
310 || PL_op->op_type == OP_READLINE
312 if (PL_op->op_private & OPpLVAL_INTRO)
313 save_gp(MUTABLE_GV(sv), !(PL_op->op_flags & OPf_SPECIAL));
318 /* Helper function for pp_rv2sv and pp_rv2av */
320 Perl_softref2xv(pTHX_ SV *const sv, const char *const what,
321 const svtype type, SV ***spp)
325 PERL_ARGS_ASSERT_SOFTREF2XV;
327 if (PL_op->op_private & HINT_STRICT_REFS) {
329 Perl_die(aTHX_ PL_no_symref_sv, sv,
330 (SvPOKp(sv) && SvCUR(sv)>32 ? "..." : ""), what);
332 Perl_die(aTHX_ PL_no_usym, what);
336 PL_op->op_flags & OPf_REF
338 Perl_die(aTHX_ PL_no_usym, what);
339 if (ckWARN(WARN_UNINITIALIZED))
341 if (type != SVt_PV && GIMME_V == G_ARRAY) {
345 **spp = &PL_sv_undef;
348 if ((PL_op->op_flags & OPf_SPECIAL) &&
349 !(PL_op->op_flags & OPf_MOD))
351 if (!(gv = gv_fetchsv_nomg(sv, GV_ADDMG, type)))
353 **spp = &PL_sv_undef;
358 gv = gv_fetchsv_nomg(sv, GV_ADD, type);
371 sv = amagic_deref_call(sv, to_sv_amg);
375 if (SvTYPE(sv) >= SVt_PVAV)
376 DIE(aTHX_ "Not a SCALAR reference");
381 if (!isGV_with_GP(gv)) {
382 gv = Perl_softref2xv(aTHX_ sv, "a SCALAR", SVt_PV, &sp);
388 if (PL_op->op_flags & OPf_MOD) {
389 if (PL_op->op_private & OPpLVAL_INTRO) {
390 if (cUNOP->op_first->op_type == OP_NULL)
391 sv = save_scalar(MUTABLE_GV(TOPs));
393 sv = save_scalar(gv);
395 Perl_croak(aTHX_ "%s", PL_no_localize_ref);
397 else if (PL_op->op_private & OPpDEREF)
398 sv = vivify_ref(sv, PL_op->op_private & OPpDEREF);
407 AV * const av = MUTABLE_AV(TOPs);
408 const I32 lvalue = PL_op->op_flags & OPf_MOD || LVRET;
410 SV ** const svp = Perl_av_arylen_p(aTHX_ MUTABLE_AV(av));
412 *svp = newSV_type(SVt_PVMG);
413 sv_magic(*svp, MUTABLE_SV(av), PERL_MAGIC_arylen, NULL, 0);
417 SETs(sv_2mortal(newSViv(AvFILL(MUTABLE_AV(av)))));
426 if (PL_op->op_flags & OPf_MOD || LVRET) {
427 SV * const ret = sv_2mortal(newSV_type(SVt_PVLV));/* Not TARG RT#67838 */
428 sv_magic(ret, NULL, PERL_MAGIC_pos, NULL, 0);
430 LvTARG(ret) = SvREFCNT_inc_simple(sv);
431 SETs(ret); /* no SvSETMAGIC */
434 const MAGIC * const mg = mg_find_mglob(sv);
435 if (mg && mg->mg_len != -1) {
437 STRLEN i = mg->mg_len;
438 if (mg->mg_flags & MGf_BYTES && DO_UTF8(sv))
439 i = sv_pos_b2u_flags(sv, i, SV_GMAGIC|SV_CONST_RETURN);
453 const I32 flags = (PL_op->op_flags & OPf_SPECIAL)
455 : ((PL_op->op_private & (OPpLVAL_INTRO|OPpMAY_RETURN_CONSTANT))
456 == OPpMAY_RETURN_CONSTANT)
459 /* We usually try to add a non-existent subroutine in case of AUTOLOAD. */
460 /* (But not in defined().) */
462 CV *cv = sv_2cv(TOPs, &stash_unused, &gv, flags);
464 else if ((flags == (GV_ADD|GV_NOEXPAND)) && gv && SvROK(gv)) {
465 cv = SvTYPE(SvRV(gv)) == SVt_PVCV
466 ? MUTABLE_CV(SvRV(gv))
470 cv = MUTABLE_CV(&PL_sv_undef);
471 SETs(MUTABLE_SV(cv));
481 SV *ret = &PL_sv_undef;
483 if (SvGMAGICAL(TOPs)) SETs(sv_mortalcopy(TOPs));
484 if (SvPOK(TOPs) && SvCUR(TOPs) >= 7) {
485 const char * s = SvPVX_const(TOPs);
486 if (strnEQ(s, "CORE::", 6)) {
487 const int code = keyword(s + 6, SvCUR(TOPs) - 6, 1);
489 DIE(aTHX_ "Can't find an opnumber for \"%"UTF8f"\"",
490 UTF8fARG(SvFLAGS(TOPs) & SVf_UTF8, SvCUR(TOPs)-6, s+6));
492 SV * const sv = core_prototype(NULL, s + 6, code, NULL);
498 cv = sv_2cv(TOPs, &stash, &gv, 0);
500 ret = newSVpvn_flags(
501 CvPROTO(cv), CvPROTOLEN(cv), SVs_TEMP | SvUTF8(cv)
511 CV *cv = MUTABLE_CV(PAD_SV(PL_op->op_targ));
513 cv = MUTABLE_CV(sv_2mortal(MUTABLE_SV(cv_clone(cv))));
515 PUSHs(MUTABLE_SV(cv));
529 if (GIMME_V != G_ARRAY) {
535 *MARK = &PL_sv_undef;
537 *MARK = refto(*MARK);
541 EXTEND_MORTAL(SP - MARK);
543 *MARK = refto(*MARK);
548 S_refto(pTHX_ SV *sv)
552 PERL_ARGS_ASSERT_REFTO;
554 if (SvTYPE(sv) == SVt_PVLV && LvTYPE(sv) == 'y') {
557 if (!(sv = LvTARG(sv)))
560 SvREFCNT_inc_void_NN(sv);
562 else if (SvTYPE(sv) == SVt_PVAV) {
563 if (!AvREAL((const AV *)sv) && AvREIFY((const AV *)sv))
564 av_reify(MUTABLE_AV(sv));
566 SvREFCNT_inc_void_NN(sv);
568 else if (SvPADTMP(sv)) {
573 SvREFCNT_inc_void_NN(sv);
576 sv_upgrade(rv, SVt_IV);
585 SV * const sv = TOPs;
593 /* use the return value that is in a register, its the same as TARG */
594 TARG = sv_ref(TARG,SvRV(sv),TRUE);
609 stash = CopSTASH(PL_curcop);
610 if (SvTYPE(stash) != SVt_PVHV)
611 Perl_croak(aTHX_ "Attempt to bless into a freed package");
614 SV * const ssv = POPs;
618 if (!ssv) goto curstash;
621 if (!SvAMAGIC(ssv)) {
623 Perl_croak(aTHX_ "Attempt to bless into a reference");
625 /* SvAMAGIC is on here, but it only means potentially overloaded,
626 so after stringification: */
627 ptr = SvPV_nomg_const(ssv,len);
628 /* We need to check the flag again: */
629 if (!SvAMAGIC(ssv)) goto frog;
631 else ptr = SvPV_nomg_const(ssv,len);
633 Perl_ck_warner(aTHX_ packWARN(WARN_MISC),
634 "Explicit blessing to '' (assuming package main)");
635 stash = gv_stashpvn(ptr, len, GV_ADD|SvUTF8(ssv));
638 (void)sv_bless(TOPs, stash);
648 const char * const elem = SvPV_const(sv, len);
649 GV * const gv = MUTABLE_GV(TOPs);
654 /* elem will always be NUL terminated. */
655 const char * const second_letter = elem + 1;
658 if (len == 5 && strEQ(second_letter, "RRAY"))
660 tmpRef = MUTABLE_SV(GvAV(gv));
661 if (tmpRef && !AvREAL((const AV *)tmpRef)
662 && AvREIFY((const AV *)tmpRef))
663 av_reify(MUTABLE_AV(tmpRef));
667 if (len == 4 && strEQ(second_letter, "ODE"))
668 tmpRef = MUTABLE_SV(GvCVu(gv));
671 if (len == 10 && strEQ(second_letter, "ILEHANDLE")) {
672 /* finally deprecated in 5.8.0 */
673 deprecate("*glob{FILEHANDLE}");
674 tmpRef = MUTABLE_SV(GvIOp(gv));
677 if (len == 6 && strEQ(second_letter, "ORMAT"))
678 tmpRef = MUTABLE_SV(GvFORM(gv));
681 if (len == 4 && strEQ(second_letter, "LOB"))
682 tmpRef = MUTABLE_SV(gv);
685 if (len == 4 && strEQ(second_letter, "ASH"))
686 tmpRef = MUTABLE_SV(GvHV(gv));
689 if (*second_letter == 'O' && !elem[2] && len == 2)
690 tmpRef = MUTABLE_SV(GvIOp(gv));
693 if (len == 4 && strEQ(second_letter, "AME"))
694 sv = newSVhek(GvNAME_HEK(gv));
697 if (len == 7 && strEQ(second_letter, "ACKAGE")) {
698 const HV * const stash = GvSTASH(gv);
699 const HEK * const hek = stash ? HvNAME_HEK(stash) : NULL;
700 sv = hek ? newSVhek(hek) : newSVpvs("__ANON__");
704 if (len == 6 && strEQ(second_letter, "CALAR"))
719 /* Pattern matching */
727 if (len == 0 || len > I32_MAX || !SvPOK(sv) || SvUTF8(sv) || SvVALID(sv)) {
728 /* Historically, study was skipped in these cases. */
733 /* Make study a no-op. It's no longer useful and its existence
734 complicates matters elsewhere. */
740 /* also used for: pp_transr() */
747 if (PL_op->op_flags & OPf_STACKED)
752 sv = PAD_SV(ARGTARG);
757 if(PL_op->op_type == OP_TRANSR) {
759 const char * const pv = SvPV(sv,len);
760 SV * const newsv = newSVpvn_flags(pv, len, SVs_TEMP|SvUTF8(sv));
765 mPUSHi(do_trans(sv));
770 /* Lvalue operators. */
773 S_do_chomp(pTHX_ SV *retval, SV *sv, bool chomping)
779 PERL_ARGS_ASSERT_DO_CHOMP;
781 if (chomping && (RsSNARF(PL_rs) || RsRECORD(PL_rs)))
783 if (SvTYPE(sv) == SVt_PVAV) {
785 AV *const av = MUTABLE_AV(sv);
786 const I32 max = AvFILL(av);
788 for (i = 0; i <= max; i++) {
789 sv = MUTABLE_SV(av_fetch(av, i, FALSE));
790 if (sv && ((sv = *(SV**)sv), sv != &PL_sv_undef))
791 count += do_chomp(retval, sv, chomping);
795 else if (SvTYPE(sv) == SVt_PVHV) {
796 HV* const hv = MUTABLE_HV(sv);
798 (void)hv_iterinit(hv);
799 while ((entry = hv_iternext(hv)))
800 count += do_chomp(retval, hv_iterval(hv,entry), chomping);
803 else if (SvREADONLY(sv)) {
804 Perl_croak_no_modify();
809 /* XXX, here sv is utf8-ized as a side-effect!
810 If encoding.pm is used properly, almost string-generating
811 operations, including literal strings, chr(), input data, etc.
812 should have been utf8-ized already, right?
814 sv_recode_to_utf8(sv, _get_encoding());
820 char *temp_buffer = NULL;
829 while (len && s[-1] == '\n') {
836 STRLEN rslen, rs_charlen;
837 const char *rsptr = SvPV_const(PL_rs, rslen);
839 rs_charlen = SvUTF8(PL_rs)
843 if (SvUTF8(PL_rs) != SvUTF8(sv)) {
844 /* Assumption is that rs is shorter than the scalar. */
846 /* RS is utf8, scalar is 8 bit. */
848 temp_buffer = (char*)bytes_from_utf8((U8*)rsptr,
851 /* Cannot downgrade, therefore cannot possibly match
853 assert (temp_buffer == rsptr);
859 else if (IN_ENCODING) {
860 /* RS is 8 bit, encoding.pm is used.
861 * Do not recode PL_rs as a side-effect. */
862 svrecode = newSVpvn(rsptr, rslen);
863 sv_recode_to_utf8(svrecode, _get_encoding());
864 rsptr = SvPV_const(svrecode, rslen);
865 rs_charlen = sv_len_utf8(svrecode);
868 /* RS is 8 bit, scalar is utf8. */
869 temp_buffer = (char*)bytes_to_utf8((U8*)rsptr, &rslen);
883 if (memNE(s, rsptr, rslen))
888 SvPV_force_nomg_nolen(sv);
896 SvREFCNT_dec(svrecode);
898 Safefree(temp_buffer);
900 if (len && (!SvPOK(sv) || SvIsCOW(sv)))
901 s = SvPV_force_nomg(sv, len);
904 char * const send = s + len;
905 char * const start = s;
907 while (s > start && UTF8_IS_CONTINUATION(*s))
909 if (is_utf8_string((U8*)s, send - s)) {
910 sv_setpvn(retval, s, send - s);
912 SvCUR_set(sv, s - start);
918 sv_setpvs(retval, "");
922 sv_setpvn(retval, s, 1);
929 sv_setpvs(retval, "");
936 /* also used for: pp_schomp() */
941 const bool chomping = PL_op->op_type == OP_SCHOMP;
943 const size_t count = do_chomp(TARG, TOPs, chomping);
945 sv_setiv(TARG, count);
951 /* also used for: pp_chomp() */
955 dSP; dMARK; dTARGET; dORIGMARK;
956 const bool chomping = PL_op->op_type == OP_CHOMP;
960 count += do_chomp(TARG, *++MARK, chomping);
962 sv_setiv(TARG, count);
973 if (!PL_op->op_private) {
985 if (SvTHINKFIRST(sv))
986 sv_force_normal_flags(sv, SV_COW_DROP_PV|SV_IMMEDIATE_UNREF);
988 switch (SvTYPE(sv)) {
992 av_undef(MUTABLE_AV(sv));
995 hv_undef(MUTABLE_HV(sv));
998 if (cv_const_sv((const CV *)sv))
999 Perl_ck_warner(aTHX_ packWARN(WARN_MISC),
1000 "Constant subroutine %"SVf" undefined",
1001 SVfARG(CvANON((const CV *)sv)
1002 ? newSVpvs_flags("(anonymous)", SVs_TEMP)
1003 : sv_2mortal(newSVhek(
1005 ? CvNAME_HEK((CV *)sv)
1006 : GvENAME_HEK(CvGV((const CV *)sv))
1011 /* let user-undef'd sub keep its identity */
1012 cv_undef_flags(MUTABLE_CV(sv), CV_UNDEF_KEEP_NAME);
1015 assert(isGV_with_GP(sv));
1016 assert(!SvFAKE(sv));
1021 /* undef *Pkg::meth_name ... */
1023 = GvCVu((const GV *)sv) && (stash = GvSTASH((const GV *)sv))
1024 && HvENAME_get(stash);
1026 if((stash = GvHV((const GV *)sv))) {
1027 if(HvENAME_get(stash))
1028 SvREFCNT_inc_simple_void_NN(sv_2mortal((SV *)stash));
1032 SvREFCNT_inc_simple_void_NN(sv_2mortal(sv));
1033 gp_free(MUTABLE_GV(sv));
1035 GvGP_set(sv, gp_ref(gp));
1036 #ifndef PERL_DONT_CREATE_GVSV
1037 GvSV(sv) = newSV(0);
1039 GvLINE(sv) = CopLINE(PL_curcop);
1040 GvEGV(sv) = MUTABLE_GV(sv);
1044 mro_package_moved(NULL, stash, (const GV *)sv, 0);
1046 /* undef *Foo::ISA */
1047 if( strEQ(GvNAME((const GV *)sv), "ISA")
1048 && (stash = GvSTASH((const GV *)sv))
1049 && (method_changed || HvENAME(stash)) )
1050 mro_isa_changed_in(stash);
1051 else if(method_changed)
1052 mro_method_changed_in(
1053 GvSTASH((const GV *)sv)
1059 if (SvTYPE(sv) >= SVt_PV && SvPVX_const(sv) && SvLEN(sv)) {
1073 /* also used for: pp_i_postdec() pp_i_postinc() pp_postdec() */
1079 PL_op->op_type == OP_POSTINC || PL_op->op_type == OP_I_POSTINC;
1080 if (SvTYPE(TOPs) >= SVt_PVAV || (isGV_with_GP(TOPs) && !SvFAKE(TOPs)))
1081 Perl_croak_no_modify();
1083 TARG = sv_newmortal();
1084 sv_setsv(TARG, TOPs);
1085 if (!SvREADONLY(TOPs) && !SvGMAGICAL(TOPs) && SvIOK_notUV(TOPs) && !SvNOK(TOPs) && !SvPOK(TOPs)
1086 && SvIVX(TOPs) != (inc ? IV_MAX : IV_MIN))
1088 SvIV_set(TOPs, SvIVX(TOPs) + (inc ? 1 : -1));
1089 SvFLAGS(TOPs) &= ~(SVp_NOK|SVp_POK);
1093 else sv_dec_nomg(TOPs);
1095 /* special case for undef: see thread at 2003-03/msg00536.html in archive */
1096 if (inc && !SvOK(TARG))
1102 /* Ordinary operators. */
1106 dSP; dATARGET; SV *svl, *svr;
1107 #ifdef PERL_PRESERVE_IVUV
1110 tryAMAGICbin_MG(pow_amg, AMGf_assign|AMGf_numeric);
1113 #ifdef PERL_PRESERVE_IVUV
1114 /* For integer to integer power, we do the calculation by hand wherever
1115 we're sure it is safe; otherwise we call pow() and try to convert to
1116 integer afterwards. */
1117 if (SvIV_please_nomg(svr) && SvIV_please_nomg(svl)) {
1125 const IV iv = SvIVX(svr);
1129 goto float_it; /* Can't do negative powers this way. */
1133 baseuok = SvUOK(svl);
1135 baseuv = SvUVX(svl);
1137 const IV iv = SvIVX(svl);
1140 baseuok = TRUE; /* effectively it's a UV now */
1142 baseuv = -iv; /* abs, baseuok == false records sign */
1145 /* now we have integer ** positive integer. */
1148 /* foo & (foo - 1) is zero only for a power of 2. */
1149 if (!(baseuv & (baseuv - 1))) {
1150 /* We are raising power-of-2 to a positive integer.
1151 The logic here will work for any base (even non-integer
1152 bases) but it can be less accurate than
1153 pow (base,power) or exp (power * log (base)) when the
1154 intermediate values start to spill out of the mantissa.
1155 With powers of 2 we know this can't happen.
1156 And powers of 2 are the favourite thing for perl
1157 programmers to notice ** not doing what they mean. */
1159 NV base = baseuok ? baseuv : -(NV)baseuv;
1164 while (power >>= 1) {
1172 SvIV_please_nomg(svr);
1175 unsigned int highbit = 8 * sizeof(UV);
1176 unsigned int diff = 8 * sizeof(UV);
1177 while (diff >>= 1) {
1179 if (baseuv >> highbit) {
1183 /* we now have baseuv < 2 ** highbit */
1184 if (power * highbit <= 8 * sizeof(UV)) {
1185 /* result will definitely fit in UV, so use UV math
1186 on same algorithm as above */
1189 const bool odd_power = cBOOL(power & 1);
1193 while (power >>= 1) {
1200 if (baseuok || !odd_power)
1201 /* answer is positive */
1203 else if (result <= (UV)IV_MAX)
1204 /* answer negative, fits in IV */
1205 SETi( -(IV)result );
1206 else if (result == (UV)IV_MIN)
1207 /* 2's complement assumption: special case IV_MIN */
1210 /* answer negative, doesn't fit */
1211 SETn( -(NV)result );
1219 NV right = SvNV_nomg(svr);
1220 NV left = SvNV_nomg(svl);
1223 #if defined(USE_LONG_DOUBLE) && defined(HAS_AIX_POWL_NEG_BASE_BUG)
1225 We are building perl with long double support and are on an AIX OS
1226 afflicted with a powl() function that wrongly returns NaNQ for any
1227 negative base. This was reported to IBM as PMR #23047-379 on
1228 03/06/2006. The problem exists in at least the following versions
1229 of AIX and the libm fileset, and no doubt others as well:
1231 AIX 4.3.3-ML10 bos.adt.libm 4.3.3.50
1232 AIX 5.1.0-ML04 bos.adt.libm 5.1.0.29
1233 AIX 5.2.0 bos.adt.libm 5.2.0.85
1235 So, until IBM fixes powl(), we provide the following workaround to
1236 handle the problem ourselves. Our logic is as follows: for
1237 negative bases (left), we use fmod(right, 2) to check if the
1238 exponent is an odd or even integer:
1240 - if odd, powl(left, right) == -powl(-left, right)
1241 - if even, powl(left, right) == powl(-left, right)
1243 If the exponent is not an integer, the result is rightly NaNQ, so
1244 we just return that (as NV_NAN).
1248 NV mod2 = Perl_fmod( right, 2.0 );
1249 if (mod2 == 1.0 || mod2 == -1.0) { /* odd integer */
1250 SETn( -Perl_pow( -left, right) );
1251 } else if (mod2 == 0.0) { /* even integer */
1252 SETn( Perl_pow( -left, right) );
1253 } else { /* fractional power */
1257 SETn( Perl_pow( left, right) );
1260 SETn( Perl_pow( left, right) );
1261 #endif /* HAS_AIX_POWL_NEG_BASE_BUG */
1263 #ifdef PERL_PRESERVE_IVUV
1265 SvIV_please_nomg(svr);
1273 dSP; dATARGET; SV *svl, *svr;
1274 tryAMAGICbin_MG(mult_amg, AMGf_assign|AMGf_numeric);
1277 #ifdef PERL_PRESERVE_IVUV
1278 if (SvIV_please_nomg(svr)) {
1279 /* Unless the left argument is integer in range we are going to have to
1280 use NV maths. Hence only attempt to coerce the right argument if
1281 we know the left is integer. */
1282 /* Left operand is defined, so is it IV? */
1283 if (SvIV_please_nomg(svl)) {
1284 bool auvok = SvUOK(svl);
1285 bool buvok = SvUOK(svr);
1286 const UV topmask = (~ (UV)0) << (4 * sizeof (UV));
1287 const UV botmask = ~((~ (UV)0) << (4 * sizeof (UV)));
1296 const IV aiv = SvIVX(svl);
1299 auvok = TRUE; /* effectively it's a UV now */
1301 /* abs, auvok == false records sign */
1302 alow = (aiv == IV_MIN) ? (UV)aiv : (UV)(-aiv);
1308 const IV biv = SvIVX(svr);
1311 buvok = TRUE; /* effectively it's a UV now */
1313 /* abs, buvok == false records sign */
1314 blow = (biv == IV_MIN) ? (UV)biv : (UV)(-biv);
1318 /* If this does sign extension on unsigned it's time for plan B */
1319 ahigh = alow >> (4 * sizeof (UV));
1321 bhigh = blow >> (4 * sizeof (UV));
1323 if (ahigh && bhigh) {
1325 /* eg 32 bit is at least 0x10000 * 0x10000 == 0x100000000
1326 which is overflow. Drop to NVs below. */
1327 } else if (!ahigh && !bhigh) {
1328 /* eg 32 bit is at most 0xFFFF * 0xFFFF == 0xFFFE0001
1329 so the unsigned multiply cannot overflow. */
1330 const UV product = alow * blow;
1331 if (auvok == buvok) {
1332 /* -ve * -ve or +ve * +ve gives a +ve result. */
1336 } else if (product <= (UV)IV_MIN) {
1337 /* 2s complement assumption that (UV)-IV_MIN is correct. */
1338 /* -ve result, which could overflow an IV */
1340 /* can't negate IV_MIN, but there are aren't two
1341 * integers such that !ahigh && !bhigh, where the
1342 * product equals 0x800....000 */
1343 assert(product != (UV)IV_MIN);
1344 SETi( -(IV)product );
1346 } /* else drop to NVs below. */
1348 /* One operand is large, 1 small */
1351 /* swap the operands */
1353 bhigh = blow; /* bhigh now the temp var for the swap */
1357 /* now, ((ahigh * blow) << half_UV_len) + (alow * blow)
1358 multiplies can't overflow. shift can, add can, -ve can. */
1359 product_middle = ahigh * blow;
1360 if (!(product_middle & topmask)) {
1361 /* OK, (ahigh * blow) won't lose bits when we shift it. */
1363 product_middle <<= (4 * sizeof (UV));
1364 product_low = alow * blow;
1366 /* as for pp_add, UV + something mustn't get smaller.
1367 IIRC ANSI mandates this wrapping *behaviour* for
1368 unsigned whatever the actual representation*/
1369 product_low += product_middle;
1370 if (product_low >= product_middle) {
1371 /* didn't overflow */
1372 if (auvok == buvok) {
1373 /* -ve * -ve or +ve * +ve gives a +ve result. */
1375 SETu( product_low );
1377 } else if (product_low <= (UV)IV_MIN) {
1378 /* 2s complement assumption again */
1379 /* -ve result, which could overflow an IV */
1381 SETi(product_low == (UV)IV_MIN
1382 ? IV_MIN : -(IV)product_low);
1384 } /* else drop to NVs below. */
1386 } /* product_middle too large */
1387 } /* ahigh && bhigh */
1392 NV right = SvNV_nomg(svr);
1393 NV left = SvNV_nomg(svl);
1395 SETn( left * right );
1402 dSP; dATARGET; SV *svl, *svr;
1403 tryAMAGICbin_MG(div_amg, AMGf_assign|AMGf_numeric);
1406 /* Only try to do UV divide first
1407 if ((SLOPPYDIVIDE is true) or
1408 (PERL_PRESERVE_IVUV is true and one or both SV is a UV too large
1410 The assumption is that it is better to use floating point divide
1411 whenever possible, only doing integer divide first if we can't be sure.
1412 If NV_PRESERVES_UV is true then we know at compile time that no UV
1413 can be too large to preserve, so don't need to compile the code to
1414 test the size of UVs. */
1417 # define PERL_TRY_UV_DIVIDE
1418 /* ensure that 20./5. == 4. */
1420 # ifdef PERL_PRESERVE_IVUV
1421 # ifndef NV_PRESERVES_UV
1422 # define PERL_TRY_UV_DIVIDE
1427 #ifdef PERL_TRY_UV_DIVIDE
1428 if (SvIV_please_nomg(svr) && SvIV_please_nomg(svl)) {
1429 bool left_non_neg = SvUOK(svl);
1430 bool right_non_neg = SvUOK(svr);
1434 if (right_non_neg) {
1438 const IV biv = SvIVX(svr);
1441 right_non_neg = TRUE; /* effectively it's a UV now */
1444 right = (biv == IV_MIN) ? (UV)biv : (UV)(-biv);
1447 /* historically undef()/0 gives a "Use of uninitialized value"
1448 warning before dieing, hence this test goes here.
1449 If it were immediately before the second SvIV_please, then
1450 DIE() would be invoked before left was even inspected, so
1451 no inspection would give no warning. */
1453 DIE(aTHX_ "Illegal division by zero");
1459 const IV aiv = SvIVX(svl);
1462 left_non_neg = TRUE; /* effectively it's a UV now */
1465 left = (aiv == IV_MIN) ? (UV)aiv : (UV)(-aiv);
1471 /* For sloppy divide we always attempt integer division. */
1473 /* Otherwise we only attempt it if either or both operands
1474 would not be preserved by an NV. If both fit in NVs
1475 we fall through to the NV divide code below. However,
1476 as left >= right to ensure integer result here, we know that
1477 we can skip the test on the right operand - right big
1478 enough not to be preserved can't get here unless left is
1481 && (left > ((UV)1 << NV_PRESERVES_UV_BITS))
1484 /* Integer division can't overflow, but it can be imprecise. */
1485 const UV result = left / right;
1486 if (result * right == left) {
1487 SP--; /* result is valid */
1488 if (left_non_neg == right_non_neg) {
1489 /* signs identical, result is positive. */
1493 /* 2s complement assumption */
1494 if (result <= (UV)IV_MIN)
1495 SETi(result == (UV)IV_MIN ? IV_MIN : -(IV)result);
1497 /* It's exact but too negative for IV. */
1498 SETn( -(NV)result );
1501 } /* tried integer divide but it was not an integer result */
1502 } /* else (PERL_ABS(result) < 1.0) or (both UVs in range for NV) */
1503 } /* one operand wasn't SvIOK */
1504 #endif /* PERL_TRY_UV_DIVIDE */
1506 NV right = SvNV_nomg(svr);
1507 NV left = SvNV_nomg(svl);
1508 (void)POPs;(void)POPs;
1509 #if defined(NAN_COMPARE_BROKEN) && defined(Perl_isnan)
1510 if (! Perl_isnan(right) && right == 0.0)
1514 DIE(aTHX_ "Illegal division by zero");
1515 PUSHn( left / right );
1523 tryAMAGICbin_MG(modulo_amg, AMGf_assign|AMGf_numeric);
1527 bool left_neg = FALSE;
1528 bool right_neg = FALSE;
1529 bool use_double = FALSE;
1530 bool dright_valid = FALSE;
1533 SV * const svr = TOPs;
1534 SV * const svl = TOPm1s;
1535 if (SvIV_please_nomg(svr)) {
1536 right_neg = !SvUOK(svr);
1540 const IV biv = SvIVX(svr);
1543 right_neg = FALSE; /* effectively it's a UV now */
1545 right = (biv == IV_MIN) ? (UV)biv : (UV)(-biv);
1550 dright = SvNV_nomg(svr);
1551 right_neg = dright < 0;
1554 if (dright < UV_MAX_P1) {
1555 right = U_V(dright);
1556 dright_valid = TRUE; /* In case we need to use double below. */
1562 /* At this point use_double is only true if right is out of range for
1563 a UV. In range NV has been rounded down to nearest UV and
1564 use_double false. */
1565 if (!use_double && SvIV_please_nomg(svl)) {
1566 left_neg = !SvUOK(svl);
1570 const IV aiv = SvIVX(svl);
1573 left_neg = FALSE; /* effectively it's a UV now */
1575 left = (aiv == IV_MIN) ? (UV)aiv : (UV)(-aiv);
1580 dleft = SvNV_nomg(svl);
1581 left_neg = dleft < 0;
1585 /* This should be exactly the 5.6 behaviour - if left and right are
1586 both in range for UV then use U_V() rather than floor. */
1588 if (dleft < UV_MAX_P1) {
1589 /* right was in range, so is dleft, so use UVs not double.
1593 /* left is out of range for UV, right was in range, so promote
1594 right (back) to double. */
1596 /* The +0.5 is used in 5.6 even though it is not strictly
1597 consistent with the implicit +0 floor in the U_V()
1598 inside the #if 1. */
1599 dleft = Perl_floor(dleft + 0.5);
1602 dright = Perl_floor(dright + 0.5);
1613 DIE(aTHX_ "Illegal modulus zero");
1615 dans = Perl_fmod(dleft, dright);
1616 if ((left_neg != right_neg) && dans)
1617 dans = dright - dans;
1620 sv_setnv(TARG, dans);
1626 DIE(aTHX_ "Illegal modulus zero");
1629 if ((left_neg != right_neg) && ans)
1632 /* XXX may warn: unary minus operator applied to unsigned type */
1633 /* could change -foo to be (~foo)+1 instead */
1634 if (ans <= ~((UV)IV_MAX)+1)
1635 sv_setiv(TARG, ~ans+1);
1637 sv_setnv(TARG, -(NV)ans);
1640 sv_setuv(TARG, ans);
1652 bool infnan = FALSE;
1654 if (GIMME_V == G_ARRAY && PL_op->op_private & OPpREPEAT_DOLIST) {
1655 /* TODO: think of some way of doing list-repeat overloading ??? */
1660 if (UNLIKELY(PL_op->op_private & OPpREPEAT_DOLIST)) {
1661 /* The parser saw this as a list repeat, and there
1662 are probably several items on the stack. But we're
1663 in scalar/void context, and there's no pp_list to save us
1664 now. So drop the rest of the items -- robin@kitsite.com
1667 if (MARK + 1 < SP) {
1673 ASSUME(MARK + 1 == SP);
1675 MARK[1] = &PL_sv_undef;
1679 tryAMAGICbin_MG(repeat_amg, AMGf_assign);
1685 const UV uv = SvUV_nomg(sv);
1687 count = IV_MAX; /* The best we can do? */
1691 count = SvIV_nomg(sv);
1694 else if (SvNOKp(sv)) {
1695 const NV nv = SvNV_nomg(sv);
1696 infnan = Perl_isinfnan(nv);
1697 if (UNLIKELY(infnan)) {
1701 count = -1; /* An arbitrary negative integer */
1707 count = SvIV_nomg(sv);
1710 Perl_ck_warner(aTHX_ packWARN(WARN_NUMERIC),
1711 "Non-finite repeat count does nothing");
1712 } else if (count < 0) {
1714 Perl_ck_warner(aTHX_ packWARN(WARN_NUMERIC),
1715 "Negative repeat count does nothing");
1718 if (GIMME_V == G_ARRAY && PL_op->op_private & OPpREPEAT_DOLIST) {
1720 const Size_t items = SP - MARK;
1721 const U8 mod = PL_op->op_flags & OPf_MOD;
1726 if ( items > MEM_SIZE_MAX / (UV)count /* max would overflow */
1727 || items > (U32)I32_MAX / sizeof(SV *) /* repeatcpy would overflow */
1729 Perl_croak(aTHX_ "%s","Out of memory during list extend");
1730 max = items * count;
1735 if (mod && SvPADTMP(*SP)) {
1736 *SP = sv_mortalcopy(*SP);
1743 repeatcpy((char*)(MARK + items), (char*)MARK,
1744 items * sizeof(const SV *), count - 1);
1747 else if (count <= 0)
1750 else { /* Note: mark already snarfed by pp_list */
1751 SV * const tmpstr = POPs;
1756 sv_setsv_nomg(TARG, tmpstr);
1757 SvPV_force_nomg(TARG, len);
1758 isutf = DO_UTF8(TARG);
1765 if ( len > (MEM_SIZE_MAX-1) / (UV)count /* max would overflow */
1766 || len > (U32)I32_MAX /* repeatcpy would overflow */
1768 Perl_croak(aTHX_ "%s",
1769 "Out of memory during string extend");
1770 max = (UV)count * len + 1;
1773 repeatcpy(SvPVX(TARG) + len, SvPVX(TARG), len, count - 1);
1774 SvCUR_set(TARG, SvCUR(TARG) * count);
1776 *SvEND(TARG) = '\0';
1779 (void)SvPOK_only_UTF8(TARG);
1781 (void)SvPOK_only(TARG);
1790 dSP; dATARGET; bool useleft; SV *svl, *svr;
1791 tryAMAGICbin_MG(subtr_amg, AMGf_assign|AMGf_numeric);
1794 useleft = USE_LEFT(svl);
1795 #ifdef PERL_PRESERVE_IVUV
1796 /* See comments in pp_add (in pp_hot.c) about Overflow, and how
1797 "bad things" happen if you rely on signed integers wrapping. */
1798 if (SvIV_please_nomg(svr)) {
1799 /* Unless the left argument is integer in range we are going to have to
1800 use NV maths. Hence only attempt to coerce the right argument if
1801 we know the left is integer. */
1808 a_valid = auvok = 1;
1809 /* left operand is undef, treat as zero. */
1811 /* Left operand is defined, so is it IV? */
1812 if (SvIV_please_nomg(svl)) {
1813 if ((auvok = SvUOK(svl)))
1816 const IV aiv = SvIVX(svl);
1819 auvok = 1; /* Now acting as a sign flag. */
1820 } else { /* 2s complement assumption for IV_MIN */
1821 auv = (aiv == IV_MIN) ? (UV)aiv : (UV)-aiv;
1828 bool result_good = 0;
1831 bool buvok = SvUOK(svr);
1836 const IV biv = SvIVX(svr);
1841 buv = (biv == IV_MIN) ? (UV)biv : (UV)-biv;
1843 /* ?uvok if value is >= 0. basically, flagged as UV if it's +ve,
1844 else "IV" now, independent of how it came in.
1845 if a, b represents positive, A, B negative, a maps to -A etc
1850 all UV maths. negate result if A negative.
1851 subtract if signs same, add if signs differ. */
1853 if (auvok ^ buvok) {
1862 /* Must get smaller */
1867 if (result <= buv) {
1868 /* result really should be -(auv-buv). as its negation
1869 of true value, need to swap our result flag */
1881 if (result <= (UV)IV_MIN)
1882 SETi(result == (UV)IV_MIN
1883 ? IV_MIN : -(IV)result);
1885 /* result valid, but out of range for IV. */
1886 SETn( -(NV)result );
1890 } /* Overflow, drop through to NVs. */
1895 NV value = SvNV_nomg(svr);
1899 /* left operand is undef, treat as zero - value */
1903 SETn( SvNV_nomg(svl) - value );
1910 dSP; dATARGET; SV *svl, *svr;
1911 tryAMAGICbin_MG(lshift_amg, AMGf_assign|AMGf_numeric);
1915 const IV shift = SvIV_nomg(svr);
1916 if (PL_op->op_private & HINT_INTEGER) {
1917 const IV i = SvIV_nomg(svl);
1921 const UV u = SvUV_nomg(svl);
1930 dSP; dATARGET; SV *svl, *svr;
1931 tryAMAGICbin_MG(rshift_amg, AMGf_assign|AMGf_numeric);
1935 const IV shift = SvIV_nomg(svr);
1936 if (PL_op->op_private & HINT_INTEGER) {
1937 const IV i = SvIV_nomg(svl);
1941 const UV u = SvUV_nomg(svl);
1953 tryAMAGICbin_MG(lt_amg, AMGf_set|AMGf_numeric);
1957 (SvIOK_notUV(left) && SvIOK_notUV(right))
1958 ? (SvIVX(left) < SvIVX(right))
1959 : (do_ncmp(left, right) == -1)
1969 tryAMAGICbin_MG(gt_amg, AMGf_set|AMGf_numeric);
1973 (SvIOK_notUV(left) && SvIOK_notUV(right))
1974 ? (SvIVX(left) > SvIVX(right))
1975 : (do_ncmp(left, right) == 1)
1985 tryAMAGICbin_MG(le_amg, AMGf_set|AMGf_numeric);
1989 (SvIOK_notUV(left) && SvIOK_notUV(right))
1990 ? (SvIVX(left) <= SvIVX(right))
1991 : (do_ncmp(left, right) <= 0)
2001 tryAMAGICbin_MG(ge_amg, AMGf_set|AMGf_numeric);
2005 (SvIOK_notUV(left) && SvIOK_notUV(right))
2006 ? (SvIVX(left) >= SvIVX(right))
2007 : ( (do_ncmp(left, right) & 2) == 0)
2017 tryAMAGICbin_MG(ne_amg, AMGf_set|AMGf_numeric);
2021 (SvIOK_notUV(left) && SvIOK_notUV(right))
2022 ? (SvIVX(left) != SvIVX(right))
2023 : (do_ncmp(left, right) != 0)
2028 /* compare left and right SVs. Returns:
2032 * 2: left or right was a NaN
2035 Perl_do_ncmp(pTHX_ SV* const left, SV * const right)
2037 PERL_ARGS_ASSERT_DO_NCMP;
2038 #ifdef PERL_PRESERVE_IVUV
2039 /* Fortunately it seems NaN isn't IOK */
2040 if (SvIV_please_nomg(right) && SvIV_please_nomg(left)) {
2042 const IV leftiv = SvIVX(left);
2043 if (!SvUOK(right)) {
2044 /* ## IV <=> IV ## */
2045 const IV rightiv = SvIVX(right);
2046 return (leftiv > rightiv) - (leftiv < rightiv);
2048 /* ## IV <=> UV ## */
2050 /* As (b) is a UV, it's >=0, so it must be < */
2053 const UV rightuv = SvUVX(right);
2054 return ((UV)leftiv > rightuv) - ((UV)leftiv < rightuv);
2059 /* ## UV <=> UV ## */
2060 const UV leftuv = SvUVX(left);
2061 const UV rightuv = SvUVX(right);
2062 return (leftuv > rightuv) - (leftuv < rightuv);
2064 /* ## UV <=> IV ## */
2066 const IV rightiv = SvIVX(right);
2068 /* As (a) is a UV, it's >=0, so it cannot be < */
2071 const UV leftuv = SvUVX(left);
2072 return (leftuv > (UV)rightiv) - (leftuv < (UV)rightiv);
2075 NOT_REACHED; /* NOTREACHED */
2079 NV const rnv = SvNV_nomg(right);
2080 NV const lnv = SvNV_nomg(left);
2082 #if defined(NAN_COMPARE_BROKEN) && defined(Perl_isnan)
2083 if (Perl_isnan(lnv) || Perl_isnan(rnv)) {
2086 return (lnv > rnv) - (lnv < rnv);
2105 tryAMAGICbin_MG(ncmp_amg, AMGf_numeric);
2108 value = do_ncmp(left, right);
2120 /* also used for: pp_sge() pp_sgt() pp_slt() */
2126 int amg_type = sle_amg;
2130 switch (PL_op->op_type) {
2149 tryAMAGICbin_MG(amg_type, AMGf_set);
2153 #ifdef USE_LOCALE_COLLATE
2154 (IN_LC_RUNTIME(LC_COLLATE))
2155 ? sv_cmp_locale_flags(left, right, 0)
2158 sv_cmp_flags(left, right, 0);
2159 SETs(boolSV(cmp * multiplier < rhs));
2167 tryAMAGICbin_MG(seq_amg, AMGf_set);
2170 SETs(boolSV(sv_eq_flags(left, right, 0)));
2178 tryAMAGICbin_MG(sne_amg, AMGf_set);
2181 SETs(boolSV(!sv_eq_flags(left, right, 0)));
2189 tryAMAGICbin_MG(scmp_amg, 0);
2193 #ifdef USE_LOCALE_COLLATE
2194 (IN_LC_RUNTIME(LC_COLLATE))
2195 ? sv_cmp_locale_flags(left, right, 0)
2198 sv_cmp_flags(left, right, 0);
2207 tryAMAGICbin_MG(band_amg, AMGf_assign);
2210 if (SvNIOKp(left) || SvNIOKp(right)) {
2211 const bool left_ro_nonnum = !SvNIOKp(left) && SvREADONLY(left);
2212 const bool right_ro_nonnum = !SvNIOKp(right) && SvREADONLY(right);
2213 if (PL_op->op_private & HINT_INTEGER) {
2214 const IV i = SvIV_nomg(left) & SvIV_nomg(right);
2218 const UV u = SvUV_nomg(left) & SvUV_nomg(right);
2221 if (left_ro_nonnum && left != TARG) SvNIOK_off(left);
2222 if (right_ro_nonnum) SvNIOK_off(right);
2225 do_vop(PL_op->op_type, TARG, left, right);
2235 tryAMAGICbin_MG(band_amg, AMGf_assign|AMGf_numarg);
2237 dATARGET; dPOPTOPssrl;
2238 if (PL_op->op_private & HINT_INTEGER) {
2239 const IV i = SvIV_nomg(left) & SvIV_nomg(right);
2243 const UV u = SvUV_nomg(left) & SvUV_nomg(right);
2253 tryAMAGICbin_MG(sband_amg, AMGf_assign);
2255 dATARGET; dPOPTOPssrl;
2256 do_vop(OP_BIT_AND, TARG, left, right);
2261 /* also used for: pp_bit_xor() */
2266 const int op_type = PL_op->op_type;
2268 tryAMAGICbin_MG((op_type == OP_BIT_OR ? bor_amg : bxor_amg), AMGf_assign);
2271 if (SvNIOKp(left) || SvNIOKp(right)) {
2272 const bool left_ro_nonnum = !SvNIOKp(left) && SvREADONLY(left);
2273 const bool right_ro_nonnum = !SvNIOKp(right) && SvREADONLY(right);
2274 if (PL_op->op_private & HINT_INTEGER) {
2275 const IV l = (USE_LEFT(left) ? SvIV_nomg(left) : 0);
2276 const IV r = SvIV_nomg(right);
2277 const IV result = op_type == OP_BIT_OR ? (l | r) : (l ^ r);
2281 const UV l = (USE_LEFT(left) ? SvUV_nomg(left) : 0);
2282 const UV r = SvUV_nomg(right);
2283 const UV result = op_type == OP_BIT_OR ? (l | r) : (l ^ r);
2286 if (left_ro_nonnum && left != TARG) SvNIOK_off(left);
2287 if (right_ro_nonnum) SvNIOK_off(right);
2290 do_vop(op_type, TARG, left, right);
2297 /* also used for: pp_nbit_xor() */
2302 const int op_type = PL_op->op_type;
2304 tryAMAGICbin_MG((op_type == OP_NBIT_OR ? bor_amg : bxor_amg),
2305 AMGf_assign|AMGf_numarg);
2307 dATARGET; dPOPTOPssrl;
2308 if (PL_op->op_private & HINT_INTEGER) {
2309 const IV l = (USE_LEFT(left) ? SvIV_nomg(left) : 0);
2310 const IV r = SvIV_nomg(right);
2311 const IV result = op_type == OP_NBIT_OR ? (l | r) : (l ^ r);
2315 const UV l = (USE_LEFT(left) ? SvUV_nomg(left) : 0);
2316 const UV r = SvUV_nomg(right);
2317 const UV result = op_type == OP_NBIT_OR ? (l | r) : (l ^ r);
2324 /* also used for: pp_sbit_xor() */
2329 const int op_type = PL_op->op_type;
2331 tryAMAGICbin_MG((op_type == OP_SBIT_OR ? sbor_amg : sbxor_amg),
2334 dATARGET; dPOPTOPssrl;
2335 do_vop(op_type == OP_SBIT_OR ? OP_BIT_OR : OP_BIT_XOR, TARG, left,
2341 PERL_STATIC_INLINE bool
2342 S_negate_string(pTHX)
2347 SV * const sv = TOPs;
2348 if (!SvPOKp(sv) || SvNIOK(sv) || (!SvPOK(sv) && SvNIOKp(sv)))
2350 s = SvPV_nomg_const(sv, len);
2351 if (isIDFIRST(*s)) {
2352 sv_setpvs(TARG, "-");
2355 else if (*s == '+' || (*s == '-' && !looks_like_number(sv))) {
2356 sv_setsv_nomg(TARG, sv);
2357 *SvPV_force_nomg(TARG, len) = *s == '-' ? '+' : '-';
2367 tryAMAGICun_MG(neg_amg, AMGf_numeric);
2368 if (S_negate_string(aTHX)) return NORMAL;
2370 SV * const sv = TOPs;
2373 /* It's publicly an integer */
2376 if (SvIVX(sv) == IV_MIN) {
2377 /* 2s complement assumption. */
2378 SETi(SvIVX(sv)); /* special case: -((UV)IV_MAX+1) ==
2382 else if (SvUVX(sv) <= IV_MAX) {
2387 else if (SvIVX(sv) != IV_MIN) {
2391 #ifdef PERL_PRESERVE_IVUV
2398 if (SvNIOKp(sv) && (SvNIOK(sv) || !SvPOK(sv)))
2399 SETn(-SvNV_nomg(sv));
2400 else if (SvPOKp(sv) && SvIV_please_nomg(sv))
2401 goto oops_its_an_int;
2403 SETn(-SvNV_nomg(sv));
2411 tryAMAGICun_MG(not_amg, AMGf_set);
2412 *PL_stack_sp = boolSV(!SvTRUE_nomg(*PL_stack_sp));
2417 S_scomplement(pTHX_ SV *targ, SV *sv)
2423 sv_copypv_nomg(TARG, sv);
2424 tmps = (U8*)SvPV_nomg(TARG, len);
2427 /* Calculate exact length, let's not estimate. */
2432 U8 * const send = tmps + len;
2433 U8 * const origtmps = tmps;
2434 const UV utf8flags = UTF8_ALLOW_ANYUV;
2436 while (tmps < send) {
2437 const UV c = utf8n_to_uvchr(tmps, send-tmps, &l, utf8flags);
2439 targlen += UNISKIP(~c);
2445 /* Now rewind strings and write them. */
2452 Newx(result, targlen + 1, U8);
2454 while (tmps < send) {
2455 const UV c = utf8n_to_uvchr(tmps, send-tmps, &l, utf8flags);
2457 p = uvchr_to_utf8_flags(p, ~c, UNICODE_ALLOW_ANY);
2460 sv_usepvn_flags(TARG, (char*)result, targlen,
2461 SV_HAS_TRAILING_NUL);
2468 Newx(result, nchar + 1, U8);
2470 while (tmps < send) {
2471 const U8 c = (U8)utf8n_to_uvchr(tmps, send-tmps, &l, utf8flags);
2476 sv_usepvn_flags(TARG, (char*)result, nchar, SV_HAS_TRAILING_NUL);
2484 for ( ; anum && (unsigned long)tmps % sizeof(long); anum--, tmps++)
2487 for ( ; anum >= (I32)sizeof(long); anum -= (I32)sizeof(long), tmpl++)
2492 for ( ; anum > 0; anum--, tmps++)
2499 tryAMAGICun_MG(compl_amg, AMGf_numeric);
2503 if (PL_op->op_private & HINT_INTEGER) {
2504 const IV i = ~SvIV_nomg(sv);
2508 const UV u = ~SvUV_nomg(sv);
2513 S_scomplement(aTHX_ TARG, sv);
2523 tryAMAGICun_MG(compl_amg, AMGf_numeric|AMGf_numarg);
2526 if (PL_op->op_private & HINT_INTEGER) {
2527 const IV i = ~SvIV_nomg(sv);
2531 const UV u = ~SvUV_nomg(sv);
2541 tryAMAGICun_MG(scompl_amg, AMGf_numeric);
2544 S_scomplement(aTHX_ TARG, sv);
2550 /* integer versions of some of the above */
2555 tryAMAGICbin_MG(mult_amg, AMGf_assign);
2558 SETi( left * right );
2567 tryAMAGICbin_MG(div_amg, AMGf_assign);
2570 IV value = SvIV_nomg(right);
2572 DIE(aTHX_ "Illegal division by zero");
2573 num = SvIV_nomg(left);
2575 /* avoid FPE_INTOVF on some platforms when num is IV_MIN */
2579 value = num / value;
2585 #if defined(__GLIBC__) && IVSIZE == 8 && !defined(PERL_DEBUG_READONLY_OPS) \
2586 && ( __GLIBC__ < 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ < 8))
2593 /* This is the vanilla old i_modulo. */
2595 tryAMAGICbin_MG(modulo_amg, AMGf_assign);
2599 DIE(aTHX_ "Illegal modulus zero");
2600 /* avoid FPE_INTOVF on some platforms when left is IV_MIN */
2604 SETi( left % right );
2609 #if defined(__GLIBC__) && IVSIZE == 8 && !defined(PERL_DEBUG_READONLY_OPS) \
2610 && ( __GLIBC__ < 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ < 8))
2615 /* This is the i_modulo with the workaround for the _moddi3 bug
2616 * in (at least) glibc 2.2.5 (the PERL_ABS() the workaround).
2617 * See below for pp_i_modulo. */
2619 tryAMAGICbin_MG(modulo_amg, AMGf_assign);
2623 DIE(aTHX_ "Illegal modulus zero");
2624 /* avoid FPE_INTOVF on some platforms when left is IV_MIN */
2628 SETi( left % PERL_ABS(right) );
2635 dVAR; dSP; dATARGET;
2636 tryAMAGICbin_MG(modulo_amg, AMGf_assign);
2640 DIE(aTHX_ "Illegal modulus zero");
2641 /* The assumption is to use hereafter the old vanilla version... */
2643 PL_ppaddr[OP_I_MODULO] =
2645 /* .. but if we have glibc, we might have a buggy _moddi3
2646 * (at least glibc 2.2.5 is known to have this bug), in other
2647 * words our integer modulus with negative quad as the second
2648 * argument might be broken. Test for this and re-patch the
2649 * opcode dispatch table if that is the case, remembering to
2650 * also apply the workaround so that this first round works
2651 * right, too. See [perl #9402] for more information. */
2655 /* Cannot do this check with inlined IV constants since
2656 * that seems to work correctly even with the buggy glibc. */
2658 /* Yikes, we have the bug.
2659 * Patch in the workaround version. */
2661 PL_ppaddr[OP_I_MODULO] =
2662 &Perl_pp_i_modulo_1;
2663 /* Make certain we work right this time, too. */
2664 right = PERL_ABS(right);
2667 /* avoid FPE_INTOVF on some platforms when left is IV_MIN */
2671 SETi( left % right );
2680 tryAMAGICbin_MG(add_amg, AMGf_assign);
2682 dPOPTOPiirl_ul_nomg;
2683 SETi( left + right );
2691 tryAMAGICbin_MG(subtr_amg, AMGf_assign);
2693 dPOPTOPiirl_ul_nomg;
2694 SETi( left - right );
2702 tryAMAGICbin_MG(lt_amg, AMGf_set);
2705 SETs(boolSV(left < right));
2713 tryAMAGICbin_MG(gt_amg, AMGf_set);
2716 SETs(boolSV(left > right));
2724 tryAMAGICbin_MG(le_amg, AMGf_set);
2727 SETs(boolSV(left <= right));
2735 tryAMAGICbin_MG(ge_amg, AMGf_set);
2738 SETs(boolSV(left >= right));
2746 tryAMAGICbin_MG(eq_amg, AMGf_set);
2749 SETs(boolSV(left == right));
2757 tryAMAGICbin_MG(ne_amg, AMGf_set);
2760 SETs(boolSV(left != right));
2768 tryAMAGICbin_MG(ncmp_amg, 0);
2775 else if (left < right)
2787 tryAMAGICun_MG(neg_amg, 0);
2788 if (S_negate_string(aTHX)) return NORMAL;
2790 SV * const sv = TOPs;
2791 IV const i = SvIV_nomg(sv);
2797 /* High falutin' math. */
2802 tryAMAGICbin_MG(atan2_amg, 0);
2805 SETn(Perl_atan2(left, right));
2811 /* also used for: pp_cos() pp_exp() pp_log() pp_sqrt() */
2816 int amg_type = fallback_amg;
2817 const char *neg_report = NULL;
2818 const int op_type = PL_op->op_type;
2821 case OP_SIN: amg_type = sin_amg; break;
2822 case OP_COS: amg_type = cos_amg; break;
2823 case OP_EXP: amg_type = exp_amg; break;
2824 case OP_LOG: amg_type = log_amg; neg_report = "log"; break;
2825 case OP_SQRT: amg_type = sqrt_amg; neg_report = "sqrt"; break;
2828 assert(amg_type != fallback_amg);
2830 tryAMAGICun_MG(amg_type, 0);
2832 SV * const arg = TOPs;
2833 const NV value = SvNV_nomg(arg);
2835 if (neg_report) { /* log or sqrt */
2837 #if defined(NAN_COMPARE_BROKEN) && defined(Perl_isnan)
2838 ! Perl_isnan(value) &&
2840 (op_type == OP_LOG ? (value <= 0.0) : (value < 0.0))) {
2841 SET_NUMERIC_STANDARD();
2842 /* diag_listed_as: Can't take log of %g */
2843 DIE(aTHX_ "Can't take %s of %"NVgf, neg_report, value);
2848 case OP_SIN: result = Perl_sin(value); break;
2849 case OP_COS: result = Perl_cos(value); break;
2850 case OP_EXP: result = Perl_exp(value); break;
2851 case OP_LOG: result = Perl_log(value); break;
2852 case OP_SQRT: result = Perl_sqrt(value); break;
2859 /* Support Configure command-line overrides for rand() functions.
2860 After 5.005, perhaps we should replace this by Configure support
2861 for drand48(), random(), or rand(). For 5.005, though, maintain
2862 compatibility by calling rand() but allow the user to override it.
2863 See INSTALL for details. --Andy Dougherty 15 July 1998
2865 /* Now it's after 5.005, and Configure supports drand48() and random(),
2866 in addition to rand(). So the overrides should not be needed any more.
2867 --Jarkko Hietaniemi 27 September 1998
2872 if (!PL_srand_called) {
2873 (void)seedDrand01((Rand_seed_t)seed());
2874 PL_srand_called = TRUE;
2886 SV * const sv = POPs;
2892 /* 1 of 2 things can be carried through SvNV, SP or TARG, SP was carried */
2893 #if defined(NAN_COMPARE_BROKEN) && defined(Perl_isnan)
2894 if (! Perl_isnan(value) && value == 0.0)
2904 sv_setnv_mg(TARG, value);
2915 if (MAXARG >= 1 && (TOPs || POPs)) {
2922 pv = SvPV(top, len);
2923 flags = grok_number(pv, len, &anum);
2925 if (!(flags & IS_NUMBER_IN_UV)) {
2926 Perl_ck_warner_d(aTHX_ packWARN(WARN_OVERFLOW),
2927 "Integer overflow in srand");
2935 (void)seedDrand01((Rand_seed_t)anum);
2936 PL_srand_called = TRUE;
2940 /* Historically srand always returned true. We can avoid breaking
2942 sv_setpvs(TARG, "0 but true");
2951 tryAMAGICun_MG(int_amg, AMGf_numeric);
2953 SV * const sv = TOPs;
2954 const IV iv = SvIV_nomg(sv);
2955 /* XXX it's arguable that compiler casting to IV might be subtly
2956 different from modf (for numbers inside (IV_MIN,UV_MAX)) in which
2957 else preferring IV has introduced a subtle behaviour change bug. OTOH
2958 relying on floating point to be accurate is a bug. */
2963 else if (SvIOK(sv)) {
2965 SETu(SvUV_nomg(sv));
2970 const NV value = SvNV_nomg(sv);
2971 if (UNLIKELY(Perl_isinfnan(value)))
2973 else if (value >= 0.0) {
2974 if (value < (NV)UV_MAX + 0.5) {
2977 SETn(Perl_floor(value));
2981 if (value > (NV)IV_MIN - 0.5) {
2984 SETn(Perl_ceil(value));
2995 tryAMAGICun_MG(abs_amg, AMGf_numeric);
2997 SV * const sv = TOPs;
2998 /* This will cache the NV value if string isn't actually integer */
2999 const IV iv = SvIV_nomg(sv);
3004 else if (SvIOK(sv)) {
3005 /* IVX is precise */
3007 SETu(SvUV_nomg(sv)); /* force it to be numeric only */
3015 /* 2s complement assumption. Also, not really needed as
3016 IV_MIN and -IV_MIN should both be %100...00 and NV-able */
3022 const NV value = SvNV_nomg(sv);
3033 /* also used for: pp_hex() */
3039 I32 flags = PERL_SCAN_ALLOW_UNDERSCORES;
3043 SV* const sv = TOPs;
3045 tmps = (SvPV_const(sv, len));
3047 /* If Unicode, try to downgrade
3048 * If not possible, croak. */
3049 SV* const tsv = sv_2mortal(newSVsv(sv));
3052 sv_utf8_downgrade(tsv, FALSE);
3053 tmps = SvPV_const(tsv, len);
3055 if (PL_op->op_type == OP_HEX)
3058 while (*tmps && len && isSPACE(*tmps))
3062 if (isALPHA_FOLD_EQ(*tmps, 'x')) {
3064 result_uv = grok_hex (tmps, &len, &flags, &result_nv);
3066 else if (isALPHA_FOLD_EQ(*tmps, 'b'))
3067 result_uv = grok_bin (tmps, &len, &flags, &result_nv);
3069 result_uv = grok_oct (tmps, &len, &flags, &result_nv);
3071 if (flags & PERL_SCAN_GREATER_THAN_UV_MAX) {
3085 SV * const sv = TOPs;
3087 U32 in_bytes = IN_BYTES;
3088 /* simplest case shortcut */
3089 /* turn off SVf_UTF8 in tmp flags if HINT_BYTES on*/
3090 U32 svflags = (SvFLAGS(sv) ^ (in_bytes << 26)) & (SVf_POK|SVs_GMG|SVf_UTF8);
3091 STATIC_ASSERT_STMT(HINT_BYTES == 0x00000008 && SVf_UTF8 == 0x20000000 && (SVf_UTF8 == HINT_BYTES << 26));
3094 if(LIKELY(svflags == SVf_POK))
3096 if(svflags & SVs_GMG)
3099 if (!IN_BYTES) /* reread to avoid using an C auto/register */
3100 sv_setiv(TARG, (IV)sv_len_utf8_nomg(sv));
3104 /* unrolled SvPV_nomg_const(sv,len) */
3109 (void)sv_2pv_flags(sv, &len, 0|SV_CONST_RETURN);
3111 sv_setiv(TARG, (IV)(len));
3114 if (!SvPADTMP(TARG)) {
3115 sv_setsv_nomg(TARG, &PL_sv_undef);
3116 } else { /* TARG is on stack at this point and is overwriten by SETs.
3117 This branch is the odd one out, so put TARG by default on
3118 stack earlier to let local SP go out of liveness sooner */
3125 return NORMAL; /* no putback, SP didn't move in this opcode */
3128 /* Returns false if substring is completely outside original string.
3129 No length is indicated by len_iv = 0 and len_is_uv = 0. len_is_uv must
3130 always be true for an explicit 0.
3133 Perl_translate_substr_offsets( STRLEN curlen, IV pos1_iv,
3134 bool pos1_is_uv, IV len_iv,
3135 bool len_is_uv, STRLEN *posp,
3141 PERL_ARGS_ASSERT_TRANSLATE_SUBSTR_OFFSETS;
3143 if (!pos1_is_uv && pos1_iv < 0 && curlen) {
3144 pos1_is_uv = curlen-1 > ~(UV)pos1_iv;
3147 if ((pos1_is_uv || pos1_iv > 0) && (UV)pos1_iv > curlen)
3150 if (len_iv || len_is_uv) {
3151 if (!len_is_uv && len_iv < 0) {
3152 pos2_iv = curlen + len_iv;
3154 pos2_is_uv = curlen-1 > ~(UV)len_iv;
3157 } else { /* len_iv >= 0 */
3158 if (!pos1_is_uv && pos1_iv < 0) {
3159 pos2_iv = pos1_iv + len_iv;
3160 pos2_is_uv = (UV)len_iv > (UV)IV_MAX;
3162 if ((UV)len_iv > curlen-(UV)pos1_iv)
3165 pos2_iv = pos1_iv+len_iv;
3175 if (!pos2_is_uv && pos2_iv < 0) {
3176 if (!pos1_is_uv && pos1_iv < 0)
3180 else if (!pos1_is_uv && pos1_iv < 0)
3183 if ((UV)pos2_iv < (UV)pos1_iv)
3185 if ((UV)pos2_iv > curlen)
3188 /* pos1_iv and pos2_iv both in 0..curlen, so the cast is safe */
3189 *posp = (STRLEN)( (UV)pos1_iv );
3190 *lenp = (STRLEN)( (UV)pos2_iv - (UV)pos1_iv );
3207 I32 lvalue = PL_op->op_flags & OPf_MOD || LVRET;
3208 const bool rvalue = (GIMME_V != G_VOID);
3211 const char *repl = NULL;
3213 int num_args = PL_op->op_private & 7;
3214 bool repl_need_utf8_upgrade = FALSE;
3218 if(!(repl_sv = POPs)) num_args--;
3220 if ((len_sv = POPs)) {
3221 len_iv = SvIV(len_sv);
3222 len_is_uv = len_iv ? SvIOK_UV(len_sv) : 1;
3227 pos1_iv = SvIV(pos_sv);
3228 pos1_is_uv = SvIOK_UV(pos_sv);
3230 if (PL_op->op_private & OPpSUBSTR_REPL_FIRST) {
3234 if (lvalue && !repl_sv) {
3236 ret = sv_2mortal(newSV_type(SVt_PVLV)); /* Not TARG RT#67838 */
3237 sv_magic(ret, NULL, PERL_MAGIC_substr, NULL, 0);
3239 LvTARG(ret) = SvREFCNT_inc_simple(sv);
3241 pos1_is_uv || pos1_iv >= 0
3242 ? (STRLEN)(UV)pos1_iv
3243 : (LvFLAGS(ret) |= 1, (STRLEN)(UV)-pos1_iv);
3245 len_is_uv || len_iv > 0
3246 ? (STRLEN)(UV)len_iv
3247 : (LvFLAGS(ret) |= 2, (STRLEN)(UV)-len_iv);
3249 PUSHs(ret); /* avoid SvSETMAGIC here */
3253 repl = SvPV_const(repl_sv, repl_len);
3256 Perl_ck_warner(aTHX_ packWARN(WARN_SUBSTR),
3257 "Attempt to use reference as lvalue in substr"
3259 tmps = SvPV_force_nomg(sv, curlen);
3260 if (DO_UTF8(repl_sv) && repl_len) {
3262 sv_utf8_upgrade_nomg(sv);
3266 else if (DO_UTF8(sv))
3267 repl_need_utf8_upgrade = TRUE;
3269 else tmps = SvPV_const(sv, curlen);
3271 utf8_curlen = sv_or_pv_len_utf8(sv, tmps, curlen);
3272 if (utf8_curlen == curlen)
3275 curlen = utf8_curlen;
3281 STRLEN pos, len, byte_len, byte_pos;
3283 if (!translate_substr_offsets(
3284 curlen, pos1_iv, pos1_is_uv, len_iv, len_is_uv, &pos, &len
3288 byte_pos = utf8_curlen
3289 ? sv_or_pv_pos_u2b(sv, tmps, pos, &byte_len) : pos;
3294 SvTAINTED_off(TARG); /* decontaminate */
3295 SvUTF8_off(TARG); /* decontaminate */
3296 sv_setpvn(TARG, tmps, byte_len);
3297 #ifdef USE_LOCALE_COLLATE
3298 sv_unmagic(TARG, PERL_MAGIC_collxfrm);
3305 SV* repl_sv_copy = NULL;
3307 if (repl_need_utf8_upgrade) {
3308 repl_sv_copy = newSVsv(repl_sv);
3309 sv_utf8_upgrade(repl_sv_copy);
3310 repl = SvPV_const(repl_sv_copy, repl_len);
3314 sv_insert_flags(sv, byte_pos, byte_len, repl, repl_len, 0);
3315 SvREFCNT_dec(repl_sv_copy);
3318 if (PL_op->op_private & OPpSUBSTR_REPL_FIRST)
3328 Perl_croak(aTHX_ "substr outside of string");
3329 Perl_ck_warner(aTHX_ packWARN(WARN_SUBSTR), "substr outside of string");
3336 const IV size = POPi;
3337 const IV offset = POPi;
3338 SV * const src = POPs;
3339 const I32 lvalue = PL_op->op_flags & OPf_MOD || LVRET;
3342 if (lvalue) { /* it's an lvalue! */
3343 ret = sv_2mortal(newSV_type(SVt_PVLV)); /* Not TARG RT#67838 */
3344 sv_magic(ret, NULL, PERL_MAGIC_vec, NULL, 0);
3346 LvTARG(ret) = SvREFCNT_inc_simple(src);
3347 LvTARGOFF(ret) = offset;
3348 LvTARGLEN(ret) = size;
3352 SvTAINTED_off(TARG); /* decontaminate */
3356 sv_setuv(ret, do_vecget(src, offset, size));
3364 /* also used for: pp_rindex() */
3377 const char *little_p;
3380 const bool is_index = PL_op->op_type == OP_INDEX;
3381 const bool threeargs = MAXARG >= 3 && (TOPs || ((void)POPs,0));
3387 big_p = SvPV_const(big, biglen);
3388 little_p = SvPV_const(little, llen);
3390 big_utf8 = DO_UTF8(big);
3391 little_utf8 = DO_UTF8(little);
3392 if (big_utf8 ^ little_utf8) {
3393 /* One needs to be upgraded. */
3394 if (little_utf8 && !IN_ENCODING) {
3395 /* Well, maybe instead we might be able to downgrade the small
3397 char * const pv = (char*)bytes_from_utf8((U8 *)little_p, &llen,
3400 /* If the large string is ISO-8859-1, and it's not possible to
3401 convert the small string to ISO-8859-1, then there is no
3402 way that it could be found anywhere by index. */
3407 /* At this point, pv is a malloc()ed string. So donate it to temp
3408 to ensure it will get free()d */
3409 little = temp = newSV(0);
3410 sv_usepvn(temp, pv, llen);
3411 little_p = SvPVX(little);
3414 ? newSVpvn(big_p, biglen) : newSVpvn(little_p, llen);
3417 sv_recode_to_utf8(temp, _get_encoding());
3419 sv_utf8_upgrade(temp);
3424 big_p = SvPV_const(big, biglen);
3427 little_p = SvPV_const(little, llen);
3431 if (SvGAMAGIC(big)) {
3432 /* Life just becomes a lot easier if I use a temporary here.
3433 Otherwise I need to avoid calls to sv_pos_u2b(), which (dangerously)
3434 will trigger magic and overloading again, as will fbm_instr()
3436 big = newSVpvn_flags(big_p, biglen,
3437 SVs_TEMP | (big_utf8 ? SVf_UTF8 : 0));
3440 if (SvGAMAGIC(little) || (is_index && !SvOK(little))) {
3441 /* index && SvOK() is a hack. fbm_instr() calls SvPV_const, which will
3442 warn on undef, and we've already triggered a warning with the
3443 SvPV_const some lines above. We can't remove that, as we need to
3444 call some SvPV to trigger overloading early and find out if the
3446 This is all getting to messy. The API isn't quite clean enough,
3447 because data access has side effects.
3449 little = newSVpvn_flags(little_p, llen,
3450 SVs_TEMP | (little_utf8 ? SVf_UTF8 : 0));
3451 little_p = SvPVX(little);
3455 offset = is_index ? 0 : biglen;
3457 if (big_utf8 && offset > 0)
3458 offset = sv_pos_u2b_flags(big, offset, 0, SV_CONST_RETURN);
3464 else if (offset > (SSize_t)biglen)
3466 if (!(little_p = is_index
3467 ? fbm_instr((unsigned char*)big_p + offset,
3468 (unsigned char*)big_p + biglen, little, 0)
3469 : rninstr(big_p, big_p + offset,
3470 little_p, little_p + llen)))
3473 retval = little_p - big_p;
3474 if (retval > 1 && big_utf8)
3475 retval = sv_pos_b2u_flags(big, retval, SV_CONST_RETURN);
3485 dSP; dMARK; dORIGMARK; dTARGET;
3486 SvTAINTED_off(TARG);
3487 do_sprintf(TARG, SP-MARK, MARK+1);
3488 TAINT_IF(SvTAINTED(TARG));
3500 const U8 *s = (U8*)SvPV_const(argsv, len);
3502 if (IN_ENCODING && SvPOK(argsv) && !DO_UTF8(argsv)) {
3503 SV * const tmpsv = sv_2mortal(newSVsv(argsv));
3504 s = (U8*)sv_recode_to_utf8(tmpsv, _get_encoding());
3505 len = UTF8SKIP(s); /* Should be well-formed; so this is its length */
3510 ? utf8n_to_uvchr(s, len, 0, UTF8_ALLOW_ANYUV)
3524 if (UNLIKELY(SvAMAGIC(top)))
3526 if (UNLIKELY(isinfnansv(top)))
3527 Perl_croak(aTHX_ "Cannot chr %"NVgf, SvNV(top));
3529 if (!IN_BYTES /* under bytes, chr(-1) eq chr(0xff), etc. */
3530 && ((SvIOKp(top) && !SvIsUV(top) && SvIV_nomg(top) < 0)
3532 ((SvNOKp(top) || (SvOK(top) && !SvIsUV(top)))
3533 && SvNV_nomg(top) < 0.0))) {
3534 if (ckWARN(WARN_UTF8)) {
3535 if (SvGMAGICAL(top)) {
3536 SV *top2 = sv_newmortal();
3537 sv_setsv_nomg(top2, top);
3540 Perl_warner(aTHX_ packWARN(WARN_UTF8),
3541 "Invalid negative number (%"SVf") in chr", SVfARG(top));
3543 value = UNICODE_REPLACEMENT;
3545 value = SvUV_nomg(top);
3549 SvUPGRADE(TARG,SVt_PV);
3551 if (value > 255 && !IN_BYTES) {
3552 SvGROW(TARG, (STRLEN)UNISKIP(value)+1);
3553 tmps = (char*)uvchr_to_utf8_flags((U8*)SvPVX(TARG), value, 0);
3554 SvCUR_set(TARG, tmps - SvPVX_const(TARG));
3556 (void)SvPOK_only(TARG);
3565 *tmps++ = (char)value;
3567 (void)SvPOK_only(TARG);
3569 if (IN_ENCODING && !IN_BYTES) {
3570 sv_recode_to_utf8(TARG, _get_encoding());
3572 if (SvCUR(TARG) == 0
3573 || ! is_utf8_string((U8*)tmps, SvCUR(TARG))
3574 || UTF8_IS_REPLACEMENT((U8*) tmps, (U8*) tmps + SvCUR(TARG)))
3579 *tmps++ = (char)value;
3595 const char *tmps = SvPV_const(left, len);
3597 if (DO_UTF8(left)) {
3598 /* If Unicode, try to downgrade.
3599 * If not possible, croak.
3600 * Yes, we made this up. */
3601 SV* const tsv = newSVpvn_flags(tmps, len, SVf_UTF8|SVs_TEMP);
3603 sv_utf8_downgrade(tsv, FALSE);
3604 tmps = SvPV_const(tsv, len);
3606 # ifdef USE_ITHREADS
3608 if (!PL_reentrant_buffer->_crypt_struct_buffer) {
3609 /* This should be threadsafe because in ithreads there is only
3610 * one thread per interpreter. If this would not be true,
3611 * we would need a mutex to protect this malloc. */
3612 PL_reentrant_buffer->_crypt_struct_buffer =
3613 (struct crypt_data *)safemalloc(sizeof(struct crypt_data));
3614 #if defined(__GLIBC__) || defined(__EMX__)
3615 if (PL_reentrant_buffer->_crypt_struct_buffer) {
3616 PL_reentrant_buffer->_crypt_struct_buffer->initialized = 0;
3617 /* work around glibc-2.2.5 bug */
3618 PL_reentrant_buffer->_crypt_struct_buffer->current_saltbits = 0;
3622 # endif /* HAS_CRYPT_R */
3623 # endif /* USE_ITHREADS */
3625 sv_setpv(TARG, fcrypt(tmps, SvPV_nolen_const(right)));
3627 sv_setpv(TARG, PerlProc_crypt(tmps, SvPV_nolen_const(right)));
3634 "The crypt() function is unimplemented due to excessive paranoia.");
3638 /* Generally UTF-8 and UTF-EBCDIC are indistinguishable at this level. So
3639 * most comments below say UTF-8, when in fact they mean UTF-EBCDIC as well */
3642 /* also used for: pp_lcfirst() */
3646 /* Actually is both lcfirst() and ucfirst(). Only the first character
3647 * changes. This means that possibly we can change in-place, ie., just
3648 * take the source and change that one character and store it back, but not
3649 * if read-only etc, or if the length changes */
3653 STRLEN slen; /* slen is the byte length of the whole SV. */
3656 bool inplace; /* ? Convert first char only, in-place */
3657 bool doing_utf8 = FALSE; /* ? using utf8 */
3658 bool convert_source_to_utf8 = FALSE; /* ? need to convert */
3659 const int op_type = PL_op->op_type;
3662 U8 tmpbuf[UTF8_MAXBYTES_CASE+1];
3663 STRLEN ulen; /* ulen is the byte length of the original Unicode character
3664 * stored as UTF-8 at s. */
3665 STRLEN tculen; /* tculen is the byte length of the freshly titlecased (or
3666 * lowercased) character stored in tmpbuf. May be either
3667 * UTF-8 or not, but in either case is the number of bytes */
3669 s = (const U8*)SvPV_const(source, slen);
3671 /* We may be able to get away with changing only the first character, in
3672 * place, but not if read-only, etc. Later we may discover more reasons to
3673 * not convert in-place. */
3674 inplace = !SvREADONLY(source)
3675 && ( SvPADTMP(source)
3676 || ( SvTEMP(source) && !SvSMAGICAL(source)
3677 && SvREFCNT(source) == 1));
3679 /* First calculate what the changed first character should be. This affects
3680 * whether we can just swap it out, leaving the rest of the string unchanged,
3681 * or even if have to convert the dest to UTF-8 when the source isn't */
3683 if (! slen) { /* If empty */
3684 need = 1; /* still need a trailing NUL */
3687 else if (DO_UTF8(source)) { /* Is the source utf8? */
3690 if (op_type == OP_UCFIRST) {
3691 #ifdef USE_LOCALE_CTYPE
3692 _to_utf8_title_flags(s, tmpbuf, &tculen, IN_LC_RUNTIME(LC_CTYPE));
3694 _to_utf8_title_flags(s, tmpbuf, &tculen, 0);
3698 #ifdef USE_LOCALE_CTYPE
3699 _to_utf8_lower_flags(s, tmpbuf, &tculen, IN_LC_RUNTIME(LC_CTYPE));
3701 _to_utf8_lower_flags(s, tmpbuf, &tculen, 0);
3705 /* we can't do in-place if the length changes. */
3706 if (ulen != tculen) inplace = FALSE;
3707 need = slen + 1 - ulen + tculen;
3709 else { /* Non-zero length, non-UTF-8, Need to consider locale and if
3710 * latin1 is treated as caseless. Note that a locale takes
3712 ulen = 1; /* Original character is 1 byte */
3713 tculen = 1; /* Most characters will require one byte, but this will
3714 * need to be overridden for the tricky ones */
3717 if (op_type == OP_LCFIRST) {
3719 /* lower case the first letter: no trickiness for any character */
3720 #ifdef USE_LOCALE_CTYPE
3721 if (IN_LC_RUNTIME(LC_CTYPE)) {
3722 _CHECK_AND_WARN_PROBLEMATIC_LOCALE;
3723 *tmpbuf = toLOWER_LC(*s);
3728 *tmpbuf = (IN_UNI_8_BIT)
3729 ? toLOWER_LATIN1(*s)
3733 #ifdef USE_LOCALE_CTYPE
3735 else if (IN_LC_RUNTIME(LC_CTYPE)) {
3736 if (IN_UTF8_CTYPE_LOCALE) {
3740 _CHECK_AND_WARN_PROBLEMATIC_LOCALE;
3741 *tmpbuf = (U8) toUPPER_LC(*s); /* This would be a bug if any
3742 locales have upper and title case
3746 else if (! IN_UNI_8_BIT) {
3747 *tmpbuf = toUPPER(*s); /* Returns caseless for non-ascii, or
3748 * on EBCDIC machines whatever the
3749 * native function does */
3752 /* Here, is ucfirst non-UTF-8, not in locale (unless that locale is
3753 * UTF-8, which we treat as not in locale), and cased latin1 */
3755 #ifdef USE_LOCALE_CTYPE
3759 title_ord = _to_upper_title_latin1(*s, tmpbuf, &tculen, 's');
3761 assert(tculen == 2);
3763 /* If the result is an upper Latin1-range character, it can
3764 * still be represented in one byte, which is its ordinal */
3765 if (UTF8_IS_DOWNGRADEABLE_START(*tmpbuf)) {
3766 *tmpbuf = (U8) title_ord;
3770 /* Otherwise it became more than one ASCII character (in
3771 * the case of LATIN_SMALL_LETTER_SHARP_S) or changed to
3772 * beyond Latin1, so the number of bytes changed, so can't
3773 * replace just the first character in place. */
3776 /* If the result won't fit in a byte, the entire result
3777 * will have to be in UTF-8. Assume worst case sizing in
3778 * conversion. (all latin1 characters occupy at most two
3780 if (title_ord > 255) {
3782 convert_source_to_utf8 = TRUE;
3783 need = slen * 2 + 1;
3785 /* The (converted) UTF-8 and UTF-EBCDIC lengths of all
3786 * (both) characters whose title case is above 255 is
3790 else { /* LATIN_SMALL_LETTER_SHARP_S expands by 1 byte */
3791 need = slen + 1 + 1;
3795 } /* End of use Unicode (Latin1) semantics */
3796 } /* End of changing the case of the first character */
3798 /* Here, have the first character's changed case stored in tmpbuf. Ready to
3799 * generate the result */
3802 /* We can convert in place. This means we change just the first
3803 * character without disturbing the rest; no need to grow */
3805 s = d = (U8*)SvPV_force_nomg(source, slen);
3811 /* Here, we can't convert in place; we earlier calculated how much
3812 * space we will need, so grow to accommodate that */
3813 SvUPGRADE(dest, SVt_PV);
3814 d = (U8*)SvGROW(dest, need);
3815 (void)SvPOK_only(dest);
3822 if (! convert_source_to_utf8) {
3824 /* Here both source and dest are in UTF-8, but have to create
3825 * the entire output. We initialize the result to be the
3826 * title/lower cased first character, and then append the rest
3828 sv_setpvn(dest, (char*)tmpbuf, tculen);
3830 sv_catpvn(dest, (char*)(s + ulen), slen - ulen);
3834 const U8 *const send = s + slen;
3836 /* Here the dest needs to be in UTF-8, but the source isn't,
3837 * except we earlier UTF-8'd the first character of the source
3838 * into tmpbuf. First put that into dest, and then append the
3839 * rest of the source, converting it to UTF-8 as we go. */
3841 /* Assert tculen is 2 here because the only two characters that
3842 * get to this part of the code have 2-byte UTF-8 equivalents */
3844 *d++ = *(tmpbuf + 1);
3845 s++; /* We have just processed the 1st char */
3847 for (; s < send; s++) {
3848 d = uvchr_to_utf8(d, *s);
3851 SvCUR_set(dest, d - (U8*)SvPVX_const(dest));
3855 else { /* in-place UTF-8. Just overwrite the first character */
3856 Copy(tmpbuf, d, tculen, U8);
3857 SvCUR_set(dest, need - 1);
3861 else { /* Neither source nor dest are in or need to be UTF-8 */
3863 if (inplace) { /* in-place, only need to change the 1st char */
3866 else { /* Not in-place */
3868 /* Copy the case-changed character(s) from tmpbuf */
3869 Copy(tmpbuf, d, tculen, U8);
3870 d += tculen - 1; /* Code below expects d to point to final
3871 * character stored */
3874 else { /* empty source */
3875 /* See bug #39028: Don't taint if empty */
3879 /* In a "use bytes" we don't treat the source as UTF-8, but, still want
3880 * the destination to retain that flag */
3881 if (SvUTF8(source) && ! IN_BYTES)
3884 if (!inplace) { /* Finish the rest of the string, unchanged */
3885 /* This will copy the trailing NUL */
3886 Copy(s + 1, d + 1, slen, U8);
3887 SvCUR_set(dest, need - 1);
3890 #ifdef USE_LOCALE_CTYPE
3891 if (IN_LC_RUNTIME(LC_CTYPE)) {
3896 if (dest != source && SvTAINTED(source))
3902 /* There's so much setup/teardown code common between uc and lc, I wonder if
3903 it would be worth merging the two, and just having a switch outside each
3904 of the three tight loops. There is less and less commonality though */
3917 if ((SvPADTMP(source)
3919 (SvTEMP(source) && !SvSMAGICAL(source) && SvREFCNT(source) == 1))
3920 && !SvREADONLY(source) && SvPOK(source)
3923 #ifdef USE_LOCALE_CTYPE
3924 (IN_LC_RUNTIME(LC_CTYPE))
3925 ? ! IN_UTF8_CTYPE_LOCALE
3931 /* We can convert in place. The reason we can't if in UNI_8_BIT is to
3932 * make the loop tight, so we overwrite the source with the dest before
3933 * looking at it, and we need to look at the original source
3934 * afterwards. There would also need to be code added to handle
3935 * switching to not in-place in midstream if we run into characters
3936 * that change the length. Since being in locale overrides UNI_8_BIT,
3937 * that latter becomes irrelevant in the above test; instead for
3938 * locale, the size can't normally change, except if the locale is a
3941 s = d = (U8*)SvPV_force_nomg(source, len);
3948 s = (const U8*)SvPV_nomg_const(source, len);
3951 SvUPGRADE(dest, SVt_PV);
3952 d = (U8*)SvGROW(dest, min);
3953 (void)SvPOK_only(dest);
3958 /* Overloaded values may have toggled the UTF-8 flag on source, so we need
3959 to check DO_UTF8 again here. */
3961 if (DO_UTF8(source)) {
3962 const U8 *const send = s + len;
3963 U8 tmpbuf[UTF8_MAXBYTES_CASE+1];
3965 /* All occurrences of these are to be moved to follow any other marks.
3966 * This is context-dependent. We may not be passed enough context to
3967 * move the iota subscript beyond all of them, but we do the best we can
3968 * with what we're given. The result is always better than if we
3969 * hadn't done this. And, the problem would only arise if we are
3970 * passed a character without all its combining marks, which would be
3971 * the caller's mistake. The information this is based on comes from a
3972 * comment in Unicode SpecialCasing.txt, (and the Standard's text
3973 * itself) and so can't be checked properly to see if it ever gets
3974 * revised. But the likelihood of it changing is remote */
3975 bool in_iota_subscript = FALSE;
3981 if (in_iota_subscript && ! _is_utf8_mark(s)) {
3983 /* A non-mark. Time to output the iota subscript */
3984 Copy(GREEK_CAPITAL_LETTER_IOTA_UTF8, d, capital_iota_len, U8);
3985 d += capital_iota_len;
3986 in_iota_subscript = FALSE;
3989 /* Then handle the current character. Get the changed case value
3990 * and copy it to the output buffer */
3993 #ifdef USE_LOCALE_CTYPE
3994 uv = _to_utf8_upper_flags(s, tmpbuf, &ulen, IN_LC_RUNTIME(LC_CTYPE));
3996 uv = _to_utf8_upper_flags(s, tmpbuf, &ulen, 0);
3998 #define GREEK_CAPITAL_LETTER_IOTA 0x0399
3999 #define COMBINING_GREEK_YPOGEGRAMMENI 0x0345
4000 if (uv == GREEK_CAPITAL_LETTER_IOTA
4001 && utf8_to_uvchr_buf(s, send, 0) == COMBINING_GREEK_YPOGEGRAMMENI)
4003 in_iota_subscript = TRUE;
4006 if (ulen > u && (SvLEN(dest) < (min += ulen - u))) {
4007 /* If the eventually required minimum size outgrows the
4008 * available space, we need to grow. */
4009 const UV o = d - (U8*)SvPVX_const(dest);
4011 /* If someone uppercases one million U+03B0s we SvGROW()
4012 * one million times. Or we could try guessing how much to
4013 * allocate without allocating too much. Such is life.
4014 * See corresponding comment in lc code for another option
4017 d = (U8*)SvPVX(dest) + o;
4019 Copy(tmpbuf, d, ulen, U8);
4024 if (in_iota_subscript) {
4025 Copy(GREEK_CAPITAL_LETTER_IOTA_UTF8, d, capital_iota_len, U8);
4026 d += capital_iota_len;
4031 SvCUR_set(dest, d - (U8*)SvPVX_const(dest));
4033 else { /* Not UTF-8 */
4035 const U8 *const send = s + len;
4037 /* Use locale casing if in locale; regular style if not treating
4038 * latin1 as having case; otherwise the latin1 casing. Do the
4039 * whole thing in a tight loop, for speed, */
4040 #ifdef USE_LOCALE_CTYPE
4041 if (IN_LC_RUNTIME(LC_CTYPE)) {
4042 if (IN_UTF8_CTYPE_LOCALE) {
4045 _CHECK_AND_WARN_PROBLEMATIC_LOCALE;
4046 for (; s < send; d++, s++)
4047 *d = (U8) toUPPER_LC(*s);
4051 if (! IN_UNI_8_BIT) {
4052 for (; s < send; d++, s++) {
4057 #ifdef USE_LOCALE_CTYPE
4060 for (; s < send; d++, s++) {
4061 *d = toUPPER_LATIN1_MOD(*s);
4062 if (LIKELY(*d != LATIN_SMALL_LETTER_Y_WITH_DIAERESIS)) {
4066 /* The mainstream case is the tight loop above. To avoid
4067 * extra tests in that, all three characters that require
4068 * special handling are mapped by the MOD to the one tested
4070 * Use the source to distinguish between the three cases */
4072 if (*s == LATIN_SMALL_LETTER_SHARP_S) {
4074 /* uc() of this requires 2 characters, but they are
4075 * ASCII. If not enough room, grow the string */
4076 if (SvLEN(dest) < ++min) {
4077 const UV o = d - (U8*)SvPVX_const(dest);
4079 d = (U8*)SvPVX(dest) + o;
4081 *d++ = 'S'; *d = 'S'; /* upper case is 'SS' */
4082 continue; /* Back to the tight loop; still in ASCII */
4085 /* The other two special handling characters have their
4086 * upper cases outside the latin1 range, hence need to be
4087 * in UTF-8, so the whole result needs to be in UTF-8. So,
4088 * here we are somewhere in the middle of processing a
4089 * non-UTF-8 string, and realize that we will have to convert
4090 * the whole thing to UTF-8. What to do? There are
4091 * several possibilities. The simplest to code is to
4092 * convert what we have so far, set a flag, and continue on
4093 * in the loop. The flag would be tested each time through
4094 * the loop, and if set, the next character would be
4095 * converted to UTF-8 and stored. But, I (khw) didn't want
4096 * to slow down the mainstream case at all for this fairly
4097 * rare case, so I didn't want to add a test that didn't
4098 * absolutely have to be there in the loop, besides the
4099 * possibility that it would get too complicated for
4100 * optimizers to deal with. Another possibility is to just
4101 * give up, convert the source to UTF-8, and restart the
4102 * function that way. Another possibility is to convert
4103 * both what has already been processed and what is yet to
4104 * come separately to UTF-8, then jump into the loop that
4105 * handles UTF-8. But the most efficient time-wise of the
4106 * ones I could think of is what follows, and turned out to
4107 * not require much extra code. */
4109 /* Convert what we have so far into UTF-8, telling the
4110 * function that we know it should be converted, and to
4111 * allow extra space for what we haven't processed yet.
4112 * Assume the worst case space requirements for converting
4113 * what we haven't processed so far: that it will require
4114 * two bytes for each remaining source character, plus the
4115 * NUL at the end. This may cause the string pointer to
4116 * move, so re-find it. */
4118 len = d - (U8*)SvPVX_const(dest);
4119 SvCUR_set(dest, len);
4120 len = sv_utf8_upgrade_flags_grow(dest,
4121 SV_GMAGIC|SV_FORCE_UTF8_UPGRADE,
4123 d = (U8*)SvPVX(dest) + len;
4125 /* Now process the remainder of the source, converting to
4126 * upper and UTF-8. If a resulting byte is invariant in
4127 * UTF-8, output it as-is, otherwise convert to UTF-8 and
4128 * append it to the output. */
4129 for (; s < send; s++) {
4130 (void) _to_upper_title_latin1(*s, d, &len, 'S');
4134 /* Here have processed the whole source; no need to continue
4135 * with the outer loop. Each character has been converted
4136 * to upper case and converted to UTF-8 */
4139 } /* End of processing all latin1-style chars */
4140 } /* End of processing all chars */
4141 } /* End of source is not empty */
4143 if (source != dest) {
4144 *d = '\0'; /* Here d points to 1 after last char, add NUL */
4145 SvCUR_set(dest, d - (U8*)SvPVX_const(dest));
4147 } /* End of isn't utf8 */
4148 #ifdef USE_LOCALE_CTYPE
4149 if (IN_LC_RUNTIME(LC_CTYPE)) {
4154 if (dest != source && SvTAINTED(source))
4172 if ( ( SvPADTMP(source)
4173 || ( SvTEMP(source) && !SvSMAGICAL(source)
4174 && SvREFCNT(source) == 1 )
4176 && !SvREADONLY(source) && SvPOK(source)
4177 && !DO_UTF8(source)) {
4179 /* We can convert in place, as lowercasing anything in the latin1 range
4180 * (or else DO_UTF8 would have been on) doesn't lengthen it */
4182 s = d = (U8*)SvPV_force_nomg(source, len);
4189 s = (const U8*)SvPV_nomg_const(source, len);
4192 SvUPGRADE(dest, SVt_PV);
4193 d = (U8*)SvGROW(dest, min);
4194 (void)SvPOK_only(dest);
4199 /* Overloaded values may have toggled the UTF-8 flag on source, so we need
4200 to check DO_UTF8 again here. */
4202 if (DO_UTF8(source)) {
4203 const U8 *const send = s + len;
4204 U8 tmpbuf[UTF8_MAXBYTES_CASE+1];
4207 const STRLEN u = UTF8SKIP(s);
4210 #ifdef USE_LOCALE_CTYPE
4211 _to_utf8_lower_flags(s, tmpbuf, &ulen, IN_LC_RUNTIME(LC_CTYPE));
4213 _to_utf8_lower_flags(s, tmpbuf, &ulen, 0);
4216 /* Here is where we would do context-sensitive actions. See the
4217 * commit message for 86510fb15 for why there isn't any */
4219 if (ulen > u && (SvLEN(dest) < (min += ulen - u))) {
4221 /* If the eventually required minimum size outgrows the
4222 * available space, we need to grow. */
4223 const UV o = d - (U8*)SvPVX_const(dest);
4225 /* If someone lowercases one million U+0130s we SvGROW() one
4226 * million times. Or we could try guessing how much to
4227 * allocate without allocating too much. Such is life.
4228 * Another option would be to grow an extra byte or two more
4229 * each time we need to grow, which would cut down the million
4230 * to 500K, with little waste */
4232 d = (U8*)SvPVX(dest) + o;
4235 /* Copy the newly lowercased letter to the output buffer we're
4237 Copy(tmpbuf, d, ulen, U8);
4240 } /* End of looping through the source string */
4243 SvCUR_set(dest, d - (U8*)SvPVX_const(dest));
4244 } else { /* Not utf8 */
4246 const U8 *const send = s + len;
4248 /* Use locale casing if in locale; regular style if not treating
4249 * latin1 as having case; otherwise the latin1 casing. Do the
4250 * whole thing in a tight loop, for speed, */
4251 #ifdef USE_LOCALE_CTYPE
4252 if (IN_LC_RUNTIME(LC_CTYPE)) {
4253 _CHECK_AND_WARN_PROBLEMATIC_LOCALE;
4254 for (; s < send; d++, s++)
4255 *d = toLOWER_LC(*s);
4259 if (! IN_UNI_8_BIT) {
4260 for (; s < send; d++, s++) {
4265 for (; s < send; d++, s++) {
4266 *d = toLOWER_LATIN1(*s);
4270 if (source != dest) {
4272 SvCUR_set(dest, d - (U8*)SvPVX_const(dest));
4275 #ifdef USE_LOCALE_CTYPE
4276 if (IN_LC_RUNTIME(LC_CTYPE)) {
4281 if (dest != source && SvTAINTED(source))
4290 SV * const sv = TOPs;
4292 const char *s = SvPV_const(sv,len);
4294 SvUTF8_off(TARG); /* decontaminate */
4297 SvUPGRADE(TARG, SVt_PV);
4298 SvGROW(TARG, (len * 2) + 1);
4302 STRLEN ulen = UTF8SKIP(s);
4303 bool to_quote = FALSE;
4305 if (UTF8_IS_INVARIANT(*s)) {
4306 if (_isQUOTEMETA(*s)) {
4310 else if (UTF8_IS_DOWNGRADEABLE_START(*s)) {
4312 #ifdef USE_LOCALE_CTYPE
4313 /* In locale, we quote all non-ASCII Latin1 chars.
4314 * Otherwise use the quoting rules */
4316 IN_LC_RUNTIME(LC_CTYPE)
4319 _isQUOTEMETA(TWO_BYTE_UTF8_TO_NATIVE(*s, *(s + 1))))
4324 else if (is_QUOTEMETA_high(s)) {
4339 else if (IN_UNI_8_BIT) {
4341 if (_isQUOTEMETA(*s))
4347 /* For non UNI_8_BIT (and hence in locale) just quote all \W
4348 * including everything above ASCII */
4350 if (!isWORDCHAR_A(*s))
4356 SvCUR_set(TARG, d - SvPVX_const(TARG));
4357 (void)SvPOK_only_UTF8(TARG);
4360 sv_setpvn(TARG, s, len);
4376 U8 tmpbuf[UTF8_MAXBYTES_CASE + 1];
4377 const bool full_folding = TRUE; /* This variable is here so we can easily
4378 move to more generality later */
4379 const U8 flags = ( full_folding ? FOLD_FLAGS_FULL : 0 )
4380 #ifdef USE_LOCALE_CTYPE
4381 | ( IN_LC_RUNTIME(LC_CTYPE) ? FOLD_FLAGS_LOCALE : 0 )
4385 /* This is a facsimile of pp_lc, but with a thousand bugs thanks to me.
4386 * You are welcome(?) -Hugmeir
4394 s = (const U8*)SvPV_nomg_const(source, len);
4396 if (ckWARN(WARN_UNINITIALIZED))
4397 report_uninit(source);
4404 SvUPGRADE(dest, SVt_PV);
4405 d = (U8*)SvGROW(dest, min);
4406 (void)SvPOK_only(dest);
4411 if (DO_UTF8(source)) { /* UTF-8 flagged string. */
4413 const STRLEN u = UTF8SKIP(s);
4416 _to_utf8_fold_flags(s, tmpbuf, &ulen, flags);
4418 if (ulen > u && (SvLEN(dest) < (min += ulen - u))) {
4419 const UV o = d - (U8*)SvPVX_const(dest);
4421 d = (U8*)SvPVX(dest) + o;
4424 Copy(tmpbuf, d, ulen, U8);
4429 } /* Unflagged string */
4431 #ifdef USE_LOCALE_CTYPE
4432 if ( IN_LC_RUNTIME(LC_CTYPE) ) { /* Under locale */
4433 if (IN_UTF8_CTYPE_LOCALE) {
4434 goto do_uni_folding;
4436 _CHECK_AND_WARN_PROBLEMATIC_LOCALE;
4437 for (; s < send; d++, s++)
4438 *d = (U8) toFOLD_LC(*s);
4442 if ( !IN_UNI_8_BIT ) { /* Under nothing, or bytes */
4443 for (; s < send; d++, s++)
4447 #ifdef USE_LOCALE_CTYPE
4450 /* For ASCII and the Latin-1 range, there's only two troublesome
4451 * folds, \x{DF} (\N{LATIN SMALL LETTER SHARP S}), which under full
4452 * casefolding becomes 'ss'; and \x{B5} (\N{MICRO SIGN}), which
4453 * under any fold becomes \x{3BC} (\N{GREEK SMALL LETTER MU}) --
4454 * For the rest, the casefold is their lowercase. */
4455 for (; s < send; d++, s++) {
4456 if (*s == MICRO_SIGN) {
4457 /* \N{MICRO SIGN}'s casefold is \N{GREEK SMALL LETTER MU},
4458 * which is outside of the latin-1 range. There's a couple
4459 * of ways to deal with this -- khw discusses them in
4460 * pp_lc/uc, so go there :) What we do here is upgrade what
4461 * we had already casefolded, then enter an inner loop that
4462 * appends the rest of the characters as UTF-8. */
4463 len = d - (U8*)SvPVX_const(dest);
4464 SvCUR_set(dest, len);
4465 len = sv_utf8_upgrade_flags_grow(dest,
4466 SV_GMAGIC|SV_FORCE_UTF8_UPGRADE,
4467 /* The max expansion for latin1
4468 * chars is 1 byte becomes 2 */
4470 d = (U8*)SvPVX(dest) + len;
4472 Copy(GREEK_SMALL_LETTER_MU_UTF8, d, small_mu_len, U8);
4475 for (; s < send; s++) {
4477 UV fc = _to_uni_fold_flags(*s, tmpbuf, &ulen, flags);
4478 if UVCHR_IS_INVARIANT(fc) {
4480 && *s == LATIN_SMALL_LETTER_SHARP_S)
4489 Copy(tmpbuf, d, ulen, U8);
4495 else if (full_folding && *s == LATIN_SMALL_LETTER_SHARP_S) {
4496 /* Under full casefolding, LATIN SMALL LETTER SHARP S
4497 * becomes "ss", which may require growing the SV. */
4498 if (SvLEN(dest) < ++min) {
4499 const UV o = d - (U8*)SvPVX_const(dest);
4501 d = (U8*)SvPVX(dest) + o;
4506 else { /* If it's not one of those two, the fold is their lower
4508 *d = toLOWER_LATIN1(*s);
4514 SvCUR_set(dest, d - (U8*)SvPVX_const(dest));
4516 #ifdef USE_LOCALE_CTYPE
4517 if (IN_LC_RUNTIME(LC_CTYPE)) {
4522 if (SvTAINTED(source))
4532 dSP; dMARK; dORIGMARK;
4533 AV *const av = MUTABLE_AV(POPs);
4534 const I32 lval = (PL_op->op_flags & OPf_MOD || LVRET);
4536 if (SvTYPE(av) == SVt_PVAV) {
4537 const bool localizing = PL_op->op_private & OPpLVAL_INTRO;
4538 bool can_preserve = FALSE;
4544 can_preserve = SvCANEXISTDELETE(av);
4547 if (lval && localizing) {
4550 for (svp = MARK + 1; svp <= SP; svp++) {
4551 const SSize_t elem = SvIV(*svp);
4555 if (max > AvMAX(av))
4559 while (++MARK <= SP) {
4561 SSize_t elem = SvIV(*MARK);
4562 bool preeminent = TRUE;
4564 if (localizing && can_preserve) {
4565 /* If we can determine whether the element exist,
4566 * Try to preserve the existenceness of a tied array
4567 * element by using EXISTS and DELETE if possible.
4568 * Fallback to FETCH and STORE otherwise. */
4569 preeminent = av_exists(av, elem);
4572 svp = av_fetch(av, elem, lval);
4575 DIE(aTHX_ PL_no_aelem, elem);
4578 save_aelem(av, elem, svp);
4580 SAVEADELETE(av, elem);
4583 *MARK = svp ? *svp : &PL_sv_undef;
4586 if (GIMME_V != G_ARRAY) {
4588 *++MARK = SP > ORIGMARK ? *SP : &PL_sv_undef;
4597 AV *const av = MUTABLE_AV(POPs);
4598 I32 lval = (PL_op->op_flags & OPf_MOD);
4599 SSize_t items = SP - MARK;
4601 if (PL_op->op_private & OPpMAYBE_LVSUB) {
4602 const I32 flags = is_lvalue_sub();
4604 if (!(flags & OPpENTERSUB_INARGS))
4605 /* diag_listed_as: Can't modify %s in %s */
4606 Perl_croak(aTHX_ "Can't modify index/value array slice in list assignment");
4613 *(MARK+items*2-1) = *(MARK+items);
4619 while (++MARK <= SP) {
4622 svp = av_fetch(av, SvIV(*MARK), lval);
4624 if (!svp || !*svp || *svp == &PL_sv_undef) {
4625 DIE(aTHX_ PL_no_aelem, SvIV(*MARK));
4627 *MARK = sv_mortalcopy(*MARK);
4629 *++MARK = svp ? *svp : &PL_sv_undef;
4631 if (GIMME_V != G_ARRAY) {
4632 MARK = SP - items*2;
4633 *++MARK = items > 0 ? *SP : &PL_sv_undef;
4640 /* Smart dereferencing for keys, values and each */
4642 /* also used for: pp_reach() pp_rvalues() */
4654 (SvTYPE(sv) != SVt_PVHV && SvTYPE(sv) != SVt_PVAV)
4659 "Type of argument to %s must be unblessed hashref or arrayref",
4660 PL_op_desc[PL_op->op_type] );
4663 if (PL_op->op_flags & OPf_SPECIAL && SvTYPE(sv) == SVt_PVAV)
4665 "Can't modify %s in %s",
4666 PL_op_desc[PL_op->op_type], PL_op_desc[PL_op->op_next->op_type]
4669 /* Delegate to correct function for op type */
4671 if (PL_op->op_type == OP_RKEYS || PL_op->op_type == OP_RVALUES) {
4672 return (SvTYPE(sv) == SVt_PVHV) ? Perl_do_kv(aTHX) : Perl_pp_akeys(aTHX);
4675 return (SvTYPE(sv) == SVt_PVHV)
4676 ? Perl_pp_each(aTHX)
4677 : Perl_pp_aeach(aTHX);
4684 AV *array = MUTABLE_AV(POPs);
4685 const I32 gimme = GIMME_V;
4686 IV *iterp = Perl_av_iter_p(aTHX_ array);
4687 const IV current = (*iterp)++;
4689 if (current > av_tindex(array)) {
4691 if (gimme == G_SCALAR)
4699 if (gimme == G_ARRAY) {
4700 SV **const element = av_fetch(array, current, 0);
4701 PUSHs(element ? *element : &PL_sv_undef);
4706 /* also used for: pp_avalues()*/
4710 AV *array = MUTABLE_AV(POPs);
4711 const I32 gimme = GIMME_V;
4713 *Perl_av_iter_p(aTHX_ array) = 0;
4715 if (gimme == G_SCALAR) {
4717 PUSHi(av_tindex(array) + 1);
4719 else if (gimme == G_ARRAY) {
4720 IV n = Perl_av_len(aTHX_ array);
4725 if (PL_op->op_type == OP_AKEYS || PL_op->op_type == OP_RKEYS) {
4726 for (i = 0; i <= n; i++) {
4731 for (i = 0; i <= n; i++) {
4732 SV *const *const elem = Perl_av_fetch(aTHX_ array, i, 0);
4733 PUSHs(elem ? *elem : &PL_sv_undef);
4740 /* Associative arrays. */
4745 HV * hash = MUTABLE_HV(POPs);
4747 const I32 gimme = GIMME_V;
4749 entry = hv_iternext(hash);
4753 SV* const sv = hv_iterkeysv(entry);
4755 if (gimme == G_ARRAY) {
4757 val = hv_iterval(hash, entry);
4761 else if (gimme == G_SCALAR)
4768 S_do_delete_local(pTHX)
4771 const I32 gimme = GIMME_V;
4774 const bool sliced = !!(PL_op->op_private & OPpSLICE);
4775 SV **unsliced_keysv = sliced ? NULL : sp--;
4776 SV * const osv = POPs;
4777 SV **mark = sliced ? PL_stack_base + POPMARK : unsliced_keysv-1;
4779 const bool tied = SvRMAGICAL(osv)
4780 && mg_find((const SV *)osv, PERL_MAGIC_tied);
4781 const bool can_preserve = SvCANEXISTDELETE(osv);
4782 const U32 type = SvTYPE(osv);
4783 SV ** const end = sliced ? SP : unsliced_keysv;
4785 if (type == SVt_PVHV) { /* hash element */
4786 HV * const hv = MUTABLE_HV(osv);
4787 while (++MARK <= end) {
4788 SV * const keysv = *MARK;
4790 bool preeminent = TRUE;
4792 preeminent = hv_exists_ent(hv, keysv, 0);
4794 HE *he = hv_fetch_ent(hv, keysv, 1, 0);
4801 sv = hv_delete_ent(hv, keysv, 0, 0);
4803 SvREFCNT_inc_simple_void(sv); /* De-mortalize */
4806 if (!sv) DIE(aTHX_ PL_no_helem_sv, SVfARG(keysv));
4807 save_helem_flags(hv, keysv, &sv, SAVEf_KEEPOLDELEM);
4809 *MARK = sv_mortalcopy(sv);
4815 SAVEHDELETE(hv, keysv);
4816 *MARK = &PL_sv_undef;
4820 else if (type == SVt_PVAV) { /* array element */
4821 if (PL_op->op_flags & OPf_SPECIAL) {
4822 AV * const av = MUTABLE_AV(osv);
4823 while (++MARK <= end) {
4824 SSize_t idx = SvIV(*MARK);
4826 bool preeminent = TRUE;
4828 preeminent = av_exists(av, idx);
4830 SV **svp = av_fetch(av, idx, 1);
4837 sv = av_delete(av, idx, 0);
4839 SvREFCNT_inc_simple_void(sv); /* De-mortalize */
4842 save_aelem_flags(av, idx, &sv, SAVEf_KEEPOLDELEM);
4844 *MARK = sv_mortalcopy(sv);
4850 SAVEADELETE(av, idx);
4851 *MARK = &PL_sv_undef;
4856 DIE(aTHX_ "panic: avhv_delete no longer supported");
4859 DIE(aTHX_ "Not a HASH reference");
4861 if (gimme == G_VOID)
4863 else if (gimme == G_SCALAR) {
4868 *++MARK = &PL_sv_undef;
4872 else if (gimme != G_VOID)
4873 PUSHs(*unsliced_keysv);
4884 if (PL_op->op_private & OPpLVAL_INTRO)
4885 return do_delete_local();
4888 discard = (gimme == G_VOID) ? G_DISCARD : 0;
4890 if (PL_op->op_private & OPpSLICE) {
4892 HV * const hv = MUTABLE_HV(POPs);
4893 const U32 hvtype = SvTYPE(hv);
4894 if (hvtype == SVt_PVHV) { /* hash element */
4895 while (++MARK <= SP) {
4896 SV * const sv = hv_delete_ent(hv, *MARK, discard, 0);
4897 *MARK = sv ? sv : &PL_sv_undef;
4900 else if (hvtype == SVt_PVAV) { /* array element */
4901 if (PL_op->op_flags & OPf_SPECIAL) {
4902 while (++MARK <= SP) {
4903 SV * const sv = av_delete(MUTABLE_AV(hv), SvIV(*MARK), discard);
4904 *MARK = sv ? sv : &PL_sv_undef;
4909 DIE(aTHX_ "Not a HASH reference");
4912 else if (gimme == G_SCALAR) {
4917 *++MARK = &PL_sv_undef;
4923 HV * const hv = MUTABLE_HV(POPs);
4925 if (SvTYPE(hv) == SVt_PVHV)
4926 sv = hv_delete_ent(hv, keysv, discard, 0);
4927 else if (SvTYPE(hv) == SVt_PVAV) {
4928 if (PL_op->op_flags & OPf_SPECIAL)
4929 sv = av_delete(MUTABLE_AV(hv), SvIV(keysv), discard);
4931 DIE(aTHX_ "panic: avhv_delete no longer supported");
4934 DIE(aTHX_ "Not a HASH reference");
4949 if (UNLIKELY( PL_op->op_private & OPpEXISTS_SUB )) {
4951 SV * const sv = POPs;
4952 CV * const cv = sv_2cv(sv, &hv, &gv, 0);
4955 if (gv && isGV(gv) && GvCV(gv) && !GvCVGEN(gv))
4960 hv = MUTABLE_HV(POPs);
4961 if (LIKELY( SvTYPE(hv) == SVt_PVHV )) {
4962 if (hv_exists_ent(hv, tmpsv, 0))
4965 else if (SvTYPE(hv) == SVt_PVAV) {
4966 if (PL_op->op_flags & OPf_SPECIAL) { /* array element */
4967 if (av_exists(MUTABLE_AV(hv), SvIV(tmpsv)))
4972 DIE(aTHX_ "Not a HASH reference");
4979 dSP; dMARK; dORIGMARK;
4980 HV * const hv = MUTABLE_HV(POPs);
4981 const I32 lval = (PL_op->op_flags & OPf_MOD || LVRET);
4982 const bool localizing = PL_op->op_private & OPpLVAL_INTRO;
4983 bool can_preserve = FALSE;
4989 if (SvCANEXISTDELETE(hv))
4990 can_preserve = TRUE;
4993 while (++MARK <= SP) {
4994 SV * const keysv = *MARK;
4997 bool preeminent = TRUE;
4999 if (localizing && can_preserve) {
5000 /* If we can determine whether the element exist,
5001 * try to preserve the existenceness of a tied hash
5002 * element by using EXISTS and DELETE if possible.
5003 * Fallback to FETCH and STORE otherwise. */
5004 preeminent = hv_exists_ent(hv, keysv, 0);
5007 he = hv_fetch_ent(hv, keysv, lval, 0);
5008 svp = he ? &HeVAL(he) : NULL;
5011 if (!svp || !*svp || *svp == &PL_sv_undef) {
5012 DIE(aTHX_ PL_no_helem_sv, SVfARG(keysv));
5015 if (HvNAME_get(hv) && isGV(*svp))
5016 save_gp(MUTABLE_GV(*svp), !(PL_op->op_flags & OPf_SPECIAL));
5017 else if (preeminent)
5018 save_helem_flags(hv, keysv, svp,
5019 (PL_op->op_flags & OPf_SPECIAL) ? 0 : SAVEf_SETMAGIC);
5021 SAVEHDELETE(hv, keysv);
5024 *MARK = svp && *svp ? *svp : &PL_sv_undef;
5026 if (GIMME_V != G_ARRAY) {
5028 *++MARK = SP > ORIGMARK ? *SP : &PL_sv_undef;
5037 HV * const hv = MUTABLE_HV(POPs);
5038 I32 lval = (PL_op->op_flags & OPf_MOD);
5039 SSize_t items = SP - MARK;
5041 if (PL_op->op_private & OPpMAYBE_LVSUB) {
5042 const I32 flags = is_lvalue_sub();
5044 if (!(flags & OPpENTERSUB_INARGS))
5045 /* diag_listed_as: Can't modify %s in %s */
5046 Perl_croak(aTHX_ "Can't modify key/value hash slice in list assignment");
5053 *(MARK+items*2-1) = *(MARK+items);
5059 while (++MARK <= SP) {
5060 SV * const keysv = *MARK;
5064 he = hv_fetch_ent(hv, keysv, lval, 0);
5065 svp = he ? &HeVAL(he) : NULL;
5068 if (!svp || !*svp || *svp == &PL_sv_undef) {
5069 DIE(aTHX_ PL_no_helem_sv, SVfARG(keysv));
5071 *MARK = sv_mortalcopy(*MARK);
5073 *++MARK = svp && *svp ? *svp : &PL_sv_undef;
5075 if (GIMME_V != G_ARRAY) {
5076 MARK = SP - items*2;
5077 *++MARK = items > 0 ? *SP : &PL_sv_undef;
5083 /* List operators. */
5087 I32 markidx = POPMARK;
5088 if (GIMME_V != G_ARRAY) {
5089 SV **mark = PL_stack_base + markidx;
5092 *MARK = *SP; /* unwanted list, return last item */
5094 *MARK = &PL_sv_undef;
5104 SV ** const lastrelem = PL_stack_sp;
5105 SV ** const lastlelem = PL_stack_base + POPMARK;
5106 SV ** const firstlelem = PL_stack_base + POPMARK + 1;
5107 SV ** const firstrelem = lastlelem + 1;
5108 const U8 mod = PL_op->op_flags & OPf_MOD;
5110 const I32 max = lastrelem - lastlelem;
5113 if (GIMME_V != G_ARRAY) {
5114 I32 ix = SvIV(*lastlelem);
5117 if (ix < 0 || ix >= max)
5118 *firstlelem = &PL_sv_undef;
5120 *firstlelem = firstrelem[ix];
5126 SP = firstlelem - 1;
5130 for (lelem = firstlelem; lelem <= lastlelem; lelem++) {
5131 I32 ix = SvIV(*lelem);
5134 if (ix < 0 || ix >= max)
5135 *lelem = &PL_sv_undef;
5137 if (!(*lelem = firstrelem[ix]))
5138 *lelem = &PL_sv_undef;
5139 else if (mod && SvPADTMP(*lelem)) {
5140 *lelem = firstrelem[ix] = sv_mortalcopy(*lelem);
5151 const I32 items = SP - MARK;
5152 SV * const av = MUTABLE_SV(av_make(items, MARK+1));
5154 mXPUSHs((PL_op->op_flags & OPf_SPECIAL)
5155 ? newRV_noinc(av) : av);
5161 dSP; dMARK; dORIGMARK;
5162 HV* const hv = newHV();
5163 SV* const retval = sv_2mortal( PL_op->op_flags & OPf_SPECIAL
5164 ? newRV_noinc(MUTABLE_SV(hv))
5169 (MARK++, SvGMAGICAL(*MARK) ? sv_mortalcopy(*MARK) : *MARK);
5176 sv_setsv_nomg(val, *MARK);
5180 Perl_ck_warner(aTHX_ packWARN(WARN_MISC), "Odd number of elements in anonymous hash");
5183 (void)hv_store_ent(hv,key,val,0);
5191 S_deref_plain_array(pTHX_ AV *ary)
5193 if (SvTYPE(ary) == SVt_PVAV) return ary;
5194 SvGETMAGIC((SV *)ary);
5195 if (!SvROK(ary) || SvTYPE(SvRV(ary)) != SVt_PVAV)
5196 Perl_die(aTHX_ "Not an ARRAY reference");
5197 else if (SvOBJECT(SvRV(ary)))
5198 Perl_die(aTHX_ "Not an unblessed ARRAY reference");
5199 return (AV *)SvRV(ary);
5202 #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
5203 # define DEREF_PLAIN_ARRAY(ary) \
5206 SvTYPE(aRrRay) == SVt_PVAV \
5208 : S_deref_plain_array(aTHX_ aRrRay); \
5211 # define DEREF_PLAIN_ARRAY(ary) \
5213 PL_Sv = (SV *)(ary), \
5214 SvTYPE(PL_Sv) == SVt_PVAV \
5216 : S_deref_plain_array(aTHX_ (AV *)PL_Sv) \
5222 dSP; dMARK; dORIGMARK;
5223 int num_args = (SP - MARK);
5224 AV *ary = DEREF_PLAIN_ARRAY(MUTABLE_AV(*++MARK));
5233 const MAGIC * const mg = SvTIED_mg((const SV *)ary, PERL_MAGIC_tied);
5236 return Perl_tied_method(aTHX_ SV_CONST(SPLICE), mark - 1, MUTABLE_SV(ary), mg,
5237 GIMME_V | TIED_METHOD_ARGUMENTS_ON_STACK,
5244 offset = i = SvIV(*MARK);
5246 offset += AvFILLp(ary) + 1;
5248 DIE(aTHX_ PL_no_aelem, i);
5250 length = SvIVx(*MARK++);
5252 length += AvFILLp(ary) - offset + 1;
5258 length = AvMAX(ary) + 1; /* close enough to infinity */
5262 length = AvMAX(ary) + 1;
5264 if (offset > AvFILLp(ary) + 1) {
5266 Perl_ck_warner(aTHX_ packWARN(WARN_MISC), "splice() offset past end of array" );
5267 offset = AvFILLp(ary) + 1;
5269 after = AvFILLp(ary) + 1 - (offset + length);
5270 if (after < 0) { /* not that much array */
5271 length += after; /* offset+length now in array */
5277 /* At this point, MARK .. SP-1 is our new LIST */
5280 diff = newlen - length;
5281 if (newlen && !AvREAL(ary) && AvREIFY(ary))
5284 /* make new elements SVs now: avoid problems if they're from the array */
5285 for (dst = MARK, i = newlen; i; i--) {
5286 SV * const h = *dst;
5287 *dst++ = newSVsv(h);
5290 if (diff < 0) { /* shrinking the area */
5291 SV **tmparyval = NULL;
5293 Newx(tmparyval, newlen, SV*); /* so remember insertion */
5294 Copy(MARK, tmparyval, newlen, SV*);
5297 MARK = ORIGMARK + 1;
5298 if (GIMME_V == G_ARRAY) { /* copy return vals to stack */
5299 const bool real = cBOOL(AvREAL(ary));
5300 MEXTEND(MARK, length);
5302 EXTEND_MORTAL(length);
5303 for (i = 0, dst = MARK; i < length; i++) {
5304 if ((*dst = AvARRAY(ary)[i+offset])) {
5306 sv_2mortal(*dst); /* free them eventually */
5309 *dst = &PL_sv_undef;
5315 *MARK = AvARRAY(ary)[offset+length-1];
5318 for (i = length - 1, dst = &AvARRAY(ary)[offset]; i > 0; i--)
5319 SvREFCNT_dec(*dst++); /* free them now */
5322 AvFILLp(ary) += diff;
5324 /* pull up or down? */
5326 if (offset < after) { /* easier to pull up */
5327 if (offset) { /* esp. if nothing to pull */
5328 src = &AvARRAY(ary)[offset-1];
5329 dst = src - diff; /* diff is negative */
5330 for (i = offset; i > 0; i--) /* can't trust Copy */
5334 AvARRAY(ary) = AvARRAY(ary) - diff; /* diff is negative */
5338 if (after) { /* anything to pull down? */
5339 src = AvARRAY(ary) + offset + length;
5340 dst = src + diff; /* diff is negative */
5341 Move(src, dst, after, SV*);
5343 dst = &AvARRAY(ary)[AvFILLp(ary)+1];
5344 /* avoid later double free */
5351 Copy( tmparyval, AvARRAY(ary) + offset, newlen, SV* );
5352 Safefree(tmparyval);
5355 else { /* no, expanding (or same) */
5356 SV** tmparyval = NULL;
5358 Newx(tmparyval, length, SV*); /* so remember deletion */
5359 Copy(AvARRAY(ary)+offset, tmparyval, length, SV*);
5362 if (diff > 0) { /* expanding */
5363 /* push up or down? */
5364 if (offset < after && diff <= AvARRAY(ary) - AvALLOC(ary)) {
5368 Move(src, dst, offset, SV*);
5370 AvARRAY(ary) = AvARRAY(ary) - diff;/* diff is positive */
5372 AvFILLp(ary) += diff;
5375 if (AvFILLp(ary) + diff >= AvMAX(ary)) /* oh, well */
5376 av_extend(ary, AvFILLp(ary) + diff);
5377 AvFILLp(ary) += diff;
5380 dst = AvARRAY(ary) + AvFILLp(ary);
5382 for (i = after; i; i--) {
5390 Copy( MARK, AvARRAY(ary) + offset, newlen, SV* );
5393 MARK = ORIGMARK + 1;
5394 if (GIMME_V == G_ARRAY) { /* copy return vals to stack */
5396 const bool real = cBOOL(AvREAL(ary));
5398 EXTEND_MORTAL(length);
5399 for (i = 0, dst = MARK; i < length; i++) {
5400 if ((*dst = tmparyval[i])) {
5402 sv_2mortal(*dst); /* free them eventually */
5404 else *dst = &PL_sv_undef;
5410 else if (length--) {
5411 *MARK = tmparyval[length];
5414 while (length-- > 0)
5415 SvREFCNT_dec(tmparyval[length]);
5419 *MARK = &PL_sv_undef;
5420 Safefree(tmparyval);
5424 mg_set(MUTABLE_SV(ary));
5432 dSP; dMARK; dORIGMARK; dTARGET;
5433 AV * const ary = DEREF_PLAIN_ARRAY(MUTABLE_AV(*++MARK));
5434 const MAGIC * const mg = SvTIED_mg((const SV *)ary, PERL_MAGIC_tied);
5437 *MARK-- = SvTIED_obj(MUTABLE_SV(ary), mg);
5440 ENTER_with_name("call_PUSH");
5441 call_sv(SV_CONST(PUSH),G_SCALAR|G_DISCARD|G_METHOD_NAMED);
5442 LEAVE_with_name("call_PUSH");
5443 /* SPAGAIN; not needed: SP is assigned to immediately below */
5446 if (SvREADONLY(ary) && MARK < SP) Perl_croak_no_modify();
5447 PL_delaymagic = DM_DELAY;
5448 for (++MARK; MARK <= SP; MARK++) {
5450 if (*MARK) SvGETMAGIC(*MARK);
5453 sv_setsv_nomg(sv, *MARK);
5454 av_store(ary, AvFILLp(ary)+1, sv);
5456 if (PL_delaymagic & DM_ARRAY_ISA)
5457 mg_set(MUTABLE_SV(ary));
5462 if (OP_GIMME(PL_op, 0) != G_VOID) {
5463 PUSHi( AvFILL(ary) + 1 );
5468 /* also used for: pp_pop()*/
5472 AV * const av = PL_op->op_flags & OPf_SPECIAL
5473 ? MUTABLE_AV(GvAV(PL_defgv)) : DEREF_PLAIN_ARRAY(MUTABLE_AV(POPs));
5474 SV * const sv = PL_op->op_type == OP_SHIFT ? av_shift(av) : av_pop(av);
5478 (void)sv_2mortal(sv);
5485 dSP; dMARK; dORIGMARK; dTARGET;
5486 AV *ary = DEREF_PLAIN_ARRAY(MUTABLE_AV(*++MARK));
5487 const MAGIC * const mg = SvTIED_mg((const SV *)ary, PERL_MAGIC_tied);
5490 *MARK-- = SvTIED_obj(MUTABLE_SV(ary), mg);
5493 ENTER_with_name("call_UNSHIFT");
5494 call_sv(SV_CONST(UNSHIFT),G_SCALAR|G_DISCARD|G_METHOD_NAMED);
5495 LEAVE_with_name("call_UNSHIFT");
5496 /* SPAGAIN; not needed: SP is assigned to immediately below */
5500 av_unshift(ary, SP - MARK);
5502 SV * const sv = newSVsv(*++MARK);
5503 (void)av_store(ary, i++, sv);
5507 if (OP_GIMME(PL_op, 0) != G_VOID) {
5508 PUSHi( AvFILL(ary) + 1 );
5517 if (GIMME_V == G_ARRAY) {
5518 if (PL_op->op_private & OPpREVERSE_INPLACE) {
5522 assert( MARK+1 == SP && *SP && SvTYPE(*SP) == SVt_PVAV);
5523 (void)POPMARK; /* remove mark associated with ex-OP_AASSIGN */
5524 av = MUTABLE_AV((*SP));
5525 /* In-place reversing only happens in void context for the array
5526 * assignment. We don't need to push anything on the stack. */
5529 if (SvMAGICAL(av)) {
5531 SV *tmp = sv_newmortal();
5532 /* For SvCANEXISTDELETE */
5535 bool can_preserve = SvCANEXISTDELETE(av);
5537 for (i = 0, j = av_tindex(av); i < j; ++i, --j) {
5541 if (!av_exists(av, i)) {
5542 if (av_exists(av, j)) {
5543 SV *sv = av_delete(av, j, 0);
5544 begin = *av_fetch(av, i, TRUE);
5545 sv_setsv_mg(begin, sv);
5549 else if (!av_exists(av, j)) {
5550 SV *sv = av_delete(av, i, 0);
5551 end = *av_fetch(av, j, TRUE);
5552 sv_setsv_mg(end, sv);
5557 begin = *av_fetch(av, i, TRUE);
5558 end = *av_fetch(av, j, TRUE);
5559 sv_setsv(tmp, begin);
5560 sv_setsv_mg(begin, end);
5561 sv_setsv_mg(end, tmp);
5565 SV **begin = AvARRAY(av);
5568 SV **end = begin + AvFILLp(av);
5570 while (begin < end) {
5571 SV * const tmp = *begin;
5582 SV * const tmp = *MARK;
5586 /* safe as long as stack cannot get extended in the above */
5597 SvUTF8_off(TARG); /* decontaminate */
5599 do_join(TARG, &PL_sv_no, MARK, SP);
5601 sv_setsv(TARG, SP > MARK ? *SP : find_rundefsv());
5604 up = SvPV_force(TARG, len);
5606 if (DO_UTF8(TARG)) { /* first reverse each character */
5607 U8* s = (U8*)SvPVX(TARG);
5608 const U8* send = (U8*)(s + len);
5610 if (UTF8_IS_INVARIANT(*s)) {
5615 if (!utf8_to_uvchr_buf(s, send, 0))
5619 down = (char*)(s - 1);
5620 /* reverse this character */
5624 *down-- = (char)tmp;
5630 down = SvPVX(TARG) + len - 1;
5634 *down-- = (char)tmp;
5636 (void)SvPOK_only_UTF8(TARG);
5647 AV *ary = PL_op->op_flags & OPf_STACKED ? (AV *)POPs : NULL;
5648 IV limit = POPi; /* note, negative is forever */
5649 SV * const sv = POPs;
5651 const char *s = SvPV_const(sv, len);
5652 const bool do_utf8 = DO_UTF8(sv);
5653 const char *strend = s + len;
5659 const STRLEN slen = do_utf8
5660 ? utf8_length((U8*)s, (U8*)strend)
5661 : (STRLEN)(strend - s);
5662 SSize_t maxiters = slen + 10;
5663 I32 trailing_empty = 0;
5665 const I32 origlimit = limit;
5668 const I32 gimme = GIMME_V;
5670 const I32 oldsave = PL_savestack_ix;
5671 U32 make_mortal = SVs_TEMP;
5676 Copy(&LvTARGOFF(POPs), &pm, 1, PMOP*);
5681 DIE(aTHX_ "panic: pp_split, pm=%p, s=%p", pm, s);
5684 TAINT_IF(get_regex_charset(RX_EXTFLAGS(rx)) == REGEX_LOCALE_CHARSET &&
5685 (RX_EXTFLAGS(rx) & (RXf_WHITE | RXf_SKIPWHITE)));
5688 if (pm->op_pmreplrootu.op_pmtargetoff) {
5689 ary = GvAVn(MUTABLE_GV(PAD_SVl(pm->op_pmreplrootu.op_pmtargetoff)));
5693 if (pm->op_pmreplrootu.op_pmtargetgv) {
5694 ary = GvAVn(pm->op_pmreplrootu.op_pmtargetgv);
5698 else if (pm->op_targ)
5699 ary = (AV *)PAD_SVl(pm->op_targ);
5705 (void)sv_2mortal(SvREFCNT_inc_simple_NN(sv));
5708 if ((mg = SvTIED_mg((const SV *)ary, PERL_MAGIC_tied))) {
5710 XPUSHs(SvTIED_obj(MUTABLE_SV(ary), mg));
5717 for (i = AvFILLp(ary); i >= 0; i--)
5718 AvARRAY(ary)[i] = &PL_sv_undef; /* don't free mere refs */
5720 /* temporarily switch stacks */
5721 SAVESWITCHSTACK(PL_curstack, ary);
5725 base = SP - PL_stack_base;
5727 if (RX_EXTFLAGS(rx) & RXf_SKIPWHITE) {
5729 while (isSPACE_utf8(s))
5732 else if (get_regex_charset(RX_EXTFLAGS(rx)) == REGEX_LOCALE_CHARSET) {
5733 while (isSPACE_LC(*s))
5741 if (RX_EXTFLAGS(rx) & RXf_PMf_MULTILINE) {
5745 gimme_scalar = gimme == G_SCALAR && !ary;
5748 limit = maxiters + 2;
5749 if (RX_EXTFLAGS(rx) & RXf_WHITE) {
5752 /* this one uses 'm' and is a negative test */
5754 while (m < strend && ! isSPACE_utf8(m) ) {
5755 const int t = UTF8SKIP(m);
5756 /* isSPACE_utf8 returns FALSE for malform utf8 */
5763 else if (get_regex_charset(RX_EXTFLAGS(rx)) == REGEX_LOCALE_CHARSET)
5765 while (m < strend && !isSPACE_LC(*m))
5768 while (m < strend && !isSPACE(*m))
5781 dstr = newSVpvn_flags(s, m-s,
5782 (do_utf8 ? SVf_UTF8 : 0) | make_mortal);
5786 /* skip the whitespace found last */
5788 s = m + UTF8SKIP(m);
5792 /* this one uses 's' and is a positive test */
5794 while (s < strend && isSPACE_utf8(s) )
5797 else if (get_regex_charset(RX_EXTFLAGS(rx)) == REGEX_LOCALE_CHARSET)
5799 while (s < strend && isSPACE_LC(*s))
5802 while (s < strend && isSPACE(*s))
5807 else if (RX_EXTFLAGS(rx) & RXf_START_ONLY) {
5809 for (m = s; m < strend && *m != '\n'; m++)
5822 dstr = newSVpvn_flags(s, m-s,
5823 (do_utf8 ? SVf_UTF8 : 0) | make_mortal);
5829 else if (RX_EXTFLAGS(rx) & RXf_NULL && !(s >= strend)) {
5831 Pre-extend the stack, either the number of bytes or
5832 characters in the string or a limited amount, triggered by:
5834 my ($x, $y) = split //, $str;
5838 if (!gimme_scalar) {
5839 const U32 items = limit - 1;
5848 /* keep track of how many bytes we skip over */
5858 dstr = newSVpvn_flags(m, s-m, SVf_UTF8 | make_mortal);
5871 dstr = newSVpvn(s, 1);
5887 else if (do_utf8 == (RX_UTF8(rx) != 0) &&
5888 (RX_EXTFLAGS(rx) & RXf_USE_INTUIT) && !RX_NPARENS(rx)
5889 && (RX_EXTFLAGS(rx) & RXf_CHECK_ALL)
5890 && !(RX_EXTFLAGS(rx) & RXf_IS_ANCHORED)) {
5891 const int tail = (RX_EXTFLAGS(rx) & RXf_INTUIT_TAIL);
5892 SV * const csv = CALLREG_INTUIT_STRING(rx);
5894 len = RX_MINLENRET(rx);
5895 if (len == 1 && !RX_UTF8(rx) && !tail) {
5896 const char c = *SvPV_nolen_const(csv);
5898 for (m = s; m < strend && *m != c; m++)
5909 dstr = newSVpvn_flags(s, m-s,
5910 (do_utf8 ? SVf_UTF8 : 0) | make_mortal);
5913 /* The rx->minlen is in characters but we want to step
5914 * s ahead by bytes. */
5916 s = (char*)utf8_hop((U8*)m, len);
5918 s = m + len; /* Fake \n at the end */
5922 while (s < strend && --limit &&
5923 (m = fbm_instr((unsigned char*)s, (unsigned char*)strend,
5924 csv, multiline ? FBMrf_MULTILINE : 0)) )
5933 dstr = newSVpvn_flags(s, m-s,
5934 (do_utf8 ? SVf_UTF8 : 0) | make_mortal);
5937 /* The rx->minlen is in characters but we want to step
5938 * s ahead by bytes. */
5940 s = (char*)utf8_hop((U8*)m, len);
5942 s = m + len; /* Fake \n at the end */
5947 maxiters += slen * RX_NPARENS(rx);
5948 while (s < strend && --limit)
5952 rex_return = CALLREGEXEC(rx, (char*)s, (char*)strend, (char*)orig, 1,
5955 if (rex_return == 0)
5957 TAINT_IF(RX_MATCH_TAINTED(rx));
5958 /* we never pass the REXEC_COPY_STR flag, so it should
5959 * never get copied */
5960 assert(!RX_MATCH_COPIED(rx));
5961 m = RX_OFFS(rx)[0].start + orig;
5970 dstr = newSVpvn_flags(s, m-s,
5971 (do_utf8 ? SVf_UTF8 : 0) | make_mortal);
5974 if (RX_NPARENS(rx)) {
5976 for (i = 1; i <= (I32)RX_NPARENS(rx); i++) {
5977 s = RX_OFFS(rx)[i].start + orig;
5978 m = RX_OFFS(rx)[i].end + orig;
5980 /* japhy (07/27/01) -- the (m && s) test doesn't catch
5981 parens that didn't match -- they should be set to
5982 undef, not the empty string */
5990 if (m >= orig && s >= orig) {
5991 dstr = newSVpvn_flags(s, m-s,
5992 (do_utf8 ? SVf_UTF8 : 0)
5996 dstr = &PL_sv_undef; /* undef, not "" */
6002 s = RX_OFFS(rx)[0].end + orig;
6006 if (!gimme_scalar) {
6007 iters = (SP - PL_stack_base) - base;
6009 if (iters > maxiters)
6010 DIE(aTHX_ "Split loop");
6012 /* keep field after final delim? */
6013 if (s < strend || (iters && origlimit)) {
6014 if (!gimme_scalar) {
6015 const STRLEN l = strend - s;
6016 dstr = newSVpvn_flags(s, l, (do_utf8 ? SVf_UTF8 : 0) | make_mortal);
6021 else if (!origlimit) {
6023 iters -= trailing_empty;
6025 while (iters > 0 && (!TOPs || !SvANY(TOPs) || SvCUR(TOPs) == 0)) {
6026 if (TOPs && !make_mortal)
6028 *SP-- = &PL_sv_undef;
6035 LEAVE_SCOPE(oldsave); /* may undo an earlier SWITCHSTACK */
6039 if (SvSMAGICAL(ary)) {
6041 mg_set(MUTABLE_SV(ary));
6044 if (gimme == G_ARRAY) {
6046 Copy(AvARRAY(ary), SP + 1, iters, SV*);
6053 ENTER_with_name("call_PUSH");
6054 call_sv(SV_CONST(PUSH),G_SCALAR|G_DISCARD|G_METHOD_NAMED);
6055 LEAVE_with_name("call_PUSH");
6057 if (gimme == G_ARRAY) {
6059 /* EXTEND should not be needed - we just popped them */
6061 for (i=0; i < iters; i++) {
6062 SV **svp = av_fetch(ary, i, FALSE);
6063 PUSHs((svp) ? *svp : &PL_sv_undef);
6070 if (gimme == G_ARRAY)
6082 SV *const sv = PAD_SVl(PL_op->op_targ);
6084 if (SvPADSTALE(sv)) {
6087 RETURNOP(cLOGOP->op_other);
6089 RETURNOP(cLOGOP->op_next);
6098 if (SvTYPE(retsv) == SVt_PVAV || SvTYPE(retsv) == SVt_PVHV
6099 || SvTYPE(retsv) == SVt_PVCV) {
6100 retsv = refto(retsv);
6107 /* used for: pp_padany(), pp_mapstart(), pp_custom(); plus any system ops
6108 * that aren't implemented on a particular platform */
6110 PP(unimplemented_op)
6112 const Optype op_type = PL_op->op_type;
6113 /* Using OP_NAME() isn't going to be helpful here. Firstly, it doesn't cope
6114 with out of range op numbers - it only "special" cases op_custom.
6115 Secondly, as the three ops we "panic" on are padmy, mapstart and custom,
6116 if we get here for a custom op then that means that the custom op didn't
6117 have an implementation. Given that OP_NAME() looks up the custom op
6118 by its pp_addr, likely it will return NULL, unless someone (unhelpfully)
6119 registers &PL_unimplemented_op as the address of their custom op.
6120 NULL doesn't generate a useful error message. "custom" does. */
6121 const char *const name = op_type >= OP_max
6122 ? "[out of range]" : PL_op_name[PL_op->op_type];
6123 if(OP_IS_SOCKET(op_type))
6124 DIE(aTHX_ PL_no_sock_func, name);
6125 DIE(aTHX_ "panic: unimplemented op %s (#%d) called", name, op_type);
6128 /* For sorting out arguments passed to a &CORE:: subroutine */
6132 int opnum = SvIOK(cSVOP_sv) ? (int)SvUV(cSVOP_sv) : 0;
6133 int defgv = PL_opargs[opnum] & OA_DEFGV ||opnum==OP_GLOB, whicharg = 0;
6134 AV * const at_ = GvAV(PL_defgv);
6135 SV **svp = at_ ? AvARRAY(at_) : NULL;
6136 I32 minargs = 0, maxargs = 0, numargs = at_ ? AvFILLp(at_)+1 : 0;
6137 I32 oa = opnum ? PL_opargs[opnum] >> OASHIFT : 0;
6138 bool seen_question = 0;
6139 const char *err = NULL;
6140 const bool pushmark = PL_op->op_private & OPpCOREARGS_PUSHMARK;
6142 /* Count how many args there are first, to get some idea how far to
6143 extend the stack. */
6145 if ((oa & 7) == OA_LIST) { maxargs = I32_MAX; break; }
6147 if (oa & OA_OPTIONAL) seen_question = 1;
6148 if (!seen_question) minargs++;
6152 if(numargs < minargs) err = "Not enough";
6153 else if(numargs > maxargs) err = "Too many";
6155 /* diag_listed_as: Too many arguments for %s */
6157 "%s arguments for %s", err,
6158 opnum ? PL_op_desc[opnum] : SvPV_nolen_const(cSVOP_sv)
6161 /* Reset the stack pointer. Without this, we end up returning our own
6162 arguments in list context, in addition to the values we are supposed
6163 to return. nextstate usually does this on sub entry, but we need
6164 to run the next op with the caller's hints, so we cannot have a
6166 SP = PL_stack_base + cxstack[cxstack_ix].blk_oldsp;
6168 if(!maxargs) RETURN;
6170 /* We do this here, rather than with a separate pushmark op, as it has
6171 to come in between two things this function does (stack reset and
6172 arg pushing). This seems the easiest way to do it. */
6175 (void)Perl_pp_pushmark(aTHX);
6178 EXTEND(SP, maxargs == I32_MAX ? numargs : maxargs);
6179 PUTBACK; /* The code below can die in various places. */
6181 oa = PL_opargs[opnum] >> OASHIFT;
6182 for (; oa&&(numargs||!pushmark); (void)(numargs&&(++svp,--numargs))) {
6187 if (!numargs && defgv && whicharg == minargs + 1) {
6188 PUSHs(find_rundefsv2(
6189 find_runcv_where(FIND_RUNCV_level_eq, 1, NULL),
6190 cxstack[cxstack_ix].blk_oldcop->cop_seq
6193 else PUSHs(numargs ? svp && *svp ? *svp : &PL_sv_undef : NULL);
6197 PUSHs(svp && *svp ? *svp : &PL_sv_undef);
6202 if (!svp || !*svp || !SvROK(*svp)
6203 || SvTYPE(SvRV(*svp)) != SVt_PVHV)
6205 /* diag_listed_as: Type of arg %d to &CORE::%s must be %s*/
6206 "Type of arg %d to &CORE::%s must be hash reference",
6207 whicharg, OP_DESC(PL_op->op_next)
6212 if (!numargs) PUSHs(NULL);
6213 else if(svp && *svp && SvROK(*svp) && isGV_with_GP(SvRV(*svp)))
6214 /* no magic here, as the prototype will have added an extra
6215 refgen and we just want what was there before that */
6218 const bool constr = PL_op->op_private & whicharg;
6220 svp && *svp ? *svp : &PL_sv_undef,
6221 constr, cBOOL(CopHINTS_get(PL_curcop) & HINT_STRICT_REFS),
6227 if (!numargs) goto try_defsv;
6229 const bool wantscalar =
6230 PL_op->op_private & OPpCOREARGS_SCALARMOD;
6231 if (!svp || !*svp || !SvROK(*svp)
6232 /* We have to permit globrefs even for the \$ proto, as
6233 *foo is indistinguishable from ${\*foo}, and the proto-
6234 type permits the latter. */
6235 || SvTYPE(SvRV(*svp)) > (
6236 wantscalar ? SVt_PVLV
6237 : opnum == OP_LOCK || opnum == OP_UNDEF
6243 "Type of arg %d to &CORE::%s must be %s",
6244 whicharg, PL_op_name[opnum],
6246 ? "scalar reference"
6247 : opnum == OP_LOCK || opnum == OP_UNDEF
6248 ? "reference to one of [$@%&*]"
6249 : "reference to one of [$@%*]"
6252 if (opnum == OP_UNDEF && SvRV(*svp) == (SV *)PL_defgv
6253 && cxstack[cxstack_ix].cx_type & CXp_HASARGS) {
6254 /* Undo @_ localisation, so that sub exit does not undo
6255 part of our undeffing. */
6256 PERL_CONTEXT *cx = &cxstack[cxstack_ix];
6258 cx->cx_type &= ~ CXp_HASARGS;
6259 assert(!AvREAL(cx->blk_sub.argarray));
6264 DIE(aTHX_ "panic: unknown OA_*: %x", (unsigned)(oa&7));
6276 if (PL_op->op_private & OPpOFFBYONE) {
6277 cv = find_runcv_where(FIND_RUNCV_level_eq, 1, NULL);
6279 else cv = find_runcv(NULL);
6280 XPUSHs(CvEVAL(cv) ? &PL_sv_undef : sv_2mortal(newRV((SV *)cv)));
6285 S_localise_aelem_lval(pTHX_ AV * const av, SV * const keysv,
6286 const bool can_preserve)
6288 const SSize_t ix = SvIV(keysv);
6289 if (can_preserve ? av_exists(av, ix) : TRUE) {
6290 SV ** const svp = av_fetch(av, ix, 1);
6292 Perl_croak(aTHX_ PL_no_aelem, ix);
6293 save_aelem(av, ix, svp);
6296 SAVEADELETE(av, ix);
6300 S_localise_helem_lval(pTHX_ HV * const hv, SV * const keysv,
6301 const bool can_preserve)
6303 if (can_preserve ? hv_exists_ent(hv, keysv, 0) : TRUE) {
6304 HE * const he = hv_fetch_ent(hv, keysv, 1, 0);
6305 SV ** const svp = he ? &HeVAL(he) : NULL;
6307 Perl_croak(aTHX_ PL_no_helem_sv, SVfARG(keysv));
6308 save_helem_flags(hv, keysv, svp, 0);
6311 SAVEHDELETE(hv, keysv);
6315 S_localise_gv_slot(pTHX_ GV *gv, U8 type)
6317 if (type == OPpLVREF_SV) {
6318 save_pushptrptr(gv, SvREFCNT_inc_simple(GvSV(gv)), SAVEt_GVSV);
6321 else if (type == OPpLVREF_AV)
6322 /* XXX Inefficient, as it creates a new AV, which we are
6323 about to clobber. */
6326 assert(type == OPpLVREF_HV);
6327 /* XXX Likewise inefficient. */
6336 SV * const key = PL_op->op_private & OPpLVREF_ELEM ? POPs : NULL;
6337 SV * const left = PL_op->op_flags & OPf_STACKED ? POPs : NULL;
6339 const char *bad = NULL;
6340 const U8 type = PL_op->op_private & OPpLVREF_TYPE;
6341 if (!SvROK(sv)) DIE(aTHX_ "Assigned value is not a reference");
6344 if (SvTYPE(SvRV(sv)) > SVt_PVLV)
6348 if (SvTYPE(SvRV(sv)) != SVt_PVAV)
6352 if (SvTYPE(SvRV(sv)) != SVt_PVHV)
6356 if (SvTYPE(SvRV(sv)) != SVt_PVCV)
6360 /* diag_listed_as: Assigned value is not %s reference */
6361 DIE(aTHX_ "Assigned value is not a%s reference", bad);
6365 switch (left ? SvTYPE(left) : 0) {
6368 SV * const old = PAD_SV(ARGTARG);
6369 PAD_SETSV(ARGTARG, SvREFCNT_inc_NN(SvRV(sv)));
6371 if ((PL_op->op_private & (OPpLVAL_INTRO|OPpPAD_STATE))
6373 SAVECLEARSV(PAD_SVl(ARGTARG));
6377 if (PL_op->op_private & OPpLVAL_INTRO) {
6378 S_localise_gv_slot(aTHX_ (GV *)left, type);
6380 gv_setref(left, sv);
6384 if (UNLIKELY(PL_op->op_private & OPpLVAL_INTRO)) {
6385 S_localise_aelem_lval(aTHX_ (AV *)left, key,
6386 SvCANEXISTDELETE(left));
6388 av_store((AV *)left, SvIV(key), SvREFCNT_inc_simple_NN(SvRV(sv)));
6391 if (UNLIKELY(PL_op->op_private & OPpLVAL_INTRO))
6392 S_localise_helem_lval(aTHX_ (HV *)left, key,
6393 SvCANEXISTDELETE(left));
6394 (void)hv_store_ent((HV *)left, key, SvREFCNT_inc_simple_NN(SvRV(sv)), 0);
6396 if (PL_op->op_flags & OPf_MOD)
6397 SETs(sv_2mortal(newSVsv(sv)));
6398 /* XXX else can weak references go stale before they are read, e.g.,
6407 SV * const ret = sv_2mortal(newSV_type(SVt_PVMG));
6408 SV * const elem = PL_op->op_private & OPpLVREF_ELEM ? POPs : NULL;
6409 SV * const arg = PL_op->op_flags & OPf_STACKED ? POPs : NULL;
6410 MAGIC * const mg = sv_magicext(ret, arg, PERL_MAGIC_lvref,
6411 &PL_vtbl_lvref, (char *)elem,
6412 elem ? HEf_SVKEY : (I32)ARGTARG);
6413 mg->mg_private = PL_op->op_private;
6414 if (PL_op->op_private & OPpLVREF_ITER)
6415 mg->mg_flags |= MGf_PERSIST;
6416 if (UNLIKELY(PL_op->op_private & OPpLVAL_INTRO)) {
6420 const bool can_preserve = SvCANEXISTDELETE(arg);
6421 if (SvTYPE(arg) == SVt_PVAV)
6422 S_localise_aelem_lval(aTHX_ (AV *)arg, elem, can_preserve);
6424 S_localise_helem_lval(aTHX_ (HV *)arg, elem, can_preserve);
6427 S_localise_gv_slot(aTHX_ (GV *)arg,
6428 PL_op->op_private & OPpLVREF_TYPE);
6430 else if (!(PL_op->op_private & OPpPAD_STATE))
6431 SAVECLEARSV(PAD_SVl(ARGTARG));
6440 AV * const av = (AV *)POPs;
6441 const bool localizing = PL_op->op_private & OPpLVAL_INTRO;
6442 bool can_preserve = FALSE;
6444 if (UNLIKELY(localizing)) {
6449 can_preserve = SvCANEXISTDELETE(av);
6451 if (SvTYPE(av) == SVt_PVAV) {
6454 for (svp = MARK + 1; svp <= SP; svp++) {
6455 const SSize_t elem = SvIV(*svp);
6459 if (max > AvMAX(av))
6464 while (++MARK <= SP) {
6465 SV * const elemsv = *MARK;
6466 if (SvTYPE(av) == SVt_PVAV)
6467 S_localise_aelem_lval(aTHX_ av, elemsv, can_preserve);
6469 S_localise_helem_lval(aTHX_ (HV *)av, elemsv, can_preserve);
6470 *MARK = sv_2mortal(newSV_type(SVt_PVMG));
6471 sv_magic(*MARK,(SV *)av,PERL_MAGIC_lvref,(char *)elemsv,HEf_SVKEY);
6478 if (PL_op->op_flags & OPf_STACKED)
6479 Perl_pp_rv2av(aTHX);
6481 Perl_pp_padav(aTHX);
6485 SETs(0); /* special alias marker that aassign recognises */
6495 SETs(sv_2mortal((SV *)newCONSTSUB(SvTYPE(CopSTASH(PL_curcop))==SVt_PVHV
6496 ? CopSTASH(PL_curcop)
6498 NULL, SvREFCNT_inc_simple_NN(sv))));
6503 * ex: set ts=8 sts=4 sw=4 et: