X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=pp_ctl.c;h=7a1ad799b8508bbf41b51ac780f2bbb5582c7058;hb=9d116dd7c895b17badf4ad422ae44da0c4df7bc2;hp=dadc145a22feefc0508dca757d2c5d07afcaba34;hpb=a868473fb9213692497e27ae968094b32a41c501;p=p5sagit%2Fp5-mst-13.2.git diff --git a/pp_ctl.c b/pp_ctl.c index dadc145..7a1ad79 100644 --- a/pp_ctl.c +++ b/pp_ctl.c @@ -25,6 +25,10 @@ #define DOCATCH(o) ((CATCH_GET == TRUE) ? docatch(o) : (o)) +#ifdef PERL_OBJECT +#define CALLOP this->*PL_op +#else +#define CALLOP *PL_op static OP *docatch _((OP *o)); static OP *dofindlabel _((OP *o, char *label, OP **opstack, OP **oplimit)); static void doparseform _((SV *sv)); @@ -32,13 +36,12 @@ static I32 dopoptoeval _((I32 startingblock)); static I32 dopoptolabel _((char *label)); static I32 dopoptoloop _((I32 startingblock)); static I32 dopoptosub _((I32 startingblock)); +static I32 dopoptosub_at _((PERL_CONTEXT *cxstk, I32 startingblock)); static void save_lines _((AV *array, SV *sv)); -static int sortcv _((const void *, const void *)); -static int sortcmp _((const void *, const void *)); -static int sortcmp_locale _((const void *, const void *)); +static I32 sortcv _((SV *a, SV *b)); +static void qsortsv _((SV **array, size_t num_elts, I32 (*fun)(SV *a, SV *b))); static OP *doeval _((int gimme, OP** startop)); - -static I32 sortcxix; +#endif PP(pp_wantarray) { @@ -65,7 +68,16 @@ PP(pp_regcmaybe) return NORMAL; } -PP(pp_regcomp) { +PP(pp_regcreset) +{ + /* XXXX Should store the old value to allow for tie/overload - and + restore in regcomp, where marked with XXXX. */ + PL_reginterp_cnt = 0; + return NORMAL; +} + +PP(pp_regcomp) +{ djSP; register PMOP *pm = (PMOP*)cLOGOP->op_other; register char *t; @@ -74,12 +86,12 @@ PP(pp_regcomp) { MAGIC *mg = Null(MAGIC*); tmpstr = POPs; - if(SvROK(tmpstr)) { + if (SvROK(tmpstr)) { SV *sv = SvRV(tmpstr); if(SvMAGICAL(sv)) mg = mg_find(sv, 'r'); } - if(mg) { + if (mg) { regexp *re = (regexp *)mg->mg_obj; ReREFCNT_dec(pm->op_pmregexp); pm->op_pmregexp = ReREFCNT_inc(re); @@ -87,28 +99,42 @@ PP(pp_regcomp) { else { t = SvPV(tmpstr, len); - /* JMR: Check against the last compiled regexp */ - if ( ! pm->op_pmregexp || ! pm->op_pmregexp->precomp - || strnNE(pm->op_pmregexp->precomp, t, len) - || pm->op_pmregexp->precomp[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->op_pmregexp) { ReREFCNT_dec(pm->op_pmregexp); pm->op_pmregexp = 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 = pregcomp(t, t + len, pm); + pm->op_pmregexp = CALLREGCOMP(t, t + len, pm); + PL_reginterp_cnt = 0; /* XXXX Be extra paranoid - needed + inside tie/overload accessors. */ } } - if (!pm->op_pmregexp->prelen && curpm) - pm = curpm; +#ifndef INCOMPLETE_TAINTS + if (PL_tainting) { + if (PL_tainted) + pm->op_pmdynflags |= PMdf_TAINTED; + else + pm->op_pmdynflags &= ~PMdf_TAINTED; + } +#endif + + if (!pm->op_pmregexp->prelen && PL_curpm) + pm = PL_curpm; else if (strEQ("\\s+", pm->op_pmregexp->precomp)) pm->op_pmflags |= PMf_WHITE; if (pm->op_pmflags & PMf_KEEP) { pm->op_private &= ~OPpRUNTIME; /* no point compiling again */ - cLOGOP->op_first->op_next = op->op_next; + cLOGOP->op_first->op_next = PL_op->op_next; } RETURN; } @@ -130,19 +156,19 @@ PP(pp_substcont) if (cx->sb_iters > cx->sb_maxiters) DIE("Substitution loop"); - if (!cx->sb_rxtainted) - cx->sb_rxtainted = SvTAINTED(TOPs); + if (!(cx->sb_rxtainted & 2) && SvTAINTED(TOPs)) + cx->sb_rxtainted |= 2; sv_catsv(dstr, POPs); /* Are we done */ - if (cx->sb_once || !regexec_flags(rx, s, cx->sb_strend, orig, + if (cx->sb_once || !CALLREGEXEC(rx, s, cx->sb_strend, orig, s == m, Nullsv, NULL, cx->sb_safebase ? 0 : REXEC_COPY_STR)) { SV *targ = cx->sb_targ; sv_catpvn(dstr, s, cx->sb_strend - s); - TAINT_IF(cx->sb_rxtainted || RX_MATCH_TAINTED(rx)); + cx->sb_rxtainted |= RX_MATCH_TAINTED(rx); (void)SvOOK_off(targ); Safefree(SvPVX(targ)); @@ -151,11 +177,15 @@ PP(pp_substcont) SvLEN_set(targ, SvLEN(dstr)); 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); + TAINT_IF(cx->sb_rxtainted); SvSETMAGIC(targ); SvTAINT(targ); - PUSHs(sv_2mortal(newSViv((I32)cx->sb_iters - 1))); LEAVE_SCOPE(cx->sb_oldsave); POPSUBST(cx); RETURNOP(pm->op_next); @@ -239,7 +269,7 @@ rxres_free(void **rsp) PP(pp_formline) { djSP; dMARK; dORIGMARK; - register SV *form = *++MARK; + register SV *tmpForm = *++MARK; register U16 *fpc; register char *t; register char *f; @@ -251,24 +281,24 @@ PP(pp_formline) I32 itemsize; I32 fieldsize; I32 lines = 0; - bool chopspace = (strchr(chopset, ' ') != Nullch); + bool chopspace = (strchr(PL_chopset, ' ') != Nullch); char *chophere; char *linemark; double value; bool gotsome; STRLEN len; - if (!SvMAGICAL(form) || !SvCOMPILED(form)) { - SvREADONLY_off(form); - doparseform(form); + if (!SvMAGICAL(tmpForm) || !SvCOMPILED(tmpForm)) { + SvREADONLY_off(tmpForm); + doparseform(tmpForm); } - SvPV_force(formtarget, len); - t = SvGROW(formtarget, len + SvCUR(form) + 1); /* XXX SvCUR bad */ + SvPV_force(PL_formtarget, len); + t = SvGROW(PL_formtarget, len + SvCUR(tmpForm) + 1); /* XXX SvCUR bad */ t += len; - f = SvPV(form, len); + f = SvPV(tmpForm, len); /* need to jump to the next word */ - s = f + len + WORD_ALIGN - SvCUR(form) % WORD_ALIGN; + s = f + len + WORD_ALIGN - SvCUR(tmpForm) % WORD_ALIGN; fpc = (U16*)s; @@ -325,8 +355,8 @@ PP(pp_formline) if (MARK < SP) sv = *++MARK; else { - sv = &sv_no; - if (dowarn) + sv = &PL_sv_no; + if (PL_dowarn) warn("Not enough format arguments"); } break; @@ -374,7 +404,7 @@ PP(pp_formline) else { if (*s & ~31) gotsome = TRUE; - if (strchr(chopset, *s)) + if (strchr(PL_chopset, *s)) chophere = s + 1; } s++; @@ -406,15 +436,13 @@ PP(pp_formline) arg = itemsize; s = item; while (arg--) { -#if 'z' - 'a' != 25 +#ifdef EBCDIC int ch = *t++ = *s++; - if (!iscntrl(ch)) - t[-1] = ' '; + if (iscntrl(ch)) #else if ( !((*t++ = *s++) & ~31) ) - t[-1] = ' '; #endif - + t[-1] = ' '; } break; @@ -441,10 +469,10 @@ PP(pp_formline) lines++; } } - SvCUR_set(formtarget, t - SvPVX(formtarget)); - sv_catpvn(formtarget, item, itemsize); - SvGROW(formtarget, SvCUR(formtarget) + SvCUR(form) + 1); - t = SvPVX(formtarget) + SvCUR(formtarget); + SvCUR_set(PL_formtarget, t - SvPVX(PL_formtarget)); + sv_catpvn(PL_formtarget, item, itemsize); + SvGROW(PL_formtarget, SvCUR(PL_formtarget) + SvCUR(tmpForm) + 1); + t = SvPVX(PL_formtarget) + SvCUR(PL_formtarget); } break; @@ -482,14 +510,14 @@ PP(pp_formline) if (gotsome) { if (arg) { /* repeat until fields exhausted? */ *t = '\0'; - SvCUR_set(formtarget, t - SvPVX(formtarget)); - lines += FmLINES(formtarget); + SvCUR_set(PL_formtarget, t - SvPVX(PL_formtarget)); + lines += FmLINES(PL_formtarget); if (lines == 200) { arg = t - linemark; if (strnEQ(linemark, linemark - arg, arg)) DIE("Runaway format"); } - FmLINES(formtarget) = lines; + FmLINES(PL_formtarget) = lines; SP = ORIGMARK; RETURNOP(cLISTOP->op_first); } @@ -510,7 +538,7 @@ PP(pp_formline) } s = t - 3; if (strnEQ(s," ",3)) { - while (s > SvPVX(formtarget) && isSPACE(s[-1])) + while (s > SvPVX(PL_formtarget) && isSPACE(s[-1])) s--; } *s++ = '.'; @@ -521,8 +549,8 @@ PP(pp_formline) case FF_END: *t = '\0'; - SvCUR_set(formtarget, t - SvPVX(formtarget)); - FmLINES(formtarget) += lines; + SvCUR_set(PL_formtarget, t - SvPVX(PL_formtarget)); + FmLINES(PL_formtarget) += lines; SP = ORIGMARK; RETPUSHYES; } @@ -534,31 +562,35 @@ PP(pp_grepstart) djSP; SV *src; - if (stack_base + *markstack_ptr == sp) { + if (PL_stack_base + *PL_markstack_ptr == SP) { (void)POPMARK; if (GIMME_V == G_SCALAR) - XPUSHs(&sv_no); - RETURNOP(op->op_next->op_next); + XPUSHs(&PL_sv_no); + RETURNOP(PL_op->op_next->op_next); } - stack_sp = stack_base + *markstack_ptr + 1; + PL_stack_sp = PL_stack_base + *PL_markstack_ptr + 1; pp_pushmark(ARGS); /* push dst */ pp_pushmark(ARGS); /* push src */ ENTER; /* enter outer scope */ SAVETMPS; - SAVESPTR(GvSV(defgv)); - +#ifdef USE_THREADS + /* SAVE_DEFSV does *not* suffice here */ + save_sptr(&THREADSV(0)); +#else + SAVESPTR(GvSV(PL_defgv)); +#endif /* USE_THREADS */ ENTER; /* enter inner scope */ - SAVESPTR(curpm); + SAVESPTR(PL_curpm); - src = stack_base[*markstack_ptr]; + src = PL_stack_base[*PL_markstack_ptr]; SvTEMP_off(src); - GvSV(defgv) = src; + DEFSV = src; PUTBACK; - if (op->op_type == OP_MAPSTART) + if (PL_op->op_type == OP_MAPSTART) pp_pushmark(ARGS); /* push top */ - return ((LOGOP*)op->op_next)->op_other; + return ((LOGOP*)PL_op->op_next)->op_other; } PP(pp_mapstart) @@ -569,27 +601,27 @@ PP(pp_mapstart) PP(pp_mapwhile) { djSP; - I32 diff = (sp - stack_base) - *markstack_ptr; + I32 diff = (SP - PL_stack_base) - *PL_markstack_ptr; I32 count; I32 shift; SV** src; SV** dst; - ++markstack_ptr[-1]; + ++PL_markstack_ptr[-1]; if (diff) { - if (diff > markstack_ptr[-1] - markstack_ptr[-2]) { - shift = diff - (markstack_ptr[-1] - markstack_ptr[-2]); - count = (sp - stack_base) - markstack_ptr[-1] + 2; + 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; - EXTEND(sp,shift); - src = sp; - dst = (sp += shift); - markstack_ptr[-1] += shift; - *markstack_ptr += shift; + EXTEND(SP,shift); + src = SP; + dst = (SP += shift); + PL_markstack_ptr[-1] += shift; + *PL_markstack_ptr += shift; while (--count) *dst-- = *src--; } - dst = stack_base + (markstack_ptr[-2] += diff) - 1; + dst = PL_stack_base + (PL_markstack_ptr[-2] += diff) - 1; ++diff; while (--diff) *dst-- = SvTEMP(TOPs) ? POPs : sv_mortalcopy(POPs); @@ -597,16 +629,16 @@ PP(pp_mapwhile) LEAVE; /* exit inner scope */ /* All done yet? */ - if (markstack_ptr[-1] > *markstack_ptr) { + if (PL_markstack_ptr[-1] > *PL_markstack_ptr) { I32 items; I32 gimme = GIMME_V; (void)POPMARK; /* pop top */ LEAVE; /* exit outer scope */ (void)POPMARK; /* pop src */ - items = --*markstack_ptr - markstack_ptr[-1]; + items = --*PL_markstack_ptr - PL_markstack_ptr[-1]; (void)POPMARK; /* pop dst */ - SP = stack_base + POPMARK; /* pop original mark */ + SP = PL_stack_base + POPMARK; /* pop original mark */ if (gimme == G_SCALAR) { dTARGET; XPUSHi(items); @@ -619,17 +651,16 @@ PP(pp_mapwhile) SV *src; ENTER; /* enter inner scope */ - SAVESPTR(curpm); + SAVESPTR(PL_curpm); - src = stack_base[markstack_ptr[-1]]; + src = PL_stack_base[PL_markstack_ptr[-1]]; SvTEMP_off(src); - GvSV(defgv) = src; + DEFSV = src; RETURNOP(cLOGOP->op_other); } } - PP(pp_sort) { djSP; dMARK; dORIGMARK; @@ -640,21 +671,22 @@ PP(pp_sort) GV *gv; CV *cv; I32 gimme = GIMME; - OP* nextop = op->op_next; + OP* nextop = PL_op->op_next; if (gimme != G_ARRAY) { SP = MARK; RETPUSHUNDEF; } - if (op->op_flags & OPf_STACKED) { - ENTER; - if (op->op_flags & OPf_SPECIAL) { + 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 */ - sortcop = kid->op_next; - stash = curcop->cop_stash; + PL_sortcop = kid->op_next; + stash = PL_curcop->cop_stash; } else { cv = sv_2cv(*++MARK, &stash, &gv, 0); @@ -674,17 +706,17 @@ PP(pp_sort) } DIE("Not a CODE reference in sort"); } - sortcop = CvSTART(cv); + PL_sortcop = CvSTART(cv); SAVESPTR(CvROOT(cv)->op_ppaddr); CvROOT(cv)->op_ppaddr = ppaddr[OP_NULL]; - SAVESPTR(curpad); - curpad = AvARRAY((AV*)AvARRAY(CvPADLIST(cv))[1]); + SAVESPTR(PL_curpad); + PL_curpad = AvARRAY((AV*)AvARRAY(CvPADLIST(cv))[1]); } } else { - sortcop = Nullop; - stash = curcop->cop_stash; + PL_sortcop = Nullop; + stash = PL_curcop->cop_stash; } up = myorigmark + 1; @@ -692,15 +724,14 @@ PP(pp_sort) /*SUPPRESS 560*/ if (*up = *++MARK) { /* Weed out nulls. */ SvTEMP_off(*up); - if (!sortcop && !SvPOK(*up)) - (void)sv_2pv(*up, &na); + if (!PL_sortcop && !SvPOK(*up)) + (void)sv_2pv(*up, &PL_na); up++; } } max = --up - myorigmark; - if (sortcop) { + if (PL_sortcop) { if (max > 1) { - AV *oldstack; PERL_CONTEXT *cx; SV** newsp; bool oldcatch = CATCH_GET; @@ -708,25 +739,19 @@ PP(pp_sort) SAVETMPS; SAVEOP(); - oldstack = curstack; - if (!sortstack) { - sortstack = newAV(); - AvREAL_off(sortstack); - av_extend(sortstack, 32); - } CATCH_SET(TRUE); - SWITCHSTACK(curstack, sortstack); - if (sortstash != stash) { - firstgv = gv_fetchpv("a", TRUE, SVt_PV); - secondgv = gv_fetchpv("b", TRUE, SVt_PV); - sortstash = stash; + 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(firstgv)); - SAVESPTR(GvSV(secondgv)); + SAVESPTR(GvSV(PL_firstgv)); + SAVESPTR(GvSV(PL_secondgv)); - PUSHBLOCK(cx, CXt_NULL, stack_base); - if (!(op->op_flags & OPf_SPECIAL)) { + 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; @@ -734,24 +759,25 @@ PP(pp_sort) if (!CvDEPTH(cv)) (void)SvREFCNT_inc(cv); /* in preparation for POPSUB */ } - sortcxix = cxstack_ix; + PL_sortcxix = cxstack_ix; + qsortsv((myorigmark+1), max, FUNC_NAME_TO_PTR(sortcv)); - qsort((char*)(myorigmark+1), max, sizeof(SV*), sortcv); - - POPBLOCK(cx,curpm); - SWITCHSTACK(sortstack, oldstack); + POPBLOCK(cx,PL_curpm); + POPSTACK; CATCH_SET(oldcatch); } - LEAVE; } else { if (max > 1) { MEXTEND(SP, 20); /* Can't afford stack realloc on signal. */ - qsort((char*)(ORIGMARK+1), max, sizeof(SV*), - (op->op_private & OPpLOCALE) ? sortcmp_locale : sortcmp); + qsortsv(ORIGMARK+1, max, + (PL_op->op_private & OPpLOCALE) + ? FUNC_NAME_TO_PTR(sv_cmp_locale) + : FUNC_NAME_TO_PTR(sv_cmp)); } } - stack_sp = ORIGMARK + max; + LEAVE; + PL_stack_sp = ORIGMARK + max; return nextop; } @@ -761,7 +787,7 @@ PP(pp_range) { if (GIMME == G_ARRAY) return cCONDOP->op_true; - return SvTRUEx(PAD_SV(op->op_targ)) ? cCONDOP->op_false : cCONDOP->op_true; + return SvTRUEx(PAD_SV(PL_op->op_targ)) ? cCONDOP->op_false : cCONDOP->op_true; } PP(pp_flip) @@ -773,20 +799,20 @@ PP(pp_flip) } else { dTOPss; - SV *targ = PAD_SV(op->op_targ); + SV *targ = PAD_SV(PL_op->op_targ); - if ((op->op_private & OPpFLIP_LINENUM) - ? last_in_gv && SvIV(sv) == IoLINES(GvIOp(last_in_gv)) + if ((PL_op->op_private & OPpFLIP_LINENUM) + ? (PL_last_in_gv && SvIV(sv) == (IV)IoLINES(GvIOp(PL_last_in_gv))) : SvTRUE(sv) ) { sv_setiv(PAD_SV(cUNOP->op_first->op_targ), 1); - if (op->op_flags & OPf_SPECIAL) { + if (PL_op->op_flags & OPf_SPECIAL) { sv_setiv(targ, 1); SETs(targ); RETURN; } else { sv_setiv(targ, 0); - sp--; + SP--; RETURNOP(((CONDOP*)cUNOP->op_first)->op_false); } } @@ -809,6 +835,8 @@ PP(pp_flop) if (SvNIOKp(left) || !SvPOKp(left) || (looks_like_number(left) && *SvPVX(left) != '0') ) { + if (SvNV(left) < IV_MIN || SvNV(right) >= IV_MAX) + croak("Range iterator outside integer range"); i = SvIV(left); max = SvIV(right); if (max >= i) { @@ -826,22 +854,22 @@ PP(pp_flop) char *tmps = SvPV(final, len); sv = sv_mortalcopy(left); - while (!SvNIOKp(sv) && SvCUR(sv) <= len && - strNE(SvPVX(sv),tmps) ) { + SvPV_force(sv,PL_na); + while (!SvNIOKp(sv) && SvCUR(sv) <= len) { XPUSHs(sv); + if (strEQ(SvPVX(sv),tmps)) + break; sv = sv_2mortal(newSVsv(sv)); sv_inc(sv); } - if (strEQ(SvPVX(sv),tmps)) - XPUSHs(sv); } } else { dTOPss; SV *targ = PAD_SV(cUNOP->op_first->op_targ); sv_inc(targ); - if ((op->op_private & OPpFLIP_LINENUM) - ? last_in_gv && SvIV(sv) == IoLINES(GvIOp(last_in_gv)) + if ((PL_op->op_private & OPpFLIP_LINENUM) + ? (PL_last_in_gv && SvIV(sv) == (IV)IoLINES(GvIOp(PL_last_in_gv))) : SvTRUE(sv) ) { sv_setiv(PAD_SV(((UNOP*)cUNOP->op_first)->op_first->op_targ), 0); sv_catpv(targ, "E0"); @@ -854,7 +882,7 @@ PP(pp_flop) /* Control. */ -static I32 +STATIC I32 dopoptolabel(char *label) { dTHR; @@ -865,20 +893,20 @@ dopoptolabel(char *label) cx = &cxstack[i]; switch (cx->cx_type) { case CXt_SUBST: - if (dowarn) - warn("Exiting substitution via %s", op_name[op->op_type]); + if (PL_dowarn) + warn("Exiting substitution via %s", op_name[PL_op->op_type]); break; case CXt_SUB: - if (dowarn) - warn("Exiting subroutine via %s", op_name[op->op_type]); + if (PL_dowarn) + warn("Exiting subroutine via %s", op_name[PL_op->op_type]); break; case CXt_EVAL: - if (dowarn) - warn("Exiting eval via %s", op_name[op->op_type]); + if (PL_dowarn) + warn("Exiting eval via %s", op_name[PL_op->op_type]); break; case CXt_NULL: - if (dowarn) - warn("Exiting pseudo-block via %s", op_name[op->op_type]); + if (PL_dowarn) + warn("Exiting pseudo-block via %s", op_name[PL_op->op_type]); return -1; case CXt_LOOP: if (!cx->blk_loop.label || @@ -912,25 +940,34 @@ block_gimme(void) return G_VOID; switch (cxstack[cxix].blk_gimme) { + case G_VOID: + return G_VOID; case G_SCALAR: return G_SCALAR; case G_ARRAY: return G_ARRAY; default: croak("panic: bad gimme: %d\n", cxstack[cxix].blk_gimme); - case G_VOID: - return G_VOID; + /* NOTREACHED */ + return 0; } } -static I32 +STATIC I32 dopoptosub(I32 startingblock) { dTHR; + return dopoptosub_at(cxstack, startingblock); +} + +STATIC I32 +dopoptosub_at(PERL_CONTEXT *cxstk, I32 startingblock) +{ + dTHR; I32 i; register PERL_CONTEXT *cx; for (i = startingblock; i >= 0; i--) { - cx = &cxstack[i]; + cx = &cxstk[i]; switch (cx->cx_type) { default: continue; @@ -943,7 +980,7 @@ dopoptosub(I32 startingblock) return i; } -static I32 +STATIC I32 dopoptoeval(I32 startingblock) { dTHR; @@ -962,7 +999,7 @@ dopoptoeval(I32 startingblock) return i; } -static I32 +STATIC I32 dopoptoloop(I32 startingblock) { dTHR; @@ -972,20 +1009,20 @@ dopoptoloop(I32 startingblock) cx = &cxstack[i]; switch (cx->cx_type) { case CXt_SUBST: - if (dowarn) - warn("Exiting substitution via %s", op_name[op->op_type]); + if (PL_dowarn) + warn("Exiting substitution via %s", op_name[PL_op->op_type]); break; case CXt_SUB: - if (dowarn) - warn("Exiting subroutine via %s", op_name[op->op_type]); + if (PL_dowarn) + warn("Exiting subroutine via %s", op_name[PL_op->op_type]); break; case CXt_EVAL: - if (dowarn) - warn("Exiting eval via %s", op_name[op->op_type]); + if (PL_dowarn) + warn("Exiting eval via %s", op_name[PL_op->op_type]); break; case CXt_NULL: - if (dowarn) - warn("Exiting pseudo-block via %s", op_name[op->op_type]); + if (PL_dowarn) + warn("Exiting pseudo-block via %s", op_name[PL_op->op_type]); return -1; case CXt_LOOP: DEBUG_l( deb("(Found loop #%ld)\n", (long)i)); @@ -1006,7 +1043,7 @@ dounwind(I32 cxix) while (cxstack_ix > cxix) { cx = &cxstack[cxstack_ix]; DEBUG_l(PerlIO_printf(Perl_debug_log, "Unwinding block %ld, type %s\n", - (long) cxstack_ix+1, block_type[cx->cx_type])); + (long) cxstack_ix, block_type[cx->cx_type])); /* Note: we don't need to restore the base context info till the end. */ switch (cx->cx_type) { case CXt_SUBST: @@ -1031,41 +1068,52 @@ dounwind(I32 cxix) OP * die_where(char *message) { - dTHR; - if (in_eval) { + dSP; + if (PL_in_eval) { I32 cxix; register PERL_CONTEXT *cx; I32 gimme; SV **newsp; - if (in_eval & 4) { - SV **svp; - STRLEN klen = strlen(message); - - svp = hv_fetch(ERRHV, message, klen, TRUE); - if (svp) { - if (!SvIOK(*svp)) { - static char prefix[] = "\t(in cleanup) "; - sv_upgrade(*svp, SVt_IV); - (void)SvIOK_only(*svp); - SvGROW(ERRSV, SvCUR(ERRSV)+sizeof(prefix)+klen); - sv_catpvn(ERRSV, prefix, sizeof(prefix)-1); - sv_catpvn(ERRSV, message, klen); + if (message) { + if (PL_in_eval & 4) { + SV **svp; + STRLEN klen = strlen(message); + + svp = hv_fetch(ERRHV, message, klen, TRUE); + if (svp) { + if (!SvIOK(*svp)) { + static char prefix[] = "\t(in cleanup) "; + SV *err = ERRSV; + sv_upgrade(*svp, SVt_IV); + (void)SvIOK_only(*svp); + if (!SvPOK(err)) + sv_setpv(err,""); + SvGROW(err, SvCUR(err)+sizeof(prefix)+klen); + sv_catpvn(err, prefix, sizeof(prefix)-1); + sv_catpvn(err, message, klen); + } + sv_inc(*svp); } - sv_inc(*svp); } + else + sv_setpv(ERRSV, message); } else - sv_setpv(ERRSV, message); - - cxix = dopoptoeval(cxstack_ix); + message = SvPVx(ERRSV, PL_na); + + while ((cxix = dopoptoeval(cxstack_ix)) < 0 && PL_curstackinfo->si_prev) { + dounwind(-1); + POPSTACK; + } + if (cxix >= 0) { I32 optype; if (cxix < cxstack_ix) dounwind(cxix); - POPBLOCK(cx,curpm); + POPBLOCK(cx,PL_curpm); if (cx->cx_type != CXt_EVAL) { PerlIO_printf(PerlIO_stderr(), "panic: die %s", message); my_exit(1); @@ -1073,13 +1121,13 @@ die_where(char *message) POPEVAL(cx); if (gimme == G_SCALAR) - *++newsp = &sv_undef; - stack_sp = newsp; + *++newsp = &PL_sv_undef; + PL_stack_sp = newsp; LEAVE; if (optype == OP_REQUIRE) { - char* msg = SvPVx(ERRSV, na); + char* msg = SvPVx(ERRSV, PL_na); DIE("%s", *msg ? msg : "Compilation failed in require"); } return pop_return(); @@ -1124,8 +1172,11 @@ PP(pp_caller) djSP; 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; SV *sv; I32 count = 0; @@ -1133,43 +1184,58 @@ PP(pp_caller) count = POPi; EXTEND(SP, 6); for (;;) { + /* we may be in a higher stacklevel, so dig down deeper */ + while (cxix < 0 && top_si->si_type != PERLSI_MAIN) { + top_si = top_si->si_prev; + ccstack = top_si->si_cxstack; + cxix = dopoptosub_at(ccstack, top_si->si_cxix); + } if (cxix < 0) { if (GIMME != G_ARRAY) RETPUSHUNDEF; RETURN; } - if (DBsub && cxix >= 0 && - cxstack[cxix].blk_sub.cv == GvCV(DBsub)) + if (PL_DBsub && cxix >= 0 && + ccstack[cxix].blk_sub.cv == GvCV(PL_DBsub)) count++; if (!count--) break; - cxix = dopoptosub(cxix - 1); + cxix = dopoptosub_at(ccstack, cxix - 1); } - cx = &cxstack[cxix]; - if (cxstack[cxix].cx_type == CXt_SUB) { - dbcxix = dopoptosub(cxix - 1); - /* We expect that cxstack[dbcxix] is CXt_SUB, anyway, the + + cx = &ccstack[cxix]; + if (ccstack[cxix].cx_type == CXt_SUB) { + dbcxix = dopoptosub_at(ccstack, cxix - 1); + /* We expect that ccstack[dbcxix] is CXt_SUB, anyway, the field below is defined for any cx. */ - if (DBsub && dbcxix >= 0 && cxstack[dbcxix].blk_sub.cv == GvCV(DBsub)) - cx = &cxstack[dbcxix]; + if (PL_DBsub && dbcxix >= 0 && ccstack[dbcxix].blk_sub.cv == GvCV(PL_DBsub)) + cx = &ccstack[dbcxix]; } if (GIMME != G_ARRAY) { - dTARGET; - - sv_setpv(TARG, HvNAME(cx->blk_oldcop->cop_stash)); - PUSHs(TARG); + hv = cx->blk_oldcop->cop_stash; + if (!hv) + PUSHs(&PL_sv_undef); + else { + dTARGET; + sv_setpv(TARG, HvNAME(hv)); + PUSHs(TARG); + } RETURN; } - PUSHs(sv_2mortal(newSVpv(HvNAME(cx->blk_oldcop->cop_stash), 0))); + hv = cx->blk_oldcop->cop_stash; + if (!hv) + PUSHs(&PL_sv_undef); + else + PUSHs(sv_2mortal(newSVpv(HvNAME(hv), 0))); PUSHs(sv_2mortal(newSVpv(SvPVX(GvSV(cx->blk_oldcop->cop_filegv)), 0))); PUSHs(sv_2mortal(newSViv((I32)cx->blk_oldcop->cop_line))); if (!MAXARG) RETURN; - if (cx->cx_type == CXt_SUB) { /* So is cxstack[dbcxix]. */ + if (cx->cx_type == CXt_SUB) { /* So is ccstack[dbcxix]. */ sv = NEWSV(49, 0); - gv_efullname3(sv, CvGV(cxstack[cxix].blk_sub.cv), Nullch); + gv_efullname3(sv, CvGV(ccstack[cxix].blk_sub.cv), Nullch); PUSHs(sv_2mortal(sv)); PUSHs(sv_2mortal(newSViv((I32)cx->blk_sub.hasargs))); } @@ -1179,81 +1245,67 @@ PP(pp_caller) } gimme = (I32)cx->blk_gimme; if (gimme == G_VOID) - PUSHs(&sv_undef); + PUSHs(&PL_sv_undef); else PUSHs(sv_2mortal(newSViv(gimme & G_ARRAY))); if (cx->cx_type == CXt_EVAL) { if (cx->blk_eval.old_op_type == OP_ENTEREVAL) { PUSHs(cx->blk_eval.cur_text); - PUSHs(&sv_no); + 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))); - PUSHs(&sv_yes); + PUSHs(&PL_sv_yes); } } else if (cx->cx_type == CXt_SUB && cx->blk_sub.hasargs && - curcop->cop_stash == debstash) + PL_curcop->cop_stash == PL_debstash) { AV *ary = cx->blk_sub.argarray; int off = AvARRAY(ary) - AvALLOC(ary); - if (!dbargs) { + if (!PL_dbargs) { GV* tmpgv; - dbargs = GvAV(gv_AVadd(tmpgv = gv_fetchpv("DB::args", TRUE, + PL_dbargs = GvAV(gv_AVadd(tmpgv = gv_fetchpv("DB::args", TRUE, SVt_PVAV))); GvMULTI_on(tmpgv); - AvREAL_off(dbargs); /* XXX Should be REIFY */ + AvREAL_off(PL_dbargs); /* XXX Should be REIFY */ } - if (AvMAX(dbargs) < AvFILL(ary) + off) - av_extend(dbargs, AvFILL(ary) + off); - Copy(AvALLOC(ary), AvARRAY(dbargs), AvFILL(ary) + 1 + off, SV*); - AvFILL(dbargs) = AvFILL(ary) + off; + if (AvMAX(PL_dbargs) < AvFILLp(ary) + off) + av_extend(PL_dbargs, AvFILLp(ary) + off); + Copy(AvALLOC(ary), AvARRAY(PL_dbargs), AvFILLp(ary) + 1 + off, SV*); + AvFILLp(PL_dbargs) = AvFILLp(ary) + off; } RETURN; } -static int -sortcv(const void *a, const void *b) +STATIC I32 +sortcv(SV *a, SV *b) { dTHR; - SV * const *str1 = (SV * const *)a; - SV * const *str2 = (SV * const *)b; - I32 oldsaveix = savestack_ix; - I32 oldscopeix = scopestack_ix; + I32 oldsaveix = PL_savestack_ix; + I32 oldscopeix = PL_scopestack_ix; I32 result; - GvSV(firstgv) = *str1; - GvSV(secondgv) = *str2; - stack_sp = stack_base; - op = sortcop; - runops(); - if (stack_sp != stack_base + 1) + GvSV(PL_firstgv) = a; + GvSV(PL_secondgv) = b; + PL_stack_sp = PL_stack_base; + PL_op = PL_sortcop; + CALLRUNOPS(); + if (PL_stack_sp != PL_stack_base + 1) croak("Sort subroutine didn't return single value"); - if (!SvNIOKp(*stack_sp)) + if (!SvNIOKp(*PL_stack_sp)) croak("Sort subroutine didn't return a numeric value"); - result = SvIV(*stack_sp); - while (scopestack_ix > oldscopeix) { + result = SvIV(*PL_stack_sp); + while (PL_scopestack_ix > oldscopeix) { LEAVE; } leave_scope(oldsaveix); return result; } -static int -sortcmp(const void *a, const void *b) -{ - return sv_cmp(*(SV * const *)a, *(SV * const *)b); -} - -static int -sortcmp_locale(const void *a, const void *b) -{ - return sv_cmp_locale(*(SV * const *)a, *(SV * const *)b); -} - PP(pp_reset) { djSP; @@ -1263,8 +1315,8 @@ PP(pp_reset) tmps = ""; else tmps = POPp; - sv_reset(tmps, curcop->cop_stash); - PUSHs(&sv_yes); + sv_reset(tmps, PL_curcop->cop_stash); + PUSHs(&PL_sv_yes); RETURN; } @@ -1275,44 +1327,44 @@ PP(pp_lineseq) PP(pp_dbstate) { - curcop = (COP*)op; + PL_curcop = (COP*)PL_op; TAINT_NOT; /* Each statement is presumed innocent */ - stack_sp = stack_base + cxstack[cxstack_ix].blk_oldsp; + PL_stack_sp = PL_stack_base + cxstack[cxstack_ix].blk_oldsp; FREETMPS; - if (op->op_private || SvIV(DBsingle) || SvIV(DBsignal) || SvIV(DBtrace)) + if (PL_op->op_private || SvIV(PL_DBsingle) || SvIV(PL_DBsignal) || SvIV(PL_DBtrace)) { - SV **sp; + djSP; register CV *cv; register PERL_CONTEXT *cx; I32 gimme = G_ARRAY; I32 hasargs; GV *gv; - gv = DBgv; + gv = PL_DBgv; cv = GvCV(gv); if (!cv) DIE("No DB::DB routine defined"); - if (CvDEPTH(cv) >= 1 && !(debug & (1<<30))) /* don't do recursive DB::DB call */ + if (CvDEPTH(cv) >= 1 && !(PL_debug & (1<<30))) /* don't do recursive DB::DB call */ return NORMAL; ENTER; SAVETMPS; - SAVEI32(debug); + SAVEI32(PL_debug); SAVESTACK_POS(); - debug = 0; + PL_debug = 0; hasargs = 0; - sp = stack_sp; + SPAGAIN; - push_return(op->op_next); - PUSHBLOCK(cx, CXt_SUB, sp); + push_return(PL_op->op_next); + PUSHBLOCK(cx, CXt_SUB, SP); PUSHSUB(cx); CvDEPTH(cv)++; (void)SvREFCNT_inc(cv); - SAVESPTR(curpad); - curpad = AvARRAY((AV*)*av_fetch(CvPADLIST(cv),1,FALSE)); + SAVESPTR(PL_curpad); + PL_curpad = AvARRAY((AV*)*av_fetch(CvPADLIST(cv),1,FALSE)); RETURNOP(CvSTART(cv)); } else @@ -1334,23 +1386,45 @@ PP(pp_enteriter) ENTER; SAVETMPS; - if (op->op_targ) - svp = &curpad[op->op_targ]; /* "my" variable */ +#ifdef USE_THREADS + if (PL_op->op_flags & OPf_SPECIAL) + svp = save_threadsv(PL_op->op_targ); /* per-thread variable */ else - svp = &GvSV((GV*)POPs); /* symbol table variable */ - - SAVESPTR(*svp); +#endif /* USE_THREADS */ + if (PL_op->op_targ) { + svp = &PL_curpad[PL_op->op_targ]; /* "my" variable */ + SAVESPTR(*svp); + } + else { + GV *gv = (GV*)POPs; + (void)save_scalar(gv); + svp = &GvSV(gv); /* symbol table variable */ + } ENTER; PUSHBLOCK(cx, CXt_LOOP, SP); PUSHLOOP(cx, svp, MARK); - if (op->op_flags & OPf_STACKED) + 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')) { + if (SvNV(sv) < IV_MIN || + SvNV((SV*)cx->blk_loop.iterary) >= IV_MAX) + croak("Range iterator outside integer range"); + cx->blk_loop.iterix = SvIV(sv); + cx->blk_loop.itermax = SvIV((SV*)cx->blk_loop.iterary); + } + else + cx->blk_loop.iterlval = newSVsv(sv); + } + } else { - cx->blk_loop.iterary = curstack; - AvFILL(curstack) = sp - stack_base; - cx->blk_loop.iterix = MARK - stack_base; + cx->blk_loop.iterary = PL_curstack; + AvFILLp(PL_curstack) = SP - PL_stack_base; + cx->blk_loop.iterix = MARK - PL_stack_base; } RETURN; @@ -1393,7 +1467,7 @@ PP(pp_leaveloop) if (mark < SP) *++newsp = sv_mortalcopy(*SP); else - *++newsp = &sv_undef; + *++newsp = &PL_sv_undef; } else { while (mark < SP) { @@ -1405,7 +1479,7 @@ PP(pp_leaveloop) PUTBACK; POPLOOP2(); /* Stack values are safe: release loop vars ... */ - curpm = newpm; /* ... and pop $1 et al */ + PL_curpm = newpm; /* ... and pop $1 et al */ LEAVE; LEAVE; @@ -1425,12 +1499,12 @@ PP(pp_return) PMOP *newpm; I32 optype = 0; - if (curstack == sortstack) { - if (cxstack_ix == sortcxix || dopoptosub(cxstack_ix) <= sortcxix) { - if (cxstack_ix > sortcxix) - dounwind(sortcxix); - AvARRAY(curstack)[1] = *SP; - stack_sp = stack_base + 1; + if (PL_curstackinfo->si_type == PERLSI_SORT) { + if (cxstack_ix == PL_sortcxix || dopoptosub(cxstack_ix) <= PL_sortcxix) { + if (cxstack_ix > PL_sortcxix) + dounwind(PL_sortcxix); + AvARRAY(PL_curstack)[1] = *SP; + PL_stack_sp = PL_stack_base + 1; return 0; } } @@ -1454,7 +1528,7 @@ PP(pp_return) { /* Unassume the success we assumed earlier. */ char *name = cx->blk_eval.old_name; - (void)hv_delete(GvHVn(incgv), name, strlen(name), G_DISCARD); + (void)hv_delete(GvHVn(PL_incgv), name, strlen(name), G_DISCARD); DIE("%s did not return a true value", name); } break; @@ -1464,11 +1538,23 @@ PP(pp_return) TAINT_NOT; if (gimme == G_SCALAR) { - if (MARK < SP) - *++newsp = (popsub2 && SvTEMP(*SP)) - ? *SP : sv_mortalcopy(*SP); - else - *++newsp = &sv_undef; + if (MARK < SP) { + if (popsub2) { + if (cxsub.cv && CvDEPTH(cxsub.cv) > 1) { + if (SvTEMP(TOPs)) { + *++newsp = SvREFCNT_inc(*SP); + FREETMPS; + sv_2mortal(*newsp); + } else { + FREETMPS; + *++newsp = sv_mortalcopy(*SP); + } + } else + *++newsp = (SvTEMP(*SP)) ? *SP : sv_mortalcopy(*SP); + } else + *++newsp = sv_mortalcopy(*SP); + } else + *++newsp = &PL_sv_undef; } else if (gimme == G_ARRAY) { while (++MARK <= SP) { @@ -1477,13 +1563,13 @@ PP(pp_return) TAINT_NOT; /* Each item is independent */ } } - stack_sp = newsp; + PL_stack_sp = newsp; /* Stack values are safe: */ if (popsub2) { POPSUB2(); /* release CV and @_ ... */ } - curpm = newpm; /* ... and pop $1 et al */ + PL_curpm = newpm; /* ... and pop $1 et al */ LEAVE; return pop_return(); @@ -1502,9 +1588,9 @@ PP(pp_last) OP *nextop; SV **newsp; PMOP *newpm; - SV **mark = stack_base + cxstack[cxstack_ix].blk_oldsp; + SV **mark = PL_stack_base + cxstack[cxstack_ix].blk_oldsp; - if (op->op_flags & OPf_SPECIAL) { + if (PL_op->op_flags & OPf_SPECIAL) { cxix = dopoptoloop(cxstack_ix); if (cxix < 0) DIE("Can't \"last\" outside a block"); @@ -1543,7 +1629,7 @@ PP(pp_last) *++newsp = ((pop2 == CXt_SUB) && SvTEMP(*SP)) ? *SP : sv_mortalcopy(*SP); else - *++newsp = &sv_undef; + *++newsp = &PL_sv_undef; } else if (gimme == G_ARRAY) { while (++MARK <= SP) { @@ -1565,7 +1651,7 @@ PP(pp_last) POPSUB2(); /* release CV and @_ ... */ break; } - curpm = newpm; /* ... and pop $1 et al */ + PL_curpm = newpm; /* ... and pop $1 et al */ LEAVE; return nextop; @@ -1577,7 +1663,7 @@ PP(pp_next) register PERL_CONTEXT *cx; I32 oldsave; - if (op->op_flags & OPf_SPECIAL) { + if (PL_op->op_flags & OPf_SPECIAL) { cxix = dopoptoloop(cxstack_ix); if (cxix < 0) DIE("Can't \"next\" outside a block"); @@ -1591,7 +1677,7 @@ PP(pp_next) dounwind(cxix); TOPBLOCK(cx); - oldsave = scopestack[scopestack_ix - 1]; + oldsave = PL_scopestack[PL_scopestack_ix - 1]; LEAVE_SCOPE(oldsave); return cx->blk_loop.next_op; } @@ -1602,7 +1688,7 @@ PP(pp_redo) register PERL_CONTEXT *cx; I32 oldsave; - if (op->op_flags & OPf_SPECIAL) { + if (PL_op->op_flags & OPf_SPECIAL) { cxix = dopoptoloop(cxstack_ix); if (cxix < 0) DIE("Can't \"redo\" outside a block"); @@ -1616,14 +1702,12 @@ PP(pp_redo) dounwind(cxix); TOPBLOCK(cx); - oldsave = scopestack[scopestack_ix - 1]; + oldsave = PL_scopestack[PL_scopestack_ix - 1]; LEAVE_SCOPE(oldsave); return cx->blk_loop.redo_op; } -static OP* lastgotoprobe; - -static OP * +STATIC OP * dofindlabel(OP *o, char *label, OP **opstack, OP **oplimit) { OP *kid; @@ -1643,6 +1727,7 @@ dofindlabel(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) && @@ -1650,7 +1735,7 @@ dofindlabel(OP *o, char *label, OP **opstack, OP **oplimit) return kid; } for (kid = cUNOPo->op_first; kid; kid = kid->op_sibling) { - if (kid == lastgotoprobe) + if (kid == PL_lastgotoprobe) continue; if ((kid->op_type == OP_NEXTSTATE || kid->op_type == OP_DBSTATE) && (ops == opstack || @@ -1680,10 +1765,10 @@ PP(pp_goto) #define GOTO_DEPTH 64 OP *enterops[GOTO_DEPTH]; char *label; - int do_dump = (op->op_type == OP_DUMP); + int do_dump = (PL_op->op_type == OP_DUMP); label = 0; - if (op->op_flags & OPf_STACKED) { + if (PL_op->op_flags & OPf_STACKED) { SV *sv = POPs; /* This egregious kludge implements goto &subroutine */ @@ -1711,25 +1796,43 @@ PP(pp_goto) if (cxix < cxstack_ix) dounwind(cxix); TOPBLOCK(cx); - mark = stack_sp; - if (cx->blk_sub.hasargs) { /* put @_ back onto stack */ + if (cx->cx_type == CXt_EVAL && cx->blk_eval.old_op_type == OP_ENTEREVAL) + DIE("Can't goto subroutine from an eval-string"); + mark = PL_stack_sp; + if (cx->cx_type == CXt_SUB && + cx->blk_sub.hasargs) { /* put @_ back onto stack */ AV* av = cx->blk_sub.argarray; - items = AvFILL(av) + 1; - stack_sp++; - EXTEND(stack_sp, items); /* @_ could have been extended. */ - Copy(AvARRAY(av), stack_sp, items, SV*); - stack_sp += items; + items = AvFILLp(av) + 1; + PL_stack_sp++; + 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(defgv)); - GvAV(defgv) = cx->blk_sub.savearray; + SvREFCNT_dec(GvAV(PL_defgv)); + GvAV(PL_defgv) = cx->blk_sub.savearray; #endif /* USE_THREADS */ AvREAL_off(av); av_clear(av); } - if (!(CvDEPTH(cx->blk_sub.cv) = cx->blk_sub.olddepth)) + 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. */ + Copy(AvARRAY(av), PL_stack_sp, items, SV*); + PL_stack_sp += items; + } + if (cx->cx_type == CXt_SUB && + !(CvDEPTH(cx->blk_sub.cv) = cx->blk_sub.olddepth)) SvREFCNT_dec(cx->blk_sub.cv); - oldsave = scopestack[scopestack_ix - 1]; + oldsave = PL_scopestack[PL_scopestack_ix - 1]; LEAVE_SCOPE(oldsave); /* Now do some callish stuff. */ @@ -1737,19 +1840,27 @@ PP(pp_goto) if (CvXSUB(cv)) { if (CvOLDSTYLE(cv)) { I32 (*fp3)_((int,int,int)); - while (sp > mark) { - sp[1] = sp[0]; - sp--; + while (SP > mark) { + SP[1] = SP[0]; + SP--; } fp3 = (I32(*)_((int,int,int)))CvXSUB(cv); items = (*fp3)(CvXSUBANY(cv).any_i32, - mark - stack_base + 1, + mark - PL_stack_base + 1, items); - sp = stack_base + items; + SP = PL_stack_base + items; } else { - stack_sp--; /* There is no cv arg. */ - (void)(*CvXSUB(cv))(cv); + SV **newsp; + I32 gimme; + + PL_stack_sp--; /* There is no cv arg. */ + /* Push a mark for the start of arglist */ + PUSHMARK(mark); + (void)(*CvXSUB(cv))(cv _PERL_OBJECT_THIS); + /* Pop the current context like a decent sub should */ + POPBLOCK(cx, PL_curpm); + /* Do _not_ use PUTBACK, keep the XSUB's return stack! */ } LEAVE; return pop_return(); @@ -1757,21 +1868,27 @@ PP(pp_goto) else { AV* padlist = CvPADLIST(cv); SV** svp = AvARRAY(padlist); + if (cx->cx_type == CXt_EVAL) { + PL_in_eval = cx->blk_eval.old_in_eval; + PL_eval_root = cx->blk_eval.old_eval_root; + cx->cx_type = CXt_SUB; + cx->blk_sub.hasargs = 0; + } cx->blk_sub.cv = cv; cx->blk_sub.olddepth = CvDEPTH(cv); CvDEPTH(cv)++; if (CvDEPTH(cv) < 2) (void)SvREFCNT_inc(cv); else { /* save temporaries on recursion? */ - if (CvDEPTH(cv) == 100 && dowarn) + if (CvDEPTH(cv) == 100 && PL_dowarn) sub_crush_depth(cv); - if (CvDEPTH(cv) > AvFILL(padlist)) { + if (CvDEPTH(cv) > AvFILLp(padlist)) { AV *newpad = newAV(); SV **oldpad = AvARRAY(svp[CvDEPTH(cv)-1]); - I32 ix = AvFILL((AV*)svp[1]); + I32 ix = AvFILLp((AV*)svp[1]); svp = AvARRAY(svp[0]); for ( ;ix > 0; ix--) { - if (svp[ix] != &sv_undef) { + if (svp[ix] != &PL_sv_undef) { char *name = SvPVX(svp[ix]); if ((SvFLAGS(svp[ix]) & SVf_FAKE) || *name == '&') @@ -1802,36 +1919,36 @@ PP(pp_goto) AvFLAGS(av) = AVf_REIFY; } av_store(padlist, CvDEPTH(cv), (SV*)newpad); - AvFILL(padlist) = CvDEPTH(cv); + AvFILLp(padlist) = CvDEPTH(cv); svp = AvARRAY(padlist); } } #ifdef USE_THREADS if (!cx->blk_sub.hasargs) { - AV* av = (AV*)curpad[0]; + AV* av = (AV*)PL_curpad[0]; - items = AvFILL(av) + 1; + 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; + EXTEND(SP, items); + Copy(AvARRAY(av), SP + 1, items, SV*); + SP += items; PUTBACK ; } } #endif /* USE_THREADS */ - SAVESPTR(curpad); - curpad = AvARRAY((AV*)svp[CvDEPTH(cv)]); + SAVESPTR(PL_curpad); + PL_curpad = AvARRAY((AV*)svp[CvDEPTH(cv)]); #ifndef USE_THREADS if (cx->blk_sub.hasargs) #endif /* USE_THREADS */ { - AV* av = (AV*)curpad[0]; + AV* av = (AV*)PL_curpad[0]; SV** ary; #ifndef USE_THREADS - cx->blk_sub.savearray = GvAV(defgv); - GvAV(defgv) = (AV*)SvREFCNT_inc(av); + cx->blk_sub.savearray = GvAV(PL_defgv); + GvAV(PL_defgv) = (AV*)SvREFCNT_inc(av); #endif /* USE_THREADS */ cx->blk_sub.argarray = av; ++mark; @@ -1850,7 +1967,7 @@ PP(pp_goto) } } Copy(mark,AvARRAY(av),items,SV*); - AvFILL(av) = items - 1; + AvFILLp(av) = items - 1; while (items--) { if (*mark) @@ -1858,22 +1975,34 @@ PP(pp_goto) mark++; } } - if (PERLDB_SUB && curstash != debstash) { + if (PERLDB_SUB) { /* Checking curstash breaks DProf. */ /* * We do not care about using sv to call CV; * it's for informational purposes only. */ - SV *sv = GvSV(DBsub); - save_item(sv); - gv_efullname3(sv, CvGV(cv), Nullch); + SV *sv = GvSV(PL_DBsub); + CV *gotocv; + + if (PERLDB_SUB_NN) { + SvIVX(sv) = (IV)cv; /* Already upgraded, saved */ + } else { + save_item(sv); + gv_efullname3(sv, CvGV(cv), Nullch); + } + if ( PERLDB_GOTO + && (gotocv = perl_get_cv("DB::goto", FALSE)) ) { + PUSHMARK( PL_stack_sp ); + perl_call_sv((SV*)gotocv, G_SCALAR | G_NODEBUG); + PL_stack_sp--; + } } RETURNOP(CvSTART(cv)); } } else - label = SvPV(sv,na); + label = SvPV(sv,PL_na); } - else if (op->op_flags & OPf_SPECIAL) { + else if (PL_op->op_flags & OPf_SPECIAL) { if (! do_dump) DIE("goto must have label"); } @@ -1885,13 +2014,13 @@ PP(pp_goto) /* find label */ - lastgotoprobe = 0; + PL_lastgotoprobe = 0; *enterops = 0; for (ix = cxstack_ix; ix >= 0; ix--) { cx = &cxstack[ix]; switch (cx->cx_type) { case CXt_EVAL: - gotoprobe = eval_root; /* XXX not good for nested eval */ + gotoprobe = PL_eval_root; /* XXX not good for nested eval */ break; case CXt_LOOP: gotoprobe = cx->blk_oldcop->op_sibling; @@ -1902,7 +2031,7 @@ PP(pp_goto) if (ix) gotoprobe = cx->blk_oldcop->op_sibling; else - gotoprobe = main_root; + gotoprobe = PL_main_root; break; case CXt_SUB: if (CvDEPTH(cx->blk_sub.cv)) { @@ -1915,14 +2044,14 @@ PP(pp_goto) default: if (ix) DIE("panic: goto"); - gotoprobe = main_root; + gotoprobe = PL_main_root; break; } retop = dofindlabel(gotoprobe, label, enterops, enterops + GOTO_DEPTH); if (retop) break; - lastgotoprobe = gotoprobe; + PL_lastgotoprobe = gotoprobe; } if (!retop) DIE("Can't find label %s", label); @@ -1936,42 +2065,42 @@ PP(pp_goto) ix = 0; dounwind(ix); TOPBLOCK(cx); - oldsave = scopestack[scopestack_ix]; + oldsave = PL_scopestack[PL_scopestack_ix]; LEAVE_SCOPE(oldsave); } /* push wanted frames */ if (*enterops && enterops[1]) { - OP *oldop = op; + OP *oldop = PL_op; for (ix = 1; enterops[ix]; ix++) { - op = enterops[ix]; + PL_op = enterops[ix]; /* Eventually we may want to stack the needed arguments * for each op. For now, we punt on the hard ones. */ - if (op->op_type == OP_ENTERITER) + if (PL_op->op_type == OP_ENTERITER) DIE("Can't \"goto\" into the middle of a foreach loop", label); - (*op->op_ppaddr)(ARGS); + (CALLOP->op_ppaddr)(ARGS); } - op = oldop; + PL_op = oldop; } } if (do_dump) { #ifdef VMS - if (!retop) retop = main_start; + if (!retop) retop = PL_main_start; #endif - restartop = retop; - do_undump = TRUE; + PL_restartop = retop; + PL_do_undump = TRUE; my_unexec(); - restartop = 0; /* hmm, must be GNU unexec().. */ - do_undump = FALSE; + PL_restartop = 0; /* hmm, must be GNU unexec().. */ + PL_do_undump = FALSE; } - if (curstack == signalstack) { - restartop = retop; + if (PL_top_env->je_prev) { + PL_restartop = retop; JMPENV_JUMP(3); } @@ -1993,7 +2122,7 @@ PP(pp_exit) #endif } my_exit(anum); - PUSHs(&sv_undef); + PUSHs(&PL_sv_undef); RETURN; } @@ -2013,8 +2142,8 @@ PP(pp_nswitch) match = 0; else if (match > cCOP->uop.scop.scop_max) match = cCOP->uop.scop.scop_max; - op = cCOP->uop.scop.scop_next[match]; - RETURNOP(op); + PL_op = cCOP->uop.scop.scop_next[match]; + RETURNOP(PL_op); } PP(pp_cswitch) @@ -2022,24 +2151,24 @@ PP(pp_cswitch) djSP; register I32 match; - if (multiline) - op = op->op_next; /* can't assume anything */ + if (PL_multiline) + PL_op = PL_op->op_next; /* can't assume anything */ else { - match = *(SvPVx(GvSV(cCOP->cop_gv), na)) & 255; + match = *(SvPVx(GvSV(cCOP->cop_gv), PL_na)) & 255; match -= cCOP->uop.scop.scop_offset; if (match < 0) match = 0; else if (match > cCOP->uop.scop.scop_max) match = cCOP->uop.scop.scop_max; - op = cCOP->uop.scop.scop_next[match]; + PL_op = cCOP->uop.scop.scop_next[match]; } - RETURNOP(op); + RETURNOP(PL_op); } #endif /* Eval. */ -static void +STATIC void save_lines(AV *array, SV *sv) { register char *s = SvPVX(sv); @@ -2063,40 +2192,40 @@ save_lines(AV *array, SV *sv) } } -static OP * +STATIC OP * docatch(OP *o) { dTHR; int ret; - OP *oldop = op; + OP *oldop = PL_op; dJMPENV; - op = o; + PL_op = o; #ifdef DEBUGGING assert(CATCH_GET == TRUE); - DEBUG_l(deb("Setting up local jumplevel %p, was %p\n", &cur_env, top_env)); + DEBUG_l(deb("Setting up local jumplevel %p, was %p\n", &cur_env, PL_top_env)); #endif JMPENV_PUSH(ret); switch (ret) { default: /* topmost level handles it */ JMPENV_POP; - op = oldop; + PL_op = oldop; JMPENV_JUMP(ret); /* NOTREACHED */ case 3: - if (!restartop) { + if (!PL_restartop) { PerlIO_printf(PerlIO_stderr(), "panic: restartop\n"); break; } - op = restartop; - restartop = 0; + PL_op = PL_restartop; + PL_restartop = 0; /* FALL THROUGH */ case 0: - runops(); + CALLRUNOPS(); break; } JMPENV_POP; - op = oldop; + PL_op = oldop; return Nullop; } @@ -2109,10 +2238,10 @@ sv_compile_2op(SV *sv, OP** startop, char *code, AV** avp) dSP; /* Make POPBLOCK work. */ PERL_CONTEXT *cx; SV **newsp; - I32 gimme; + I32 gimme = 0; /* SUSPECT - INITIALZE TO WHAT? NI-S */ I32 optype; OP dummy; - OP *oop = op, *rop; + OP *oop = PL_op, *rop; char tmpbuf[TYPE_DIGITS(long) + 12 + 10]; char *safestr; @@ -2121,175 +2250,197 @@ sv_compile_2op(SV *sv, OP** startop, char *code, AV** avp) SAVETMPS; /* switch to eval mode */ - SAVESPTR(compiling.cop_filegv); - SAVEI16(compiling.cop_line); - sprintf(tmpbuf, "_<(%.10s_eval %lu)", code, (unsigned long)++evalseq); - compiling.cop_filegv = gv_fetchfile(tmpbuf+2); - compiling.cop_line = 1; + if (PL_curcop == &PL_compiling) { + SAVESPTR(PL_compiling.cop_stash); + PL_compiling.cop_stash = PL_curstash; + } + SAVESPTR(PL_compiling.cop_filegv); + SAVEI16(PL_compiling.cop_line); + sprintf(tmpbuf, "_<(%.10s_eval %lu)", code, (unsigned long)++PL_evalseq); + PL_compiling.cop_filegv = gv_fetchfile(tmpbuf+2); + PL_compiling.cop_line = 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 ensues, we always turn GvMULTI_on for any globals that were introduced within evals. See force_ident(). GSAR 96-10-12 */ safestr = savepv(tmpbuf); - SAVEDELETE(defstash, safestr, strlen(safestr)); - SAVEI32(hints); - SAVEPPTR(op); - hints = 0; - - op = &dummy; - op->op_type = 0; /* Avoid uninit warning. */ - op->op_flags = 0; /* Avoid uninit warning. */ + SAVEDELETE(PL_defstash, safestr, strlen(safestr)); + SAVEHINTS(); +#ifdef OP_IN_REGISTER + PL_opsave = op; +#else + SAVEPPTR(PL_op); +#endif + PL_hints = 0; + + PL_op = &dummy; + PL_op->op_type = 0; /* Avoid uninit warning. */ + PL_op->op_flags = 0; /* Avoid uninit warning. */ PUSHBLOCK(cx, CXt_EVAL, SP); - PUSHEVAL(cx, 0, compiling.cop_filegv); + PUSHEVAL(cx, 0, PL_compiling.cop_filegv); rop = doeval(G_SCALAR, startop); - POPBLOCK(cx,curpm); + POPBLOCK(cx,PL_curpm); POPEVAL(cx); (*startop)->op_type = OP_NULL; (*startop)->op_ppaddr = ppaddr[OP_NULL]; lex_end(); - *avp = (AV*)SvREFCNT_inc(comppad); + *avp = (AV*)SvREFCNT_inc(PL_comppad); LEAVE; +#ifdef OP_IN_REGISTER + op = PL_opsave; +#endif return rop; } /* With USE_THREADS, eval_owner must be held on entry to doeval */ -static OP * +STATIC OP * doeval(int gimme, OP** startop) { dSP; - OP *saveop = op; + OP *saveop = PL_op; HV *newstash; CV *caller; AV* comppadlist; + I32 i; - in_eval = 1; + PL_in_eval = 1; PUSHMARK(SP); /* set up a scratch pad */ - SAVEI32(padix); - SAVESPTR(curpad); - SAVESPTR(comppad); - SAVESPTR(comppad_name); - SAVEI32(comppad_name_fill); - SAVEI32(min_intro_pending); - SAVEI32(max_intro_pending); - - caller = compcv; - SAVESPTR(compcv); - compcv = (CV*)NEWSV(1104,0); - sv_upgrade((SV *)compcv, SVt_PVCV); - CvUNIQUE_on(compcv); + 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; i >= 0; i--) { + PERL_CONTEXT *cx = &cxstack[i]; + if (cx->cx_type == CXt_EVAL) + break; + else if (cx->cx_type == CXt_SUB) { + caller = cx->blk_sub.cv; + break; + } + } + + SAVESPTR(PL_compcv); + PL_compcv = (CV*)NEWSV(1104,0); + sv_upgrade((SV *)PL_compcv, SVt_PVCV); + CvUNIQUE_on(PL_compcv); #ifdef USE_THREADS - CvOWNER(compcv) = 0; - New(666, CvMUTEXP(compcv), 1, perl_mutex); - MUTEX_INIT(CvMUTEXP(compcv)); + CvOWNER(PL_compcv) = 0; + New(666, CvMUTEXP(PL_compcv), 1, perl_mutex); + MUTEX_INIT(CvMUTEXP(PL_compcv)); #endif /* USE_THREADS */ - comppad = newAV(); - av_push(comppad, Nullsv); - curpad = AvARRAY(comppad); - comppad_name = newAV(); - comppad_name_fill = 0; - min_intro_pending = 0; - padix = 0; + 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(comppad_name, 0, newSVpv("@_", 2)); - curpad[0] = (SV*)newAV(); - SvPADMY_on(curpad[0]); /* XXX Needed? */ + av_store(PL_comppad_name, 0, newSVpv("@_", 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*)comppad_name); - av_store(comppadlist, 1, (SV*)comppad); - CvPADLIST(compcv) = 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(compcv) = (CV*)SvREFCNT_inc(caller); + CvOUTSIDE(PL_compcv) = (CV*)SvREFCNT_inc(caller); - SAVEFREESV(compcv); + SAVEFREESV(PL_compcv); /* make sure we compile in the right package */ - newstash = curcop->cop_stash; - if (curstash != newstash) { - SAVESPTR(curstash); - curstash = newstash; + newstash = PL_curcop->cop_stash; + if (PL_curstash != newstash) { + SAVESPTR(PL_curstash); + PL_curstash = newstash; } - SAVESPTR(beginav); - beginav = newAV(); - SAVEFREESV(beginav); + SAVESPTR(PL_beginav); + PL_beginav = newAV(); + SAVEFREESV(PL_beginav); /* try to compile it */ - eval_root = Nullop; - error_count = 0; - curcop = &compiling; - curcop->cop_arybase = 0; - SvREFCNT_dec(rs); - rs = newSVpv("\n", 1); + PL_eval_root = Nullop; + PL_error_count = 0; + PL_curcop = &PL_compiling; + PL_curcop->cop_arybase = 0; + SvREFCNT_dec(PL_rs); + PL_rs = newSVpv("\n", 1); if (saveop && saveop->op_flags & OPf_SPECIAL) - in_eval |= 4; + PL_in_eval |= 4; else sv_setpv(ERRSV,""); - if (yyparse() || error_count || !eval_root) { + if (yyparse() || PL_error_count || !PL_eval_root) { SV **newsp; I32 gimme; PERL_CONTEXT *cx; I32 optype = 0; /* Might be reset by POPEVAL. */ - op = saveop; - if (eval_root) { - op_free(eval_root); - eval_root = Nullop; + PL_op = saveop; + if (PL_eval_root) { + op_free(PL_eval_root); + PL_eval_root = Nullop; } - SP = stack_base + POPMARK; /* pop original mark */ + SP = PL_stack_base + POPMARK; /* pop original mark */ if (!startop) { - POPBLOCK(cx,curpm); + POPBLOCK(cx,PL_curpm); POPEVAL(cx); pop_return(); } lex_end(); LEAVE; if (optype == OP_REQUIRE) { - char* msg = SvPVx(ERRSV, na); + char* msg = SvPVx(ERRSV, PL_na); DIE("%s", *msg ? msg : "Compilation failed in require"); } else if (startop) { - char* msg = SvPVx(ERRSV, na); + char* msg = SvPVx(ERRSV, PL_na); - POPBLOCK(cx,curpm); + POPBLOCK(cx,PL_curpm); POPEVAL(cx); croak("%sCompilation failed in regexp", (*msg ? msg : "Unknown error\n")); } - SvREFCNT_dec(rs); - rs = SvREFCNT_inc(nrs); + SvREFCNT_dec(PL_rs); + PL_rs = SvREFCNT_inc(PL_nrs); #ifdef USE_THREADS - MUTEX_LOCK(&eval_mutex); - eval_owner = 0; - COND_SIGNAL(&eval_cond); - MUTEX_UNLOCK(&eval_mutex); + MUTEX_LOCK(&PL_eval_mutex); + PL_eval_owner = 0; + COND_SIGNAL(&PL_eval_cond); + MUTEX_UNLOCK(&PL_eval_mutex); #endif /* USE_THREADS */ RETPUSHUNDEF; } - SvREFCNT_dec(rs); - rs = SvREFCNT_inc(nrs); - compiling.cop_line = 0; + SvREFCNT_dec(PL_rs); + PL_rs = SvREFCNT_inc(PL_nrs); + PL_compiling.cop_line = 0; if (startop) { - *startop = eval_root; - SvREFCNT_dec(CvOUTSIDE(compcv)); - CvOUTSIDE(compcv) = Nullcv; + *startop = PL_eval_root; + SvREFCNT_dec(CvOUTSIDE(PL_compcv)); + CvOUTSIDE(PL_compcv) = Nullcv; } else - SAVEFREEOP(eval_root); + SAVEFREEOP(PL_eval_root); if (gimme & G_VOID) - scalarvoid(eval_root); + scalarvoid(PL_eval_root); else if (gimme & G_ARRAY) - list(eval_root); + list(PL_eval_root); else - scalar(eval_root); + scalar(PL_eval_root); DEBUG_x(dump_eval()); @@ -2298,8 +2449,8 @@ doeval(int gimme, OP** startop) CV *cv = perl_get_cv("DB::postponed", FALSE); if (cv) { dSP; - PUSHMARK(sp); - XPUSHs((SV*)compiling.cop_filegv); + PUSHMARK(SP); + XPUSHs((SV*)PL_compiling.cop_filegv); PUTBACK; perl_call_sv((SV*)cv, G_DISCARD); } @@ -2307,17 +2458,17 @@ doeval(int gimme, OP** startop) /* compiled okay, so do it */ - CvDEPTH(compcv) = 1; - SP = stack_base + POPMARK; /* pop original mark */ - op = saveop; /* The caller may need it. */ + 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(&eval_mutex); - eval_owner = 0; - COND_SIGNAL(&eval_cond); - MUTEX_UNLOCK(&eval_mutex); + MUTEX_LOCK(&PL_eval_mutex); + PL_eval_owner = 0; + COND_SIGNAL(&PL_eval_cond); + MUTEX_UNLOCK(&PL_eval_mutex); #endif /* USE_THREADS */ - RETURNOP(eval_start); + RETURNOP(PL_eval_start); } PP(pp_require) @@ -2326,6 +2477,7 @@ PP(pp_require) register PERL_CONTEXT *cx; SV *sv; char *name; + STRLEN len; char *tryname; SV *namesv = Nullsv; SV** svp; @@ -2335,18 +2487,18 @@ PP(pp_require) sv = POPs; if (SvNIOKp(sv) && !SvPOKp(sv)) { SET_NUMERIC_STANDARD(); - if (atof(patchlevel) + 0.00000999 < SvNV(sv)) + if (atof(PL_patchlevel) + 0.00000999 < SvNV(sv)) DIE("Perl %s required--this is only version %s, stopped", - SvPV(sv,na),patchlevel); + SvPV(sv,PL_na),PL_patchlevel); RETPUSHYES; } - name = SvPV(sv, na); - if (!*name) + name = SvPV(sv, len); + if (!(name && len > 0 && *name)) DIE("Null filename used"); TAINT_PROPER("require"); - if (op->op_type == OP_REQUIRE && - (svp = hv_fetch(GvHVn(incgv), name, SvCUR(sv), 0)) && - *svp != &sv_undef) + if (PL_op->op_type == OP_REQUIRE && + (svp = hv_fetch(GvHVn(PL_incgv), name, len, 0)) && + *svp != &PL_sv_undef) RETPUSHYES; /* prepare to compile file */ @@ -2371,7 +2523,7 @@ PP(pp_require) tryrsfp = PerlIO_open(name,PERL_SCRIPT_MODE); } else { - AV *ar = GvAVn(incgv); + AV *ar = GvAVn(PL_incgv); I32 i; #ifdef VMS char *unixname; @@ -2380,7 +2532,7 @@ PP(pp_require) { namesv = NEWSV(806, 0); for (i = 0; i <= AvFILL(ar); i++) { - char *dir = SvPVx(*av_fetch(ar, i, TRUE), na); + char *dir = SvPVx(*av_fetch(ar, i, TRUE), PL_na); #ifdef VMS char *unixdir; if ((unixdir = tounixpath(dir, Nullch)) == Nullch) @@ -2400,14 +2552,14 @@ PP(pp_require) } } } - SAVESPTR(compiling.cop_filegv); - compiling.cop_filegv = gv_fetchfile(tryrsfp ? tryname : name); + SAVESPTR(PL_compiling.cop_filegv); + PL_compiling.cop_filegv = gv_fetchfile(tryrsfp ? tryname : name); SvREFCNT_dec(namesv); if (!tryrsfp) { - if (op->op_type == OP_REQUIRE) { + if (PL_op->op_type == OP_REQUIRE) { SV *msg = sv_2mortal(newSVpvf("Can't locate %s in @INC", name)); SV *dirmsgsv = NEWSV(0, 0); - AV *ar = GvAVn(incgv); + AV *ar = GvAVn(PL_incgv); I32 i; if (instr(SvPVX(msg), ".h ")) sv_catpv(msg, " (change .h to .ph maybe?)"); @@ -2415,7 +2567,7 @@ PP(pp_require) sv_catpv(msg, " (did you run h2ph?)"); sv_catpv(msg, " (@INC contains:"); for (i = 0; i <= AvFILL(ar); i++) { - char *dir = SvPVx(*av_fetch(ar, i, TRUE), na); + char *dir = SvPVx(*av_fetch(ar, i, TRUE), PL_na); sv_setpvf(dirmsgsv, " %s", dir); sv_catsv(msg, dirmsgsv); } @@ -2428,39 +2580,39 @@ PP(pp_require) } /* Assume success here to prevent recursive requirement. */ - (void)hv_store(GvHVn(incgv), name, strlen(name), - newSVsv(GvSV(compiling.cop_filegv)), 0 ); + (void)hv_store(GvHVn(PL_incgv), name, strlen(name), + newSVsv(GvSV(PL_compiling.cop_filegv)), 0 ); ENTER; SAVETMPS; lex_start(sv_2mortal(newSVpv("",0))); - if (rsfp_filters){ - save_aptr(&rsfp_filters); - rsfp_filters = NULL; + if (PL_rsfp_filters){ + save_aptr(&PL_rsfp_filters); + PL_rsfp_filters = NULL; } - rsfp = tryrsfp; + PL_rsfp = tryrsfp; name = savepv(name); SAVEFREEPV(name); - SAVEI32(hints); - hints = 0; + SAVEHINTS(); + PL_hints = 0; /* switch to eval mode */ - push_return(op->op_next); + push_return(PL_op->op_next); PUSHBLOCK(cx, CXt_EVAL, SP); - PUSHEVAL(cx, name, compiling.cop_filegv); + PUSHEVAL(cx, name, PL_compiling.cop_filegv); - compiling.cop_line = 0; + PL_compiling.cop_line = 0; PUTBACK; #ifdef USE_THREADS - MUTEX_LOCK(&eval_mutex); - if (eval_owner && eval_owner != thr) - while (eval_owner) - COND_WAIT(&eval_cond, &eval_mutex); - eval_owner = thr; - MUTEX_UNLOCK(&eval_mutex); + 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)); } @@ -2475,7 +2627,7 @@ PP(pp_entereval) djSP; register PERL_CONTEXT *cx; dPOPss; - I32 gimme = GIMME_V, was = sub_generation; + I32 gimme = GIMME_V, was = PL_sub_generation; char tmpbuf[TYPE_DIGITS(long) + 12]; char *safestr; STRLEN len; @@ -2491,40 +2643,40 @@ PP(pp_entereval) /* switch to eval mode */ - SAVESPTR(compiling.cop_filegv); - sprintf(tmpbuf, "_<(eval %lu)", (unsigned long)++evalseq); - compiling.cop_filegv = gv_fetchfile(tmpbuf+2); - compiling.cop_line = 1; + SAVESPTR(PL_compiling.cop_filegv); + sprintf(tmpbuf, "_<(eval %lu)", (unsigned long)++PL_evalseq); + PL_compiling.cop_filegv = gv_fetchfile(tmpbuf+2); + PL_compiling.cop_line = 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 ensues, we always turn GvMULTI_on for any globals that were introduced within evals. See force_ident(). GSAR 96-10-12 */ safestr = savepv(tmpbuf); - SAVEDELETE(defstash, safestr, strlen(safestr)); - SAVEI32(hints); - hints = op->op_targ; + SAVEDELETE(PL_defstash, safestr, strlen(safestr)); + SAVEHINTS(); + PL_hints = PL_op->op_targ; - push_return(op->op_next); + push_return(PL_op->op_next); PUSHBLOCK(cx, CXt_EVAL, SP); - PUSHEVAL(cx, 0, compiling.cop_filegv); + PUSHEVAL(cx, 0, PL_compiling.cop_filegv); /* prepare to compile string */ - if (PERLDB_LINE && curstash != debstash) - save_lines(GvAV(compiling.cop_filegv), linestr); + if (PERLDB_LINE && PL_curstash != PL_debstash) + save_lines(GvAV(PL_compiling.cop_filegv), PL_linestr); PUTBACK; #ifdef USE_THREADS - MUTEX_LOCK(&eval_mutex); - if (eval_owner && eval_owner != thr) - while (eval_owner) - COND_WAIT(&eval_cond, &eval_mutex); - eval_owner = thr; - MUTEX_UNLOCK(&eval_mutex); + 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 != sub_generation /* Some subs defined here. */ - && ret != op->op_next) { /* Successive compilation. */ + if (PERLDB_INTER && was != PL_sub_generation /* Some subs defined here. */ + && ret != PL_op->op_next) { /* Successive compilation. */ strcpy(safestr, "_<(eval )"); /* Anything fake and short. */ } return DOCATCH(ret); @@ -2539,7 +2691,7 @@ PP(pp_leaveeval) I32 gimme; register PERL_CONTEXT *cx; OP *retop; - U8 save_flags = op -> op_flags; + U8 save_flags = PL_op -> op_flags; I32 optype; POPBLOCK(cx,newpm); @@ -2559,7 +2711,7 @@ PP(pp_leaveeval) } else { MEXTEND(mark,0); - *MARK = &sv_undef; + *MARK = &PL_sv_undef; } } else { @@ -2571,7 +2723,7 @@ PP(pp_leaveeval) } } } - curpm = newpm; /* Don't pop $1 et al till now */ + PL_curpm = newpm; /* Don't pop $1 et al till now */ /* * Closures mentioned at top level of eval cannot be referenced @@ -2579,16 +2731,16 @@ PP(pp_leaveeval) * (Note that the fact that compcv and friends are still set here * is, AFAIK, an accident.) --Chip */ - if (AvFILL(comppad_name) >= 0) { - SV **svp = AvARRAY(comppad_name); + if (AvFILLp(PL_comppad_name) >= 0) { + SV **svp = AvARRAY(PL_comppad_name); I32 ix; - for (ix = AvFILL(comppad_name); ix >= 0; ix--) { + for (ix = AvFILLp(PL_comppad_name); ix >= 0; ix--) { SV *sv = svp[ix]; - if (sv && sv != &sv_undef && *SvPVX(sv) == '&') { + if (sv && sv != &PL_sv_undef && *SvPVX(sv) == '&') { SvREFCNT_dec(sv); - svp[ix] = &sv_undef; + svp[ix] = &PL_sv_undef; - sv = curpad[ix]; + sv = PL_curpad[ix]; if (CvCLONE(sv)) { SvREFCNT_dec(CvOUTSIDE(sv)); CvOUTSIDE(sv) = Nullcv; @@ -2597,31 +2749,32 @@ PP(pp_leaveeval) SvREFCNT_dec(sv); sv = NEWSV(0,0); SvPADTMP_on(sv); - curpad[ix] = sv; + PL_curpad[ix] = sv; } } } } #ifdef DEBUGGING - assert(CvDEPTH(compcv) == 1); + assert(CvDEPTH(PL_compcv) == 1); #endif - CvDEPTH(compcv) = 0; + CvDEPTH(PL_compcv) = 0; + lex_end(); if (optype == OP_REQUIRE && - !(gimme == G_SCALAR ? SvTRUE(*sp) : sp > newsp)) + !(gimme == G_SCALAR ? SvTRUE(*SP) : SP > newsp)) { /* Unassume the success we assumed earlier. */ char *name = cx->blk_eval.old_name; - (void)hv_delete(GvHVn(incgv), name, strlen(name), G_DISCARD); + (void)hv_delete(GvHVn(PL_incgv), name, strlen(name), G_DISCARD); retop = die("%s did not return a true value", name); + /* die_where() did LEAVE, or we won't be here */ + } + else { + LEAVE; + if (!(save_flags & OPf_SPECIAL)) + sv_setpv(ERRSV,""); } - - lex_end(); - LEAVE; - - if (!(save_flags & OPf_SPECIAL)) - sv_setpv(ERRSV,""); RETURNOP(retop); } @@ -2638,12 +2791,12 @@ PP(pp_entertry) push_return(cLOGOP->op_other->op_next); PUSHBLOCK(cx, CXt_EVAL, SP); PUSHEVAL(cx, 0, 0); - eval_root = op; /* Only needed so that goto works right. */ + PL_eval_root = PL_op; /* Only needed so that goto works right. */ - in_eval = 1; + PL_in_eval = 1; sv_setpv(ERRSV,""); PUTBACK; - return DOCATCH(op->op_next); + return DOCATCH(PL_op->op_next); } PP(pp_leavetry) @@ -2673,7 +2826,7 @@ PP(pp_leavetry) } else { MEXTEND(mark,0); - *MARK = &sv_undef; + *MARK = &PL_sv_undef; } SP = MARK; } @@ -2686,14 +2839,14 @@ PP(pp_leavetry) } } } - curpm = newpm; /* Don't pop $1 et al till now */ + PL_curpm = newpm; /* Don't pop $1 et al till now */ LEAVE; sv_setpv(ERRSV,""); RETURN; } -static void +STATIC void doparseform(SV *sv) { STRLEN len; @@ -2871,3 +3024,693 @@ doparseform(SV *sv) 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 +*/ +#ifdef PERL_OBJECT +#define qsort_cmp(elt1, elt2) \ + ((this->*compare)(array[elt1], array[elt2])) +#else +#define qsort_cmp(elt1, elt2) \ + ((*compare)(array[elt1], array[elt2])) +#endif + +#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 +#ifdef PERL_OBJECT +qsortsv(SV ** array, size_t num_elts, SVCOMPARE compare) +#else +qsortsv( + SV ** array, + size_t num_elts, + I32 (*compare)(SV *a, SV *b)) +#endif +{ + 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! */ +}