3 * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4 * 2000, 2001, 2002, 2003, 2004, 2005, 2006, 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 to discover,
13 * and no knowing what you'll find around a corner. And Elves, sir!" --Samwise
16 /* This file contains general pp ("push/pop") functions that execute the
17 * opcodes that make up a perl program. A typical pp function expects to
18 * find its arguments on the stack, and usually pushes its results onto
19 * the stack, hence the 'pp' terminology. Each OP structure contains
20 * a pointer to the relevant pp_foo() function.
30 /* XXX I can't imagine anyone who doesn't have this actually _needs_
31 it, since pid_t is an integral type.
34 #ifdef NEED_GETPID_PROTO
35 extern Pid_t getpid (void);
39 * Some BSDs and Cygwin default to POSIX math instead of IEEE.
40 * This switches them over to IEEE.
42 #if defined(LIBM_LIB_VERSION)
43 _LIB_VERSION_TYPE _LIB_VERSION = _IEEE_;
46 /* variations on pp_null */
52 if (GIMME_V == G_SCALAR)
63 if (PL_op->op_private & OPpLVAL_INTRO)
64 SAVECLEARSV(PAD_SVl(PL_op->op_targ));
66 if (PL_op->op_flags & OPf_REF) {
70 if (GIMME == G_SCALAR)
71 Perl_croak(aTHX_ "Can't return array to lvalue scalar context");
76 if (gimme == G_ARRAY) {
77 const I32 maxarg = AvFILL((AV*)TARG) + 1;
79 if (SvMAGICAL(TARG)) {
81 for (i=0; i < (U32)maxarg; i++) {
82 SV * const * const svp = av_fetch((AV*)TARG, i, FALSE);
83 SP[i+1] = (svp) ? *svp : &PL_sv_undef;
87 Copy(AvARRAY((AV*)TARG), SP+1, maxarg, SV*);
91 else if (gimme == G_SCALAR) {
92 SV* const sv = sv_newmortal();
93 const I32 maxarg = AvFILL((AV*)TARG) + 1;
106 if (PL_op->op_private & OPpLVAL_INTRO)
107 SAVECLEARSV(PAD_SVl(PL_op->op_targ));
108 if (PL_op->op_flags & OPf_REF)
111 if (GIMME == G_SCALAR)
112 Perl_croak(aTHX_ "Can't return hash to lvalue scalar context");
116 if (gimme == G_ARRAY) {
119 else if (gimme == G_SCALAR) {
120 SV* const sv = Perl_hv_scalar(aTHX_ (HV*)TARG);
134 tryAMAGICunDEREF(to_gv);
137 if (SvTYPE(sv) == SVt_PVIO) {
138 GV * const gv = (GV*) sv_newmortal();
139 gv_init(gv, 0, "", 0, 0);
140 GvIOp(gv) = (IO *)sv;
141 (void)SvREFCNT_inc(sv);
144 else if (SvTYPE(sv) != SVt_PVGV)
145 DIE(aTHX_ "Not a GLOB reference");
148 if (SvTYPE(sv) != SVt_PVGV) {
149 if (SvGMAGICAL(sv)) {
154 if (!SvOK(sv) && sv != &PL_sv_undef) {
155 /* If this is a 'my' scalar and flag is set then vivify
159 Perl_croak(aTHX_ PL_no_modify);
160 if (PL_op->op_private & OPpDEREF) {
162 if (cUNOP->op_targ) {
164 SV * const namesv = PAD_SV(cUNOP->op_targ);
165 const char * const name = SvPV(namesv, len);
167 gv_init(gv, CopSTASH(PL_curcop), name, len, 0);
170 const char * const name = CopSTASHPV(PL_curcop);
173 if (SvTYPE(sv) < SVt_RV)
174 sv_upgrade(sv, SVt_RV);
175 if (SvPVX_const(sv)) {
180 SvRV_set(sv, (SV*)gv);
185 if (PL_op->op_flags & OPf_REF ||
186 PL_op->op_private & HINT_STRICT_REFS)
187 DIE(aTHX_ PL_no_usym, "a symbol");
188 if (ckWARN(WARN_UNINITIALIZED))
192 if ((PL_op->op_flags & OPf_SPECIAL) &&
193 !(PL_op->op_flags & OPf_MOD))
195 SV * const temp = (SV*)gv_fetchsv(sv, 0, SVt_PVGV);
197 && (!is_gv_magical_sv(sv,0)
198 || !(sv = (SV*)gv_fetchsv(sv, GV_ADD, SVt_PVGV)))) {
204 if (PL_op->op_private & HINT_STRICT_REFS)
205 DIE(aTHX_ PL_no_symref_sv, sv, "a symbol");
206 if ((PL_op->op_private & (OPpLVAL_INTRO|OPpDONT_INIT_GV))
207 == OPpDONT_INIT_GV) {
208 /* We are the target of a coderef assignment. Return
209 the scalar unchanged, and let pp_sasssign deal with
213 sv = (SV*)gv_fetchsv(sv, GV_ADD, SVt_PVGV);
217 if (PL_op->op_private & OPpLVAL_INTRO)
218 save_gp((GV*)sv, !(PL_op->op_flags & OPf_SPECIAL));
230 tryAMAGICunDEREF(to_sv);
233 switch (SvTYPE(sv)) {
237 DIE(aTHX_ "Not a SCALAR reference");
243 if (SvTYPE(gv) != SVt_PVGV) {
244 if (SvGMAGICAL(sv)) {
249 if (PL_op->op_private & HINT_STRICT_REFS) {
251 DIE(aTHX_ PL_no_symref_sv, sv, "a SCALAR");
253 DIE(aTHX_ PL_no_usym, "a SCALAR");
256 if (PL_op->op_flags & OPf_REF)
257 DIE(aTHX_ PL_no_usym, "a SCALAR");
258 if (ckWARN(WARN_UNINITIALIZED))
262 if ((PL_op->op_flags & OPf_SPECIAL) &&
263 !(PL_op->op_flags & OPf_MOD))
265 gv = (GV*)gv_fetchsv(sv, 0, SVt_PV);
267 && (!is_gv_magical_sv(sv, 0)
268 || !(gv = (GV*)gv_fetchsv(sv, GV_ADD, SVt_PV))))
274 gv = (GV*)gv_fetchsv(sv, GV_ADD, SVt_PV);
279 if (PL_op->op_flags & OPf_MOD) {
280 if (PL_op->op_private & OPpLVAL_INTRO) {
281 if (cUNOP->op_first->op_type == OP_NULL)
282 sv = save_scalar((GV*)TOPs);
284 sv = save_scalar(gv);
286 Perl_croak(aTHX_ PL_no_localize_ref);
288 else if (PL_op->op_private & OPpDEREF)
289 vivify_ref(sv, PL_op->op_private & OPpDEREF);
298 AV * const av = (AV*)TOPs;
299 SV ** const sv = Perl_av_arylen_p(aTHX_ (AV*)av);
302 sv_upgrade(*sv, SVt_PVMG);
303 sv_magic(*sv, (SV*)av, PERL_MAGIC_arylen, NULL, 0);
311 dVAR; dSP; dTARGET; dPOPss;
313 if (PL_op->op_flags & OPf_MOD || LVRET) {
314 if (SvTYPE(TARG) < SVt_PVLV) {
315 sv_upgrade(TARG, SVt_PVLV);
316 sv_magic(TARG, NULL, PERL_MAGIC_pos, NULL, 0);
320 if (LvTARG(TARG) != sv) {
322 SvREFCNT_dec(LvTARG(TARG));
323 LvTARG(TARG) = SvREFCNT_inc(sv);
325 PUSHs(TARG); /* no SvSETMAGIC */
329 if (SvTYPE(sv) >= SVt_PVMG && SvMAGIC(sv)) {
330 const MAGIC * const mg = mg_find(sv, PERL_MAGIC_regex_global);
331 if (mg && mg->mg_len >= 0) {
335 PUSHi(i + PL_curcop->cop_arybase);
348 const I32 flags = (PL_op->op_flags & OPf_SPECIAL)
350 : ((PL_op->op_private & (OPpLVAL_INTRO|OPpMAY_RETURN_CONSTANT)) == OPpMAY_RETURN_CONSTANT)
353 /* We usually try to add a non-existent subroutine in case of AUTOLOAD. */
354 /* (But not in defined().) */
356 CV *cv = sv_2cv(TOPs, &stash, &gv, flags);
359 cv = (CV*)sv_2mortal((SV*)cv_clone(cv));
360 if ((PL_op->op_private & OPpLVAL_INTRO)) {
361 if (gv && GvCV(gv) == cv && (gv = gv_autoload4(GvSTASH(gv), GvNAME(gv), GvNAMELEN(gv), FALSE)))
364 DIE(aTHX_ "Can't modify non-lvalue subroutine call");
367 else if ((flags == (GV_ADD|GV_NOEXPAND)) && gv && SvROK(gv)) {
371 cv = (CV*)&PL_sv_undef;
382 SV *ret = &PL_sv_undef;
384 if (SvPOK(TOPs) && SvCUR(TOPs) >= 7) {
385 const char * const s = SvPVX_const(TOPs);
386 if (strnEQ(s, "CORE::", 6)) {
387 const int code = keyword(s + 6, SvCUR(TOPs) - 6);
388 if (code < 0) { /* Overridable. */
389 #define MAX_ARGS_OP ((sizeof(I32) - 1) * 2)
390 int i = 0, n = 0, seen_question = 0;
392 char str[ MAX_ARGS_OP * 2 + 2 ]; /* One ';', one '\0' */
394 if (code == -KEY_chop || code == -KEY_chomp
395 || code == -KEY_exec || code == -KEY_system)
397 while (i < MAXO) { /* The slow way. */
398 if (strEQ(s + 6, PL_op_name[i])
399 || strEQ(s + 6, PL_op_desc[i]))
405 goto nonesuch; /* Should not happen... */
407 oa = PL_opargs[i] >> OASHIFT;
409 if (oa & OA_OPTIONAL && !seen_question) {
413 if ((oa & (OA_OPTIONAL - 1)) >= OA_AVREF
414 && (oa & (OA_OPTIONAL - 1)) <= OA_SCALARREF
415 /* But globs are already references (kinda) */
416 && (oa & (OA_OPTIONAL - 1)) != OA_FILEREF
420 str[n++] = ("?$@@%&*$")[oa & (OA_OPTIONAL - 1)];
424 ret = sv_2mortal(newSVpvn(str, n - 1));
426 else if (code) /* Non-Overridable */
428 else { /* None such */
430 DIE(aTHX_ "Can't find an opnumber for \"%s\"", s+6);
434 cv = sv_2cv(TOPs, &stash, &gv, 0);
436 ret = sv_2mortal(newSVpvn(SvPVX_const(cv), SvCUR(cv)));
445 CV* cv = (CV*)PAD_SV(PL_op->op_targ);
447 cv = (CV*)sv_2mortal((SV*)cv_clone(cv));
463 if (GIMME != G_ARRAY) {
467 *MARK = &PL_sv_undef;
468 *MARK = refto(*MARK);
472 EXTEND_MORTAL(SP - MARK);
474 *MARK = refto(*MARK);
479 S_refto(pTHX_ SV *sv)
484 if (SvTYPE(sv) == SVt_PVLV && LvTYPE(sv) == 'y') {
487 if (!(sv = LvTARG(sv)))
490 (void)SvREFCNT_inc(sv);
492 else if (SvTYPE(sv) == SVt_PVAV) {
493 if (!AvREAL((AV*)sv) && AvREIFY((AV*)sv))
496 (void)SvREFCNT_inc(sv);
498 else if (SvPADTMP(sv) && !IS_PADGV(sv))
502 (void)SvREFCNT_inc(sv);
505 sv_upgrade(rv, SVt_RV);
515 SV * const sv = POPs;
520 if (!sv || !SvROK(sv))
523 pv = sv_reftype(SvRV(sv),TRUE);
524 PUSHp(pv, strlen(pv));
534 stash = CopSTASH(PL_curcop);
536 SV * const ssv = POPs;
540 if (ssv && !SvGMAGICAL(ssv) && !SvAMAGIC(ssv) && SvROK(ssv))
541 Perl_croak(aTHX_ "Attempt to bless into a reference");
542 ptr = SvPV_const(ssv,len);
543 if (len == 0 && ckWARN(WARN_MISC))
544 Perl_warner(aTHX_ packWARN(WARN_MISC),
545 "Explicit blessing to '' (assuming package main)");
546 stash = gv_stashpvn(ptr, len, TRUE);
549 (void)sv_bless(TOPs, stash);
558 const char * const elem = SvPV_nolen_const(sv);
559 GV * const gv = (GV*)POPs;
564 /* elem will always be NUL terminated. */
565 const char * const second_letter = elem + 1;
568 if (strEQ(second_letter, "RRAY"))
569 tmpRef = (SV*)GvAV(gv);
572 if (strEQ(second_letter, "ODE"))
573 tmpRef = (SV*)GvCVu(gv);
576 if (strEQ(second_letter, "ILEHANDLE")) {
577 /* finally deprecated in 5.8.0 */
578 deprecate("*glob{FILEHANDLE}");
579 tmpRef = (SV*)GvIOp(gv);
582 if (strEQ(second_letter, "ORMAT"))
583 tmpRef = (SV*)GvFORM(gv);
586 if (strEQ(second_letter, "LOB"))
590 if (strEQ(second_letter, "ASH"))
591 tmpRef = (SV*)GvHV(gv);
594 if (*second_letter == 'O' && !elem[2])
595 tmpRef = (SV*)GvIOp(gv);
598 if (strEQ(second_letter, "AME"))
599 sv = newSVpvn(GvNAME(gv), GvNAMELEN(gv));
602 if (strEQ(second_letter, "ACKAGE")) {
603 const HV * const stash = GvSTASH(gv);
604 const HEK * const hek = stash ? HvNAME_HEK(stash) : NULL;
605 sv = hek ? newSVhek(hek) : newSVpvs("__ANON__");
609 if (strEQ(second_letter, "CALAR"))
624 /* Pattern matching */
629 register unsigned char *s;
632 register I32 *sfirst;
636 if (sv == PL_lastscream) {
642 SvSCREAM_off(PL_lastscream);
643 SvREFCNT_dec(PL_lastscream);
645 PL_lastscream = SvREFCNT_inc(sv);
648 s = (unsigned char*)(SvPV(sv, len));
652 if (pos > PL_maxscream) {
653 if (PL_maxscream < 0) {
654 PL_maxscream = pos + 80;
655 Newx(PL_screamfirst, 256, I32);
656 Newx(PL_screamnext, PL_maxscream, I32);
659 PL_maxscream = pos + pos / 4;
660 Renew(PL_screamnext, PL_maxscream, I32);
664 sfirst = PL_screamfirst;
665 snext = PL_screamnext;
667 if (!sfirst || !snext)
668 DIE(aTHX_ "do_study: out of memory");
670 for (ch = 256; ch; --ch)
675 register const I32 ch = s[pos];
677 snext[pos] = sfirst[ch] - pos;
684 /* piggyback on m//g magic */
685 sv_magic(sv, NULL, PERL_MAGIC_regex_global, NULL, 0);
694 if (PL_op->op_flags & OPf_STACKED)
696 else if (PL_op->op_private & OPpTARGET_MY)
702 TARG = sv_newmortal();
707 /* Lvalue operators. */
719 dVAR; dSP; dMARK; dTARGET; dORIGMARK;
721 do_chop(TARG, *++MARK);
730 SETi(do_chomp(TOPs));
736 dVAR; dSP; dMARK; dTARGET;
737 register I32 count = 0;
740 count += do_chomp(POPs);
750 if (!PL_op->op_private) {
759 SV_CHECK_THINKFIRST_COW_DROP(sv);
761 switch (SvTYPE(sv)) {
771 if (cv_const_sv((CV*)sv) && ckWARN(WARN_MISC))
772 Perl_warner(aTHX_ packWARN(WARN_MISC), "Constant subroutine %s undefined",
773 CvANON((CV*)sv) ? "(anonymous)" : GvENAME(CvGV((CV*)sv)));
777 /* let user-undef'd sub keep its identity */
778 GV* const gv = CvGV((CV*)sv);
785 SvSetMagicSV(sv, &PL_sv_undef);
790 GvGP(sv) = gp_ref(gp);
792 GvLINE(sv) = CopLINE(PL_curcop);
798 if (SvTYPE(sv) >= SVt_PV && SvPVX_const(sv) && SvLEN(sv)) {
813 if (SvTYPE(TOPs) >= SVt_PVGV && SvTYPE(TOPs) != SVt_PVLV)
814 DIE(aTHX_ PL_no_modify);
815 if (!SvREADONLY(TOPs) && SvIOK_notUV(TOPs) && !SvNOK(TOPs) && !SvPOK(TOPs)
816 && SvIVX(TOPs) != IV_MIN)
818 SvIV_set(TOPs, SvIVX(TOPs) - 1);
819 SvFLAGS(TOPs) &= ~(SVp_NOK|SVp_POK);
830 if (SvTYPE(TOPs) >= SVt_PVGV && SvTYPE(TOPs) != SVt_PVLV)
831 DIE(aTHX_ PL_no_modify);
832 sv_setsv(TARG, TOPs);
833 if (!SvREADONLY(TOPs) && SvIOK_notUV(TOPs) && !SvNOK(TOPs) && !SvPOK(TOPs)
834 && SvIVX(TOPs) != IV_MAX)
836 SvIV_set(TOPs, SvIVX(TOPs) + 1);
837 SvFLAGS(TOPs) &= ~(SVp_NOK|SVp_POK);
842 /* special case for undef: see thread at 2003-03/msg00536.html in archive */
852 if (SvTYPE(TOPs) >= SVt_PVGV && SvTYPE(TOPs) != SVt_PVLV)
853 DIE(aTHX_ PL_no_modify);
854 sv_setsv(TARG, TOPs);
855 if (!SvREADONLY(TOPs) && SvIOK_notUV(TOPs) && !SvNOK(TOPs) && !SvPOK(TOPs)
856 && SvIVX(TOPs) != IV_MIN)
858 SvIV_set(TOPs, SvIVX(TOPs) - 1);
859 SvFLAGS(TOPs) &= ~(SVp_NOK|SVp_POK);
868 /* Ordinary operators. */
873 #ifdef PERL_PRESERVE_IVUV
876 tryAMAGICbin(pow,opASSIGN);
877 #ifdef PERL_PRESERVE_IVUV
878 /* For integer to integer power, we do the calculation by hand wherever
879 we're sure it is safe; otherwise we call pow() and try to convert to
880 integer afterwards. */
893 const IV iv = SvIVX(TOPs);
897 goto float_it; /* Can't do negative powers this way. */
901 baseuok = SvUOK(TOPm1s);
903 baseuv = SvUVX(TOPm1s);
905 const IV iv = SvIVX(TOPm1s);
908 baseuok = TRUE; /* effectively it's a UV now */
910 baseuv = -iv; /* abs, baseuok == false records sign */
913 /* now we have integer ** positive integer. */
916 /* foo & (foo - 1) is zero only for a power of 2. */
917 if (!(baseuv & (baseuv - 1))) {
918 /* We are raising power-of-2 to a positive integer.
919 The logic here will work for any base (even non-integer
920 bases) but it can be less accurate than
921 pow (base,power) or exp (power * log (base)) when the
922 intermediate values start to spill out of the mantissa.
923 With powers of 2 we know this can't happen.
924 And powers of 2 are the favourite thing for perl
925 programmers to notice ** not doing what they mean. */
927 NV base = baseuok ? baseuv : -(NV)baseuv;
932 while (power >>= 1) {
943 register unsigned int highbit = 8 * sizeof(UV);
944 register unsigned int diff = 8 * sizeof(UV);
947 if (baseuv >> highbit) {
951 /* we now have baseuv < 2 ** highbit */
952 if (power * highbit <= 8 * sizeof(UV)) {
953 /* result will definitely fit in UV, so use UV math
954 on same algorithm as above */
955 register UV result = 1;
956 register UV base = baseuv;
957 const bool odd_power = (bool)(power & 1);
961 while (power >>= 1) {
968 if (baseuok || !odd_power)
969 /* answer is positive */
971 else if (result <= (UV)IV_MAX)
972 /* answer negative, fits in IV */
974 else if (result == (UV)IV_MIN)
975 /* 2's complement assumption: special case IV_MIN */
978 /* answer negative, doesn't fit */
990 SETn( Perl_pow( left, right) );
991 #ifdef PERL_PRESERVE_IVUV
1001 dVAR; dSP; dATARGET; tryAMAGICbin(mult,opASSIGN);
1002 #ifdef PERL_PRESERVE_IVUV
1005 /* Unless the left argument is integer in range we are going to have to
1006 use NV maths. Hence only attempt to coerce the right argument if
1007 we know the left is integer. */
1008 /* Left operand is defined, so is it IV? */
1009 SvIV_please(TOPm1s);
1010 if (SvIOK(TOPm1s)) {
1011 bool auvok = SvUOK(TOPm1s);
1012 bool buvok = SvUOK(TOPs);
1013 const UV topmask = (~ (UV)0) << (4 * sizeof (UV));
1014 const UV botmask = ~((~ (UV)0) << (4 * sizeof (UV)));
1021 alow = SvUVX(TOPm1s);
1023 const IV aiv = SvIVX(TOPm1s);
1026 auvok = TRUE; /* effectively it's a UV now */
1028 alow = -aiv; /* abs, auvok == false records sign */
1034 const IV biv = SvIVX(TOPs);
1037 buvok = TRUE; /* effectively it's a UV now */
1039 blow = -biv; /* abs, buvok == false records sign */
1043 /* If this does sign extension on unsigned it's time for plan B */
1044 ahigh = alow >> (4 * sizeof (UV));
1046 bhigh = blow >> (4 * sizeof (UV));
1048 if (ahigh && bhigh) {
1050 /* eg 32 bit is at least 0x10000 * 0x10000 == 0x100000000
1051 which is overflow. Drop to NVs below. */
1052 } else if (!ahigh && !bhigh) {
1053 /* eg 32 bit is at most 0xFFFF * 0xFFFF == 0xFFFE0001
1054 so the unsigned multiply cannot overflow. */
1055 const UV product = alow * blow;
1056 if (auvok == buvok) {
1057 /* -ve * -ve or +ve * +ve gives a +ve result. */
1061 } else if (product <= (UV)IV_MIN) {
1062 /* 2s complement assumption that (UV)-IV_MIN is correct. */
1063 /* -ve result, which could overflow an IV */
1065 SETi( -(IV)product );
1067 } /* else drop to NVs below. */
1069 /* One operand is large, 1 small */
1072 /* swap the operands */
1074 bhigh = blow; /* bhigh now the temp var for the swap */
1078 /* now, ((ahigh * blow) << half_UV_len) + (alow * blow)
1079 multiplies can't overflow. shift can, add can, -ve can. */
1080 product_middle = ahigh * blow;
1081 if (!(product_middle & topmask)) {
1082 /* OK, (ahigh * blow) won't lose bits when we shift it. */
1084 product_middle <<= (4 * sizeof (UV));
1085 product_low = alow * blow;
1087 /* as for pp_add, UV + something mustn't get smaller.
1088 IIRC ANSI mandates this wrapping *behaviour* for
1089 unsigned whatever the actual representation*/
1090 product_low += product_middle;
1091 if (product_low >= product_middle) {
1092 /* didn't overflow */
1093 if (auvok == buvok) {
1094 /* -ve * -ve or +ve * +ve gives a +ve result. */
1096 SETu( product_low );
1098 } else if (product_low <= (UV)IV_MIN) {
1099 /* 2s complement assumption again */
1100 /* -ve result, which could overflow an IV */
1102 SETi( -(IV)product_low );
1104 } /* else drop to NVs below. */
1106 } /* product_middle too large */
1107 } /* ahigh && bhigh */
1108 } /* SvIOK(TOPm1s) */
1113 SETn( left * right );
1120 dVAR; dSP; dATARGET; tryAMAGICbin(div,opASSIGN);
1121 /* Only try to do UV divide first
1122 if ((SLOPPYDIVIDE is true) or
1123 (PERL_PRESERVE_IVUV is true and one or both SV is a UV too large
1125 The assumption is that it is better to use floating point divide
1126 whenever possible, only doing integer divide first if we can't be sure.
1127 If NV_PRESERVES_UV is true then we know at compile time that no UV
1128 can be too large to preserve, so don't need to compile the code to
1129 test the size of UVs. */
1132 # define PERL_TRY_UV_DIVIDE
1133 /* ensure that 20./5. == 4. */
1135 # ifdef PERL_PRESERVE_IVUV
1136 # ifndef NV_PRESERVES_UV
1137 # define PERL_TRY_UV_DIVIDE
1142 #ifdef PERL_TRY_UV_DIVIDE
1145 SvIV_please(TOPm1s);
1146 if (SvIOK(TOPm1s)) {
1147 bool left_non_neg = SvUOK(TOPm1s);
1148 bool right_non_neg = SvUOK(TOPs);
1152 if (right_non_neg) {
1153 right = SvUVX(TOPs);
1156 const IV biv = SvIVX(TOPs);
1159 right_non_neg = TRUE; /* effectively it's a UV now */
1165 /* historically undef()/0 gives a "Use of uninitialized value"
1166 warning before dieing, hence this test goes here.
1167 If it were immediately before the second SvIV_please, then
1168 DIE() would be invoked before left was even inspected, so
1169 no inpsection would give no warning. */
1171 DIE(aTHX_ "Illegal division by zero");
1174 left = SvUVX(TOPm1s);
1177 const IV aiv = SvIVX(TOPm1s);
1180 left_non_neg = TRUE; /* effectively it's a UV now */
1189 /* For sloppy divide we always attempt integer division. */
1191 /* Otherwise we only attempt it if either or both operands
1192 would not be preserved by an NV. If both fit in NVs
1193 we fall through to the NV divide code below. However,
1194 as left >= right to ensure integer result here, we know that
1195 we can skip the test on the right operand - right big
1196 enough not to be preserved can't get here unless left is
1199 && (left > ((UV)1 << NV_PRESERVES_UV_BITS))
1202 /* Integer division can't overflow, but it can be imprecise. */
1203 const UV result = left / right;
1204 if (result * right == left) {
1205 SP--; /* result is valid */
1206 if (left_non_neg == right_non_neg) {
1207 /* signs identical, result is positive. */
1211 /* 2s complement assumption */
1212 if (result <= (UV)IV_MIN)
1213 SETi( -(IV)result );
1215 /* It's exact but too negative for IV. */
1216 SETn( -(NV)result );
1219 } /* tried integer divide but it was not an integer result */
1220 } /* else (PERL_ABS(result) < 1.0) or (both UVs in range for NV) */
1221 } /* left wasn't SvIOK */
1222 } /* right wasn't SvIOK */
1223 #endif /* PERL_TRY_UV_DIVIDE */
1227 DIE(aTHX_ "Illegal division by zero");
1228 PUSHn( left / right );
1235 dVAR; dSP; dATARGET; tryAMAGICbin(modulo,opASSIGN);
1239 bool left_neg = FALSE;
1240 bool right_neg = FALSE;
1241 bool use_double = FALSE;
1242 bool dright_valid = FALSE;
1248 right_neg = !SvUOK(TOPs);
1250 right = SvUVX(POPs);
1252 const IV biv = SvIVX(POPs);
1255 right_neg = FALSE; /* effectively it's a UV now */
1263 right_neg = dright < 0;
1266 if (dright < UV_MAX_P1) {
1267 right = U_V(dright);
1268 dright_valid = TRUE; /* In case we need to use double below. */
1274 /* At this point use_double is only true if right is out of range for
1275 a UV. In range NV has been rounded down to nearest UV and
1276 use_double false. */
1278 if (!use_double && SvIOK(TOPs)) {
1280 left_neg = !SvUOK(TOPs);
1284 const IV aiv = SvIVX(POPs);
1287 left_neg = FALSE; /* effectively it's a UV now */
1296 left_neg = dleft < 0;
1300 /* This should be exactly the 5.6 behaviour - if left and right are
1301 both in range for UV then use U_V() rather than floor. */
1303 if (dleft < UV_MAX_P1) {
1304 /* right was in range, so is dleft, so use UVs not double.
1308 /* left is out of range for UV, right was in range, so promote
1309 right (back) to double. */
1311 /* The +0.5 is used in 5.6 even though it is not strictly
1312 consistent with the implicit +0 floor in the U_V()
1313 inside the #if 1. */
1314 dleft = Perl_floor(dleft + 0.5);
1317 dright = Perl_floor(dright + 0.5);
1327 DIE(aTHX_ "Illegal modulus zero");
1329 dans = Perl_fmod(dleft, dright);
1330 if ((left_neg != right_neg) && dans)
1331 dans = dright - dans;
1334 sv_setnv(TARG, dans);
1340 DIE(aTHX_ "Illegal modulus zero");
1343 if ((left_neg != right_neg) && ans)
1346 /* XXX may warn: unary minus operator applied to unsigned type */
1347 /* could change -foo to be (~foo)+1 instead */
1348 if (ans <= ~((UV)IV_MAX)+1)
1349 sv_setiv(TARG, ~ans+1);
1351 sv_setnv(TARG, -(NV)ans);
1354 sv_setuv(TARG, ans);
1363 dVAR; dSP; dATARGET; tryAMAGICbin(repeat,opASSIGN);
1370 const UV uv = SvUV(sv);
1372 count = IV_MAX; /* The best we can do? */
1376 const IV iv = SvIV(sv);
1383 else if (SvNOKp(sv)) {
1384 const NV nv = SvNV(sv);
1392 if (GIMME == G_ARRAY && PL_op->op_private & OPpREPEAT_DOLIST) {
1394 static const char oom_list_extend[] = "Out of memory during list extend";
1395 const I32 items = SP - MARK;
1396 const I32 max = items * count;
1398 MEM_WRAP_CHECK_1(max, SV*, oom_list_extend);
1399 /* Did the max computation overflow? */
1400 if (items > 0 && max > 0 && (max < items || max < count))
1401 Perl_croak(aTHX_ oom_list_extend);
1406 /* This code was intended to fix 20010809.028:
1409 for (($x =~ /./g) x 2) {
1410 print chop; # "abcdabcd" expected as output.
1413 * but that change (#11635) broke this code:
1415 $x = [("foo")x2]; # only one "foo" ended up in the anonlist.
1417 * I can't think of a better fix that doesn't introduce
1418 * an efficiency hit by copying the SVs. The stack isn't
1419 * refcounted, and mortalisation obviously doesn't
1420 * Do The Right Thing when the stack has more than
1421 * one pointer to the same mortal value.
1425 *SP = sv_2mortal(newSVsv(*SP));
1435 repeatcpy((char*)(MARK + items), (char*)MARK,
1436 items * sizeof(SV*), count - 1);
1439 else if (count <= 0)
1442 else { /* Note: mark already snarfed by pp_list */
1443 SV * const tmpstr = POPs;
1446 static const char oom_string_extend[] =
1447 "Out of memory during string extend";
1449 SvSetSV(TARG, tmpstr);
1450 SvPV_force(TARG, len);
1451 isutf = DO_UTF8(TARG);
1456 const STRLEN max = (UV)count * len;
1457 if (len > ((MEM_SIZE)~0)/count)
1458 Perl_croak(aTHX_ oom_string_extend);
1459 MEM_WRAP_CHECK_1(max, char, oom_string_extend);
1460 SvGROW(TARG, max + 1);
1461 repeatcpy(SvPVX(TARG) + len, SvPVX(TARG), len, count - 1);
1462 SvCUR_set(TARG, SvCUR(TARG) * count);
1464 *SvEND(TARG) = '\0';
1467 (void)SvPOK_only_UTF8(TARG);
1469 (void)SvPOK_only(TARG);
1471 if (PL_op->op_private & OPpREPEAT_DOLIST) {
1472 /* The parser saw this as a list repeat, and there
1473 are probably several items on the stack. But we're
1474 in scalar context, and there's no pp_list to save us
1475 now. So drop the rest of the items -- robin@kitsite.com
1488 dVAR; dSP; dATARGET; bool useleft; tryAMAGICbin(subtr,opASSIGN);
1489 useleft = USE_LEFT(TOPm1s);
1490 #ifdef PERL_PRESERVE_IVUV
1491 /* See comments in pp_add (in pp_hot.c) about Overflow, and how
1492 "bad things" happen if you rely on signed integers wrapping. */
1495 /* Unless the left argument is integer in range we are going to have to
1496 use NV maths. Hence only attempt to coerce the right argument if
1497 we know the left is integer. */
1498 register UV auv = 0;
1504 a_valid = auvok = 1;
1505 /* left operand is undef, treat as zero. */
1507 /* Left operand is defined, so is it IV? */
1508 SvIV_please(TOPm1s);
1509 if (SvIOK(TOPm1s)) {
1510 if ((auvok = SvUOK(TOPm1s)))
1511 auv = SvUVX(TOPm1s);
1513 register const IV aiv = SvIVX(TOPm1s);
1516 auvok = 1; /* Now acting as a sign flag. */
1517 } else { /* 2s complement assumption for IV_MIN */
1525 bool result_good = 0;
1528 bool buvok = SvUOK(TOPs);
1533 register const IV biv = SvIVX(TOPs);
1540 /* ?uvok if value is >= 0. basically, flagged as UV if it's +ve,
1541 else "IV" now, independent of how it came in.
1542 if a, b represents positive, A, B negative, a maps to -A etc
1547 all UV maths. negate result if A negative.
1548 subtract if signs same, add if signs differ. */
1550 if (auvok ^ buvok) {
1559 /* Must get smaller */
1564 if (result <= buv) {
1565 /* result really should be -(auv-buv). as its negation
1566 of true value, need to swap our result flag */
1578 if (result <= (UV)IV_MIN)
1579 SETi( -(IV)result );
1581 /* result valid, but out of range for IV. */
1582 SETn( -(NV)result );
1586 } /* Overflow, drop through to NVs. */
1590 useleft = USE_LEFT(TOPm1s);
1594 /* left operand is undef, treat as zero - value */
1598 SETn( TOPn - value );
1605 dVAR; dSP; dATARGET; tryAMAGICbin(lshift,opASSIGN);
1607 const IV shift = POPi;
1608 if (PL_op->op_private & HINT_INTEGER) {
1622 dVAR; dSP; dATARGET; tryAMAGICbin(rshift,opASSIGN);
1624 const IV shift = POPi;
1625 if (PL_op->op_private & HINT_INTEGER) {
1639 dVAR; dSP; tryAMAGICbinSET(lt,0);
1640 #ifdef PERL_PRESERVE_IVUV
1643 SvIV_please(TOPm1s);
1644 if (SvIOK(TOPm1s)) {
1645 bool auvok = SvUOK(TOPm1s);
1646 bool buvok = SvUOK(TOPs);
1648 if (!auvok && !buvok) { /* ## IV < IV ## */
1649 const IV aiv = SvIVX(TOPm1s);
1650 const IV biv = SvIVX(TOPs);
1653 SETs(boolSV(aiv < biv));
1656 if (auvok && buvok) { /* ## UV < UV ## */
1657 const UV auv = SvUVX(TOPm1s);
1658 const UV buv = SvUVX(TOPs);
1661 SETs(boolSV(auv < buv));
1664 if (auvok) { /* ## UV < IV ## */
1666 const IV biv = SvIVX(TOPs);
1669 /* As (a) is a UV, it's >=0, so it cannot be < */
1674 SETs(boolSV(auv < (UV)biv));
1677 { /* ## IV < UV ## */
1678 const IV aiv = SvIVX(TOPm1s);
1682 /* As (b) is a UV, it's >=0, so it must be < */
1689 SETs(boolSV((UV)aiv < buv));
1695 #ifndef NV_PRESERVES_UV
1696 #ifdef PERL_PRESERVE_IVUV
1699 if (SvROK(TOPs) && !SvAMAGIC(TOPs) && SvROK(TOPm1s) && !SvAMAGIC(TOPm1s)) {
1701 SETs(boolSV(SvRV(TOPs) < SvRV(TOPp1s)));
1707 SETs(boolSV(TOPn < value));
1714 dVAR; dSP; tryAMAGICbinSET(gt,0);
1715 #ifdef PERL_PRESERVE_IVUV
1718 SvIV_please(TOPm1s);
1719 if (SvIOK(TOPm1s)) {
1720 bool auvok = SvUOK(TOPm1s);
1721 bool buvok = SvUOK(TOPs);
1723 if (!auvok && !buvok) { /* ## IV > IV ## */
1724 const IV aiv = SvIVX(TOPm1s);
1725 const IV biv = SvIVX(TOPs);
1728 SETs(boolSV(aiv > biv));
1731 if (auvok && buvok) { /* ## UV > UV ## */
1732 const UV auv = SvUVX(TOPm1s);
1733 const UV buv = SvUVX(TOPs);
1736 SETs(boolSV(auv > buv));
1739 if (auvok) { /* ## UV > IV ## */
1741 const IV biv = SvIVX(TOPs);
1745 /* As (a) is a UV, it's >=0, so it must be > */
1750 SETs(boolSV(auv > (UV)biv));
1753 { /* ## IV > UV ## */
1754 const IV aiv = SvIVX(TOPm1s);
1758 /* As (b) is a UV, it's >=0, so it cannot be > */
1765 SETs(boolSV((UV)aiv > buv));
1771 #ifndef NV_PRESERVES_UV
1772 #ifdef PERL_PRESERVE_IVUV
1775 if (SvROK(TOPs) && !SvAMAGIC(TOPs) && SvROK(TOPm1s) && !SvAMAGIC(TOPm1s)) {
1777 SETs(boolSV(SvRV(TOPs) > SvRV(TOPp1s)));
1783 SETs(boolSV(TOPn > value));
1790 dVAR; dSP; tryAMAGICbinSET(le,0);
1791 #ifdef PERL_PRESERVE_IVUV
1794 SvIV_please(TOPm1s);
1795 if (SvIOK(TOPm1s)) {
1796 bool auvok = SvUOK(TOPm1s);
1797 bool buvok = SvUOK(TOPs);
1799 if (!auvok && !buvok) { /* ## IV <= IV ## */
1800 const IV aiv = SvIVX(TOPm1s);
1801 const IV biv = SvIVX(TOPs);
1804 SETs(boolSV(aiv <= biv));
1807 if (auvok && buvok) { /* ## UV <= UV ## */
1808 UV auv = SvUVX(TOPm1s);
1809 UV buv = SvUVX(TOPs);
1812 SETs(boolSV(auv <= buv));
1815 if (auvok) { /* ## UV <= IV ## */
1817 const IV biv = SvIVX(TOPs);
1821 /* As (a) is a UV, it's >=0, so a cannot be <= */
1826 SETs(boolSV(auv <= (UV)biv));
1829 { /* ## IV <= UV ## */
1830 const IV aiv = SvIVX(TOPm1s);
1834 /* As (b) is a UV, it's >=0, so a must be <= */
1841 SETs(boolSV((UV)aiv <= buv));
1847 #ifndef NV_PRESERVES_UV
1848 #ifdef PERL_PRESERVE_IVUV
1851 if (SvROK(TOPs) && !SvAMAGIC(TOPs) && SvROK(TOPm1s) && !SvAMAGIC(TOPm1s)) {
1853 SETs(boolSV(SvRV(TOPs) <= SvRV(TOPp1s)));
1859 SETs(boolSV(TOPn <= value));
1866 dVAR; dSP; tryAMAGICbinSET(ge,0);
1867 #ifdef PERL_PRESERVE_IVUV
1870 SvIV_please(TOPm1s);
1871 if (SvIOK(TOPm1s)) {
1872 bool auvok = SvUOK(TOPm1s);
1873 bool buvok = SvUOK(TOPs);
1875 if (!auvok && !buvok) { /* ## IV >= IV ## */
1876 const IV aiv = SvIVX(TOPm1s);
1877 const IV biv = SvIVX(TOPs);
1880 SETs(boolSV(aiv >= biv));
1883 if (auvok && buvok) { /* ## UV >= UV ## */
1884 const UV auv = SvUVX(TOPm1s);
1885 const UV buv = SvUVX(TOPs);
1888 SETs(boolSV(auv >= buv));
1891 if (auvok) { /* ## UV >= IV ## */
1893 const IV biv = SvIVX(TOPs);
1897 /* As (a) is a UV, it's >=0, so it must be >= */
1902 SETs(boolSV(auv >= (UV)biv));
1905 { /* ## IV >= UV ## */
1906 const IV aiv = SvIVX(TOPm1s);
1910 /* As (b) is a UV, it's >=0, so a cannot be >= */
1917 SETs(boolSV((UV)aiv >= buv));
1923 #ifndef NV_PRESERVES_UV
1924 #ifdef PERL_PRESERVE_IVUV
1927 if (SvROK(TOPs) && !SvAMAGIC(TOPs) && SvROK(TOPm1s) && !SvAMAGIC(TOPm1s)) {
1929 SETs(boolSV(SvRV(TOPs) >= SvRV(TOPp1s)));
1935 SETs(boolSV(TOPn >= value));
1942 dVAR; dSP; tryAMAGICbinSET(ne,0);
1943 #ifndef NV_PRESERVES_UV
1944 if (SvROK(TOPs) && !SvAMAGIC(TOPs) && SvROK(TOPm1s) && !SvAMAGIC(TOPm1s)) {
1946 SETs(boolSV(SvRV(TOPs) != SvRV(TOPp1s)));
1950 #ifdef PERL_PRESERVE_IVUV
1953 SvIV_please(TOPm1s);
1954 if (SvIOK(TOPm1s)) {
1955 const bool auvok = SvUOK(TOPm1s);
1956 const bool buvok = SvUOK(TOPs);
1958 if (auvok == buvok) { /* ## IV == IV or UV == UV ## */
1959 /* Casting IV to UV before comparison isn't going to matter
1960 on 2s complement. On 1s complement or sign&magnitude
1961 (if we have any of them) it could make negative zero
1962 differ from normal zero. As I understand it. (Need to
1963 check - is negative zero implementation defined behaviour
1965 const UV buv = SvUVX(POPs);
1966 const UV auv = SvUVX(TOPs);
1968 SETs(boolSV(auv != buv));
1971 { /* ## Mixed IV,UV ## */
1975 /* != is commutative so swap if needed (save code) */
1977 /* swap. top of stack (b) is the iv */
1981 /* As (a) is a UV, it's >0, so it cannot be == */
1990 /* As (b) is a UV, it's >0, so it cannot be == */
1994 uv = SvUVX(*(SP+1)); /* Do I want TOPp1s() ? */
1996 SETs(boolSV((UV)iv != uv));
2004 SETs(boolSV(TOPn != value));
2011 dVAR; dSP; dTARGET; tryAMAGICbin(ncmp,0);
2012 #ifndef NV_PRESERVES_UV
2013 if (SvROK(TOPs) && !SvAMAGIC(TOPs) && SvROK(TOPm1s) && !SvAMAGIC(TOPm1s)) {
2014 const UV right = PTR2UV(SvRV(POPs));
2015 const UV left = PTR2UV(SvRV(TOPs));
2016 SETi((left > right) - (left < right));
2020 #ifdef PERL_PRESERVE_IVUV
2021 /* Fortunately it seems NaN isn't IOK */
2024 SvIV_please(TOPm1s);
2025 if (SvIOK(TOPm1s)) {
2026 const bool leftuvok = SvUOK(TOPm1s);
2027 const bool rightuvok = SvUOK(TOPs);
2029 if (!leftuvok && !rightuvok) { /* ## IV <=> IV ## */
2030 const IV leftiv = SvIVX(TOPm1s);
2031 const IV rightiv = SvIVX(TOPs);
2033 if (leftiv > rightiv)
2035 else if (leftiv < rightiv)
2039 } else if (leftuvok && rightuvok) { /* ## UV <=> UV ## */
2040 const UV leftuv = SvUVX(TOPm1s);
2041 const UV rightuv = SvUVX(TOPs);
2043 if (leftuv > rightuv)
2045 else if (leftuv < rightuv)
2049 } else if (leftuvok) { /* ## UV <=> IV ## */
2050 const IV rightiv = SvIVX(TOPs);
2052 /* As (a) is a UV, it's >=0, so it cannot be < */
2055 const UV leftuv = SvUVX(TOPm1s);
2056 if (leftuv > (UV)rightiv) {
2058 } else if (leftuv < (UV)rightiv) {
2064 } else { /* ## IV <=> UV ## */
2065 const IV leftiv = SvIVX(TOPm1s);
2067 /* As (b) is a UV, it's >=0, so it must be < */
2070 const UV rightuv = SvUVX(TOPs);
2071 if ((UV)leftiv > rightuv) {
2073 } else if ((UV)leftiv < rightuv) {
2091 if (Perl_isnan(left) || Perl_isnan(right)) {
2095 value = (left > right) - (left < right);
2099 else if (left < right)
2101 else if (left > right)
2117 int amg_type = sle_amg;
2121 switch (PL_op->op_type) {
2140 tryAMAGICbinSET_var(amg_type,0);
2143 const int cmp = (IN_LOCALE_RUNTIME
2144 ? sv_cmp_locale(left, right)
2145 : sv_cmp(left, right));
2146 SETs(boolSV(cmp * multiplier < rhs));
2153 dVAR; dSP; tryAMAGICbinSET(seq,0);
2156 SETs(boolSV(sv_eq(left, right)));
2163 dVAR; dSP; tryAMAGICbinSET(sne,0);
2166 SETs(boolSV(!sv_eq(left, right)));
2173 dVAR; dSP; dTARGET; tryAMAGICbin(scmp,0);
2176 const int cmp = (IN_LOCALE_RUNTIME
2177 ? sv_cmp_locale(left, right)
2178 : sv_cmp(left, right));
2186 dVAR; dSP; dATARGET; tryAMAGICbin(band,opASSIGN);
2191 if (SvNIOKp(left) || SvNIOKp(right)) {
2192 if (PL_op->op_private & HINT_INTEGER) {
2193 const IV i = SvIV_nomg(left) & SvIV_nomg(right);
2197 const UV u = SvUV_nomg(left) & SvUV_nomg(right);
2202 do_vop(PL_op->op_type, TARG, left, right);
2211 dVAR; dSP; dATARGET;
2212 const int op_type = PL_op->op_type;
2214 tryAMAGICbin_var((op_type == OP_BIT_OR ? bor_amg : bxor_amg), opASSIGN);
2219 if (SvNIOKp(left) || SvNIOKp(right)) {
2220 if (PL_op->op_private & HINT_INTEGER) {
2221 const IV l = (USE_LEFT(left) ? SvIV_nomg(left) : 0);
2222 const IV r = SvIV_nomg(right);
2223 const IV result = op_type == OP_BIT_OR ? (l | r) : (l ^ r);
2227 const UV l = (USE_LEFT(left) ? SvUV_nomg(left) : 0);
2228 const UV r = SvUV_nomg(right);
2229 const UV result = op_type == OP_BIT_OR ? (l | r) : (l ^ r);
2234 do_vop(op_type, TARG, left, right);
2243 dVAR; dSP; dTARGET; tryAMAGICun(neg);
2246 const int flags = SvFLAGS(sv);
2248 if ((flags & SVf_IOK) || ((flags & (SVp_IOK | SVp_NOK)) == SVp_IOK)) {
2249 /* It's publicly an integer, or privately an integer-not-float */
2252 if (SvIVX(sv) == IV_MIN) {
2253 /* 2s complement assumption. */
2254 SETi(SvIVX(sv)); /* special case: -((UV)IV_MAX+1) == IV_MIN */
2257 else if (SvUVX(sv) <= IV_MAX) {
2262 else if (SvIVX(sv) != IV_MIN) {
2266 #ifdef PERL_PRESERVE_IVUV
2275 else if (SvPOKp(sv)) {
2277 const char * const s = SvPV_const(sv, len);
2278 if (isIDFIRST(*s)) {
2279 sv_setpvn(TARG, "-", 1);
2282 else if (*s == '+' || *s == '-') {
2284 *SvPV_force(TARG, len) = *s == '-' ? '+' : '-';
2286 else if (DO_UTF8(sv)) {
2289 goto oops_its_an_int;
2291 sv_setnv(TARG, -SvNV(sv));
2293 sv_setpvn(TARG, "-", 1);
2300 goto oops_its_an_int;
2301 sv_setnv(TARG, -SvNV(sv));
2313 dVAR; dSP; tryAMAGICunSET(not);
2314 *PL_stack_sp = boolSV(!SvTRUE(*PL_stack_sp));
2320 dVAR; dSP; dTARGET; tryAMAGICun(compl);
2325 if (PL_op->op_private & HINT_INTEGER) {
2326 const IV i = ~SvIV_nomg(sv);
2330 const UV u = ~SvUV_nomg(sv);
2339 (void)SvPV_nomg_const(sv,len); /* force check for uninit var */
2340 sv_setsv_nomg(TARG, sv);
2341 tmps = (U8*)SvPV_force(TARG, len);
2344 /* Calculate exact length, let's not estimate. */
2353 while (tmps < send) {
2354 const UV c = utf8n_to_uvchr(tmps, send-tmps, &l, UTF8_ALLOW_ANYUV);
2355 tmps += UTF8SKIP(tmps);
2356 targlen += UNISKIP(~c);
2362 /* Now rewind strings and write them. */
2366 Newxz(result, targlen + 1, U8);
2367 while (tmps < send) {
2368 const UV c = utf8n_to_uvchr(tmps, send-tmps, &l, UTF8_ALLOW_ANYUV);
2369 tmps += UTF8SKIP(tmps);
2370 result = uvchr_to_utf8_flags(result, ~c, UNICODE_ALLOW_ANY);
2374 sv_setpvn(TARG, (char*)result, targlen);
2378 Newxz(result, nchar + 1, U8);
2379 while (tmps < send) {
2380 const U8 c = (U8)utf8n_to_uvchr(tmps, 0, &l, UTF8_ALLOW_ANY);
2381 tmps += UTF8SKIP(tmps);
2386 sv_setpvn(TARG, (char*)result, nchar);
2395 register long *tmpl;
2396 for ( ; anum && (unsigned long)tmps % sizeof(long); anum--, tmps++)
2399 for ( ; anum >= sizeof(long); anum -= sizeof(long), tmpl++)
2404 for ( ; anum > 0; anum--, tmps++)
2413 /* integer versions of some of the above */
2417 dVAR; dSP; dATARGET; tryAMAGICbin(mult,opASSIGN);
2420 SETi( left * right );
2428 dVAR; dSP; dATARGET; tryAMAGICbin(div,opASSIGN);
2432 DIE(aTHX_ "Illegal division by zero");
2434 if (num == IV_MIN && value == -1)
2435 DIE(aTHX_ "Integer overflow in division");
2436 value = num / value;
2445 /* This is the vanilla old i_modulo. */
2446 dVAR; dSP; dATARGET; tryAMAGICbin(modulo,opASSIGN);
2450 DIE(aTHX_ "Illegal modulus zero");
2451 SETi( left % right );
2456 #if defined(__GLIBC__) && IVSIZE == 8
2460 /* This is the i_modulo with the workaround for the _moddi3 bug
2461 * in (at least) glibc 2.2.5 (the PERL_ABS() the workaround).
2462 * See below for pp_i_modulo. */
2463 dVAR; dVAR; dSP; dATARGET; tryAMAGICbin(modulo,opASSIGN);
2467 DIE(aTHX_ "Illegal modulus zero");
2468 SETi( left % PERL_ABS(right) );
2476 dVAR; dSP; dATARGET; tryAMAGICbin(modulo,opASSIGN);
2480 DIE(aTHX_ "Illegal modulus zero");
2481 /* The assumption is to use hereafter the old vanilla version... */
2483 PL_ppaddr[OP_I_MODULO] =
2485 /* .. but if we have glibc, we might have a buggy _moddi3
2486 * (at least glicb 2.2.5 is known to have this bug), in other
2487 * words our integer modulus with negative quad as the second
2488 * argument might be broken. Test for this and re-patch the
2489 * opcode dispatch table if that is the case, remembering to
2490 * also apply the workaround so that this first round works
2491 * right, too. See [perl #9402] for more information. */
2492 #if defined(__GLIBC__) && IVSIZE == 8
2496 /* Cannot do this check with inlined IV constants since
2497 * that seems to work correctly even with the buggy glibc. */
2499 /* Yikes, we have the bug.
2500 * Patch in the workaround version. */
2502 PL_ppaddr[OP_I_MODULO] =
2503 &Perl_pp_i_modulo_1;
2504 /* Make certain we work right this time, too. */
2505 right = PERL_ABS(right);
2509 SETi( left % right );
2516 dVAR; dSP; dATARGET; tryAMAGICbin(add,opASSIGN);
2519 SETi( left + right );
2526 dVAR; dSP; dATARGET; tryAMAGICbin(subtr,opASSIGN);
2529 SETi( left - right );
2536 dVAR; dSP; tryAMAGICbinSET(lt,0);
2539 SETs(boolSV(left < right));
2546 dVAR; dSP; tryAMAGICbinSET(gt,0);
2549 SETs(boolSV(left > right));
2556 dVAR; dSP; tryAMAGICbinSET(le,0);
2559 SETs(boolSV(left <= right));
2566 dVAR; dSP; tryAMAGICbinSET(ge,0);
2569 SETs(boolSV(left >= right));
2576 dVAR; dSP; tryAMAGICbinSET(eq,0);
2579 SETs(boolSV(left == right));
2586 dVAR; dSP; tryAMAGICbinSET(ne,0);
2589 SETs(boolSV(left != right));
2596 dVAR; dSP; dTARGET; tryAMAGICbin(ncmp,0);
2603 else if (left < right)
2614 dVAR; dSP; dTARGET; tryAMAGICun(neg);
2619 /* High falutin' math. */
2623 dVAR; dSP; dTARGET; tryAMAGICbin(atan2,0);
2626 SETn(Perl_atan2(left, right));
2634 int amg_type = sin_amg;
2635 const char *neg_report = NULL;
2636 NV (*func)(NV) = Perl_sin;
2637 const int op_type = PL_op->op_type;
2654 amg_type = sqrt_amg;
2656 neg_report = "sqrt";
2660 tryAMAGICun_var(amg_type);
2662 const NV value = POPn;
2664 if (op_type == OP_LOG ? (value <= 0.0) : (value < 0.0)) {
2665 SET_NUMERIC_STANDARD();
2666 DIE(aTHX_ "Can't take %s of %"NVgf, neg_report, value);
2669 XPUSHn(func(value));
2674 /* Support Configure command-line overrides for rand() functions.
2675 After 5.005, perhaps we should replace this by Configure support
2676 for drand48(), random(), or rand(). For 5.005, though, maintain
2677 compatibility by calling rand() but allow the user to override it.
2678 See INSTALL for details. --Andy Dougherty 15 July 1998
2680 /* Now it's after 5.005, and Configure supports drand48() and random(),
2681 in addition to rand(). So the overrides should not be needed any more.
2682 --Jarkko Hietaniemi 27 September 1998
2685 #ifndef HAS_DRAND48_PROTO
2686 extern double drand48 (void);
2699 if (!PL_srand_called) {
2700 (void)seedDrand01((Rand_seed_t)seed());
2701 PL_srand_called = TRUE;
2711 const UV anum = (MAXARG < 1) ? seed() : POPu;
2712 (void)seedDrand01((Rand_seed_t)anum);
2713 PL_srand_called = TRUE;
2720 dVAR; dSP; dTARGET; tryAMAGICun(int);
2722 const IV iv = TOPi; /* attempt to convert to IV if possible. */
2723 /* XXX it's arguable that compiler casting to IV might be subtly
2724 different from modf (for numbers inside (IV_MIN,UV_MAX)) in which
2725 else preferring IV has introduced a subtle behaviour change bug. OTOH
2726 relying on floating point to be accurate is a bug. */
2730 else if (SvIOK(TOPs)) {
2737 const NV value = TOPn;
2739 if (value < (NV)UV_MAX + 0.5) {
2742 SETn(Perl_floor(value));
2746 if (value > (NV)IV_MIN - 0.5) {
2749 SETn(Perl_ceil(value));
2759 dVAR; dSP; dTARGET; tryAMAGICun(abs);
2761 /* This will cache the NV value if string isn't actually integer */
2766 else if (SvIOK(TOPs)) {
2767 /* IVX is precise */
2769 SETu(TOPu); /* force it to be numeric only */
2777 /* 2s complement assumption. Also, not really needed as
2778 IV_MIN and -IV_MIN should both be %100...00 and NV-able */
2784 const NV value = TOPn;
2798 I32 flags = PERL_SCAN_ALLOW_UNDERSCORES;
2802 SV* const sv = POPs;
2804 tmps = (SvPV_const(sv, len));
2806 /* If Unicode, try to downgrade
2807 * If not possible, croak. */
2808 SV* const tsv = sv_2mortal(newSVsv(sv));
2811 sv_utf8_downgrade(tsv, FALSE);
2812 tmps = SvPV_const(tsv, len);
2814 if (PL_op->op_type == OP_HEX)
2817 while (*tmps && len && isSPACE(*tmps))
2823 result_uv = grok_hex (tmps, &len, &flags, &result_nv);
2825 else if (*tmps == 'b')
2826 result_uv = grok_bin (tmps, &len, &flags, &result_nv);
2828 result_uv = grok_oct (tmps, &len, &flags, &result_nv);
2830 if (flags & PERL_SCAN_GREATER_THAN_UV_MAX) {
2844 SV * const sv = TOPs;
2847 SETi(sv_len_utf8(sv));
2863 const I32 lvalue = PL_op->op_flags & OPf_MOD || LVRET;
2865 const I32 arybase = PL_curcop->cop_arybase;
2867 const char *repl = NULL;
2869 const int num_args = PL_op->op_private & 7;
2870 bool repl_need_utf8_upgrade = FALSE;
2871 bool repl_is_utf8 = FALSE;
2873 SvTAINTED_off(TARG); /* decontaminate */
2874 SvUTF8_off(TARG); /* decontaminate */
2878 repl = SvPV_const(repl_sv, repl_len);
2879 repl_is_utf8 = DO_UTF8(repl_sv) && SvCUR(repl_sv);
2889 sv_utf8_upgrade(sv);
2891 else if (DO_UTF8(sv))
2892 repl_need_utf8_upgrade = TRUE;
2894 tmps = SvPV_const(sv, curlen);
2896 utf8_curlen = sv_len_utf8(sv);
2897 if (utf8_curlen == curlen)
2900 curlen = utf8_curlen;
2905 if (pos >= arybase) {
2923 else if (len >= 0) {
2925 if (rem > (I32)curlen)
2940 Perl_croak(aTHX_ "substr outside of string");
2941 if (ckWARN(WARN_SUBSTR))
2942 Perl_warner(aTHX_ packWARN(WARN_SUBSTR), "substr outside of string");
2946 const I32 upos = pos;
2947 const I32 urem = rem;
2949 sv_pos_u2b(sv, &pos, &rem);
2951 /* we either return a PV or an LV. If the TARG hasn't been used
2952 * before, or is of that type, reuse it; otherwise use a mortal
2953 * instead. Note that LVs can have an extended lifetime, so also
2954 * dont reuse if refcount > 1 (bug #20933) */
2955 if (SvTYPE(TARG) > SVt_NULL) {
2956 if ( (SvTYPE(TARG) == SVt_PVLV)
2957 ? (!lvalue || SvREFCNT(TARG) > 1)
2960 TARG = sv_newmortal();
2964 sv_setpvn(TARG, tmps, rem);
2965 #ifdef USE_LOCALE_COLLATE
2966 sv_unmagic(TARG, PERL_MAGIC_collxfrm);
2971 SV* repl_sv_copy = NULL;
2973 if (repl_need_utf8_upgrade) {
2974 repl_sv_copy = newSVsv(repl_sv);
2975 sv_utf8_upgrade(repl_sv_copy);
2976 repl = SvPV_const(repl_sv_copy, repl_len);
2977 repl_is_utf8 = DO_UTF8(repl_sv_copy) && SvCUR(sv);
2979 sv_insert(sv, pos, rem, repl, repl_len);
2983 SvREFCNT_dec(repl_sv_copy);
2985 else if (lvalue) { /* it's an lvalue! */
2986 if (!SvGMAGICAL(sv)) {
2988 SvPV_force_nolen(sv);
2989 if (ckWARN(WARN_SUBSTR))
2990 Perl_warner(aTHX_ packWARN(WARN_SUBSTR),
2991 "Attempt to use reference as lvalue in substr");
2993 if (SvOK(sv)) /* is it defined ? */
2994 (void)SvPOK_only_UTF8(sv);
2996 sv_setpvn(sv,"",0); /* avoid lexical reincarnation */
2999 if (SvTYPE(TARG) < SVt_PVLV) {
3000 sv_upgrade(TARG, SVt_PVLV);
3001 sv_magic(TARG, NULL, PERL_MAGIC_substr, NULL, 0);
3007 if (LvTARG(TARG) != sv) {
3009 SvREFCNT_dec(LvTARG(TARG));
3010 LvTARG(TARG) = SvREFCNT_inc(sv);
3012 LvTARGOFF(TARG) = upos;
3013 LvTARGLEN(TARG) = urem;
3017 PUSHs(TARG); /* avoid SvSETMAGIC here */
3024 register const IV size = POPi;
3025 register const IV offset = POPi;
3026 register SV * const src = POPs;
3027 const I32 lvalue = PL_op->op_flags & OPf_MOD || LVRET;
3029 SvTAINTED_off(TARG); /* decontaminate */
3030 if (lvalue) { /* it's an lvalue! */
3031 if (SvREFCNT(TARG) > 1) /* don't share the TARG (#20933) */
3032 TARG = sv_newmortal();
3033 if (SvTYPE(TARG) < SVt_PVLV) {
3034 sv_upgrade(TARG, SVt_PVLV);
3035 sv_magic(TARG, NULL, PERL_MAGIC_vec, NULL, 0);
3038 if (LvTARG(TARG) != src) {
3040 SvREFCNT_dec(LvTARG(TARG));
3041 LvTARG(TARG) = SvREFCNT_inc(src);
3043 LvTARGOFF(TARG) = offset;
3044 LvTARGLEN(TARG) = size;
3047 sv_setuv(TARG, do_vecget(src, offset, size));
3064 const I32 arybase = PL_curcop->cop_arybase;
3067 const bool is_index = PL_op->op_type == OP_INDEX;
3070 /* arybase is in characters, like offset, so combine prior to the
3071 UTF-8 to bytes calculation. */
3072 offset = POPi - arybase;
3076 big_utf8 = DO_UTF8(big);
3077 little_utf8 = DO_UTF8(little);
3078 if (big_utf8 ^ little_utf8) {
3079 /* One needs to be upgraded. */
3080 if (little_utf8 && !PL_encoding) {
3081 /* Well, maybe instead we might be able to downgrade the small
3084 const U8 * const little_pv = (U8*) SvPV_const(little, little_len);
3085 char * const pv = (char*)bytes_from_utf8(little_pv, &little_len,
3088 /* If the large string is ISO-8859-1, and it's not possible to
3089 convert the small string to ISO-8859-1, then there is no
3090 way that it could be found anywhere by index. */
3095 /* At this point, pv is a malloc()ed string. So donate it to temp
3096 to ensure it will get free()d */
3097 little = temp = newSV(0);
3098 sv_usepvn(temp, pv, little_len);
3100 SV * const bytes = little_utf8 ? big : little;
3102 const char * const p = SvPV_const(bytes, len);
3104 temp = newSVpvn(p, len);
3107 sv_recode_to_utf8(temp, PL_encoding);
3109 sv_utf8_upgrade(temp);
3119 /* Don't actually need the NULL initialisation, but it keeps gcc quiet. */
3120 tmps2 = is_index ? NULL : SvPV_const(little, llen);
3121 tmps = SvPV_const(big, biglen);
3124 offset = is_index ? 0 : biglen;
3126 if (big_utf8 && offset > 0)
3127 sv_pos_u2b(big, &offset, 0);
3132 else if (offset > (I32)biglen)
3134 if (!(tmps2 = is_index
3135 ? fbm_instr((unsigned char*)tmps + offset,
3136 (unsigned char*)tmps + biglen, little, 0)
3137 : rninstr(tmps, tmps + offset,
3138 tmps2, tmps2 + llen)))
3141 retval = tmps2 - tmps;
3142 if (retval > 0 && big_utf8)
3143 sv_pos_b2u(big, &retval);
3148 PUSHi(retval + arybase);
3154 dVAR; dSP; dMARK; dORIGMARK; dTARGET;
3155 do_sprintf(TARG, SP-MARK, MARK+1);
3156 TAINT_IF(SvTAINTED(TARG));
3167 const U8 *s = (U8*)SvPV_const(argsv, len);
3170 if (PL_encoding && SvPOK(argsv) && !DO_UTF8(argsv)) {
3171 tmpsv = sv_2mortal(newSVsv(argsv));
3172 s = (U8*)sv_recode_to_utf8(tmpsv, PL_encoding);
3176 XPUSHu(DO_UTF8(argsv) ?
3177 utf8n_to_uvchr(s, UTF8_MAXBYTES, 0, UTF8_ALLOW_ANYUV) :
3189 if (((SvIOK_notUV(TOPs) && SvIV(TOPs) < 0)
3191 (SvNOK(TOPs) && SvNV(TOPs) < 0.0))) {
3193 value = POPu; /* chr(-1) eq chr(0xff), etc. */
3195 (void) POPs; /* Ignore the argument value. */
3196 value = UNICODE_REPLACEMENT;
3202 SvUPGRADE(TARG,SVt_PV);
3204 if (value > 255 && !IN_BYTES) {
3205 SvGROW(TARG, (STRLEN)UNISKIP(value)+1);
3206 tmps = (char*)uvchr_to_utf8_flags((U8*)SvPVX(TARG), value, 0);
3207 SvCUR_set(TARG, tmps - SvPVX_const(TARG));
3209 (void)SvPOK_only(TARG);
3218 *tmps++ = (char)value;
3220 (void)SvPOK_only(TARG);
3221 if (PL_encoding && !IN_BYTES) {
3222 sv_recode_to_utf8(TARG, PL_encoding);
3224 if (SvCUR(TARG) == 0 || !is_utf8_string((U8*)tmps, SvCUR(TARG)) ||
3225 memEQ(tmps, "\xef\xbf\xbd\0", 4)) {
3229 *tmps++ = (U8)UTF8_EIGHT_BIT_HI(value);
3230 *tmps++ = (U8)UTF8_EIGHT_BIT_LO(value);
3245 const char *tmps = SvPV_const(left, len);
3247 if (DO_UTF8(left)) {
3248 /* If Unicode, try to downgrade.
3249 * If not possible, croak.
3250 * Yes, we made this up. */
3251 SV* const tsv = sv_2mortal(newSVsv(left));
3254 sv_utf8_downgrade(tsv, FALSE);
3255 tmps = SvPV_const(tsv, len);
3257 # ifdef USE_ITHREADS
3259 if (!PL_reentrant_buffer->_crypt_struct_buffer) {
3260 /* This should be threadsafe because in ithreads there is only
3261 * one thread per interpreter. If this would not be true,
3262 * we would need a mutex to protect this malloc. */
3263 PL_reentrant_buffer->_crypt_struct_buffer =
3264 (struct crypt_data *)safemalloc(sizeof(struct crypt_data));
3265 #if defined(__GLIBC__) || defined(__EMX__)
3266 if (PL_reentrant_buffer->_crypt_struct_buffer) {
3267 PL_reentrant_buffer->_crypt_struct_buffer->initialized = 0;
3268 /* work around glibc-2.2.5 bug */
3269 PL_reentrant_buffer->_crypt_struct_buffer->current_saltbits = 0;
3273 # endif /* HAS_CRYPT_R */
3274 # endif /* USE_ITHREADS */
3276 sv_setpv(TARG, fcrypt(tmps, SvPV_nolen_const(right)));
3278 sv_setpv(TARG, PerlProc_crypt(tmps, SvPV_nolen_const(right)));
3284 "The crypt() function is unimplemented due to excessive paranoia.");
3295 const int op_type = PL_op->op_type;
3299 (s = (const U8*)SvPV_nomg_const(sv, slen)) && slen &&
3300 UTF8_IS_START(*s)) {
3301 U8 tmpbuf[UTF8_MAXBYTES_CASE+1];
3305 utf8_to_uvchr(s, &ulen);
3306 if (op_type == OP_UCFIRST) {
3307 toTITLE_utf8(s, tmpbuf, &tculen);
3309 toLOWER_utf8(s, tmpbuf, &tculen);
3312 if (!SvPADTMP(sv) || SvREADONLY(sv) || ulen != tculen) {
3314 /* slen is the byte length of the whole SV.
3315 * ulen is the byte length of the original Unicode character
3316 * stored as UTF-8 at s.
3317 * tculen is the byte length of the freshly titlecased (or
3318 * lowercased) Unicode character stored as UTF-8 at tmpbuf.
3319 * We first set the result to be the titlecased (/lowercased)
3320 * character, and then append the rest of the SV data. */
3321 sv_setpvn(TARG, (char*)tmpbuf, tculen);
3323 sv_catpvn(TARG, (char*)(s + ulen), slen - ulen);
3328 s = (U8*)SvPV_force_nomg(sv, slen);
3329 Copy(tmpbuf, s, tculen, U8);
3334 if (!SvPADTMP(sv) || SvREADONLY(sv)) {
3336 SvUTF8_off(TARG); /* decontaminate */
3337 sv_setsv_nomg(TARG, sv);
3341 s1 = (U8*)SvPV_force_nomg(sv, slen);
3343 if (IN_LOCALE_RUNTIME) {
3346 *s1 = (op_type == OP_UCFIRST)
3347 ? toUPPER_LC(*s1) : toLOWER_LC(*s1);
3350 *s1 = (op_type == OP_UCFIRST) ? toUPPER(*s1) : toLOWER(*s1);
3371 U8 tmpbuf[UTF8_MAXBYTES+1];
3373 s = (const U8*)SvPV_nomg_const(sv,len);
3375 SvUTF8_off(TARG); /* decontaminate */
3376 sv_setpvn(TARG, "", 0);
3380 STRLEN min = len + 1;
3382 SvUPGRADE(TARG, SVt_PV);
3384 (void)SvPOK_only(TARG);
3385 d = (U8*)SvPVX(TARG);
3388 STRLEN u = UTF8SKIP(s);
3390 toUPPER_utf8(s, tmpbuf, &ulen);
3391 if (ulen > u && (SvLEN(TARG) < (min += ulen - u))) {
3392 /* If the eventually required minimum size outgrows
3393 * the available space, we need to grow. */
3394 const UV o = d - (U8*)SvPVX_const(TARG);
3396 /* If someone uppercases one million U+03B0s we
3397 * SvGROW() one million times. Or we could try
3398 * guessing how much to allocate without allocating
3399 * too much. Such is life. */
3401 d = (U8*)SvPVX(TARG) + o;
3403 Copy(tmpbuf, d, ulen, U8);
3409 SvCUR_set(TARG, d - (U8*)SvPVX_const(TARG));
3415 if (!SvPADTMP(sv) || SvREADONLY(sv)) {
3417 SvUTF8_off(TARG); /* decontaminate */
3418 sv_setsv_nomg(TARG, sv);
3422 s = (U8*)SvPV_force_nomg(sv, len);
3424 register const U8 *send = s + len;
3426 if (IN_LOCALE_RUNTIME) {
3429 for (; s < send; s++)
3430 *s = toUPPER_LC(*s);
3433 for (; s < send; s++)
3456 U8 tmpbuf[UTF8_MAXBYTES_CASE+1];
3458 s = (const U8*)SvPV_nomg_const(sv,len);
3460 SvUTF8_off(TARG); /* decontaminate */
3461 sv_setpvn(TARG, "", 0);
3465 STRLEN min = len + 1;
3467 SvUPGRADE(TARG, SVt_PV);
3469 (void)SvPOK_only(TARG);
3470 d = (U8*)SvPVX(TARG);
3473 const STRLEN u = UTF8SKIP(s);
3474 const UV uv = toLOWER_utf8(s, tmpbuf, &ulen);
3476 #define GREEK_CAPITAL_LETTER_SIGMA 0x03A3 /* Unicode U+03A3 */
3477 if (uv == GREEK_CAPITAL_LETTER_SIGMA) {
3480 * Now if the sigma is NOT followed by
3481 * /$ignorable_sequence$cased_letter/;
3482 * and it IS preceded by
3483 * /$cased_letter$ignorable_sequence/;
3484 * where $ignorable_sequence is
3485 * [\x{2010}\x{AD}\p{Mn}]*
3486 * and $cased_letter is
3487 * [\p{Ll}\p{Lo}\p{Lt}]
3488 * then it should be mapped to 0x03C2,
3489 * (GREEK SMALL LETTER FINAL SIGMA),
3490 * instead of staying 0x03A3.
3491 * "should be": in other words,
3492 * this is not implemented yet.
3493 * See lib/unicore/SpecialCasing.txt.
3496 if (ulen > u && (SvLEN(TARG) < (min += ulen - u))) {
3497 /* If the eventually required minimum size outgrows
3498 * the available space, we need to grow. */
3499 const UV o = d - (U8*)SvPVX_const(TARG);
3501 /* If someone lowercases one million U+0130s we
3502 * SvGROW() one million times. Or we could try
3503 * guessing how much to allocate without allocating.
3504 * too much. Such is life. */
3506 d = (U8*)SvPVX(TARG) + o;
3508 Copy(tmpbuf, d, ulen, U8);
3514 SvCUR_set(TARG, d - (U8*)SvPVX_const(TARG));
3520 if (!SvPADTMP(sv) || SvREADONLY(sv)) {
3522 SvUTF8_off(TARG); /* decontaminate */
3523 sv_setsv_nomg(TARG, sv);
3528 s = (U8*)SvPV_force_nomg(sv, len);
3530 register const U8 * const send = s + len;
3532 if (IN_LOCALE_RUNTIME) {
3535 for (; s < send; s++)
3536 *s = toLOWER_LC(*s);
3539 for (; s < send; s++)
3551 SV * const sv = TOPs;
3553 register const char *s = SvPV_const(sv,len);
3555 SvUTF8_off(TARG); /* decontaminate */
3558 SvUPGRADE(TARG, SVt_PV);
3559 SvGROW(TARG, (len * 2) + 1);
3563 if (UTF8_IS_CONTINUED(*s)) {
3564 STRLEN ulen = UTF8SKIP(s);
3588 SvCUR_set(TARG, d - SvPVX_const(TARG));
3589 (void)SvPOK_only_UTF8(TARG);
3592 sv_setpvn(TARG, s, len);
3594 if (SvSMAGICAL(TARG))
3603 dVAR; dSP; dMARK; dORIGMARK;
3604 register AV* const av = (AV*)POPs;
3605 register const I32 lval = (PL_op->op_flags & OPf_MOD || LVRET);
3607 if (SvTYPE(av) == SVt_PVAV) {
3608 const I32 arybase = PL_curcop->cop_arybase;
3609 if (lval && PL_op->op_private & OPpLVAL_INTRO) {
3612 for (svp = MARK + 1; svp <= SP; svp++) {
3613 const I32 elem = SvIVx(*svp);
3617 if (max > AvMAX(av))
3620 while (++MARK <= SP) {
3622 I32 elem = SvIVx(*MARK);
3626 svp = av_fetch(av, elem, lval);
3628 if (!svp || *svp == &PL_sv_undef)
3629 DIE(aTHX_ PL_no_aelem, elem);
3630 if (PL_op->op_private & OPpLVAL_INTRO)
3631 save_aelem(av, elem, svp);
3633 *MARK = svp ? *svp : &PL_sv_undef;
3636 if (GIMME != G_ARRAY) {
3638 *++MARK = SP > ORIGMARK ? *SP : &PL_sv_undef;
3644 /* Associative arrays. */
3650 HV * const hash = (HV*)POPs;
3652 const I32 gimme = GIMME_V;
3655 /* might clobber stack_sp */
3656 entry = hv_iternext(hash);
3661 SV* const sv = hv_iterkeysv(entry);
3662 PUSHs(sv); /* won't clobber stack_sp */
3663 if (gimme == G_ARRAY) {
3666 /* might clobber stack_sp */
3667 val = hv_iterval(hash, entry);
3672 else if (gimme == G_SCALAR)
3682 const I32 gimme = GIMME_V;
3683 const I32 discard = (gimme == G_VOID) ? G_DISCARD : 0;
3685 if (PL_op->op_private & OPpSLICE) {
3687 HV * const hv = (HV*)POPs;
3688 const U32 hvtype = SvTYPE(hv);
3689 if (hvtype == SVt_PVHV) { /* hash element */
3690 while (++MARK <= SP) {
3691 SV * const sv = hv_delete_ent(hv, *MARK, discard, 0);
3692 *MARK = sv ? sv : &PL_sv_undef;
3695 else if (hvtype == SVt_PVAV) { /* array element */
3696 if (PL_op->op_flags & OPf_SPECIAL) {
3697 while (++MARK <= SP) {
3698 SV * const sv = av_delete((AV*)hv, SvIV(*MARK), discard);
3699 *MARK = sv ? sv : &PL_sv_undef;
3704 DIE(aTHX_ "Not a HASH reference");
3707 else if (gimme == G_SCALAR) {
3712 *++MARK = &PL_sv_undef;
3718 HV * const hv = (HV*)POPs;
3720 if (SvTYPE(hv) == SVt_PVHV)
3721 sv = hv_delete_ent(hv, keysv, discard, 0);
3722 else if (SvTYPE(hv) == SVt_PVAV) {
3723 if (PL_op->op_flags & OPf_SPECIAL)
3724 sv = av_delete((AV*)hv, SvIV(keysv), discard);
3726 DIE(aTHX_ "panic: avhv_delete no longer supported");
3729 DIE(aTHX_ "Not a HASH reference");
3745 if (PL_op->op_private & OPpEXISTS_SUB) {
3747 SV * const sv = POPs;
3748 CV * const cv = sv_2cv(sv, &hv, &gv, 0);
3751 if (gv && isGV(gv) && GvCV(gv) && !GvCVGEN(gv))
3757 if (SvTYPE(hv) == SVt_PVHV) {
3758 if (hv_exists_ent(hv, tmpsv, 0))
3761 else if (SvTYPE(hv) == SVt_PVAV) {
3762 if (PL_op->op_flags & OPf_SPECIAL) { /* array element */
3763 if (av_exists((AV*)hv, SvIV(tmpsv)))
3768 DIE(aTHX_ "Not a HASH reference");
3775 dVAR; dSP; dMARK; dORIGMARK;
3776 register HV * const hv = (HV*)POPs;
3777 register const I32 lval = (PL_op->op_flags & OPf_MOD || LVRET);
3778 const bool localizing = PL_op->op_private & OPpLVAL_INTRO;
3779 bool other_magic = FALSE;
3785 other_magic = mg_find((SV*)hv, PERL_MAGIC_env) ||
3786 ((mg = mg_find((SV*)hv, PERL_MAGIC_tied))
3787 /* Try to preserve the existenceness of a tied hash
3788 * element by using EXISTS and DELETE if possible.
3789 * Fallback to FETCH and STORE otherwise */
3790 && (stash = SvSTASH(SvRV(SvTIED_obj((SV*)hv, mg))))
3791 && gv_fetchmethod_autoload(stash, "EXISTS", TRUE)
3792 && gv_fetchmethod_autoload(stash, "DELETE", TRUE));
3795 while (++MARK <= SP) {
3796 SV * const keysv = *MARK;
3799 bool preeminent = FALSE;
3802 preeminent = SvRMAGICAL(hv) && !other_magic ? 1 :
3803 hv_exists_ent(hv, keysv, 0);
3806 he = hv_fetch_ent(hv, keysv, lval, 0);
3807 svp = he ? &HeVAL(he) : 0;
3810 if (!svp || *svp == &PL_sv_undef) {
3811 DIE(aTHX_ PL_no_helem_sv, keysv);
3815 save_helem(hv, keysv, svp);
3818 const char *key = SvPV_const(keysv, keylen);
3819 SAVEDELETE(hv, savepvn(key,keylen), keylen);
3823 *MARK = svp ? *svp : &PL_sv_undef;
3825 if (GIMME != G_ARRAY) {
3827 *++MARK = SP > ORIGMARK ? *SP : &PL_sv_undef;
3833 /* List operators. */
3838 if (GIMME != G_ARRAY) {
3840 *MARK = *SP; /* unwanted list, return last item */
3842 *MARK = &PL_sv_undef;
3852 SV ** const lastrelem = PL_stack_sp;
3853 SV ** const lastlelem = PL_stack_base + POPMARK;
3854 SV ** const firstlelem = PL_stack_base + POPMARK + 1;
3855 register SV ** const firstrelem = lastlelem + 1;
3856 const I32 arybase = PL_curcop->cop_arybase;
3857 I32 is_something_there = PL_op->op_flags & OPf_MOD;
3859 register const I32 max = lastrelem - lastlelem;
3860 register SV **lelem;
3862 if (GIMME != G_ARRAY) {
3863 I32 ix = SvIVx(*lastlelem);
3868 if (ix < 0 || ix >= max)
3869 *firstlelem = &PL_sv_undef;
3871 *firstlelem = firstrelem[ix];
3877 SP = firstlelem - 1;
3881 for (lelem = firstlelem; lelem <= lastlelem; lelem++) {
3882 I32 ix = SvIVx(*lelem);
3887 if (ix < 0 || ix >= max)
3888 *lelem = &PL_sv_undef;
3890 is_something_there = TRUE;
3891 if (!(*lelem = firstrelem[ix]))
3892 *lelem = &PL_sv_undef;
3895 if (is_something_there)
3898 SP = firstlelem - 1;
3904 dVAR; dSP; dMARK; dORIGMARK;
3905 const I32 items = SP - MARK;
3906 SV * const av = sv_2mortal((SV*)av_make(items, MARK+1));
3907 SP = ORIGMARK; /* av_make() might realloc stack_sp */
3914 dVAR; dSP; dMARK; dORIGMARK;
3915 HV* const hv = (HV*)sv_2mortal((SV*)newHV());
3918 SV * const key = *++MARK;
3919 SV * const val = newSV(0);
3921 sv_setsv(val, *++MARK);
3922 else if (ckWARN(WARN_MISC))
3923 Perl_warner(aTHX_ packWARN(WARN_MISC), "Odd number of elements in anonymous hash");
3924 (void)hv_store_ent(hv,key,val,0);
3933 dVAR; dSP; dMARK; dORIGMARK;
3934 register AV *ary = (AV*)*++MARK;
3938 register I32 offset;
3939 register I32 length;
3943 SV **tmparyval = NULL;
3944 const MAGIC * const mg = SvTIED_mg((SV*)ary, PERL_MAGIC_tied);
3947 *MARK-- = SvTIED_obj((SV*)ary, mg);
3951 call_method("SPLICE",GIMME_V);
3960 offset = i = SvIVx(*MARK);
3962 offset += AvFILLp(ary) + 1;
3964 offset -= PL_curcop->cop_arybase;
3966 DIE(aTHX_ PL_no_aelem, i);
3968 length = SvIVx(*MARK++);
3970 length += AvFILLp(ary) - offset + 1;
3976 length = AvMAX(ary) + 1; /* close enough to infinity */
3980 length = AvMAX(ary) + 1;
3982 if (offset > AvFILLp(ary) + 1) {
3983 if (ckWARN(WARN_MISC))
3984 Perl_warner(aTHX_ packWARN(WARN_MISC), "splice() offset past end of array" );
3985 offset = AvFILLp(ary) + 1;
3987 after = AvFILLp(ary) + 1 - (offset + length);
3988 if (after < 0) { /* not that much array */
3989 length += after; /* offset+length now in array */
3995 /* At this point, MARK .. SP-1 is our new LIST */
3998 diff = newlen - length;
3999 if (newlen && !AvREAL(ary) && AvREIFY(ary))
4002 /* make new elements SVs now: avoid problems if they're from the array */
4003 for (dst = MARK, i = newlen; i; i--) {
4004 SV * const h = *dst;
4005 *dst++ = newSVsv(h);
4008 if (diff < 0) { /* shrinking the area */
4010 Newx(tmparyval, newlen, SV*); /* so remember insertion */
4011 Copy(MARK, tmparyval, newlen, SV*);
4014 MARK = ORIGMARK + 1;
4015 if (GIMME == G_ARRAY) { /* copy return vals to stack */
4016 MEXTEND(MARK, length);
4017 Copy(AvARRAY(ary)+offset, MARK, length, SV*);
4019 EXTEND_MORTAL(length);
4020 for (i = length, dst = MARK; i; i--) {
4021 sv_2mortal(*dst); /* free them eventualy */
4028 *MARK = AvARRAY(ary)[offset+length-1];
4031 for (i = length - 1, dst = &AvARRAY(ary)[offset]; i > 0; i--)
4032 SvREFCNT_dec(*dst++); /* free them now */
4035 AvFILLp(ary) += diff;
4037 /* pull up or down? */
4039 if (offset < after) { /* easier to pull up */
4040 if (offset) { /* esp. if nothing to pull */
4041 src = &AvARRAY(ary)[offset-1];
4042 dst = src - diff; /* diff is negative */
4043 for (i = offset; i > 0; i--) /* can't trust Copy */
4047 SvPV_set(ary, (char*)(AvARRAY(ary) - diff)); /* diff is negative */
4051 if (after) { /* anything to pull down? */
4052 src = AvARRAY(ary) + offset + length;
4053 dst = src + diff; /* diff is negative */
4054 Move(src, dst, after, SV*);
4056 dst = &AvARRAY(ary)[AvFILLp(ary)+1];
4057 /* avoid later double free */
4061 dst[--i] = &PL_sv_undef;
4064 Copy( tmparyval, AvARRAY(ary) + offset, newlen, SV* );
4065 Safefree(tmparyval);
4068 else { /* no, expanding (or same) */
4070 Newx(tmparyval, length, SV*); /* so remember deletion */
4071 Copy(AvARRAY(ary)+offset, tmparyval, length, SV*);
4074 if (diff > 0) { /* expanding */
4076 /* push up or down? */
4078 if (offset < after && diff <= AvARRAY(ary) - AvALLOC(ary)) {
4082 Move(src, dst, offset, SV*);
4084 SvPV_set(ary, (char*)(AvARRAY(ary) - diff));/* diff is positive */
4086 AvFILLp(ary) += diff;
4089 if (AvFILLp(ary) + diff >= AvMAX(ary)) /* oh, well */
4090 av_extend(ary, AvFILLp(ary) + diff);
4091 AvFILLp(ary) += diff;
4094 dst = AvARRAY(ary) + AvFILLp(ary);
4096 for (i = after; i; i--) {
4104 Copy( MARK, AvARRAY(ary) + offset, newlen, SV* );
4107 MARK = ORIGMARK + 1;
4108 if (GIMME == G_ARRAY) { /* copy return vals to stack */
4110 Copy(tmparyval, MARK, length, SV*);
4112 EXTEND_MORTAL(length);
4113 for (i = length, dst = MARK; i; i--) {
4114 sv_2mortal(*dst); /* free them eventualy */
4118 Safefree(tmparyval);
4122 else if (length--) {
4123 *MARK = tmparyval[length];
4126 while (length-- > 0)
4127 SvREFCNT_dec(tmparyval[length]);
4129 Safefree(tmparyval);
4132 *MARK = &PL_sv_undef;
4140 dVAR; dSP; dMARK; dORIGMARK; dTARGET;
4141 register AV *ary = (AV*)*++MARK;
4142 const MAGIC * const mg = SvTIED_mg((SV*)ary, PERL_MAGIC_tied);
4145 *MARK-- = SvTIED_obj((SV*)ary, mg);
4149 call_method("PUSH",G_SCALAR|G_DISCARD);
4153 PUSHi( AvFILL(ary) + 1 );
4156 for (++MARK; MARK <= SP; MARK++) {
4157 SV * const sv = newSV(0);
4159 sv_setsv(sv, *MARK);
4160 av_store(ary, AvFILLp(ary)+1, sv);
4163 PUSHi( AvFILLp(ary) + 1 );
4172 AV * const av = (AV*)POPs;
4173 SV * const sv = PL_op->op_type == OP_SHIFT ? av_shift(av) : av_pop(av);
4177 (void)sv_2mortal(sv);
4184 dVAR; dSP; dMARK; dORIGMARK; dTARGET;
4185 register AV *ary = (AV*)*++MARK;
4186 const MAGIC * const mg = SvTIED_mg((SV*)ary, PERL_MAGIC_tied);
4189 *MARK-- = SvTIED_obj((SV*)ary, mg);
4193 call_method("UNSHIFT",G_SCALAR|G_DISCARD);
4199 av_unshift(ary, SP - MARK);
4201 SV * const sv = newSVsv(*++MARK);
4202 (void)av_store(ary, i++, sv);
4206 PUSHi( AvFILL(ary) + 1 );
4213 SV ** const oldsp = SP;
4215 if (GIMME == G_ARRAY) {
4218 register SV * const tmp = *MARK;
4222 /* safe as long as stack cannot get extended in the above */
4227 register char *down;
4233 SvUTF8_off(TARG); /* decontaminate */
4235 do_join(TARG, &PL_sv_no, MARK, SP);
4237 sv_setsv(TARG, (SP > MARK)
4239 : (padoff_du = find_rundefsvoffset(),
4240 (padoff_du == NOT_IN_PAD || PAD_COMPNAME_FLAGS(padoff_du) & SVpad_OUR)
4241 ? DEFSV : PAD_SVl(padoff_du)));
4242 up = SvPV_force(TARG, len);
4244 if (DO_UTF8(TARG)) { /* first reverse each character */
4245 U8* s = (U8*)SvPVX(TARG);
4246 const U8* send = (U8*)(s + len);
4248 if (UTF8_IS_INVARIANT(*s)) {
4253 if (!utf8_to_uvchr(s, 0))
4257 down = (char*)(s - 1);
4258 /* reverse this character */
4262 *down-- = (char)tmp;
4268 down = SvPVX(TARG) + len - 1;
4272 *down-- = (char)tmp;
4274 (void)SvPOK_only_UTF8(TARG);
4286 register IV limit = POPi; /* note, negative is forever */
4287 SV * const sv = POPs;
4289 register const char *s = SvPV_const(sv, len);
4290 const bool do_utf8 = DO_UTF8(sv);
4291 const char *strend = s + len;
4293 register REGEXP *rx;
4295 register const char *m;
4297 const STRLEN slen = do_utf8 ? utf8_length((U8*)s, (U8*)strend) : (strend - s);
4298 I32 maxiters = slen + 10;
4300 const I32 origlimit = limit;
4303 const I32 gimme = GIMME_V;
4304 const I32 oldsave = PL_savestack_ix;
4305 I32 make_mortal = 1;
4307 MAGIC *mg = (MAGIC *) NULL;
4310 Copy(&LvTARGOFF(POPs), &pm, 1, PMOP*);
4315 DIE(aTHX_ "panic: pp_split");
4318 TAINT_IF((pm->op_pmflags & PMf_LOCALE) &&
4319 (pm->op_pmflags & (PMf_WHITE | PMf_SKIPWHITE)));
4321 RX_MATCH_UTF8_set(rx, do_utf8);
4323 if (pm->op_pmreplroot) {
4325 ary = GvAVn((GV*)PAD_SVl(INT2PTR(PADOFFSET, pm->op_pmreplroot)));
4327 ary = GvAVn((GV*)pm->op_pmreplroot);
4330 else if (gimme != G_ARRAY)
4331 ary = GvAVn(PL_defgv);
4334 if (ary && (gimme != G_ARRAY || (pm->op_pmflags & PMf_ONCE))) {
4340 if ((mg = SvTIED_mg((SV*)ary, PERL_MAGIC_tied))) {
4342 XPUSHs(SvTIED_obj((SV*)ary, mg));
4349 for (i = AvFILLp(ary); i >= 0; i--)
4350 AvARRAY(ary)[i] = &PL_sv_undef; /* don't free mere refs */
4352 /* temporarily switch stacks */
4353 SAVESWITCHSTACK(PL_curstack, ary);
4357 base = SP - PL_stack_base;
4359 if (pm->op_pmflags & PMf_SKIPWHITE) {
4360 if (pm->op_pmflags & PMf_LOCALE) {
4361 while (isSPACE_LC(*s))
4369 if (pm->op_pmflags & PMf_MULTILINE) {
4374 limit = maxiters + 2;
4375 if (pm->op_pmflags & PMf_WHITE) {
4378 while (m < strend &&
4379 !((pm->op_pmflags & PMf_LOCALE)
4380 ? isSPACE_LC(*m) : isSPACE(*m)))
4385 dstr = newSVpvn(s, m-s);
4389 (void)SvUTF8_on(dstr);
4393 while (s < strend &&
4394 ((pm->op_pmflags & PMf_LOCALE)
4395 ? isSPACE_LC(*s) : isSPACE(*s)))
4399 else if (rx->precomp[0] == '^' && rx->precomp[1] == '\0') {
4401 for (m = s; m < strend && *m != '\n'; m++)
4406 dstr = newSVpvn(s, m-s);
4410 (void)SvUTF8_on(dstr);
4415 else if (do_utf8 == ((rx->reganch & ROPT_UTF8) != 0) &&
4416 (rx->reganch & RE_USE_INTUIT) && !rx->nparens
4417 && (rx->reganch & ROPT_CHECK_ALL)
4418 && !(rx->reganch & ROPT_ANCH)) {
4419 const int tail = (rx->reganch & RE_INTUIT_TAIL);
4420 SV * const csv = CALLREG_INTUIT_STRING(aTHX_ rx);
4423 if (len == 1 && !(rx->reganch & ROPT_UTF8) && !tail) {
4424 const char c = *SvPV_nolen_const(csv);
4426 for (m = s; m < strend && *m != c; m++)
4430 dstr = newSVpvn(s, m-s);
4434 (void)SvUTF8_on(dstr);
4436 /* The rx->minlen is in characters but we want to step
4437 * s ahead by bytes. */
4439 s = (char*)utf8_hop((U8*)m, len);
4441 s = m + len; /* Fake \n at the end */
4445 while (s < strend && --limit &&
4446 (m = fbm_instr((unsigned char*)s, (unsigned char*)strend,
4447 csv, multiline ? FBMrf_MULTILINE : 0)) )
4449 dstr = newSVpvn(s, m-s);
4453 (void)SvUTF8_on(dstr);
4455 /* The rx->minlen is in characters but we want to step
4456 * s ahead by bytes. */
4458 s = (char*)utf8_hop((U8*)m, len);
4460 s = m + len; /* Fake \n at the end */
4465 maxiters += slen * rx->nparens;
4466 while (s < strend && --limit)
4470 rex_return = CALLREGEXEC(aTHX_ rx, (char*)s, (char*)strend, (char*)orig, 1 ,
4473 if (rex_return == 0)
4475 TAINT_IF(RX_MATCH_TAINTED(rx));
4476 if (RX_MATCH_COPIED(rx) && rx->subbeg != orig) {
4481 strend = s + (strend - m);
4483 m = rx->startp[0] + orig;
4484 dstr = newSVpvn(s, m-s);
4488 (void)SvUTF8_on(dstr);
4492 for (i = 1; i <= (I32)rx->nparens; i++) {
4493 s = rx->startp[i] + orig;
4494 m = rx->endp[i] + orig;
4496 /* japhy (07/27/01) -- the (m && s) test doesn't catch
4497 parens that didn't match -- they should be set to
4498 undef, not the empty string */
4499 if (m >= orig && s >= orig) {
4500 dstr = newSVpvn(s, m-s);
4503 dstr = &PL_sv_undef; /* undef, not "" */
4507 (void)SvUTF8_on(dstr);
4511 s = rx->endp[0] + orig;
4515 iters = (SP - PL_stack_base) - base;
4516 if (iters > maxiters)
4517 DIE(aTHX_ "Split loop");
4519 /* keep field after final delim? */
4520 if (s < strend || (iters && origlimit)) {
4521 const STRLEN l = strend - s;
4522 dstr = newSVpvn(s, l);
4526 (void)SvUTF8_on(dstr);
4530 else if (!origlimit) {
4531 while (iters > 0 && (!TOPs || !SvANY(TOPs) || SvCUR(TOPs) == 0)) {
4532 if (TOPs && !make_mortal)
4535 *SP-- = &PL_sv_undef;
4540 LEAVE_SCOPE(oldsave); /* may undo an earlier SWITCHSTACK */
4544 if (SvSMAGICAL(ary)) {
4549 if (gimme == G_ARRAY) {
4551 Copy(AvARRAY(ary), SP + 1, iters, SV*);
4559 call_method("PUSH",G_SCALAR|G_DISCARD);
4562 if (gimme == G_ARRAY) {
4564 /* EXTEND should not be needed - we just popped them */
4566 for (i=0; i < iters; i++) {
4567 SV **svp = av_fetch(ary, i, FALSE);
4568 PUSHs((svp) ? *svp : &PL_sv_undef);
4575 if (gimme == G_ARRAY)
4591 if (SvTYPE(retsv) == SVt_PVAV || SvTYPE(retsv) == SVt_PVHV
4592 || SvTYPE(retsv) == SVt_PVCV) {
4593 retsv = refto(retsv);
4600 PP(unimplemented_op)
4603 DIE(aTHX_ "panic: unimplemented op %s (#%d) called", OP_NAME(PL_op),
4609 * c-indentation-style: bsd
4611 * indent-tabs-mode: t
4614 * ex: set ts=8 sts=4 sw=4 noet: