X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=pp_ctl.c;h=76a2466ca540826ac9a23d720ce841c5dd392e77;hb=1a67fee7d910c67790fff4a69f2f20f7628aa80a;hp=746f483dd0421eb6b9040b18e894729641a436b7;hpb=d20626d86bf3d55ba658adbc2678de4c519cbc6c;p=p5sagit%2Fp5-mst-13.2.git diff --git a/pp_ctl.c b/pp_ctl.c index 746f483..76a2466 100644 --- a/pp_ctl.c +++ b/pp_ctl.c @@ -1,6 +1,6 @@ /* pp_ctl.c * - * Copyright (c) 1991-1999, Larry Wall + * Copyright (c) 1991-2002, Larry Wall * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. @@ -26,26 +26,11 @@ #define DOCATCH(o) ((CATCH_GET == TRUE) ? docatch(o) : (o)) -static I32 sortcv(pTHXo_ SV *a, SV *b); -static I32 sv_ncmp(pTHXo_ SV *a, SV *b); -static I32 sv_i_ncmp(pTHXo_ SV *a, SV *b); -static I32 amagic_ncmp(pTHXo_ SV *a, SV *b); -static I32 amagic_i_ncmp(pTHXo_ SV *a, SV *b); -static I32 amagic_cmp(pTHXo_ SV *a, SV *b); -static I32 amagic_cmp_locale(pTHXo_ SV *a, SV *b); -static I32 run_user_filter(pTHXo_ int idx, SV *buf_sv, int maxlen); - -#ifdef PERL_OBJECT -static I32 sv_cmp_static(pTHXo_ SV *a, SV *b); -static I32 sv_cmp_locale_static(pTHXo_ SV *a, SV *b); -#else -#define sv_cmp_static Perl_sv_cmp -#define sv_cmp_locale_static Perl_sv_cmp_locale -#endif +static I32 run_user_filter(pTHX_ int idx, SV *buf_sv, int maxlen); PP(pp_wantarray) { - djSP; + dSP; I32 cxix; EXTEND(SP, 1); @@ -78,42 +63,58 @@ PP(pp_regcreset) PP(pp_regcomp) { - djSP; + dSP; register PMOP *pm = (PMOP*)cLOGOP->op_other; register char *t; SV *tmpstr; STRLEN len; MAGIC *mg = Null(MAGIC*); - + tmpstr = POPs; + + /* prevent recompiling under /o and ithreads. */ +#if defined(USE_ITHREADS) + if (pm->op_pmflags & PMf_KEEP && PM_GETRE(pm)) + RETURN; +#endif + if (SvROK(tmpstr)) { SV *sv = SvRV(tmpstr); if(SvMAGICAL(sv)) - mg = mg_find(sv, 'r'); + mg = mg_find(sv, PERL_MAGIC_qr); } if (mg) { regexp *re = (regexp *)mg->mg_obj; - ReREFCNT_dec(pm->op_pmregexp); - pm->op_pmregexp = ReREFCNT_inc(re); + ReREFCNT_dec(PM_GETRE(pm)); + PM_SETRE(pm, ReREFCNT_inc(re)); } else { t = SvPV(tmpstr, len); /* Check against the last compiled regexp. */ - if (!pm->op_pmregexp || !pm->op_pmregexp->precomp || - pm->op_pmregexp->prelen != len || - memNE(pm->op_pmregexp->precomp, t, len)) + if (!PM_GETRE(pm) || !PM_GETRE(pm)->precomp || + PM_GETRE(pm)->prelen != (I32)len || + memNE(PM_GETRE(pm)->precomp, t, len)) { - if (pm->op_pmregexp) { - ReREFCNT_dec(pm->op_pmregexp); - pm->op_pmregexp = Null(REGEXP*); /* crucial if regcomp aborts */ + if (PM_GETRE(pm)) { + ReREFCNT_dec(PM_GETRE(pm)); + PM_SETRE(pm, Null(REGEXP*)); /* crucial if regcomp aborts */ } if (PL_op->op_flags & OPf_SPECIAL) PL_reginterp_cnt = I32_MAX; /* Mark as safe. */ pm->op_pmflags = pm->op_pmpermflags; /* reset case sensitivity */ - pm->op_pmregexp = CALLREGCOMP(aTHX_ t, t + len, pm); - PL_reginterp_cnt = 0; /* XXXX Be extra paranoid - needed + if (DO_UTF8(tmpstr)) + pm->op_pmdynflags |= PMdf_DYN_UTF8; + else { + pm->op_pmdynflags &= ~PMdf_DYN_UTF8; + if (pm->op_pmdynflags & PMdf_UTF8) + t = (char*)bytes_to_utf8((U8*)t, &len); + } + PM_SETRE(pm, CALLREGCOMP(aTHX_ t, t + len, pm)); + if (!DO_UTF8(tmpstr) && (pm->op_pmdynflags & PMdf_UTF8)) + Safefree(t); + PL_reginterp_cnt = 0; /* XXXX Be extra paranoid - needed inside tie/overload accessors. */ } } @@ -127,21 +128,27 @@ PP(pp_regcomp) } #endif - if (!pm->op_pmregexp->prelen && PL_curpm) + if (!PM_GETRE(pm)->prelen && PL_curpm) pm = PL_curpm; - else if (strEQ("\\s+", pm->op_pmregexp->precomp)) + else if (strEQ("\\s+", PM_GETRE(pm)->precomp)) pm->op_pmflags |= PMf_WHITE; + else + pm->op_pmflags &= ~PMf_WHITE; + /* XXX runtime compiled output needs to move to the pad */ if (pm->op_pmflags & PMf_KEEP) { pm->op_private &= ~OPpRUNTIME; /* no point compiling again */ +#if !defined(USE_ITHREADS) + /* XXX can't change the optree at runtime either */ cLOGOP->op_first->op_next = PL_op->op_next; +#endif } RETURN; } PP(pp_substcont) { - djSP; + dSP; register PMOP *pm = (PMOP*) cLOGOP->op_other; register PERL_CONTEXT *cx = &cxstack[cxstack_ix]; register SV *dstr = cx->sb_dstr; @@ -151,8 +158,10 @@ PP(pp_substcont) register REGEXP *rx = cx->sb_rx; rxres_restore(&cx->sb_rxres, rx); + PL_reg_match_utf8 = SvUTF8(cx->sb_targ) ? 1 : 0; if (cx->sb_iters++) { + I32 saviters = cx->sb_iters; if (cx->sb_iters > cx->sb_maxiters) DIE(aTHX_ "Substitution loop"); @@ -168,8 +177,8 @@ PP(pp_substcont) : (REXEC_COPY_STR|REXEC_IGNOREPOS|REXEC_NOT_FIRST)))) { SV *targ = cx->sb_targ; - sv_catpvn(dstr, s, cx->sb_strend - s); + sv_catpvn(dstr, s, cx->sb_strend - s); cx->sb_rxtainted |= RX_MATCH_TAINTED(rx); (void)SvOOK_off(targ); @@ -177,13 +186,15 @@ PP(pp_substcont) SvPVX(targ) = SvPVX(dstr); SvCUR_set(targ, SvCUR(dstr)); SvLEN_set(targ, SvLEN(dstr)); + if (DO_UTF8(dstr)) + SvUTF8_on(targ); SvPVX(dstr) = 0; sv_free(dstr); TAINT_IF(cx->sb_rxtainted & 1); PUSHs(sv_2mortal(newSViv((I32)cx->sb_iters - 1))); - (void)SvPOK_only(targ); + (void)SvPOK_only_UTF8(targ); TAINT_IF(cx->sb_rxtainted); SvSETMAGIC(targ); SvTAINT(targ); @@ -192,6 +203,7 @@ PP(pp_substcont) POPSUBST(cx); RETURNOP(pm->op_next); } + cx->sb_iters = saviters; } if (RX_MATCH_COPIED(rx) && rx->subbeg != orig) { m = s; @@ -201,8 +213,24 @@ PP(pp_substcont) cx->sb_strend = s + (cx->sb_strend - m); } cx->sb_m = m = rx->startp[0] + orig; - sv_catpvn(dstr, s, m-s); + if (m > s) + sv_catpvn(dstr, s, m-s); cx->sb_s = rx->endp[0] + orig; + { /* Update the pos() information. */ + SV *sv = cx->sb_targ; + MAGIC *mg; + I32 i; + if (SvTYPE(sv) < SVt_PVMG) + (void)SvUPGRADE(sv, SVt_PVMG); + if (!(mg = mg_find(sv, PERL_MAGIC_regex_global))) { + sv_magic(sv, Nullsv, PERL_MAGIC_regex_global, Nullch, 0); + mg = mg_find(sv, PERL_MAGIC_regex_global); + } + i = m - orig; + if (DO_UTF8(sv)) + sv_pos_b2u(sv, &i); + mg->mg_len = i; + } cx->sb_rxtainted |= RX_MATCH_TAINTED(rx); rxres_save(&cx->sb_rxres, rx); RETURNOP(pm->op_pmreplstart); @@ -271,7 +299,7 @@ Perl_rxres_free(pTHX_ void **rsp) PP(pp_formline) { - djSP; dMARK; dORIGMARK; + dSP; dMARK; dORIGMARK; register SV *tmpForm = *++MARK; register U16 *fpc; register char *t; @@ -279,22 +307,28 @@ PP(pp_formline) register char *s; register char *send; register I32 arg; - register SV *sv; - char *item; - I32 itemsize; - I32 fieldsize; + register SV *sv = Nullsv; + char *item = Nullch; + I32 itemsize = 0; + I32 fieldsize = 0; I32 lines = 0; bool chopspace = (strchr(PL_chopset, ' ') != Nullch); - char *chophere; - char *linemark; + char *chophere = Nullch; + char *linemark = Nullch; NV value; - bool gotsome; + bool gotsome = FALSE; STRLEN len; - STRLEN fudge = SvCUR(tmpForm) * (IN_UTF8 ? 3 : 1) + 1; + STRLEN fudge = SvCUR(tmpForm) * (IN_BYTES ? 1 : 3) + 1; + bool item_is_utf = FALSE; if (!SvMAGICAL(tmpForm) || !SvCOMPILED(tmpForm)) { - SvREADONLY_off(tmpForm); - doparseform(tmpForm); + if (SvREADONLY(tmpForm)) { + SvREADONLY_off(tmpForm); + doparseform(tmpForm); + SvREADONLY_on(tmpForm); + } + else + doparseform(tmpForm); } SvPV_force(PL_formtarget, len); @@ -328,12 +362,13 @@ PP(pp_formline) case FF_MORE: name = "MORE"; break; case FF_LINEMARK: name = "LINEMARK"; break; case FF_END: name = "END"; break; + case FF_0DECIMAL: name = "0DECIMAL"; break; } if (arg >= 0) PerlIO_printf(Perl_debug_log, "%-16s%ld\n", name, (long) arg); else PerlIO_printf(Perl_debug_log, "%-16s\n", name); - } ) + } ); switch (*fpc++) { case FF_LINEMARK: linemark = t; @@ -361,16 +396,16 @@ PP(pp_formline) else { sv = &PL_sv_no; if (ckWARN(WARN_SYNTAX)) - Perl_warner(aTHX_ WARN_SYNTAX, "Not enough format arguments"); + Perl_warner(aTHX_ packWARN(WARN_SYNTAX), "Not enough format arguments"); } break; case FF_CHECKNL: item = s = SvPV(sv, len); itemsize = len; - if (IN_UTF8) { + if (DO_UTF8(sv)) { itemsize = sv_len_utf8(sv); - if (itemsize != len) { + if (itemsize != (I32)len) { I32 itembytes; if (itemsize > fieldsize) { itemsize = fieldsize; @@ -387,11 +422,13 @@ PP(pp_formline) break; s++; } + item_is_utf = TRUE; itemsize = s - item; sv_pos_b2u(sv, &itemsize); break; } } + item_is_utf = FALSE; if (itemsize > fieldsize) itemsize = fieldsize; send = chophere = s + itemsize; @@ -408,9 +445,9 @@ PP(pp_formline) case FF_CHECKCHOP: item = s = SvPV(sv, len); itemsize = len; - if (IN_UTF8) { + if (DO_UTF8(sv)) { itemsize = sv_len_utf8(sv); - if (itemsize != len) { + if (itemsize != (I32)len) { I32 itembytes; if (itemsize <= fieldsize) { send = chophere = s + itemsize; @@ -446,9 +483,11 @@ PP(pp_formline) itemsize = chophere - item; sv_pos_b2u(sv, &itemsize); } + item_is_utf = TRUE; break; } } + item_is_utf = FALSE; if (itemsize <= fieldsize) { send = chophere = s + itemsize; while (s < send) { @@ -504,10 +543,16 @@ PP(pp_formline) case FF_ITEM: arg = itemsize; s = item; - if (IN_UTF8) { + if (item_is_utf) { while (arg--) { - if (*s & 0x80) { - switch (UTF8SKIP(s)) { + if (UTF8_IS_CONTINUED(*s)) { + STRLEN skip = UTF8SKIP(s); + switch (skip) { + default: + Move(s,t,skip,char); + s += skip; + t += skip; + break; case 7: *t++ = *s++; case 6: *t++ = *s++; case 5: *t++ = *s++; @@ -547,6 +592,7 @@ PP(pp_formline) case FF_LINEGLOB: item = s = SvPV(sv, len); itemsize = len; + item_is_utf = FALSE; /* XXX is this correct? */ if (itemsize) { gotsome = TRUE; send = s + itemsize; @@ -579,7 +625,7 @@ PP(pp_formline) value = SvNV(sv); /* Formats aren't yet marked for locales, so assume "yes". */ { - RESTORE_NUMERIC_LOCAL(); + STORE_NUMERIC_STANDARD_SET_LOCAL(); #if defined(USE_LONG_DOUBLE) if (arg & 256) { sprintf(t, "%#*.*" PERL_PRIfldbl, @@ -601,6 +647,43 @@ PP(pp_formline) t += fieldsize; break; + case FF_0DECIMAL: + /* If the field is marked with ^ and the value is undefined, + blank it out. */ + arg = *fpc++; + if ((arg & 512) && !SvOK(sv)) { + arg = fieldsize; + while (arg--) + *t++ = ' '; + break; + } + gotsome = TRUE; + value = SvNV(sv); + /* Formats aren't yet marked for locales, so assume "yes". */ + { + STORE_NUMERIC_STANDARD_SET_LOCAL(); +#if defined(USE_LONG_DOUBLE) + if (arg & 256) { + sprintf(t, "%#0*.*" PERL_PRIfldbl, + (int) fieldsize, (int) arg & 255, value); +/* is this legal? I don't have long doubles */ + } else { + sprintf(t, "%0*.0" PERL_PRIfldbl, (int) fieldsize, value); + } +#else + if (arg & 256) { + sprintf(t, "%#0*.*f", + (int) fieldsize, (int) arg & 255, value); + } else { + sprintf(t, "%0*.0f", + (int) fieldsize, value); + } +#endif + RESTORE_NUMERIC_STANDARD(); + } + t += fieldsize; + break; + case FF_NEWLINE: f++; while (t-- > linemark && *t == ' ') ; @@ -668,7 +751,7 @@ PP(pp_formline) PP(pp_grepstart) { - djSP; + dSP; SV *src; if (PL_stack_base + *PL_markstack_ptr == SP) { @@ -683,10 +766,10 @@ PP(pp_grepstart) ENTER; /* enter outer scope */ SAVETMPS; - /* SAVE_DEFSV does *not* suffice here for USE_THREADS */ + /* SAVE_DEFSV does *not* suffice here for USE_5005THREADS */ SAVESPTR(DEFSV); ENTER; /* enter inner scope */ - SAVESPTR(PL_curpm); + SAVEVPTR(PL_curpm); src = PL_stack_base[*PL_markstack_ptr]; SvTEMP_off(src); @@ -705,37 +788,61 @@ PP(pp_mapstart) PP(pp_mapwhile) { - djSP; - I32 diff = (SP - PL_stack_base) - *PL_markstack_ptr; + dSP; + I32 items = (SP - PL_stack_base) - *PL_markstack_ptr; /* how many new items */ I32 count; I32 shift; SV** src; - SV** dst; + SV** dst; + /* first, move source pointer to the next item in the source list */ ++PL_markstack_ptr[-1]; - if (diff) { - if (diff > PL_markstack_ptr[-1] - PL_markstack_ptr[-2]) { - shift = diff - (PL_markstack_ptr[-1] - PL_markstack_ptr[-2]); - count = (SP - PL_stack_base) - PL_markstack_ptr[-1] + 2; - + + /* if there are new items, push them into the destination list */ + if (items) { + /* might need to make room back there first */ + if (items > PL_markstack_ptr[-1] - PL_markstack_ptr[-2]) { + /* XXX this implementation is very pessimal because the stack + * is repeatedly extended for every set of items. Is possible + * to do this without any stack extension or copying at all + * by maintaining a separate list over which the map iterates + * (like foreach does). --gsar */ + + /* everything in the stack after the destination list moves + * towards the end the stack by the amount of room needed */ + shift = items - (PL_markstack_ptr[-1] - PL_markstack_ptr[-2]); + + /* items to shift up (accounting for the moved source pointer) */ + count = (SP - PL_stack_base) - (PL_markstack_ptr[-1] - 1); + + /* This optimization is by Ben Tilly and it does + * things differently from what Sarathy (gsar) + * is describing. The downside of this optimization is + * that leaves "holes" (uninitialized and hopefully unused areas) + * to the Perl stack, but on the other hand this + * shouldn't be a problem. If Sarathy's idea gets + * implemented, this optimization should become + * irrelevant. --jhi */ + if (shift < count) + shift = count; /* Avoid shifting too often --Ben Tilly */ + EXTEND(SP,shift); src = SP; dst = (SP += shift); PL_markstack_ptr[-1] += shift; *PL_markstack_ptr += shift; - while (--count) + while (count--) *dst-- = *src--; } - dst = PL_stack_base + (PL_markstack_ptr[-2] += diff) - 1; - ++diff; - while (--diff) - *dst-- = SvTEMP(TOPs) ? POPs : sv_mortalcopy(POPs); + /* copy the new items down to the destination list */ + dst = PL_stack_base + (PL_markstack_ptr[-2] += items) - 1; + while (items-- > 0) + *dst-- = SvTEMP(TOPs) ? POPs : sv_mortalcopy(POPs); } LEAVE; /* exit inner scope */ /* All done yet? */ if (PL_markstack_ptr[-1] > *PL_markstack_ptr) { - I32 items; I32 gimme = GIMME_V; (void)POPMARK; /* pop top */ @@ -756,8 +863,9 @@ PP(pp_mapwhile) SV *src; ENTER; /* enter inner scope */ - SAVESPTR(PL_curpm); + SAVEVPTR(PL_curpm); + /* set $_ to the new source item */ src = PL_stack_base[PL_markstack_ptr[-1]]; SvTEMP_off(src); DEFSV = src; @@ -766,148 +874,6 @@ PP(pp_mapwhile) } } -PP(pp_sort) -{ - djSP; dMARK; dORIGMARK; - register SV **up; - SV **myorigmark = ORIGMARK; - register I32 max; - HV *stash; - GV *gv; - CV *cv; - I32 gimme = GIMME; - OP* nextop = PL_op->op_next; - I32 overloading = 0; - - if (gimme != G_ARRAY) { - SP = MARK; - RETPUSHUNDEF; - } - - ENTER; - SAVEPPTR(PL_sortcop); - if (PL_op->op_flags & OPf_STACKED) { - if (PL_op->op_flags & OPf_SPECIAL) { - OP *kid = cLISTOP->op_first->op_sibling; /* pass pushmark */ - kid = kUNOP->op_first; /* pass rv2gv */ - kid = kUNOP->op_first; /* pass leave */ - PL_sortcop = kid->op_next; - stash = PL_curcop->cop_stash; - } - else { - cv = sv_2cv(*++MARK, &stash, &gv, 0); - if (!(cv && CvROOT(cv))) { - if (gv) { - SV *tmpstr = sv_newmortal(); - gv_efullname3(tmpstr, gv, Nullch); - if (cv && CvXSUB(cv)) - DIE(aTHX_ "Xsub \"%s\" called in sort", SvPVX(tmpstr)); - DIE(aTHX_ "Undefined sort subroutine \"%s\" called", - SvPVX(tmpstr)); - } - if (cv) { - if (CvXSUB(cv)) - DIE(aTHX_ "Xsub called in sort"); - DIE(aTHX_ "Undefined subroutine in sort"); - } - DIE(aTHX_ "Not a CODE reference in sort"); - } - PL_sortcop = CvSTART(cv); - SAVESPTR(CvROOT(cv)->op_ppaddr); - CvROOT(cv)->op_ppaddr = PL_ppaddr[OP_NULL]; - - SAVESPTR(PL_curpad); - PL_curpad = AvARRAY((AV*)AvARRAY(CvPADLIST(cv))[1]); - } - } - else { - PL_sortcop = Nullop; - stash = PL_curcop->cop_stash; - } - - up = myorigmark + 1; - while (MARK < SP) { /* This may or may not shift down one here. */ - /*SUPPRESS 560*/ - if (*up = *++MARK) { /* Weed out nulls. */ - SvTEMP_off(*up); - if (!PL_sortcop && !SvPOK(*up)) { - STRLEN n_a; - if (SvAMAGIC(*up)) - overloading = 1; - else - (void)sv_2pv(*up, &n_a); - } - up++; - } - } - max = --up - myorigmark; - if (PL_sortcop) { - if (max > 1) { - PERL_CONTEXT *cx; - SV** newsp; - bool oldcatch = CATCH_GET; - - SAVETMPS; - SAVEOP(); - - CATCH_SET(TRUE); - PUSHSTACKi(PERLSI_SORT); - if (PL_sortstash != stash) { - PL_firstgv = gv_fetchpv("a", TRUE, SVt_PV); - PL_secondgv = gv_fetchpv("b", TRUE, SVt_PV); - PL_sortstash = stash; - } - - SAVESPTR(GvSV(PL_firstgv)); - SAVESPTR(GvSV(PL_secondgv)); - - PUSHBLOCK(cx, CXt_NULL, PL_stack_base); - if (!(PL_op->op_flags & OPf_SPECIAL)) { - bool hasargs = FALSE; - cx->cx_type = CXt_SUB; - cx->blk_gimme = G_SCALAR; - PUSHSUB(cx); - if (!CvDEPTH(cv)) - (void)SvREFCNT_inc(cv); /* in preparation for POPSUB */ - } - PL_sortcxix = cxstack_ix; - qsortsv((myorigmark+1), max, sortcv); - - POPBLOCK(cx,PL_curpm); - PL_stack_sp = newsp; - POPSTACK; - CATCH_SET(oldcatch); - } - } - else { - if (max > 1) { - MEXTEND(SP, 20); /* Can't afford stack realloc on signal. */ - qsortsv(ORIGMARK+1, max, - (PL_op->op_private & OPpSORT_NUMERIC) - ? ( (PL_op->op_private & OPpSORT_INTEGER) - ? ( overloading ? amagic_i_ncmp : sv_i_ncmp) - : ( overloading ? amagic_ncmp : sv_ncmp)) - : ( (PL_op->op_private & OPpLOCALE) - ? ( overloading - ? amagic_cmp_locale - : sv_cmp_locale_static) - : ( overloading ? amagic_cmp : sv_cmp_static))); - if (PL_op->op_private & OPpSORT_REVERSE) { - SV **p = ORIGMARK+1; - SV **q = ORIGMARK+max; - while (p < q) { - SV *tmp = *p; - *p++ = *q; - *q-- = tmp; - } - } - } - } - LEAVE; - PL_stack_sp = ORIGMARK + max; - return nextop; -} - /* Range stuff. */ PP(pp_range) @@ -922,7 +888,7 @@ PP(pp_range) PP(pp_flip) { - djSP; + dSP; if (GIMME == G_ARRAY) { RETURNOP(((LOGOP*)cUNOP->op_first)->op_other); @@ -930,10 +896,20 @@ PP(pp_flip) else { dTOPss; SV *targ = PAD_SV(PL_op->op_targ); + int flip = 0; - if ((PL_op->op_private & OPpFLIP_LINENUM) - ? (PL_last_in_gv && SvIV(sv) == (IV)IoLINES(GvIOp(PL_last_in_gv))) - : SvTRUE(sv) ) { + if (PL_op->op_private & OPpFLIP_LINENUM) { + if (GvIO(PL_last_in_gv)) { + flip = SvIV(sv) == (IV)IoLINES(GvIOp(PL_last_in_gv)); + } + else { + GV *gv = gv_fetchpv(".", TRUE, SVt_PV); + if (gv && GvSV(gv)) flip = SvIV(sv) == SvIV(GvSV(gv)); + } + } else { + flip = SvTRUE(sv); + } + if (flip) { sv_setiv(PAD_SV(cUNOP->op_first->op_targ), 1); if (PL_op->op_flags & OPf_SPECIAL) { sv_setiv(targ, 1); @@ -954,7 +930,7 @@ PP(pp_flip) PP(pp_flop) { - djSP; + dSP; if (GIMME == G_ARRAY) { dPOPPOPssrl; @@ -967,8 +943,14 @@ PP(pp_flop) if (SvGMAGICAL(right)) mg_get(right); + /* This code tries to decide if "$left .. $right" should use the + magical string increment, or if the range is numeric (we make + an exception for .."0" [#18165]). AMS 20021031. */ + if (SvNIOKp(left) || !SvPOKp(left) || - (looks_like_number(left) && *SvPVX(left) != '0') ) + SvNIOKp(right) || !SvPOKp(right) || + (looks_like_number(left) && *SvPVX(left) != '0' && + looks_like_number(right))) { if (SvNV(left) < IV_MIN || SvNV(right) > IV_MAX) DIE(aTHX_ "Range iterator outside integer range"); @@ -1005,10 +987,23 @@ PP(pp_flop) else { dTOPss; SV *targ = PAD_SV(cUNOP->op_first->op_targ); + int flop = 0; sv_inc(targ); - if ((PL_op->op_private & OPpFLIP_LINENUM) - ? (PL_last_in_gv && SvIV(sv) == (IV)IoLINES(GvIOp(PL_last_in_gv))) - : SvTRUE(sv) ) { + + if (PL_op->op_private & OPpFLIP_LINENUM) { + if (GvIO(PL_last_in_gv)) { + flop = SvIV(sv) == (IV)IoLINES(GvIOp(PL_last_in_gv)); + } + else { + GV *gv = gv_fetchpv(".", TRUE, SVt_PV); + if (gv && GvSV(gv)) flop = SvIV(sv) == SvIV(GvSV(gv)); + } + } + else { + flop = SvTRUE(sv); + } + + if (flop) { sv_setiv(PAD_SV(((UNOP*)cUNOP->op_first)->op_first->op_targ), 0); sv_catpv(targ, "E0"); } @@ -1023,7 +1018,6 @@ PP(pp_flop) STATIC I32 S_dopoptolabel(pTHX_ char *label) { - dTHR; register I32 i; register PERL_CONTEXT *cx; @@ -1031,24 +1025,29 @@ S_dopoptolabel(pTHX_ char *label) cx = &cxstack[i]; switch (CxTYPE(cx)) { case CXt_SUBST: - if (ckWARN(WARN_UNSAFE)) - Perl_warner(aTHX_ WARN_UNSAFE, "Exiting substitution via %s", - PL_op_name[PL_op->op_type]); + if (ckWARN(WARN_EXITING)) + Perl_warner(aTHX_ packWARN(WARN_EXITING), "Exiting substitution via %s", + OP_NAME(PL_op)); break; case CXt_SUB: - if (ckWARN(WARN_UNSAFE)) - Perl_warner(aTHX_ WARN_UNSAFE, "Exiting subroutine via %s", - PL_op_name[PL_op->op_type]); + if (ckWARN(WARN_EXITING)) + Perl_warner(aTHX_ packWARN(WARN_EXITING), "Exiting subroutine via %s", + OP_NAME(PL_op)); + break; + case CXt_FORMAT: + if (ckWARN(WARN_EXITING)) + Perl_warner(aTHX_ packWARN(WARN_EXITING), "Exiting format via %s", + OP_NAME(PL_op)); break; case CXt_EVAL: - if (ckWARN(WARN_UNSAFE)) - Perl_warner(aTHX_ WARN_UNSAFE, "Exiting eval via %s", - PL_op_name[PL_op->op_type]); + if (ckWARN(WARN_EXITING)) + Perl_warner(aTHX_ packWARN(WARN_EXITING), "Exiting eval via %s", + OP_NAME(PL_op)); break; case CXt_NULL: - if (ckWARN(WARN_UNSAFE)) - Perl_warner(aTHX_ WARN_UNSAFE, "Exiting pseudo-block via %s", - PL_op_name[PL_op->op_type]); + if (ckWARN(WARN_EXITING)) + Perl_warner(aTHX_ packWARN(WARN_EXITING), "Exiting pseudo-block via %s", + OP_NAME(PL_op)); return -1; case CXt_LOOP: if (!cx->blk_loop.label || @@ -1074,7 +1073,6 @@ Perl_dowantarray(pTHX) I32 Perl_block_gimme(pTHX) { - dTHR; I32 cxix; cxix = dopoptosub(cxstack_ix); @@ -1095,17 +1093,29 @@ Perl_block_gimme(pTHX) } } +I32 +Perl_is_lvalue_sub(pTHX) +{ + I32 cxix; + + cxix = dopoptosub(cxstack_ix); + assert(cxix >= 0); /* We should only be called from inside subs */ + + if (cxstack[cxix].blk_sub.lval && CvLVALUE(cxstack[cxix].blk_sub.cv)) + return cxstack[cxix].blk_sub.lval; + else + return 0; +} + STATIC I32 S_dopoptosub(pTHX_ I32 startingblock) { - dTHR; return dopoptosub_at(cxstack, startingblock); } STATIC I32 S_dopoptosub_at(pTHX_ PERL_CONTEXT *cxstk, I32 startingblock) { - dTHR; I32 i; register PERL_CONTEXT *cx; for (i = startingblock; i >= 0; i--) { @@ -1115,6 +1125,7 @@ S_dopoptosub_at(pTHX_ PERL_CONTEXT *cxstk, I32 startingblock) continue; case CXt_EVAL: case CXt_SUB: + case CXt_FORMAT: DEBUG_l( Perl_deb(aTHX_ "(Found sub #%ld)\n", (long)i)); return i; } @@ -1125,7 +1136,6 @@ S_dopoptosub_at(pTHX_ PERL_CONTEXT *cxstk, I32 startingblock) STATIC I32 S_dopoptoeval(pTHX_ I32 startingblock) { - dTHR; I32 i; register PERL_CONTEXT *cx; for (i = startingblock; i >= 0; i--) { @@ -1144,31 +1154,35 @@ S_dopoptoeval(pTHX_ I32 startingblock) STATIC I32 S_dopoptoloop(pTHX_ I32 startingblock) { - dTHR; I32 i; register PERL_CONTEXT *cx; for (i = startingblock; i >= 0; i--) { cx = &cxstack[i]; switch (CxTYPE(cx)) { case CXt_SUBST: - if (ckWARN(WARN_UNSAFE)) - Perl_warner(aTHX_ WARN_UNSAFE, "Exiting substitution via %s", - PL_op_name[PL_op->op_type]); + if (ckWARN(WARN_EXITING)) + Perl_warner(aTHX_ packWARN(WARN_EXITING), "Exiting substitution via %s", + OP_NAME(PL_op)); break; case CXt_SUB: - if (ckWARN(WARN_UNSAFE)) - Perl_warner(aTHX_ WARN_UNSAFE, "Exiting subroutine via %s", - PL_op_name[PL_op->op_type]); + if (ckWARN(WARN_EXITING)) + Perl_warner(aTHX_ packWARN(WARN_EXITING), "Exiting subroutine via %s", + OP_NAME(PL_op)); + break; + case CXt_FORMAT: + if (ckWARN(WARN_EXITING)) + Perl_warner(aTHX_ packWARN(WARN_EXITING), "Exiting format via %s", + OP_NAME(PL_op)); break; case CXt_EVAL: - if (ckWARN(WARN_UNSAFE)) - Perl_warner(aTHX_ WARN_UNSAFE, "Exiting eval via %s", - PL_op_name[PL_op->op_type]); + if (ckWARN(WARN_EXITING)) + Perl_warner(aTHX_ packWARN(WARN_EXITING), "Exiting eval via %s", + OP_NAME(PL_op)); break; case CXt_NULL: - if (ckWARN(WARN_UNSAFE)) - Perl_warner(aTHX_ WARN_UNSAFE, "Exiting pseudo-block via %s", - PL_op_name[PL_op->op_type]); + if (ckWARN(WARN_EXITING)) + Perl_warner(aTHX_ packWARN(WARN_EXITING), "Exiting pseudo-block via %s", + OP_NAME(PL_op)); return -1; case CXt_LOOP: DEBUG_l( Perl_deb(aTHX_ "(Found loop #%ld)\n", (long)i)); @@ -1181,9 +1195,7 @@ S_dopoptoloop(pTHX_ I32 startingblock) void Perl_dounwind(pTHX_ I32 cxix) { - dTHR; register PERL_CONTEXT *cx; - SV **newsp; I32 optype; while (cxstack_ix > cxix) { @@ -1208,47 +1220,14 @@ Perl_dounwind(pTHX_ I32 cxix) break; case CXt_NULL: break; + case CXt_FORMAT: + POPFORMAT(cx); + break; } cxstack_ix--; } } -/* - * Closures mentioned at top level of eval cannot be referenced - * again, and their presence indirectly causes a memory leak. - * (Note that the fact that compcv and friends are still set here - * is, AFAIK, an accident.) --Chip - * - * XXX need to get comppad et al from eval's cv rather than - * relying on the incidental global values. - */ -STATIC void -S_free_closures(pTHX) -{ - dTHR; - SV **svp = AvARRAY(PL_comppad_name); - I32 ix; - for (ix = AvFILLp(PL_comppad_name); ix >= 0; ix--) { - SV *sv = svp[ix]; - if (sv && sv != &PL_sv_undef && *SvPVX(sv) == '&') { - SvREFCNT_dec(sv); - svp[ix] = &PL_sv_undef; - - sv = PL_curpad[ix]; - if (CvCLONE(sv)) { - SvREFCNT_dec(CvOUTSIDE(sv)); - CvOUTSIDE(sv) = Nullcv; - } - else { - SvREFCNT_dec(sv); - sv = NEWSV(0,0); - SvPADTMP_on(sv); - PL_curpad[ix] = sv; - } - } - } -} - void Perl_qerror(pTHX_ SV *err) { @@ -1257,15 +1236,17 @@ Perl_qerror(pTHX_ SV *err) else if (PL_errors) sv_catsv(PL_errors, err); else - Perl_warn(aTHX_ "%_", err); + Perl_warn(aTHX_ "%"SVf, err); ++PL_error_count; } OP * Perl_die_where(pTHX_ char *message, STRLEN msglen) { - dSP; STRLEN n_a; + IO *io; + MAGIC *mg; + if (PL_in_eval) { I32 cxix; register PERL_CONTEXT *cx; @@ -1289,14 +1270,15 @@ Perl_die_where(pTHX_ char *message, STRLEN msglen) SvGROW(err, SvCUR(err)+sizeof(prefix)+msglen); sv_catpvn(err, prefix, sizeof(prefix)-1); sv_catpvn(err, message, msglen); - if (ckWARN(WARN_UNSAFE)) { + if (ckWARN(WARN_MISC)) { STRLEN start = SvCUR(err)-msglen-sizeof(prefix)+1; - Perl_warner(aTHX_ WARN_UNSAFE, SvPVX(err)+start); + Perl_warner(aTHX_ packWARN(WARN_MISC), SvPVX(err)+start); } } } - else + else { sv_setpvn(ERRSV, message, msglen); + } } else message = SvPVx(ERRSV, msglen); @@ -1328,6 +1310,12 @@ Perl_die_where(pTHX_ char *message, STRLEN msglen) LEAVE; + /* LEAVE could clobber PL_curcop (see save_re_context()) + * XXX it might be better to find a way to avoid messing with + * PL_curcop in save_re_context() instead, but this is a more + * minimal fix --GSAR */ + PL_curcop = cx->blk_oldcop; + if (optype == OP_REQUIRE) { char* msg = SvPVx(ERRSV, n_a); DIE(aTHX_ "%sCompilation failed in require", @@ -1338,14 +1326,26 @@ Perl_die_where(pTHX_ char *message, STRLEN msglen) } if (!message) message = SvPVx(ERRSV, msglen); - { + + /* if STDERR is tied, print to it instead */ + if (PL_stderrgv && (io = GvIOp(PL_stderrgv)) + && (mg = SvTIED_mg((SV*)io, PERL_MAGIC_tiedscalar))) { + dSP; ENTER; + PUSHMARK(SP); + XPUSHs(SvTIED_obj((SV*)io, mg)); + XPUSHs(sv_2mortal(newSVpvn(message, msglen))); + PUTBACK; + call_method("PRINT", G_SCALAR); + LEAVE; + } + else { #ifdef USE_SFIO /* SFIO can really mess with your errno */ int e = errno; #endif PerlIO *serr = Perl_error_log; - PerlIO_write(serr, message, msglen); + PERL_WRITE_MSG_TO_CONSOLE(serr, message, msglen); (void)PerlIO_flush(serr); #ifdef USE_SFIO errno = e; @@ -1358,7 +1358,7 @@ Perl_die_where(pTHX_ char *message, STRLEN msglen) PP(pp_xor) { - djSP; dPOPTOPssrl; + dSP; dPOPTOPssrl; if (SvTRUE(left) != SvTRUE(right)) RETSETYES; else @@ -1367,7 +1367,7 @@ PP(pp_xor) PP(pp_andassign) { - djSP; + dSP; if (!SvTRUE(TOPs)) RETURN; else @@ -1376,29 +1376,62 @@ PP(pp_andassign) PP(pp_orassign) { - djSP; + dSP; if (SvTRUE(TOPs)) RETURN; else RETURNOP(cLOGOP->op_other); } - + +PP(pp_dorassign) +{ + dSP; + register SV* sv; + + sv = TOPs; + if (!sv || !SvANY(sv)) { + RETURNOP(cLOGOP->op_other); + } + + switch (SvTYPE(sv)) { + case SVt_PVAV: + if (AvMAX(sv) >= 0 || SvGMAGICAL(sv) || (SvRMAGICAL(sv) && mg_find(sv, PERL_MAGIC_tied))) + RETURN; + break; + case SVt_PVHV: + if (HvARRAY(sv) || SvGMAGICAL(sv) || (SvRMAGICAL(sv) && mg_find(sv, PERL_MAGIC_tied))) + RETURN; + break; + case SVt_PVCV: + if (CvROOT(sv) || CvXSUB(sv)) + RETURN; + break; + default: + if (SvGMAGICAL(sv)) + mg_get(sv); + if (SvOK(sv)) + RETURN; + } + + RETURNOP(cLOGOP->op_other); +} + PP(pp_caller) { - djSP; + dSP; register I32 cxix = dopoptosub(cxstack_ix); register PERL_CONTEXT *cx; register PERL_CONTEXT *ccstack = cxstack; PERL_SI *top_si = PL_curstackinfo; I32 dbcxix; I32 gimme; - HV *hv; + char *stashname; SV *sv; I32 count = 0; if (MAXARG) count = POPi; - EXTEND(SP, 7); + for (;;) { /* we may be in a higher stacklevel, so dig down deeper */ while (cxix < 0 && top_si->si_type != PERLSI_MAIN) { @@ -1407,8 +1440,10 @@ PP(pp_caller) cxix = dopoptosub_at(ccstack, top_si->si_cxix); } if (cxix < 0) { - if (GIMME != G_ARRAY) + if (GIMME != G_ARRAY) { + EXTEND(SP, 1); RETPUSHUNDEF; + } RETURN; } if (PL_DBsub && cxix >= 0 && @@ -1420,7 +1455,7 @@ PP(pp_caller) } cx = &ccstack[cxix]; - if (CxTYPE(cx) == CXt_SUB) { + if (CxTYPE(cx) == CXt_SUB || CxTYPE(cx) == CXt_FORMAT) { dbcxix = dopoptosub_at(ccstack, cxix - 1); /* We expect that ccstack[dbcxix] is CXt_SUB, anyway, the field below is defined for any cx. */ @@ -1428,32 +1463,42 @@ PP(pp_caller) cx = &ccstack[dbcxix]; } + stashname = CopSTASHPV(cx->blk_oldcop); if (GIMME != G_ARRAY) { - hv = cx->blk_oldcop->cop_stash; - if (!hv) + EXTEND(SP, 1); + if (!stashname) PUSHs(&PL_sv_undef); else { dTARGET; - sv_setpv(TARG, HvNAME(hv)); + sv_setpv(TARG, stashname); PUSHs(TARG); } RETURN; } - hv = cx->blk_oldcop->cop_stash; - if (!hv) + EXTEND(SP, 10); + + if (!stashname) PUSHs(&PL_sv_undef); else - PUSHs(sv_2mortal(newSVpv(HvNAME(hv), 0))); - PUSHs(sv_2mortal(newSVsv(CopFILESV(cx->blk_oldcop)))); - PUSHs(sv_2mortal(newSViv((I32)cx->blk_oldcop->cop_line))); + PUSHs(sv_2mortal(newSVpv(stashname, 0))); + PUSHs(sv_2mortal(newSVpv(OutCopFILE(cx->blk_oldcop), 0))); + PUSHs(sv_2mortal(newSViv((I32)CopLINE(cx->blk_oldcop)))); if (!MAXARG) RETURN; - if (CxTYPE(cx) == CXt_SUB) { /* So is ccstack[dbcxix]. */ - sv = NEWSV(49, 0); - gv_efullname3(sv, CvGV(ccstack[cxix].blk_sub.cv), Nullch); - PUSHs(sv_2mortal(sv)); - PUSHs(sv_2mortal(newSViv((I32)cx->blk_sub.hasargs))); + if (CxTYPE(cx) == CXt_SUB || CxTYPE(cx) == CXt_FORMAT) { + GV *cvgv = CvGV(ccstack[cxix].blk_sub.cv); + /* So is ccstack[dbcxix]. */ + if (isGV(cvgv)) { + sv = NEWSV(49, 0); + gv_efullname3(sv, cvgv, Nullch); + PUSHs(sv_2mortal(sv)); + PUSHs(sv_2mortal(newSViv((I32)cx->blk_sub.hasargs))); + } + else { + PUSHs(sv_2mortal(newSVpvn("(unknown)",9))); + PUSHs(sv_2mortal(newSViv((I32)cx->blk_sub.hasargs))); + } } else { PUSHs(sv_2mortal(newSVpvn("(eval)",6))); @@ -1465,22 +1510,28 @@ PP(pp_caller) else PUSHs(sv_2mortal(newSViv(gimme & G_ARRAY))); if (CxTYPE(cx) == CXt_EVAL) { + /* eval STRING */ if (cx->blk_eval.old_op_type == OP_ENTEREVAL) { PUSHs(cx->blk_eval.cur_text); PUSHs(&PL_sv_no); - } - else if (cx->blk_eval.old_name) { /* Try blocks have old_name == 0. */ - /* Require, put the name. */ - PUSHs(sv_2mortal(newSVpv(cx->blk_eval.old_name, 0))); + } + /* require */ + else if (cx->blk_eval.old_namesv) { + PUSHs(sv_2mortal(newSVsv(cx->blk_eval.old_namesv))); PUSHs(&PL_sv_yes); } + /* eval BLOCK (try blocks have old_namesv == 0) */ + else { + PUSHs(&PL_sv_undef); + PUSHs(&PL_sv_undef); + } } else { PUSHs(&PL_sv_undef); PUSHs(&PL_sv_undef); } if (CxTYPE(cx) == CXt_SUB && cx->blk_sub.hasargs - && PL_curcop->cop_stash == PL_debstash) + && CopSTASH_eq(PL_curcop, PL_debstash)) { AV *ary = cx->blk_sub.argarray; int off = AvARRAY(ary) - AvALLOC(ary); @@ -1490,7 +1541,7 @@ PP(pp_caller) PL_dbargs = GvAV(gv_AVadd(tmpgv = gv_fetchpv("DB::args", TRUE, SVt_PVAV))); GvMULTI_on(tmpgv); - AvREAL_off(PL_dbargs); /* XXX Should be REIFY */ + AvREAL_off(PL_dbargs); /* XXX should be REIFY (see av.h) */ } if (AvMAX(PL_dbargs) < AvFILLp(ary) + off) @@ -1503,12 +1554,26 @@ PP(pp_caller) * use the global PL_hints) */ PUSHs(sv_2mortal(newSViv((I32)cx->blk_oldcop->op_private & HINT_PRIVATE_MASK))); + { + SV * mask ; + SV * old_warnings = cx->blk_oldcop->cop_warnings ; + + if (old_warnings == pWARN_NONE || + (old_warnings == pWARN_STD && (PL_dowarn & G_WARN_ON) == 0)) + mask = newSVpvn(WARN_NONEstring, WARNsize) ; + else if (old_warnings == pWARN_ALL || + (old_warnings == pWARN_STD && PL_dowarn & G_WARN_ON)) + mask = newSVpvn(WARN_ALLstring, WARNsize) ; + else + mask = newSVsv(old_warnings); + PUSHs(sv_2mortal(mask)); + } RETURN; } PP(pp_reset) { - djSP; + dSP; char *tmps; STRLEN n_a; @@ -1516,7 +1581,7 @@ PP(pp_reset) tmps = ""; else tmps = POPpx; - sv_reset(tmps, PL_curcop->cop_stash); + sv_reset(tmps, CopSTASH(PL_curcop)); PUSHs(&PL_sv_yes); RETURN; } @@ -1526,6 +1591,8 @@ PP(pp_lineseq) return NORMAL; } +/* like pp_nextstate, but used instead when the debugger is active */ + PP(pp_dbstate) { PL_curcop = (COP*)PL_op; @@ -1535,11 +1602,11 @@ PP(pp_dbstate) if (PL_op->op_private || SvIV(PL_DBsingle) || SvIV(PL_DBsignal) || SvIV(PL_DBtrace)) { - djSP; + dSP; register CV *cv; register PERL_CONTEXT *cx; I32 gimme = G_ARRAY; - I32 hasargs; + U8 hasargs; GV *gv; gv = PL_DBgv; @@ -1547,7 +1614,8 @@ PP(pp_dbstate) if (!cv) DIE(aTHX_ "No DB::DB routine defined"); - if (CvDEPTH(cv) >= 1 && !(PL_debug & (1<<30))) /* don't do recursive DB::DB call */ + if (CvDEPTH(cv) >= 1 && !(PL_debug & DEBUG_DB_RECURSE_FLAG)) + /* don't do recursive DB::DB call */ return NORMAL; ENTER; @@ -1564,8 +1632,7 @@ PP(pp_dbstate) PUSHSUB(cx); CvDEPTH(cv)++; (void)SvREFCNT_inc(cv); - SAVESPTR(PL_curpad); - PL_curpad = AvARRAY((AV*)*av_fetch(CvPADLIST(cv),1,FALSE)); + PAD_SET_CUR(CvPADLIST(cv),1); RETURNOP(CvSTART(cv)); } else @@ -1579,43 +1646,56 @@ PP(pp_scope) PP(pp_enteriter) { - djSP; dMARK; + dSP; dMARK; register PERL_CONTEXT *cx; I32 gimme = GIMME_V; SV **svp; + U32 cxtype = CXt_LOOP; +#ifdef USE_ITHREADS + void *iterdata; +#endif ENTER; SAVETMPS; -#ifdef USE_THREADS - if (PL_op->op_flags & OPf_SPECIAL) { - dTHR; - svp = &THREADSV(PL_op->op_targ); /* per-thread variable */ - SAVEGENERICSV(*svp); - *svp = NEWSV(0,0); - } - else -#endif /* USE_THREADS */ if (PL_op->op_targ) { - svp = &PL_curpad[PL_op->op_targ]; /* "my" variable */ +#ifndef USE_ITHREADS + svp = &PAD_SVl(PL_op->op_targ); /* "my" variable */ SAVESPTR(*svp); +#else + SAVEPADSV(PL_op->op_targ); + iterdata = INT2PTR(void*, PL_op->op_targ); + cxtype |= CXp_PADVAR; +#endif } else { - svp = &GvSV((GV*)POPs); /* symbol table variable */ + GV *gv = (GV*)POPs; + svp = &GvSV(gv); /* symbol table variable */ SAVEGENERICSV(*svp); *svp = NEWSV(0,0); +#ifdef USE_ITHREADS + iterdata = (void*)gv; +#endif } ENTER; - PUSHBLOCK(cx, CXt_LOOP, SP); + PUSHBLOCK(cx, cxtype, SP); +#ifdef USE_ITHREADS + PUSHLOOP(cx, iterdata, MARK); +#else PUSHLOOP(cx, svp, MARK); +#endif if (PL_op->op_flags & OPf_STACKED) { cx->blk_loop.iterary = (AV*)SvREFCNT_inc(POPs); if (SvTYPE(cx->blk_loop.iterary) != SVt_PVAV) { dPOPss; if (SvNIOKp(sv) || !SvPOKp(sv) || - (looks_like_number(sv) && *SvPVX(sv) != '0')) { + SvNIOKp(cx->blk_loop.iterary) || !SvPOKp(cx->blk_loop.iterary) || + (looks_like_number(sv) && *SvPVX(sv) != '0' && + looks_like_number((SV*)cx->blk_loop.iterary) && + *SvPVX(cx->blk_loop.iterary) != '0')) + { if (SvNV(sv) < IV_MIN || SvNV((SV*)cx->blk_loop.iterary) >= IV_MAX) DIE(aTHX_ "Range iterator outside integer range"); @@ -1637,7 +1717,7 @@ PP(pp_enteriter) PP(pp_enterloop) { - djSP; + dSP; register PERL_CONTEXT *cx; I32 gimme = GIMME_V; @@ -1653,7 +1733,7 @@ PP(pp_enterloop) PP(pp_leaveloop) { - djSP; + dSP; register PERL_CONTEXT *cx; I32 gimme; SV **newsp; @@ -1693,10 +1773,11 @@ PP(pp_leaveloop) PP(pp_return) { - djSP; dMARK; + dSP; dMARK; I32 cxix; register PERL_CONTEXT *cx; bool popsub2 = FALSE; + bool clear_errsv = FALSE; I32 gimme; SV **newsp; PMOP *newpm; @@ -1704,7 +1785,9 @@ PP(pp_return) SV *sv; if (PL_curstackinfo->si_type == PERLSI_SORT) { - if (cxstack_ix == PL_sortcxix || dopoptosub(cxstack_ix) <= PL_sortcxix) { + if (cxstack_ix == PL_sortcxix + || dopoptosub(cxstack_ix) <= PL_sortcxix) + { if (cxstack_ix > PL_sortcxix) dounwind(PL_sortcxix); AvARRAY(PL_curstack)[1] = *SP; @@ -1725,19 +1808,24 @@ PP(pp_return) popsub2 = TRUE; break; case CXt_EVAL: + if (!(PL_in_eval & EVAL_KEEPERR)) + clear_errsv = TRUE; POPEVAL(cx); - if (AvFILLp(PL_comppad_name) >= 0) - free_closures(); + if (CxTRYBLOCK(cx)) + break; lex_end(); if (optype == OP_REQUIRE && (MARK == SP || (gimme == G_SCALAR && !SvTRUE(*SP))) ) { /* Unassume the success we assumed earlier. */ - char *name = cx->blk_eval.old_name; - (void)hv_delete(GvHVn(PL_incgv), name, strlen(name), G_DISCARD); - DIE(aTHX_ "%s did not return a true value", name); + SV *nsv = cx->blk_eval.old_namesv; + (void)hv_delete(GvHVn(PL_incgv), SvPVX(nsv), SvCUR(nsv), G_DISCARD); + DIE(aTHX_ "%s did not return a true value", SvPVX(nsv)); } break; + case CXt_FORMAT: + POPFORMAT(cx); + break; default: DIE(aTHX_ "panic: return"); } @@ -1751,15 +1839,21 @@ PP(pp_return) *++newsp = SvREFCNT_inc(*SP); FREETMPS; sv_2mortal(*newsp); - } else { + } + else { + sv = SvREFCNT_inc(*SP); /* FREETMPS could clobber it */ FREETMPS; - *++newsp = sv_mortalcopy(*SP); + *++newsp = sv_mortalcopy(sv); + SvREFCNT_dec(sv); } - } else + } + else *++newsp = (SvTEMP(*SP)) ? *SP : sv_mortalcopy(*SP); - } else + } + else *++newsp = sv_mortalcopy(*SP); - } else + } + else *++newsp = &PL_sv_undef; } else if (gimme == G_ARRAY) { @@ -1781,12 +1875,14 @@ PP(pp_return) LEAVE; LEAVESUB(sv); + if (clear_errsv) + sv_setpv(ERRSV,""); return pop_return(); } PP(pp_last) { - djSP; + dSP; I32 cxix; register PERL_CONTEXT *cx; I32 pop2 = 0; @@ -1801,7 +1897,7 @@ PP(pp_last) if (PL_op->op_flags & OPf_SPECIAL) { cxix = dopoptoloop(cxstack_ix); if (cxix < 0) - DIE(aTHX_ "Can't \"last\" outside a block"); + DIE(aTHX_ "Can't \"last\" outside a loop block"); } else { cxix = dopoptolabel(cPVOP->op_pv); @@ -1827,6 +1923,10 @@ PP(pp_last) POPEVAL(cx); nextop = pop_return(); break; + case CXt_FORMAT: + POPFORMAT(cx); + nextop = pop_return(); + break; default: DIE(aTHX_ "panic: last"); } @@ -1870,12 +1970,12 @@ PP(pp_next) { I32 cxix; register PERL_CONTEXT *cx; - I32 oldsave; + I32 inner; if (PL_op->op_flags & OPf_SPECIAL) { cxix = dopoptoloop(cxstack_ix); if (cxix < 0) - DIE(aTHX_ "Can't \"next\" outside a block"); + DIE(aTHX_ "Can't \"next\" outside a loop block"); } else { cxix = dopoptolabel(cPVOP->op_pv); @@ -1885,9 +1985,12 @@ PP(pp_next) if (cxix < cxstack_ix) dounwind(cxix); + /* clear off anything above the scope we're re-entering, but + * save the rest until after a possible continue block */ + inner = PL_scopestack_ix; TOPBLOCK(cx); - oldsave = PL_scopestack[PL_scopestack_ix - 1]; - LEAVE_SCOPE(oldsave); + if (PL_scopestack_ix < inner) + leave_scope(PL_scopestack[PL_scopestack_ix]); return cx->blk_loop.next_op; } @@ -1900,7 +2003,7 @@ PP(pp_redo) if (PL_op->op_flags & OPf_SPECIAL) { cxix = dopoptoloop(cxstack_ix); if (cxix < 0) - DIE(aTHX_ "Can't \"redo\" outside a block"); + DIE(aTHX_ "Can't \"redo\" outside a loop block"); } else { cxix = dopoptolabel(cPVOP->op_pv); @@ -1919,7 +2022,7 @@ PP(pp_redo) STATIC OP * S_dofindlabel(pTHX_ OP *o, char *label, OP **opstack, OP **oplimit) { - OP *kid; + OP *kid = Nullop; OP **ops = opstack; static char too_deep[] = "Target of goto is too deeply nested"; @@ -1936,7 +2039,6 @@ S_dofindlabel(pTHX_ OP *o, char *label, OP **opstack, OP **oplimit) } *ops = 0; if (o->op_flags & OPf_KIDS) { - dTHR; /* First try all the kids at this level, since that's likeliest. */ for (kid = cUNOPo->op_first; kid; kid = kid->op_sibling) { if ((kid->op_type == OP_NEXTSTATE || kid->op_type == OP_DBSTATE) && @@ -1951,7 +2053,7 @@ S_dofindlabel(pTHX_ OP *o, char *label, OP **opstack, OP **oplimit) (ops[-1]->op_type != OP_NEXTSTATE && ops[-1]->op_type != OP_DBSTATE))) *ops++ = kid; - if (o = dofindlabel(kid, label, ops, oplimit)) + if ((o = dofindlabel(kid, label, ops, oplimit))) return o; } } @@ -1967,7 +2069,7 @@ PP(pp_dump) PP(pp_goto) { - djSP; + dSP; OP *retop = 0; I32 ix; register PERL_CONTEXT *cx; @@ -2018,7 +2120,7 @@ PP(pp_goto) if (cxix < cxstack_ix) dounwind(cxix); TOPBLOCK(cx); - if (CxTYPE(cx) == CXt_EVAL && cx->blk_eval.old_op_type == OP_ENTEREVAL) + if (CxREALEVAL(cx)) DIE(aTHX_ "Can't goto subroutine from an eval-string"); mark = PL_stack_sp; if (CxTYPE(cx) == CXt_SUB && cx->blk_sub.hasargs) { @@ -2030,27 +2132,20 @@ PP(pp_goto) EXTEND(PL_stack_sp, items); /* @_ could have been extended. */ Copy(AvARRAY(av), PL_stack_sp, items, SV*); PL_stack_sp += items; -#ifndef USE_THREADS SvREFCNT_dec(GvAV(PL_defgv)); GvAV(PL_defgv) = cx->blk_sub.savearray; -#endif /* USE_THREADS */ /* abandon @_ if it got reified */ if (AvREAL(av)) { (void)sv_2mortal((SV*)av); /* delay until return */ av = newAV(); av_extend(av, items-1); AvFLAGS(av) = AVf_REIFY; - PL_curpad[0] = (SV*)(cx->blk_sub.argarray = av); + PAD_SVl(0) = (SV*)(cx->blk_sub.argarray = av); } } else if (CvXSUB(cv)) { /* put GvAV(defgv) back onto stack */ AV* av; - int i; -#ifdef USE_THREADS - av = (AV*)PL_curpad[0]; -#else av = GvAV(PL_defgv); -#endif items = AvFILLp(av) + 1; PL_stack_sp++; EXTEND(PL_stack_sp, items); /* @_ could have been extended. */ @@ -2073,7 +2168,7 @@ PP(pp_goto) SP[1] = SP[0]; SP--; } - fp3 = (I32(*)(int,int,int)))CvXSUB(cv; + fp3 = (I32(*)(int,int,int))CvXSUB(cv); items = (*fp3)(CvXSUBANY(cv).any_i32, mark - PL_stack_base + 1, items); @@ -2087,8 +2182,8 @@ PP(pp_goto) PL_stack_sp--; /* There is no cv arg. */ /* Push a mark for the start of arglist */ - PUSHMARK(mark); - (void)(*CvXSUB(cv))(aTHXo_ cv); + PUSHMARK(mark); + (void)(*CvXSUB(cv))(aTHX_ cv); /* Pop the current context like a decent sub should */ POPBLOCK(cx, PL_curpm); /* Do _not_ use PUTBACK, keep the XSUB's return stack! */ @@ -2098,7 +2193,6 @@ PP(pp_goto) } else { AV* padlist = CvPADLIST(cv); - SV** svp = AvARRAY(padlist); if (CxTYPE(cx) == CXt_EVAL) { PL_in_eval = cx->blk_eval.old_in_eval; PL_eval_root = cx->blk_eval.old_eval_root; @@ -2106,81 +2200,25 @@ PP(pp_goto) cx->blk_sub.hasargs = 0; } cx->blk_sub.cv = cv; - cx->blk_sub.olddepth = CvDEPTH(cv); + cx->blk_sub.olddepth = (U16)CvDEPTH(cv); + CvDEPTH(cv)++; if (CvDEPTH(cv) < 2) (void)SvREFCNT_inc(cv); - else { /* save temporaries on recursion? */ + else { if (CvDEPTH(cv) == 100 && ckWARN(WARN_RECURSION)) sub_crush_depth(cv); - if (CvDEPTH(cv) > AvFILLp(padlist)) { - AV *newpad = newAV(); - SV **oldpad = AvARRAY(svp[CvDEPTH(cv)-1]); - I32 ix = AvFILLp((AV*)svp[1]); - svp = AvARRAY(svp[0]); - for ( ;ix > 0; ix--) { - if (svp[ix] != &PL_sv_undef) { - char *name = SvPVX(svp[ix]); - if ((SvFLAGS(svp[ix]) & SVf_FAKE) - || *name == '&') - { - /* outer lexical or anon code */ - av_store(newpad, ix, - SvREFCNT_inc(oldpad[ix]) ); - } - else { /* our own lexical */ - if (*name == '@') - av_store(newpad, ix, sv = (SV*)newAV()); - else if (*name == '%') - av_store(newpad, ix, sv = (SV*)newHV()); - else - av_store(newpad, ix, sv = NEWSV(0,0)); - SvPADMY_on(sv); - } - } - else { - av_store(newpad, ix, sv = NEWSV(0,0)); - SvPADTMP_on(sv); - } - } - if (cx->blk_sub.hasargs) { - AV* av = newAV(); - av_extend(av, 0); - av_store(newpad, 0, (SV*)av); - AvFLAGS(av) = AVf_REIFY; - } - av_store(padlist, CvDEPTH(cv), (SV*)newpad); - AvFILLp(padlist) = CvDEPTH(cv); - svp = AvARRAY(padlist); - } - } -#ifdef USE_THREADS - if (!cx->blk_sub.hasargs) { - AV* av = (AV*)PL_curpad[0]; - - items = AvFILLp(av) + 1; - if (items) { - /* Mark is at the end of the stack. */ - EXTEND(SP, items); - Copy(AvARRAY(av), SP + 1, items, SV*); - SP += items; - PUTBACK ; - } + pad_push(padlist, CvDEPTH(cv), cx->blk_sub.hasargs); } -#endif /* USE_THREADS */ - SAVESPTR(PL_curpad); - PL_curpad = AvARRAY((AV*)svp[CvDEPTH(cv)]); -#ifndef USE_THREADS + PAD_SET_CUR(padlist, CvDEPTH(cv)); if (cx->blk_sub.hasargs) -#endif /* USE_THREADS */ { - AV* av = (AV*)PL_curpad[0]; + AV* av = (AV*)PAD_SVl(0); SV** ary; -#ifndef USE_THREADS cx->blk_sub.savearray = GvAV(PL_defgv); GvAV(PL_defgv) = (AV*)SvREFCNT_inc(av); -#endif /* USE_THREADS */ + CX_CURPAD_SAVE(cx->blk_sub); cx->blk_sub.argarray = av; ++mark; @@ -2213,7 +2251,7 @@ PP(pp_goto) */ SV *sv = GvSV(PL_DBsub); CV *gotocv; - + if (PERLDB_SUB_NN) { SvIVX(sv) = PTR2IV(cv); /* Already upgraded, saved */ } else { @@ -2245,6 +2283,8 @@ PP(pp_goto) if (label && *label) { OP *gotoprobe = 0; + bool leaving_eval = FALSE; + PERL_CONTEXT *last_eval_cx = 0; /* find label */ @@ -2254,8 +2294,15 @@ PP(pp_goto) cx = &cxstack[ix]; switch (CxTYPE(cx)) { case CXt_EVAL: - gotoprobe = PL_eval_root; /* XXX not good for nested eval */ - break; + leaving_eval = TRUE; + if (CxREALEVAL(cx)) { + gotoprobe = (last_eval_cx ? + last_eval_cx->blk_eval.old_eval_root : + PL_eval_root); + last_eval_cx = cx; + break; + } + /* else fall through */ case CXt_LOOP: gotoprobe = cx->blk_oldcop->op_sibling; break; @@ -2273,23 +2320,37 @@ PP(pp_goto) break; } /* FALL THROUGH */ + case CXt_FORMAT: case CXt_NULL: - DIE(aTHX_ "Can't \"goto\" outside a block"); + DIE(aTHX_ "Can't \"goto\" out of a pseudo block"); default: if (ix) DIE(aTHX_ "panic: goto"); gotoprobe = PL_main_root; break; } - retop = dofindlabel(gotoprobe, label, - enterops, enterops + GOTO_DEPTH); - if (retop) - break; + if (gotoprobe) { + retop = dofindlabel(gotoprobe, label, + enterops, enterops + GOTO_DEPTH); + if (retop) + break; + } PL_lastgotoprobe = gotoprobe; } if (!retop) DIE(aTHX_ "Can't find label %s", label); + /* if we're leaving an eval, check before we pop any frames + that we're not going to punt, otherwise the error + won't be caught */ + + if (leaving_eval && *enterops && enterops[1]) { + I32 i; + for (i = 1; enterops[i]; i++) + if (enterops[i]->op_type == OP_ENTERITER) + DIE(aTHX_ "Can't \"goto\" into the middle of a foreach loop"); + } + /* pop unwanted frames */ if (ix < cxstack_ix) { @@ -2312,8 +2373,7 @@ PP(pp_goto) /* Eventually we may want to stack the needed arguments * for each op. For now, we punt on the hard ones. */ if (PL_op->op_type == OP_ENTERITER) - DIE(aTHX_ "Can't \"goto\" into the middle of a foreach loop", - label); + DIE(aTHX_ "Can't \"goto\" into the middle of a foreach loop"); CALL_FPTR(PL_op->op_ppaddr)(aTHX); } PL_op = oldop; @@ -2338,18 +2398,20 @@ PP(pp_goto) PP(pp_exit) { - djSP; + dSP; I32 anum; if (MAXARG < 1) anum = 0; else { anum = SvIVx(POPs); -#ifdef VMSISH_EXIT - if (anum == 1 && VMSISH_EXIT) +#ifdef VMS + if (anum == 1 && (PL_op->op_private & OPpEXIT_VMSISH)) anum = 0; + VMSISH_HUSHED = VMSISH_HUSHED || (PL_op->op_private & OPpHUSH_VMSISH); #endif } + PL_exit_flags |= PERL_EXIT_EXPECTED; my_exit(anum); PUSHs(&PL_sv_undef); RETURN; @@ -2358,7 +2420,7 @@ PP(pp_exit) #ifdef NOTYET PP(pp_nswitch) { - djSP; + dSP; NV value = SvNVx(GvSV(cCOP->cop_gv)); register I32 match = I_32(value); @@ -2377,7 +2439,7 @@ PP(pp_nswitch) PP(pp_cswitch) { - djSP; + dSP; register I32 match; if (PL_multiline) @@ -2422,9 +2484,17 @@ S_save_lines(pTHX_ AV *array, SV *sv) } } +#ifdef PERL_FLEXIBLE_EXCEPTIONS STATIC void * S_docatch_body(pTHX_ va_list args) { + return docatch_body(); +} +#endif + +STATIC void * +S_docatch_body(pTHX) +{ CALLRUNOPS(aTHX); return NULL; } @@ -2432,9 +2502,9 @@ S_docatch_body(pTHX_ va_list args) STATIC OP * S_docatch(pTHX_ OP *o) { - dTHR; int ret; OP *oldop = PL_op; + OP *retop; volatile PERL_SI *cursi = PL_curstackinfo; dJMPENV; @@ -2442,29 +2512,52 @@ S_docatch(pTHX_ OP *o) assert(CATCH_GET == TRUE); #endif PL_op = o; + + /* Normally, the leavetry at the end of this block of ops will + * pop an op off the return stack and continue there. By setting + * the op to Nullop, we force an exit from the inner runops() + * loop. DAPM. + */ + retop = pop_return(); + push_return(Nullop); + +#ifdef PERL_FLEXIBLE_EXCEPTIONS redo_body: CALLPROTECT(aTHX_ pcur_env, &ret, MEMBER_TO_FPTR(S_docatch_body)); +#else + JMPENV_PUSH(ret); +#endif switch (ret) { case 0: +#ifndef PERL_FLEXIBLE_EXCEPTIONS + redo_body: + docatch_body(); +#endif break; case 3: + /* die caught by an inner eval - continue inner loop */ if (PL_restartop && cursi == PL_curstackinfo) { PL_op = PL_restartop; PL_restartop = 0; goto redo_body; } + /* a die in this eval - continue in outer loop */ + if (!PL_restartop) + break; /* FALL THROUGH */ default: + JMPENV_POP; PL_op = oldop; JMPENV_JUMP(ret); /* NOTREACHED */ } + JMPENV_POP; PL_op = oldop; - return Nullop; + return retop; } OP * -Perl_sv_compile_2op(pTHX_ SV *sv, OP** startop, char *code, AV** avp) +Perl_sv_compile_2op(pTHX_ SV *sv, OP** startop, char *code, PAD** padp) /* sv Text to convert to OP tree. */ /* startop op_free() this to undo. */ /* code Short string id of the caller. */ @@ -2475,9 +2568,12 @@ Perl_sv_compile_2op(pTHX_ SV *sv, OP** startop, char *code, AV** avp) I32 gimme = 0; /* SUSPECT - INITIALZE TO WHAT? NI-S */ I32 optype; OP dummy; - OP *oop = PL_op, *rop; - char tmpbuf[TYPE_DIGITS(long) + 12 + 10]; + OP *rop; + char tbuf[TYPE_DIGITS(long) + 12 + 10]; + char *tmpbuf = tbuf; char *safestr; + int runtime; + CV* runcv; ENTER; lex_start(sv); @@ -2485,14 +2581,22 @@ Perl_sv_compile_2op(pTHX_ SV *sv, OP** startop, char *code, AV** avp) /* switch to eval mode */ if (PL_curcop == &PL_compiling) { - SAVESPTR(PL_compiling.cop_stash); - PL_compiling.cop_stash = PL_curstash; + SAVECOPSTASH_FREE(&PL_compiling); + CopSTASH_set(&PL_compiling, PL_curstash); + } + if (PERLDB_NAMEEVAL && CopLINE(PL_curcop)) { + SV *sv = sv_newmortal(); + Perl_sv_setpvf(aTHX_ sv, "_<(%.10seval %lu)[%s:%"IVdf"]", + code, (unsigned long)++PL_evalseq, + CopFILE(PL_curcop), (IV)CopLINE(PL_curcop)); + tmpbuf = SvPVX(sv); } - SAVESPTR(CopFILEGV(&PL_compiling)); - SAVEI16(PL_compiling.cop_line); - sprintf(tmpbuf, "_<(%.10s_eval %lu)", code, (unsigned long)++PL_evalseq); - CopFILEGV_set(&PL_compiling, gv_fetchfile(tmpbuf+2)); - PL_compiling.cop_line = 1; + else + sprintf(tmpbuf, "_<(%.10s_eval %lu)", code, (unsigned long)++PL_evalseq); + SAVECOPFILE_FREE(&PL_compiling); + CopFILE_set(&PL_compiling, tmpbuf+2); + SAVECOPLINE(&PL_compiling); + CopLINE_set(&PL_compiling, 1); /* XXX For Cs within BEGIN {} blocks, this ends up deleting the eval's FILEGV from the stash before gv_check() runs (i.e. before run-time proper). To work around the coredump that @@ -2504,112 +2608,117 @@ Perl_sv_compile_2op(pTHX_ SV *sv, OP** startop, char *code, AV** avp) #ifdef OP_IN_REGISTER PL_opsave = op; #else - SAVEPPTR(PL_op); + SAVEVPTR(PL_op); #endif - PL_hints = 0; + PL_hints &= HINT_UTF8; + + /* we get here either during compilation, or via pp_regcomp at runtime */ + runtime = PL_op && (PL_op->op_type == OP_REGCOMP); + if (runtime) + runcv = find_runcv(); PL_op = &dummy; PL_op->op_type = OP_ENTEREVAL; PL_op->op_flags = 0; /* Avoid uninit warning. */ - PUSHBLOCK(cx, CXt_EVAL, SP); + PUSHBLOCK(cx, CXt_EVAL|(PL_curcop == &PL_compiling ? 0 : CXp_REAL), SP); PUSHEVAL(cx, 0, Nullgv); - rop = doeval(G_SCALAR, startop); + + if (runtime) + rop = doeval(G_SCALAR, startop, runcv, PL_curcop->cop_seq); + else + rop = doeval(G_SCALAR, startop, PL_compcv, PL_cop_seqmax); POPBLOCK(cx,PL_curpm); POPEVAL(cx); (*startop)->op_type = OP_NULL; (*startop)->op_ppaddr = PL_ppaddr[OP_NULL]; lex_end(); - *avp = (AV*)SvREFCNT_inc(PL_comppad); + /* XXX DAPM do this properly one year */ + *padp = (AV*)SvREFCNT_inc(PL_comppad); LEAVE; if (PL_curcop == &PL_compiling) - PL_compiling.op_private = PL_hints; + PL_compiling.op_private = (U8)(PL_hints & HINT_PRIVATE_MASK); #ifdef OP_IN_REGISTER op = PL_opsave; #endif return rop; } -/* With USE_THREADS, eval_owner must be held on entry to doeval */ + +/* +=for apidoc find_runcv + +Locate the CV corresponding to the currently executing sub or eval. + +=cut +*/ + +CV* +Perl_find_runcv(pTHX) +{ + I32 ix; + PERL_SI *si; + PERL_CONTEXT *cx; + + for (si = PL_curstackinfo; si; si = si->si_prev) { + for (ix = si->si_cxix; ix >= 0; ix--) { + cx = &(si->si_cxstack[ix]); + if (CxTYPE(cx) == CXt_SUB || CxTYPE(cx) == CXt_FORMAT) + return cx->blk_sub.cv; + else if (CxTYPE(cx) == CXt_EVAL && !CxTRYBLOCK(cx)) + return PL_compcv; + } + } + return PL_main_cv; +} + + +/* Compile a require/do, an eval '', or a /(?{...})/. + * In the last case, startop is non-null, and contains the address of + * a pointer that should be set to the just-compiled code. + * outside is the lexically enclosing CV (if any) that invoked us. + */ + +/* With USE_5005THREADS, eval_owner must be held on entry to doeval */ STATIC OP * -S_doeval(pTHX_ int gimme, OP** startop) +S_doeval(pTHX_ int gimme, OP** startop, CV* outside, U32 seq) { dSP; OP *saveop = PL_op; - HV *newstash; - CV *caller; - AV* comppadlist; - I32 i; - PL_in_eval = EVAL_INEVAL; + PL_in_eval = ((saveop && saveop->op_type == OP_REQUIRE) + ? (EVAL_INREQUIRE | (PL_in_eval & EVAL_INEVAL)) + : EVAL_INEVAL); PUSHMARK(SP); - /* set up a scratch pad */ - - SAVEI32(PL_padix); - SAVESPTR(PL_curpad); - SAVESPTR(PL_comppad); - SAVESPTR(PL_comppad_name); - SAVEI32(PL_comppad_name_fill); - SAVEI32(PL_min_intro_pending); - SAVEI32(PL_max_intro_pending); - - caller = PL_compcv; - for (i = cxstack_ix - 1; i >= 0; i--) { - PERL_CONTEXT *cx = &cxstack[i]; - if (CxTYPE(cx) == CXt_EVAL) - break; - else if (CxTYPE(cx) == CXt_SUB) { - caller = cx->blk_sub.cv; - break; - } - } - SAVESPTR(PL_compcv); PL_compcv = (CV*)NEWSV(1104,0); sv_upgrade((SV *)PL_compcv, SVt_PVCV); CvEVAL_on(PL_compcv); -#ifdef USE_THREADS - CvOWNER(PL_compcv) = 0; - New(666, CvMUTEXP(PL_compcv), 1, perl_mutex); - MUTEX_INIT(CvMUTEXP(PL_compcv)); -#endif /* USE_THREADS */ - - PL_comppad = newAV(); - av_push(PL_comppad, Nullsv); - PL_curpad = AvARRAY(PL_comppad); - PL_comppad_name = newAV(); - PL_comppad_name_fill = 0; - PL_min_intro_pending = 0; - PL_padix = 0; -#ifdef USE_THREADS - av_store(PL_comppad_name, 0, newSVpvn("@_", 2)); - PL_curpad[0] = (SV*)newAV(); - SvPADMY_on(PL_curpad[0]); /* XXX Needed? */ -#endif /* USE_THREADS */ - - comppadlist = newAV(); - AvREAL_off(comppadlist); - av_store(comppadlist, 0, (SV*)PL_comppad_name); - av_store(comppadlist, 1, (SV*)PL_comppad); - CvPADLIST(PL_compcv) = comppadlist; - - if (!saveop || saveop->op_type != OP_REQUIRE) - CvOUTSIDE(PL_compcv) = (CV*)SvREFCNT_inc(caller); - - SAVEFREESV(PL_compcv); + assert(CxTYPE(&cxstack[cxstack_ix]) == CXt_EVAL); + cxstack[cxstack_ix].blk_eval.cv = PL_compcv; + + CvOUTSIDE_SEQ(PL_compcv) = seq; + CvOUTSIDE(PL_compcv) = outside ? (CV*)SvREFCNT_inc(outside) : outside; + + /* set up a scratch pad */ + + CvPADLIST(PL_compcv) = pad_new(padnew_SAVE); + + + SAVEMORTALIZESV(PL_compcv); /* must remain until end of current statement */ /* make sure we compile in the right package */ - newstash = PL_curcop->cop_stash; - if (PL_curstash != newstash) { + if (CopSTASH_ne(PL_curcop, PL_curstash)) { SAVESPTR(PL_curstash); - PL_curstash = newstash; + PL_curstash = CopSTASH(PL_curcop); } SAVESPTR(PL_beginav); PL_beginav = newAV(); SAVEFREESV(PL_beginav); + SAVEI32(PL_error_count); /* try to compile it */ @@ -2617,8 +2726,6 @@ S_doeval(pTHX_ int gimme, OP** startop) PL_error_count = 0; PL_curcop = &PL_compiling; PL_curcop->cop_arybase = 0; - SvREFCNT_dec(PL_rs); - PL_rs = newSVpvn("\n", 1); if (saveop && saveop->op_flags & OPf_SPECIAL) PL_in_eval |= EVAL_KEEPERR; else @@ -2656,23 +2763,17 @@ S_doeval(pTHX_ int gimme, OP** startop) Perl_croak(aTHX_ "%sCompilation failed in regexp", (*msg ? msg : "Unknown error\n")); } - SvREFCNT_dec(PL_rs); - PL_rs = SvREFCNT_inc(PL_nrs); -#ifdef USE_THREADS - MUTEX_LOCK(&PL_eval_mutex); - PL_eval_owner = 0; - COND_SIGNAL(&PL_eval_cond); - MUTEX_UNLOCK(&PL_eval_mutex); -#endif /* USE_THREADS */ + else { + char* msg = SvPVx(ERRSV, n_a); + if (!*msg) { + sv_setpv(ERRSV, "Compilation error"); + } + } RETPUSHUNDEF; } - SvREFCNT_dec(PL_rs); - PL_rs = SvREFCNT_inc(PL_nrs); - PL_compiling.cop_line = 0; + CopLINE_set(&PL_compiling, 0); if (startop) { *startop = PL_eval_root; - SvREFCNT_dec(CvOUTSIDE(PL_compcv)); - CvOUTSIDE(PL_compcv) = Nullcv; } else SAVEFREEOP(PL_eval_root); if (gimme & G_VOID) @@ -2701,12 +2802,7 @@ S_doeval(pTHX_ int gimme, OP** startop) CvDEPTH(PL_compcv) = 1; SP = PL_stack_base + POPMARK; /* pop original mark */ PL_op = saveop; /* The caller may need it. */ -#ifdef USE_THREADS - MUTEX_LOCK(&PL_eval_mutex); - PL_eval_owner = 0; - COND_SIGNAL(&PL_eval_cond); - MUTEX_UNLOCK(&PL_eval_mutex); -#endif /* USE_THREADS */ + PL_lex_state = LEX_NOTPARSING; /* $^S needs this. */ RETURNOP(PL_eval_start); } @@ -2745,28 +2841,86 @@ S_doopen_pmc(pTHX_ const char *name, const char *mode) PP(pp_require) { - djSP; + dSP; register PERL_CONTEXT *cx; SV *sv; char *name; STRLEN len; - char *tryname; + char *tryname = Nullch; SV *namesv = Nullsv; SV** svp; - I32 gimme = G_SCALAR; + I32 gimme = GIMME_V; PerlIO *tryrsfp = 0; STRLEN n_a; int filter_has_file = 0; GV *filter_child_proc = 0; SV *filter_state = 0; SV *filter_sub = 0; + SV *hook_sv = 0; + SV *encoding; + OP *op; sv = POPs; - if (SvNIOKp(sv) && !SvPOKp(sv)) { - if (Atof(PL_patchlevel) + 0.00000999 < SvNV(sv)) - DIE(aTHX_ "Perl %s required--this is only version %s, stopped", - SvPV(sv,n_a),PL_patchlevel); - RETPUSHYES; + if (SvNIOKp(sv) && PL_op->op_type != OP_DOFILE) { + if (SvPOK(sv) && SvNOK(sv) && SvNV(sv)) { /* require v5.6.1 */ + UV rev = 0, ver = 0, sver = 0; + STRLEN len; + U8 *s = (U8*)SvPVX(sv); + U8 *end = (U8*)SvPVX(sv) + SvCUR(sv); + if (s < end) { + rev = utf8n_to_uvchr(s, end - s, &len, 0); + s += len; + if (s < end) { + ver = utf8n_to_uvchr(s, end - s, &len, 0); + s += len; + if (s < end) + sver = utf8n_to_uvchr(s, end - s, &len, 0); + } + } + if (PERL_REVISION < rev + || (PERL_REVISION == rev + && (PERL_VERSION < ver + || (PERL_VERSION == ver + && PERL_SUBVERSION < sver)))) + { + DIE(aTHX_ "Perl v%"UVuf".%"UVuf".%"UVuf" required--this is only " + "v%d.%d.%d, stopped", rev, ver, sver, PERL_REVISION, + PERL_VERSION, PERL_SUBVERSION); + } + if (ckWARN(WARN_PORTABLE)) + Perl_warner(aTHX_ packWARN(WARN_PORTABLE), + "v-string in use/require non-portable"); + RETPUSHYES; + } + else if (!SvPOKp(sv)) { /* require 5.005_03 */ + if ((NV)PERL_REVISION + ((NV)PERL_VERSION/(NV)1000) + + ((NV)PERL_SUBVERSION/(NV)1000000) + + 0.00000099 < SvNV(sv)) + { + NV nrev = SvNV(sv); + UV rev = (UV)nrev; + NV nver = (nrev - rev) * 1000; + UV ver = (UV)(nver + 0.0009); + NV nsver = (nver - ver) * 1000; + UV sver = (UV)(nsver + 0.0009); + + /* help out with the "use 5.6" confusion */ + if (sver == 0 && (rev > 5 || (rev == 5 && ver >= 100))) { + DIE(aTHX_ "Perl v%"UVuf".%"UVuf".%"UVuf" required" + " (did you mean v%"UVuf".%03"UVuf"?)--" + "this is only v%d.%d.%d, stopped", + rev, ver, sver, rev, ver/100, + PERL_REVISION, PERL_VERSION, PERL_SUBVERSION); + } + else { + DIE(aTHX_ "Perl v%"UVuf".%"UVuf".%"UVuf" required--" + "this is only v%d.%d.%d, stopped", + rev, ver, sver, PERL_REVISION, PERL_VERSION, + PERL_SUBVERSION); + } + } + RETPUSHYES; + } } name = SvPV(sv, len); if (!(name && len > 0 && *name)) @@ -2779,26 +2933,22 @@ PP(pp_require) /* prepare to compile file */ - if (*name == '/' || - (*name == '.' && - (name[1] == '/' || - (name[1] == '.' && name[2] == '/'))) -#ifdef DOSISH - || (name[0] && name[1] == ':') -#endif -#ifdef WIN32 - || (name[0] == '\\' && name[1] == '\\') /* UNC path */ -#endif -#ifdef VMS - || (strchr(name,':') || ((*name == '[' || *name == '<') && - (isALNUM(name[1]) || strchr("$-_]>",name[1])))) -#endif - ) - { + if (path_is_absolute(name)) { tryname = name; tryrsfp = doopen_pmc(name,PERL_SCRIPT_MODE); } - else { +#ifdef MACOS_TRADITIONAL + if (!tryrsfp) { + char newname[256]; + + MacPerl_CanonDir(name, newname, 1); + if (path_is_absolute(newname)) { + tryname = newname; + tryrsfp = doopen_pmc(newname,PERL_SCRIPT_MODE); + } + } +#endif + if (!tryrsfp) { AV *ar = GvAVn(PL_incgv); I32 i; #ifdef VMS @@ -2814,12 +2964,14 @@ PP(pp_require) int count; SV *loader = dirsv; - if (SvTYPE(SvRV(loader)) == SVt_PVAV) { + if (SvTYPE(SvRV(loader)) == SVt_PVAV + && !sv_isobject(loader)) + { loader = *av_fetch((AV *)SvRV(loader), 0, TRUE); } Perl_sv_setpvf(aTHX_ namesv, "/loader/0x%"UVxf"/%s", - PTR2UV(SvANY(loader)), name); + PTR2UV(SvRV(dirsv)), name); tryname = SvPVX(namesv); tryrsfp = 0; @@ -2831,7 +2983,10 @@ PP(pp_require) PUSHs(dirsv); PUSHs(sv); PUTBACK; - count = call_sv(loader, G_ARRAY); + if (sv_isobject(loader)) + count = call_method("INC", G_ARRAY); + else + count = call_sv(loader, G_ARRAY); SPAGAIN; if (count > 0) { @@ -2852,7 +3007,7 @@ PP(pp_require) if (io) { tryrsfp = IoIFP(io); - if (IoTYPE(io) == '|') { + if (IoTYPE(io) == IoTYPE_PIPE) { /* reading from a child process doesn't nest -- when returning from reading the inner module, the outer one is @@ -2897,6 +3052,7 @@ PP(pp_require) LEAVE; if (tryrsfp) { + hook_sv = dirsv; break; } @@ -2915,7 +3071,22 @@ PP(pp_require) } } else { + if (!path_is_absolute(name) +#ifdef MACOS_TRADITIONAL + /* We consider paths of the form :a:b ambiguous and interpret them first + as global then as local + */ + || (*name == ':' && name[1] != ':' && strchr(name+2, ':')) +#endif + ) { char *dir = SvPVx(dirsv, n_a); +#ifdef MACOS_TRADITIONAL + char buf1[256]; + char buf2[256]; + + MacPerl_CanonDir(name, buf2, 1); + Perl_sv_setpvf(aTHX_ namesv, "%s%s", MacPerl_CanonDir(dir, buf1, 0), buf2+(buf2[0] == ':')); +#else #ifdef VMS char *unixdir; if ((unixdir = tounixpath(dir, Nullch)) == Nullch) @@ -2925,6 +3096,7 @@ PP(pp_require) #else Perl_sv_setpvf(aTHX_ namesv, "%s/%s", dir, name); #endif +#endif TAINT_PROPER("require"); tryname = SvPVX(namesv); tryrsfp = doopen_pmc(tryname, PERL_SCRIPT_MODE); @@ -2933,12 +3105,13 @@ PP(pp_require) tryname += 2; break; } + } } } } } - SAVESPTR(CopFILEGV(&PL_compiling)); - CopFILEGV_set(&PL_compiling, gv_fetchfile(tryrsfp ? tryname : name)); + SAVECOPFILE_FREE(&PL_compiling); + CopFILE_set(&PL_compiling, tryrsfp ? tryname : name); SvREFCNT_dec(namesv); if (!tryrsfp) { if (PL_op->op_type == OP_REQUIRE) { @@ -2969,11 +3142,17 @@ PP(pp_require) RETPUSHUNDEF; } else - SETERRNO(0, SS$_NORMAL); + SETERRNO(0, SS_NORMAL); /* Assume success here to prevent recursive requirement. */ - (void)hv_store(GvHVn(PL_incgv), name, strlen(name), - newSVsv(CopFILESV(&PL_compiling)), 0 ); + len = strlen(name); + /* Check whether a hook in @INC has already filled %INC */ + if (!hook_sv || !(svp = hv_fetch(GvHVn(PL_incgv), name, len, 0))) { + (void)hv_store(GvHVn(PL_incgv), name, len, + (hook_sv ? SvREFCNT_inc(hook_sv) + : newSVpv(CopFILE(&PL_compiling), 0)), + 0 ); + } ENTER; SAVETMPS; @@ -2982,17 +3161,19 @@ PP(pp_require) PL_rsfp_filters = Nullav; PL_rsfp = tryrsfp; - name = savepv(name); - SAVEFREEPV(name); SAVEHINTS(); PL_hints = 0; - SAVEPPTR(PL_compiling.cop_warnings); + SAVESPTR(PL_compiling.cop_warnings); if (PL_dowarn & G_WARN_ALL_ON) - PL_compiling.cop_warnings = WARN_ALL ; + PL_compiling.cop_warnings = pWARN_ALL ; else if (PL_dowarn & G_WARN_ALL_OFF) - PL_compiling.cop_warnings = WARN_NONE ; - else - PL_compiling.cop_warnings = WARN_STD ; + PL_compiling.cop_warnings = pWARN_NONE ; + else if (PL_taint_warn) + PL_compiling.cop_warnings = newSVpvn(WARN_TAINTstring, WARNsize); + else + PL_compiling.cop_warnings = pWARN_STD ; + SAVESPTR(PL_compiling.cop_io); + PL_compiling.cop_io = Nullsv; if (filter_sub || filter_child_proc) { SV *datasv = filter_add(run_user_filter, Nullsv); @@ -3007,19 +3188,21 @@ PP(pp_require) PUSHBLOCK(cx, CXt_EVAL, SP); PUSHEVAL(cx, name, Nullgv); - SAVEI16(PL_compiling.cop_line); - PL_compiling.cop_line = 0; + SAVECOPLINE(&PL_compiling); + CopLINE_set(&PL_compiling, 0); PUTBACK; -#ifdef USE_THREADS - MUTEX_LOCK(&PL_eval_mutex); - if (PL_eval_owner && PL_eval_owner != thr) - while (PL_eval_owner) - COND_WAIT(&PL_eval_cond, &PL_eval_mutex); - PL_eval_owner = thr; - MUTEX_UNLOCK(&PL_eval_mutex); -#endif /* USE_THREADS */ - return DOCATCH(doeval(G_SCALAR, NULL)); + + /* Store and reset encoding. */ + encoding = PL_encoding; + PL_encoding = Nullsv; + + op = DOCATCH(doeval(gimme, NULL, Nullcv, PL_curcop->cop_seq)); + + /* Restore encoding. */ + PL_encoding = encoding; + + return op; } PP(pp_dofile) @@ -3029,29 +3212,40 @@ PP(pp_dofile) PP(pp_entereval) { - djSP; + dSP; register PERL_CONTEXT *cx; dPOPss; I32 gimme = GIMME_V, was = PL_sub_generation; - char tmpbuf[TYPE_DIGITS(long) + 12]; + char tbuf[TYPE_DIGITS(long) + 12]; + char *tmpbuf = tbuf; char *safestr; STRLEN len; OP *ret; + CV* runcv; - if (!SvPV(sv,len) || !len) + if (!SvPV(sv,len)) RETPUSHUNDEF; TAINT_PROPER("eval"); ENTER; lex_start(sv); SAVETMPS; - + /* switch to eval mode */ - SAVESPTR(CopFILEGV(&PL_compiling)); - sprintf(tmpbuf, "_<(eval %lu)", (unsigned long)++PL_evalseq); - CopFILEGV_set(&PL_compiling, gv_fetchfile(tmpbuf+2)); - PL_compiling.cop_line = 1; + if (PERLDB_NAMEEVAL && CopLINE(PL_curcop)) { + SV *sv = sv_newmortal(); + Perl_sv_setpvf(aTHX_ sv, "_<(eval %lu)[%s:%"IVdf"]", + (unsigned long)++PL_evalseq, + CopFILE(PL_curcop), (IV)CopLINE(PL_curcop)); + tmpbuf = SvPVX(sv); + } + else + sprintf(tmpbuf, "_<(eval %lu)", (unsigned long)++PL_evalseq); + SAVECOPFILE_FREE(&PL_compiling); + CopFILE_set(&PL_compiling, tmpbuf+2); + SAVECOPLINE(&PL_compiling); + CopLINE_set(&PL_compiling, 1); /* XXX For Cs within BEGIN {} blocks, this ends up deleting the eval's FILEGV from the stash before gv_check() runs (i.e. before run-time proper). To work around the coredump that @@ -3061,11 +3255,21 @@ PP(pp_entereval) SAVEDELETE(PL_defstash, safestr, strlen(safestr)); SAVEHINTS(); PL_hints = PL_op->op_targ; - SAVEPPTR(PL_compiling.cop_warnings); - if (!specialWARN(PL_compiling.cop_warnings)) { - PL_compiling.cop_warnings = newSVsv(PL_compiling.cop_warnings) ; - SAVEFREESV(PL_compiling.cop_warnings) ; + SAVESPTR(PL_compiling.cop_warnings); + if (specialWARN(PL_curcop->cop_warnings)) + PL_compiling.cop_warnings = PL_curcop->cop_warnings; + else { + PL_compiling.cop_warnings = newSVsv(PL_curcop->cop_warnings); + SAVEFREESV(PL_compiling.cop_warnings); + } + SAVESPTR(PL_compiling.cop_io); + if (specialCopIO(PL_curcop->cop_io)) + PL_compiling.cop_io = PL_curcop->cop_io; + else { + PL_compiling.cop_io = newSVsv(PL_curcop->cop_io); + SAVEFREESV(PL_compiling.cop_io); } + runcv = find_runcv(); push_return(PL_op->op_next); PUSHBLOCK(cx, (CXt_EVAL|CXp_REAL), SP); @@ -3076,16 +3280,8 @@ PP(pp_entereval) if (PERLDB_LINE && PL_curstash != PL_debstash) save_lines(CopFILEAV(&PL_compiling), PL_linestr); PUTBACK; -#ifdef USE_THREADS - MUTEX_LOCK(&PL_eval_mutex); - if (PL_eval_owner && PL_eval_owner != thr) - while (PL_eval_owner) - COND_WAIT(&PL_eval_cond, &PL_eval_mutex); - PL_eval_owner = thr; - MUTEX_UNLOCK(&PL_eval_mutex); -#endif /* USE_THREADS */ - ret = doeval(gimme, NULL); - if (PERLDB_INTER && was != PL_sub_generation /* Some subs defined here. */ + ret = doeval(gimme, NULL, runcv, PL_curcop->cop_seq); + if (PERLDB_INTER && was != (I32)PL_sub_generation /* Some subs defined here. */ && ret != PL_op->op_next) { /* Successive compilation. */ strcpy(safestr, "_<(eval )"); /* Anything fake and short. */ } @@ -3094,7 +3290,7 @@ PP(pp_entereval) PP(pp_leaveeval) { - djSP; + dSP; register SV **mark; SV **newsp; PMOP *newpm; @@ -3136,9 +3332,6 @@ PP(pp_leaveeval) } PL_curpm = newpm; /* Don't pop $1 et al till now */ - if (AvFILLp(PL_comppad_name) >= 0) - free_closures(); - #ifdef DEBUGGING assert(CvDEPTH(PL_compcv) == 1); #endif @@ -3149,9 +3342,9 @@ PP(pp_leaveeval) !(gimme == G_SCALAR ? SvTRUE(*SP) : SP > newsp)) { /* Unassume the success we assumed earlier. */ - char *name = cx->blk_eval.old_name; - (void)hv_delete(GvHVn(PL_incgv), name, strlen(name), G_DISCARD); - retop = Perl_die(aTHX_ "%s did not return a true value", name); + SV *nsv = cx->blk_eval.old_namesv; + (void)hv_delete(GvHVn(PL_incgv), SvPVX(nsv), SvCUR(nsv), G_DISCARD); + retop = Perl_die(aTHX_ "%s did not return a true value", SvPVX(nsv)); /* die_where() did LEAVE, or we won't be here */ } else { @@ -3165,7 +3358,7 @@ PP(pp_leaveeval) PP(pp_entertry) { - djSP; + dSP; register PERL_CONTEXT *cx; I32 gimme = GIMME_V; @@ -3173,9 +3366,8 @@ PP(pp_entertry) SAVETMPS; push_return(cLOGOP->op_other->op_next); - PUSHBLOCK(cx, CXt_EVAL, SP); + PUSHBLOCK(cx, (CXt_EVAL|CXp_TRYBLOCK), SP); PUSHEVAL(cx, 0, 0); - PL_eval_root = PL_op; /* Only needed so that goto works right. */ PL_in_eval = EVAL_INEVAL; sv_setpv(ERRSV,""); @@ -3185,17 +3377,18 @@ PP(pp_entertry) PP(pp_leavetry) { - djSP; + dSP; register SV **mark; SV **newsp; PMOP *newpm; + OP* retop; I32 gimme; register PERL_CONTEXT *cx; I32 optype; POPBLOCK(cx,newpm); POPEVAL(cx); - pop_return(); + retop = pop_return(); TAINT_NOT; if (gimme == G_VOID) @@ -3227,7 +3420,7 @@ PP(pp_leavetry) LEAVE; sv_setpv(ERRSV,""); - RETURN; + RETURNOP(retop); } STATIC void @@ -3236,20 +3429,20 @@ S_doparseform(pTHX_ SV *sv) STRLEN len; register char *s = SvPV_force(sv, len); register char *send = s + len; - register char *base; + register char *base = Nullch; register I32 skipspaces = 0; - bool noblank; - bool repeat; + bool noblank = FALSE; + bool repeat = FALSE; bool postspace = FALSE; U16 *fops; register U16 *fpc; - U16 *linepc; + U16 *linepc = 0; register I32 arg; bool ischop; if (len == 0) Perl_croak(aTHX_ "Null picture in formline"); - + New(804, fops, (send - s)*3+10, U16); /* Almost certainly too long... */ fpc = fops; @@ -3277,7 +3470,7 @@ S_doparseform(pTHX_ SV *sv) case ' ': case '\t': skipspaces++; continue; - + case '\n': case 0: arg = s - base; skipspaces++; @@ -3286,14 +3479,14 @@ S_doparseform(pTHX_ SV *sv) if (postspace) *fpc++ = FF_SPACE; *fpc++ = FF_LITERAL; - *fpc++ = arg; + *fpc++ = (U16)arg; } postspace = FALSE; if (s <= send) skipspaces--; if (skipspaces) { *fpc++ = FF_SKIP; - *fpc++ = skipspaces; + *fpc++ = (U16)skipspaces; } skipspaces = 0; if (s <= send) @@ -3304,7 +3497,7 @@ S_doparseform(pTHX_ SV *sv) arg = fpc - linepc + 1; else arg = 0; - *fpc++ = arg; + *fpc++ = (U16)arg; } if (s < send) { linepc = fpc; @@ -3327,7 +3520,7 @@ S_doparseform(pTHX_ SV *sv) arg = (s - base) - 1; if (arg) { *fpc++ = FF_LITERAL; - *fpc++ = arg; + *fpc++ = (U16)arg; } base = s - 1; @@ -3352,7 +3545,25 @@ S_doparseform(pTHX_ SV *sv) } *fpc++ = s - base; /* fieldsize for FETCH */ *fpc++ = FF_DECIMAL; - *fpc++ = arg; + *fpc++ = (U16)arg; + } + else if (*s == '0' && s[1] == '#') { /* Zero padded decimals */ + arg = ischop ? 512 : 0; + base = s - 1; + s++; /* skip the '0' first */ + while (*s == '#') + s++; + if (*s == '.') { + char *f; + s++; + f = s; + while (*s == '#') + s++; + arg |= 256 + (s - f); + } + *fpc++ = s - base; /* fieldsize for FETCH */ + *fpc++ = FF_0DECIMAL; + *fpc++ = (U16)arg; } else { I32 prespace = 0; @@ -3381,7 +3592,7 @@ S_doparseform(pTHX_ SV *sv) *fpc++ = ischop ? FF_CHECKCHOP : FF_CHECKNL; if (prespace) - *fpc++ = prespace; + *fpc++ = (U16)prespace; *fpc++ = FF_ITEM; if (ismore) *fpc++ = FF_MORE; @@ -3404,838 +3615,12 @@ S_doparseform(pTHX_ SV *sv) } Copy(fops, s, arg, U16); Safefree(fops); - sv_magic(sv, Nullsv, 'f', Nullch, 0); + sv_magic(sv, Nullsv, PERL_MAGIC_fm, Nullch, 0); SvCOMPILED_on(sv); } -/* - * The rest of this file was derived from source code contributed - * by Tom Horsley. - * - * NOTE: this code was derived from Tom Horsley's qsort replacement - * and should not be confused with the original code. - */ - -/* Copyright (C) Tom Horsley, 1997. All rights reserved. - - Permission granted to distribute under the same terms as perl which are - (briefly): - - This program is free software; you can redistribute it and/or modify - it under the terms of either: - - a) the GNU General Public License as published by the Free - Software Foundation; either version 1, or (at your option) any - later version, or - - b) the "Artistic License" which comes with this Kit. - - Details on the perl license can be found in the perl source code which - may be located via the www.perl.com web page. - - This is the most wonderfulest possible qsort I can come up with (and - still be mostly portable) My (limited) tests indicate it consistently - does about 20% fewer calls to compare than does the qsort in the Visual - C++ library, other vendors may vary. - - Some of the ideas in here can be found in "Algorithms" by Sedgewick, - others I invented myself (or more likely re-invented since they seemed - pretty obvious once I watched the algorithm operate for a while). - - Most of this code was written while watching the Marlins sweep the Giants - in the 1997 National League Playoffs - no Braves fans allowed to use this - code (just kidding :-). - - I realize that if I wanted to be true to the perl tradition, the only - comment in this file would be something like: - - ...they shuffled back towards the rear of the line. 'No, not at the - rear!' the slave-driver shouted. 'Three files up. And stay there... - - However, I really needed to violate that tradition just so I could keep - track of what happens myself, not to mention some poor fool trying to - understand this years from now :-). -*/ - -/* ********************************************************** Configuration */ - -#ifndef QSORT_ORDER_GUESS -#define QSORT_ORDER_GUESS 2 /* Select doubling version of the netBSD trick */ -#endif - -/* QSORT_MAX_STACK is the largest number of partitions that can be stacked up for - future processing - a good max upper bound is log base 2 of memory size - (32 on 32 bit machines, 64 on 64 bit machines, etc). In reality can - safely be smaller than that since the program is taking up some space and - most operating systems only let you grab some subset of contiguous - memory (not to mention that you are normally sorting data larger than - 1 byte element size :-). -*/ -#ifndef QSORT_MAX_STACK -#define QSORT_MAX_STACK 32 -#endif - -/* QSORT_BREAK_EVEN is the size of the largest partition we should insertion sort. - Anything bigger and we use qsort. If you make this too small, the qsort - will probably break (or become less efficient), because it doesn't expect - the middle element of a partition to be the same as the right or left - - you have been warned). -*/ -#ifndef QSORT_BREAK_EVEN -#define QSORT_BREAK_EVEN 6 -#endif - -/* ************************************************************* Data Types */ - -/* hold left and right index values of a partition waiting to be sorted (the - partition includes both left and right - right is NOT one past the end or - anything like that). -*/ -struct partition_stack_entry { - int left; - int right; -#ifdef QSORT_ORDER_GUESS - int qsort_break_even; -#endif -}; - -/* ******************************************************* Shorthand Macros */ - -/* Note that these macros will be used from inside the qsort function where - we happen to know that the variable 'elt_size' contains the size of an - array element and the variable 'temp' points to enough space to hold a - temp element and the variable 'array' points to the array being sorted - and 'compare' is the pointer to the compare routine. - - Also note that there are very many highly architecture specific ways - these might be sped up, but this is simply the most generally portable - code I could think of. -*/ - -/* Return < 0 == 0 or > 0 as the value of elt1 is < elt2, == elt2, > elt2 -*/ -#define qsort_cmp(elt1, elt2) \ - ((*compare)(aTHXo_ array[elt1], array[elt2])) - -#ifdef QSORT_ORDER_GUESS -#define QSORT_NOTICE_SWAP swapped++; -#else -#define QSORT_NOTICE_SWAP -#endif - -/* swaps contents of array elements elt1, elt2. -*/ -#define qsort_swap(elt1, elt2) \ - STMT_START { \ - QSORT_NOTICE_SWAP \ - temp = array[elt1]; \ - array[elt1] = array[elt2]; \ - array[elt2] = temp; \ - } STMT_END - -/* rotate contents of elt1, elt2, elt3 such that elt1 gets elt2, elt2 gets - elt3 and elt3 gets elt1. -*/ -#define qsort_rotate(elt1, elt2, elt3) \ - STMT_START { \ - QSORT_NOTICE_SWAP \ - temp = array[elt1]; \ - array[elt1] = array[elt2]; \ - array[elt2] = array[elt3]; \ - array[elt3] = temp; \ - } STMT_END - -/* ************************************************************ Debug stuff */ - -#ifdef QSORT_DEBUG - -static void -break_here() -{ - return; /* good place to set a breakpoint */ -} - -#define qsort_assert(t) (void)( (t) || (break_here(), 0) ) - -static void -doqsort_all_asserts( - void * array, - size_t num_elts, - size_t elt_size, - int (*compare)(const void * elt1, const void * elt2), - int pc_left, int pc_right, int u_left, int u_right) -{ - int i; - - qsort_assert(pc_left <= pc_right); - qsort_assert(u_right < pc_left); - qsort_assert(pc_right < u_left); - for (i = u_right + 1; i < pc_left; ++i) { - qsort_assert(qsort_cmp(i, pc_left) < 0); - } - for (i = pc_left; i < pc_right; ++i) { - qsort_assert(qsort_cmp(i, pc_right) == 0); - } - for (i = pc_right + 1; i < u_left; ++i) { - qsort_assert(qsort_cmp(pc_right, i) < 0); - } -} - -#define qsort_all_asserts(PC_LEFT, PC_RIGHT, U_LEFT, U_RIGHT) \ - doqsort_all_asserts(array, num_elts, elt_size, compare, \ - PC_LEFT, PC_RIGHT, U_LEFT, U_RIGHT) - -#else - -#define qsort_assert(t) ((void)0) - -#define qsort_all_asserts(PC_LEFT, PC_RIGHT, U_LEFT, U_RIGHT) ((void)0) - -#endif - -/* ****************************************************************** qsort */ - -STATIC void -S_qsortsv(pTHX_ SV ** array, size_t num_elts, SVCOMPARE_t compare) -{ - register SV * temp; - - struct partition_stack_entry partition_stack[QSORT_MAX_STACK]; - int next_stack_entry = 0; - - int part_left; - int part_right; -#ifdef QSORT_ORDER_GUESS - int qsort_break_even; - int swapped; -#endif - - /* Make sure we actually have work to do. - */ - if (num_elts <= 1) { - return; - } - - /* Setup the initial partition definition and fall into the sorting loop - */ - part_left = 0; - part_right = (int)(num_elts - 1); -#ifdef QSORT_ORDER_GUESS - qsort_break_even = QSORT_BREAK_EVEN; -#else -#define qsort_break_even QSORT_BREAK_EVEN -#endif - for ( ; ; ) { - if ((part_right - part_left) >= qsort_break_even) { - /* OK, this is gonna get hairy, so lets try to document all the - concepts and abbreviations and variables and what they keep - track of: - - pc: pivot chunk - the set of array elements we accumulate in the - middle of the partition, all equal in value to the original - pivot element selected. The pc is defined by: - - pc_left - the leftmost array index of the pc - pc_right - the rightmost array index of the pc - - we start with pc_left == pc_right and only one element - in the pivot chunk (but it can grow during the scan). - - u: uncompared elements - the set of elements in the partition - we have not yet compared to the pivot value. There are two - uncompared sets during the scan - one to the left of the pc - and one to the right. - - u_right - the rightmost index of the left side's uncompared set - u_left - the leftmost index of the right side's uncompared set - - The leftmost index of the left sides's uncompared set - doesn't need its own variable because it is always defined - by the leftmost edge of the whole partition (part_left). The - same goes for the rightmost edge of the right partition - (part_right). - - We know there are no uncompared elements on the left once we - get u_right < part_left and no uncompared elements on the - right once u_left > part_right. When both these conditions - are met, we have completed the scan of the partition. - - Any elements which are between the pivot chunk and the - uncompared elements should be less than the pivot value on - the left side and greater than the pivot value on the right - side (in fact, the goal of the whole algorithm is to arrange - for that to be true and make the groups of less-than and - greater-then elements into new partitions to sort again). - - As you marvel at the complexity of the code and wonder why it - has to be so confusing. Consider some of the things this level - of confusion brings: - - Once I do a compare, I squeeze every ounce of juice out of it. I - never do compare calls I don't have to do, and I certainly never - do redundant calls. - - I also never swap any elements unless I can prove there is a - good reason. Many sort algorithms will swap a known value with - an uncompared value just to get things in the right place (or - avoid complexity :-), but that uncompared value, once it gets - compared, may then have to be swapped again. A lot of the - complexity of this code is due to the fact that it never swaps - anything except compared values, and it only swaps them when the - compare shows they are out of position. - */ - int pc_left, pc_right; - int u_right, u_left; - - int s; - - pc_left = ((part_left + part_right) / 2); - pc_right = pc_left; - u_right = pc_left - 1; - u_left = pc_right + 1; - - /* Qsort works best when the pivot value is also the median value - in the partition (unfortunately you can't find the median value - without first sorting :-), so to give the algorithm a helping - hand, we pick 3 elements and sort them and use the median value - of that tiny set as the pivot value. - - Some versions of qsort like to use the left middle and right as - the 3 elements to sort so they can insure the ends of the - partition will contain values which will stop the scan in the - compare loop, but when you have to call an arbitrarily complex - routine to do a compare, its really better to just keep track of - array index values to know when you hit the edge of the - partition and avoid the extra compare. An even better reason to - avoid using a compare call is the fact that you can drop off the - edge of the array if someone foolishly provides you with an - unstable compare function that doesn't always provide consistent - results. - - So, since it is simpler for us to compare the three adjacent - elements in the middle of the partition, those are the ones we - pick here (conveniently pointed at by u_right, pc_left, and - u_left). The values of the left, center, and right elements - are refered to as l c and r in the following comments. - */ - -#ifdef QSORT_ORDER_GUESS - swapped = 0; -#endif - s = qsort_cmp(u_right, pc_left); - if (s < 0) { - /* l < c */ - s = qsort_cmp(pc_left, u_left); - /* if l < c, c < r - already in order - nothing to do */ - if (s == 0) { - /* l < c, c == r - already in order, pc grows */ - ++pc_right; - qsort_all_asserts(pc_left, pc_right, u_left + 1, u_right - 1); - } else if (s > 0) { - /* l < c, c > r - need to know more */ - s = qsort_cmp(u_right, u_left); - if (s < 0) { - /* l < c, c > r, l < r - swap c & r to get ordered */ - qsort_swap(pc_left, u_left); - qsort_all_asserts(pc_left, pc_right, u_left + 1, u_right - 1); - } else if (s == 0) { - /* l < c, c > r, l == r - swap c&r, grow pc */ - qsort_swap(pc_left, u_left); - --pc_left; - qsort_all_asserts(pc_left, pc_right, u_left + 1, u_right - 1); - } else { - /* l < c, c > r, l > r - make lcr into rlc to get ordered */ - qsort_rotate(pc_left, u_right, u_left); - qsort_all_asserts(pc_left, pc_right, u_left + 1, u_right - 1); - } - } - } else if (s == 0) { - /* l == c */ - s = qsort_cmp(pc_left, u_left); - if (s < 0) { - /* l == c, c < r - already in order, grow pc */ - --pc_left; - qsort_all_asserts(pc_left, pc_right, u_left + 1, u_right - 1); - } else if (s == 0) { - /* l == c, c == r - already in order, grow pc both ways */ - --pc_left; - ++pc_right; - qsort_all_asserts(pc_left, pc_right, u_left + 1, u_right - 1); - } else { - /* l == c, c > r - swap l & r, grow pc */ - qsort_swap(u_right, u_left); - ++pc_right; - qsort_all_asserts(pc_left, pc_right, u_left + 1, u_right - 1); - } - } else { - /* l > c */ - s = qsort_cmp(pc_left, u_left); - if (s < 0) { - /* l > c, c < r - need to know more */ - s = qsort_cmp(u_right, u_left); - if (s < 0) { - /* l > c, c < r, l < r - swap l & c to get ordered */ - qsort_swap(u_right, pc_left); - qsort_all_asserts(pc_left, pc_right, u_left + 1, u_right - 1); - } else if (s == 0) { - /* l > c, c < r, l == r - swap l & c, grow pc */ - qsort_swap(u_right, pc_left); - ++pc_right; - qsort_all_asserts(pc_left, pc_right, u_left + 1, u_right - 1); - } else { - /* l > c, c < r, l > r - rotate lcr into crl to order */ - qsort_rotate(u_right, pc_left, u_left); - qsort_all_asserts(pc_left, pc_right, u_left + 1, u_right - 1); - } - } else if (s == 0) { - /* l > c, c == r - swap ends, grow pc */ - qsort_swap(u_right, u_left); - --pc_left; - qsort_all_asserts(pc_left, pc_right, u_left + 1, u_right - 1); - } else { - /* l > c, c > r - swap ends to get in order */ - qsort_swap(u_right, u_left); - qsort_all_asserts(pc_left, pc_right, u_left + 1, u_right - 1); - } - } - /* We now know the 3 middle elements have been compared and - arranged in the desired order, so we can shrink the uncompared - sets on both sides - */ - --u_right; - ++u_left; - qsort_all_asserts(pc_left, pc_right, u_left, u_right); - - /* The above massive nested if was the simple part :-). We now have - the middle 3 elements ordered and we need to scan through the - uncompared sets on either side, swapping elements that are on - the wrong side or simply shuffling equal elements around to get - all equal elements into the pivot chunk. - */ - - for ( ; ; ) { - int still_work_on_left; - int still_work_on_right; - - /* Scan the uncompared values on the left. If I find a value - equal to the pivot value, move it over so it is adjacent to - the pivot chunk and expand the pivot chunk. If I find a value - less than the pivot value, then just leave it - its already - on the correct side of the partition. If I find a greater - value, then stop the scan. - */ - while (still_work_on_left = (u_right >= part_left)) { - s = qsort_cmp(u_right, pc_left); - if (s < 0) { - --u_right; - } else if (s == 0) { - --pc_left; - if (pc_left != u_right) { - qsort_swap(u_right, pc_left); - } - --u_right; - } else { - break; - } - qsort_assert(u_right < pc_left); - qsort_assert(pc_left <= pc_right); - qsort_assert(qsort_cmp(u_right + 1, pc_left) <= 0); - qsort_assert(qsort_cmp(pc_left, pc_right) == 0); - } - - /* Do a mirror image scan of uncompared values on the right - */ - while (still_work_on_right = (u_left <= part_right)) { - s = qsort_cmp(pc_right, u_left); - if (s < 0) { - ++u_left; - } else if (s == 0) { - ++pc_right; - if (pc_right != u_left) { - qsort_swap(pc_right, u_left); - } - ++u_left; - } else { - break; - } - qsort_assert(u_left > pc_right); - qsort_assert(pc_left <= pc_right); - qsort_assert(qsort_cmp(pc_right, u_left - 1) <= 0); - qsort_assert(qsort_cmp(pc_left, pc_right) == 0); - } - - if (still_work_on_left) { - /* I know I have a value on the left side which needs to be - on the right side, but I need to know more to decide - exactly the best thing to do with it. - */ - if (still_work_on_right) { - /* I know I have values on both side which are out of - position. This is a big win because I kill two birds - with one swap (so to speak). I can advance the - uncompared pointers on both sides after swapping both - of them into the right place. - */ - qsort_swap(u_right, u_left); - --u_right; - ++u_left; - qsort_all_asserts(pc_left, pc_right, u_left, u_right); - } else { - /* I have an out of position value on the left, but the - right is fully scanned, so I "slide" the pivot chunk - and any less-than values left one to make room for the - greater value over on the right. If the out of position - value is immediately adjacent to the pivot chunk (there - are no less-than values), I can do that with a swap, - otherwise, I have to rotate one of the less than values - into the former position of the out of position value - and the right end of the pivot chunk into the left end - (got all that?). - */ - --pc_left; - if (pc_left == u_right) { - qsort_swap(u_right, pc_right); - qsort_all_asserts(pc_left, pc_right-1, u_left, u_right-1); - } else { - qsort_rotate(u_right, pc_left, pc_right); - qsort_all_asserts(pc_left, pc_right-1, u_left, u_right-1); - } - --pc_right; - --u_right; - } - } else if (still_work_on_right) { - /* Mirror image of complex case above: I have an out of - position value on the right, but the left is fully - scanned, so I need to shuffle things around to make room - for the right value on the left. - */ - ++pc_right; - if (pc_right == u_left) { - qsort_swap(u_left, pc_left); - qsort_all_asserts(pc_left+1, pc_right, u_left+1, u_right); - } else { - qsort_rotate(pc_right, pc_left, u_left); - qsort_all_asserts(pc_left+1, pc_right, u_left+1, u_right); - } - ++pc_left; - ++u_left; - } else { - /* No more scanning required on either side of partition, - break out of loop and figure out next set of partitions - */ - break; - } - } - - /* The elements in the pivot chunk are now in the right place. They - will never move or be compared again. All I have to do is decide - what to do with the stuff to the left and right of the pivot - chunk. - - Notes on the QSORT_ORDER_GUESS ifdef code: - - 1. If I just built these partitions without swapping any (or - very many) elements, there is a chance that the elements are - already ordered properly (being properly ordered will - certainly result in no swapping, but the converse can't be - proved :-). - - 2. A (properly written) insertion sort will run faster on - already ordered data than qsort will. - - 3. Perhaps there is some way to make a good guess about - switching to an insertion sort earlier than partition size 6 - (for instance - we could save the partition size on the stack - and increase the size each time we find we didn't swap, thus - switching to insertion sort earlier for partitions with a - history of not swapping). - - 4. Naturally, if I just switch right away, it will make - artificial benchmarks with pure ascending (or descending) - data look really good, but is that a good reason in general? - Hard to say... - */ - -#ifdef QSORT_ORDER_GUESS - if (swapped < 3) { -#if QSORT_ORDER_GUESS == 1 - qsort_break_even = (part_right - part_left) + 1; -#endif -#if QSORT_ORDER_GUESS == 2 - qsort_break_even *= 2; -#endif -#if QSORT_ORDER_GUESS == 3 - int prev_break = qsort_break_even; - qsort_break_even *= qsort_break_even; - if (qsort_break_even < prev_break) { - qsort_break_even = (part_right - part_left) + 1; - } -#endif - } else { - qsort_break_even = QSORT_BREAK_EVEN; - } -#endif - - if (part_left < pc_left) { - /* There are elements on the left which need more processing. - Check the right as well before deciding what to do. - */ - if (pc_right < part_right) { - /* We have two partitions to be sorted. Stack the biggest one - and process the smallest one on the next iteration. This - minimizes the stack height by insuring that any additional - stack entries must come from the smallest partition which - (because it is smallest) will have the fewest - opportunities to generate additional stack entries. - */ - if ((part_right - pc_right) > (pc_left - part_left)) { - /* stack the right partition, process the left */ - partition_stack[next_stack_entry].left = pc_right + 1; - partition_stack[next_stack_entry].right = part_right; -#ifdef QSORT_ORDER_GUESS - partition_stack[next_stack_entry].qsort_break_even = qsort_break_even; -#endif - part_right = pc_left - 1; - } else { - /* stack the left partition, process the right */ - partition_stack[next_stack_entry].left = part_left; - partition_stack[next_stack_entry].right = pc_left - 1; -#ifdef QSORT_ORDER_GUESS - partition_stack[next_stack_entry].qsort_break_even = qsort_break_even; -#endif - part_left = pc_right + 1; - } - qsort_assert(next_stack_entry < QSORT_MAX_STACK); - ++next_stack_entry; - } else { - /* The elements on the left are the only remaining elements - that need sorting, arrange for them to be processed as the - next partition. - */ - part_right = pc_left - 1; - } - } else if (pc_right < part_right) { - /* There is only one chunk on the right to be sorted, make it - the new partition and loop back around. - */ - part_left = pc_right + 1; - } else { - /* This whole partition wound up in the pivot chunk, so - we need to get a new partition off the stack. - */ - if (next_stack_entry == 0) { - /* the stack is empty - we are done */ - break; - } - --next_stack_entry; - part_left = partition_stack[next_stack_entry].left; - part_right = partition_stack[next_stack_entry].right; -#ifdef QSORT_ORDER_GUESS - qsort_break_even = partition_stack[next_stack_entry].qsort_break_even; -#endif - } - } else { - /* This partition is too small to fool with qsort complexity, just - do an ordinary insertion sort to minimize overhead. - */ - int i; - /* Assume 1st element is in right place already, and start checking - at 2nd element to see where it should be inserted. - */ - for (i = part_left + 1; i <= part_right; ++i) { - int j; - /* Scan (backwards - just in case 'i' is already in right place) - through the elements already sorted to see if the ith element - belongs ahead of one of them. - */ - for (j = i - 1; j >= part_left; --j) { - if (qsort_cmp(i, j) >= 0) { - /* i belongs right after j - */ - break; - } - } - ++j; - if (j != i) { - /* Looks like we really need to move some things - */ - int k; - temp = array[i]; - for (k = i - 1; k >= j; --k) - array[k + 1] = array[k]; - array[j] = temp; - } - } - - /* That partition is now sorted, grab the next one, or get out - of the loop if there aren't any more. - */ - - if (next_stack_entry == 0) { - /* the stack is empty - we are done */ - break; - } - --next_stack_entry; - part_left = partition_stack[next_stack_entry].left; - part_right = partition_stack[next_stack_entry].right; -#ifdef QSORT_ORDER_GUESS - qsort_break_even = partition_stack[next_stack_entry].qsort_break_even; -#endif - } - } - - /* Believe it or not, the array is sorted at this point! */ -} - - -#ifdef PERL_OBJECT -#undef this -#define this pPerl -#include "XSUB.h" -#endif - - -static I32 -sortcv(pTHXo_ SV *a, SV *b) -{ - dTHR; - I32 oldsaveix = PL_savestack_ix; - I32 oldscopeix = PL_scopestack_ix; - I32 result; - GvSV(PL_firstgv) = a; - GvSV(PL_secondgv) = b; - PL_stack_sp = PL_stack_base; - PL_op = PL_sortcop; - CALLRUNOPS(aTHX); - if (PL_stack_sp != PL_stack_base + 1) - Perl_croak(aTHX_ "Sort subroutine didn't return single value"); - if (!SvNIOKp(*PL_stack_sp)) - Perl_croak(aTHX_ "Sort subroutine didn't return a numeric value"); - result = SvIV(*PL_stack_sp); - while (PL_scopestack_ix > oldscopeix) { - LEAVE; - } - leave_scope(oldsaveix); - return result; -} - - -static I32 -sv_ncmp(pTHXo_ SV *a, SV *b) -{ - NV nv1 = SvNV(a); - NV nv2 = SvNV(b); - return nv1 < nv2 ? -1 : nv1 > nv2 ? 1 : 0; -} - -static I32 -sv_i_ncmp(pTHXo_ SV *a, SV *b) -{ - IV iv1 = SvIV(a); - IV iv2 = SvIV(b); - return iv1 < iv2 ? -1 : iv1 > iv2 ? 1 : 0; -} -#define tryCALL_AMAGICbin(left,right,meth,svp) STMT_START { \ - *svp = Nullsv; \ - if (PL_amagic_generation) { \ - if (SvAMAGIC(left)||SvAMAGIC(right))\ - *svp = amagic_call(left, \ - right, \ - CAT2(meth,_amg), \ - 0); \ - } \ - } STMT_END - -static I32 -amagic_ncmp(pTHXo_ register SV *a, register SV *b) -{ - SV *tmpsv; - tryCALL_AMAGICbin(a,b,ncmp,&tmpsv); - if (tmpsv) { - NV d; - - if (SvIOK(tmpsv)) { - I32 i = SvIVX(tmpsv); - if (i > 0) - return 1; - return i? -1 : 0; - } - d = SvNV(tmpsv); - if (d > 0) - return 1; - return d? -1 : 0; - } - return sv_ncmp(aTHXo_ a, b); -} - -static I32 -amagic_i_ncmp(pTHXo_ register SV *a, register SV *b) -{ - SV *tmpsv; - tryCALL_AMAGICbin(a,b,ncmp,&tmpsv); - if (tmpsv) { - NV d; - - if (SvIOK(tmpsv)) { - I32 i = SvIVX(tmpsv); - if (i > 0) - return 1; - return i? -1 : 0; - } - d = SvNV(tmpsv); - if (d > 0) - return 1; - return d? -1 : 0; - } - return sv_i_ncmp(aTHXo_ a, b); -} - -static I32 -amagic_cmp(pTHXo_ register SV *str1, register SV *str2) -{ - SV *tmpsv; - tryCALL_AMAGICbin(str1,str2,scmp,&tmpsv); - if (tmpsv) { - NV d; - - if (SvIOK(tmpsv)) { - I32 i = SvIVX(tmpsv); - if (i > 0) - return 1; - return i? -1 : 0; - } - d = SvNV(tmpsv); - if (d > 0) - return 1; - return d? -1 : 0; - } - return sv_cmp(str1, str2); -} - -static I32 -amagic_cmp_locale(pTHXo_ register SV *str1, register SV *str2) -{ - SV *tmpsv; - tryCALL_AMAGICbin(str1,str2,scmp,&tmpsv); - if (tmpsv) { - NV d; - - if (SvIOK(tmpsv)) { - I32 i = SvIVX(tmpsv); - if (i > 0) - return 1; - return i? -1 : 0; - } - d = SvNV(tmpsv); - if (d > 0) - return 1; - return d? -1 : 0; - } - return sv_cmp_locale(str1, str2); -} - static I32 -run_user_filter(pTHXo_ int idx, SV *buf_sv, int maxlen) +run_user_filter(pTHX_ int idx, SV *buf_sv, int maxlen) { SV *datasv = FILTER_DATA(idx); int filter_has_file = IoLINES(datasv); @@ -4254,7 +3639,7 @@ run_user_filter(pTHXo_ int idx, SV *buf_sv, int maxlen) } if (filter_sub && len >= 0) { - djSP; + dSP; int count; ENTER; @@ -4304,18 +3689,21 @@ run_user_filter(pTHXo_ int idx, SV *buf_sv, int maxlen) return len; } -#ifdef PERL_OBJECT - -static I32 -sv_cmp_locale_static(pTHXo_ register SV *str1, register SV *str2) -{ - return sv_cmp_locale(str1, str2); -} - -static I32 -sv_cmp_static(pTHXo_ register SV *str1, register SV *str2) +/* perhaps someone can come up with a better name for + this? it is not really "absolute", per se ... */ +static bool +S_path_is_absolute(pTHX_ char *name) { - return sv_cmp(str1, str2); + if (PERL_FILE_IS_ABSOLUTE(name) +#ifdef MACOS_TRADITIONAL + || (*name == ':')) +#else + || (*name == '.' && (name[1] == '/' || + (name[1] == '.' && name[2] == '/')))) +#endif + { + return TRUE; + } + else + return FALSE; } - -#endif /* PERL_OBJECT */