integrate ansi branch to get s/foo/PL_foo/ changes

p4raw-id: //depot/perl@1575

1 files changed, 391 insertions, 391 deletions

diff --git a/pp_ctl.c b/pp_ctl.c
index 5a4dcf4a4e..81b4281278 100644
--- a/pp_ctl.c
+++ b/pp_ctl.c
@@ -28,7 +28,7 @@
 #ifdef PERL_OBJECT
 #define CALLOP this->*op
 #else
-#define CALLOP *op
+#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));
@@ -72,7 +72,7 @@ PP(pp_regcreset)
 {
     /* XXXX Should store the old value to allow for tie/overload - and
        restore in regcomp, where marked with XXXX. */
-    reginterp_cnt = 0;
+    PL_reginterp_cnt = 0;
     return NORMAL;
 }
 
@@ -108,33 +108,33 @@ PP(pp_regcomp)
 		ReREFCNT_dec(pm->op_pmregexp);
 		pm->op_pmregexp = Null(REGEXP*);	/* crucial if regcomp aborts */
 	    }
-	    if (op->op_flags & OPf_SPECIAL)
-		reginterp_cnt = I32_MAX; /* Mark as safe.  */
+	    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(t, t + len, pm);
-	    reginterp_cnt = 0;		/* XXXX Be extra paranoid - needed
+	    PL_reginterp_cnt = 0;		/* XXXX Be extra paranoid - needed
 					   inside tie/overload accessors.  */
 	}
     }
 
 #ifndef INCOMPLETE_TAINTS
-    if (tainting) {
-	if (tainted)
+    if (PL_tainting) {
+	if (PL_tainted)
 	    pm->op_pmdynflags |= PMdf_TAINTED;
 	else
 	    pm->op_pmdynflags &= ~PMdf_TAINTED;
     }
 #endif
 
-    if (!pm->op_pmregexp->prelen && curpm)
-	pm = curpm;
+    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;
 }
@@ -281,7 +281,7 @@ 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;
@@ -293,8 +293,8 @@ PP(pp_formline)
 	doparseform(tmpForm);
     }
 
-    SvPV_force(formtarget, len);
-    t = SvGROW(formtarget, len + SvCUR(tmpForm) + 1);  /* XXX SvCUR bad */
+    SvPV_force(PL_formtarget, len);
+    t = SvGROW(PL_formtarget, len + SvCUR(tmpForm) + 1);  /* XXX SvCUR bad */
     t += len;
     f = SvPV(tmpForm, len);
     /* need to jump to the next word */
@@ -355,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;
@@ -404,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++;
@@ -471,10 +471,10 @@ PP(pp_formline)
 			    lines++;
 		    }
 		}
-		SvCUR_set(formtarget, t - SvPVX(formtarget));
-		sv_catpvn(formtarget, item, itemsize);
-		SvGROW(formtarget, SvCUR(formtarget) + SvCUR(tmpForm) + 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;
 
@@ -512,14 +512,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);
 		}
@@ -540,7 +540,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++ = '.';
@@ -551,8 +551,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;
 	}
@@ -564,13 +564,13 @@ 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 */
@@ -580,19 +580,19 @@ PP(pp_grepstart)
     /* SAVE_DEFSV does *not* suffice here */
     save_sptr(&THREADSV(0));
 #else
-    SAVESPTR(GvSV(defgv));
+    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);
     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)
@@ -603,27 +603,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;
+	    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); 
@@ -631,16 +631,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);
@@ -653,9 +653,9 @@ 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);
 	DEFSV = src;
 
@@ -673,7 +673,7 @@ 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;
@@ -681,14 +681,14 @@ PP(pp_sort)
     }
 
     ENTER;
-    SAVEPPTR(sortcop);
-    if (op->op_flags & OPf_STACKED) {
-	if (op->op_flags & OPf_SPECIAL) {
+    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);
@@ -708,17 +708,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;
@@ -726,13 +726,13 @@ 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) {
 	    PERL_CONTEXT *cx;
 	    SV** newsp;
@@ -743,17 +743,17 @@ PP(pp_sort)
 
 	    CATCH_SET(TRUE);
 	    PUSHSTACKi(PERLSI_SORT);
-	    if (sortstash != stash) {
-		firstgv = gv_fetchpv("a", TRUE, SVt_PV);
-		secondgv = gv_fetchpv("b", TRUE, SVt_PV);
-		sortstash = stash;
+	    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;
@@ -761,10 +761,10 @@ 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));
 
-	    POPBLOCK(cx,curpm);
+	    POPBLOCK(cx,PL_curpm);
 	    POPSTACK;
 	    CATCH_SET(oldcatch);
 	}
@@ -773,13 +773,13 @@ PP(pp_sort)
 	if (max > 1) {
 	    MEXTEND(SP, 20);	/* Can't afford stack realloc on signal. */
 	    qsortsv(ORIGMARK+1, max,
-		    (op->op_private & OPpLOCALE)
+		    (PL_op->op_private & OPpLOCALE)
 		    ? FUNC_NAME_TO_PTR(sv_cmp_locale)
 		    : FUNC_NAME_TO_PTR(sv_cmp));
 	}
     }
     LEAVE;
-    stack_sp = ORIGMARK + max;
+    PL_stack_sp = ORIGMARK + max;
     return nextop;
 }
 
@@ -789,7 +789,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)
@@ -801,13 +801,13 @@ 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) == (IV)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;
@@ -870,8 +870,8 @@ PP(pp_flop)
 	dTOPss;
 	SV *targ = PAD_SV(cUNOP->op_first->op_targ);
 	sv_inc(targ);
-	if ((op->op_private & OPpFLIP_LINENUM)
-	  ? (last_in_gv && SvIV(sv) == (IV)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");
@@ -895,20 +895,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 ||
@@ -1011,20 +1011,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));
@@ -1071,14 +1071,14 @@ OP *
 die_where(char *message)
 {
     dSP;
-    if (in_eval) {
+    if (PL_in_eval) {
 	I32 cxix;
 	register PERL_CONTEXT *cx;
 	I32 gimme;
 	SV **newsp;
 
 	if (message) {
-	    if (in_eval & 4) {
+	    if (PL_in_eval & 4) {
 		SV **svp;
 		STRLEN klen = strlen(message);
 		
@@ -1102,9 +1102,9 @@ die_where(char *message)
 		sv_setpv(ERRSV, message);
 	}
 	else
-	    message = SvPVx(ERRSV, na);
+	    message = SvPVx(ERRSV, PL_na);
 
-	while ((cxix = dopoptoeval(cxstack_ix)) < 0 && curstackinfo->si_prev) {
+	while ((cxix = dopoptoeval(cxstack_ix)) < 0 && PL_curstackinfo->si_prev) {
 	    dounwind(-1);
 	    POPSTACK;
 	}
@@ -1115,7 +1115,7 @@ die_where(char *message)
 	    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);
@@ -1123,13 +1123,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();
@@ -1175,7 +1175,7 @@ PP(pp_caller)
     register I32 cxix = dopoptosub(cxstack_ix);
     register PERL_CONTEXT *cx;
     register PERL_CONTEXT *ccstack = cxstack;
-    PERL_SI *top_si = curstackinfo;
+    PERL_SI *top_si = PL_curstackinfo;
     I32 dbcxix;
     I32 gimme;
     HV *hv;
@@ -1197,8 +1197,8 @@ PP(pp_caller)
 		RETPUSHUNDEF;
 	    RETURN;
 	}
-	if (DBsub && cxix >= 0 &&
-		ccstack[cxix].blk_sub.cv == GvCV(DBsub))
+	if (PL_DBsub && cxix >= 0 &&
+		ccstack[cxix].blk_sub.cv == GvCV(PL_DBsub))
 	    count++;
 	if (!count--)
 	    break;
@@ -1210,14 +1210,14 @@ PP(pp_caller)
         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 && ccstack[dbcxix].blk_sub.cv == GvCV(DBsub))
+	if (PL_DBsub && dbcxix >= 0 && ccstack[dbcxix].blk_sub.cv == GvCV(PL_DBsub))
 	    cx = &ccstack[dbcxix];
     }
 
     if (GIMME != G_ARRAY) {
 	hv = cx->blk_oldcop->cop_stash;
 	if (!hv)
-	    PUSHs(&sv_undef);
+	    PUSHs(&PL_sv_undef);
 	else {
 	    dTARGET;
 	    sv_setpv(TARG, HvNAME(hv));
@@ -1228,7 +1228,7 @@ PP(pp_caller)
 
     hv = cx->blk_oldcop->cop_stash;
     if (!hv)
-	PUSHs(&sv_undef);
+	PUSHs(&PL_sv_undef);
     else
 	PUSHs(sv_2mortal(newSVpv(HvNAME(hv), 0)));
     PUSHs(sv_2mortal(newSVpv(SvPVX(GvSV(cx->blk_oldcop->cop_filegv)), 0)));
@@ -1247,39 +1247,39 @@ 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) < AvFILLp(ary) + off)
-	    av_extend(dbargs, AvFILLp(ary) + off);
-	Copy(AvALLOC(ary), AvARRAY(dbargs), AvFILLp(ary) + 1 + off, SV*);
-	AvFILLp(dbargs) = AvFILLp(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;
 }
@@ -1288,20 +1288,20 @@ STATIC I32
 sortcv(SV *a, SV *b)
 {
     dTHR;
-    I32 oldsaveix = savestack_ix;
-    I32 oldscopeix = scopestack_ix;
+    I32 oldsaveix = PL_savestack_ix;
+    I32 oldscopeix = PL_scopestack_ix;
     I32 result;
-    GvSV(firstgv) = a;
-    GvSV(secondgv) = b;
-    stack_sp = stack_base;
-    op = sortcop;
+    GvSV(PL_firstgv) = a;
+    GvSV(PL_secondgv) = b;
+    PL_stack_sp = PL_stack_base;
+    PL_op = PL_sortcop;
     CALLRUNOPS();
-    if (stack_sp != stack_base + 1)
+    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);
@@ -1317,8 +1317,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;
 }
 
@@ -1329,12 +1329,12 @@ 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))
     {
 	djSP;
 	register CV *cv;
@@ -1343,30 +1343,30 @@ PP(pp_dbstate)
 	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;
 	SPAGAIN;
 
-	push_return(op->op_next);
+	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
@@ -1389,12 +1389,12 @@ PP(pp_enteriter)
     SAVETMPS;
 
 #ifdef USE_THREADS
-    if (op->op_flags & OPf_SPECIAL)
-	svp = save_threadsv(op->op_targ);	/* per-thread variable */
+    if (PL_op->op_flags & OPf_SPECIAL)
+	svp = save_threadsv(PL_op->op_targ);	/* per-thread variable */
     else
 #endif /* USE_THREADS */
-    if (op->op_targ) {
-	svp = &curpad[op->op_targ];		/* "my" variable */
+    if (PL_op->op_targ) {
+	svp = &PL_curpad[PL_op->op_targ];		/* "my" variable */
 	SAVESPTR(*svp);
     }
     else {
@@ -1407,7 +1407,7 @@ PP(pp_enteriter)
 
     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;
@@ -1424,9 +1424,9 @@ PP(pp_enteriter)
 	}
     }
     else {
-	cx->blk_loop.iterary = curstack;
-	AvFILLp(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;
@@ -1469,7 +1469,7 @@ PP(pp_leaveloop)
 	if (mark < SP)
 	    *++newsp = sv_mortalcopy(*SP);
 	else
-	    *++newsp = &sv_undef;
+	    *++newsp = &PL_sv_undef;
     }
     else {
 	while (mark < SP) {
@@ -1481,7 +1481,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;
@@ -1501,12 +1501,12 @@ PP(pp_return)
     PMOP *newpm;
     I32 optype = 0;
 
-    if (curstackinfo->si_type == PERLSI_SORT) {
-	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;
 	}
     }
@@ -1530,7 +1530,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;
@@ -1556,7 +1556,7 @@ PP(pp_return)
 	    } else
 		*++newsp = sv_mortalcopy(*SP);
 	} else
-	    *++newsp = &sv_undef;
+	    *++newsp = &PL_sv_undef;
     }
     else if (gimme == G_ARRAY) {
 	while (++MARK <= SP) {
@@ -1565,13 +1565,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();
@@ -1590,9 +1590,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");
@@ -1631,7 +1631,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) {
@@ -1653,7 +1653,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;
@@ -1665,7 +1665,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");
@@ -1679,7 +1679,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;
 }
@@ -1690,7 +1690,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");
@@ -1704,7 +1704,7 @@ 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;
 }
@@ -1737,7 +1737,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 ||
@@ -1767,10 +1767,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 */
@@ -1800,19 +1800,19 @@ PP(pp_goto)
 	    TOPBLOCK(cx);
 	    if (cx->cx_type == CXt_EVAL && cx->blk_eval.old_op_type == OP_ENTEREVAL) 
 		DIE("Can't goto subroutine from an eval-string");
-	    mark = stack_sp;
+	    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 = AvFILLp(av) + 1;
-		stack_sp++;
-		EXTEND(stack_sp, items); /* @_ could have been extended. */
-		Copy(AvARRAY(av), stack_sp, items, SV*);
-		stack_sp += items;
+		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);
@@ -1821,20 +1821,20 @@ PP(pp_goto)
 		AV* av;
 		int i;
 #ifdef USE_THREADS
-		av = (AV*)curpad[0];
+		av = (AV*)PL_curpad[0];
 #else
-		av = GvAV(defgv);
+		av = GvAV(PL_defgv);
 #endif
 		items = AvFILLp(av) + 1;
-		stack_sp++;
-		EXTEND(stack_sp, items); /* @_ could have been extended. */
-		Copy(AvARRAY(av), stack_sp, items, SV*);
-		stack_sp += items;
+		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. */
@@ -1848,20 +1848,20 @@ PP(pp_goto)
 		    }
 		    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 {
 		    SV **newsp;
 		    I32 gimme;
 
-		    stack_sp--;		/* There is no cv arg. */
+		    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, curpm);
+		    POPBLOCK(cx, PL_curpm);
 		    /* Do _not_ use PUTBACK, keep the XSUB's return stack! */
 		}
 		LEAVE;
@@ -1871,8 +1871,8 @@ PP(pp_goto)
 		AV* padlist = CvPADLIST(cv);
 		SV** svp = AvARRAY(padlist);
 		if (cx->cx_type == CXt_EVAL) {
-		    in_eval = cx->blk_eval.old_in_eval;
-		    eval_root = cx->blk_eval.old_eval_root;
+		    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;
 		}
@@ -1882,7 +1882,7 @@ PP(pp_goto)
 		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) > AvFILLp(padlist)) {
 			AV *newpad = newAV();
@@ -1890,7 +1890,7 @@ PP(pp_goto)
 			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 == '&')
@@ -1927,7 +1927,7 @@ PP(pp_goto)
 		}
 #ifdef USE_THREADS
 		if (!cx->blk_sub.hasargs) {
-		    AV* av = (AV*)curpad[0];
+		    AV* av = (AV*)PL_curpad[0];
 		    
 		    items = AvFILLp(av) + 1;
 		    if (items) {
@@ -1939,18 +1939,18 @@ PP(pp_goto)
 		    }
 		}
 #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;
@@ -1982,7 +1982,7 @@ PP(pp_goto)
 		     * We do not care about using sv to call CV;
 		     * it's for informational purposes only.
 		     */
-		    SV *sv = GvSV(DBsub);
+		    SV *sv = GvSV(PL_DBsub);
 		    CV *gotocv;
 		    
 		    if (PERLDB_SUB_NN) {
@@ -1993,18 +1993,18 @@ PP(pp_goto)
 		    }
 		    if (  PERLDB_GOTO
 			  && (gotocv = perl_get_cv("DB::goto", FALSE)) ) {
-			PUSHMARK( stack_sp );
+			PUSHMARK( PL_stack_sp );
 			perl_call_sv((SV*)gotocv, G_SCALAR | G_NODEBUG);
-			stack_sp--;
+			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");
     }
@@ -2016,13 +2016,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;
@@ -2033,7 +2033,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)) {
@@ -2046,14 +2046,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);
@@ -2067,24 +2067,24 @@ 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);
 		(CALLOP->op_ppaddr)(ARGS);
 	    }
-	    op = oldop;
+	    PL_op = oldop;
 	}
     }
 
@@ -2092,17 +2092,17 @@ PP(pp_goto)
 #ifdef VMS
 	if (!retop) retop = 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 (top_env->je_prev) {
-        restartop = retop;
+    if (PL_top_env->je_prev) {
+        PL_restartop = retop;
         JMPENV_JUMP(3);
     }
 
@@ -2124,7 +2124,7 @@ PP(pp_exit)
 #endif
     }
     my_exit(anum);
-    PUSHs(&sv_undef);
+    PUSHs(&PL_sv_undef);
     RETURN;
 }
 
@@ -2199,35 +2199,35 @@ 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:
         CALLRUNOPS();
 	break;
     }
     JMPENV_POP;
-    op = oldop;
+    PL_op = oldop;
     return Nullop;
 }
 
@@ -2243,7 +2243,7 @@ sv_compile_2op(SV *sv, OP** startop, char *code, AV** avp)
     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;
 
@@ -2252,39 +2252,39 @@ 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;
+    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 C<eval "...">s 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));
+    SAVEDELETE(PL_defstash, safestr, strlen(safestr));
     SAVEHINTS();
 #ifdef OP_IN_REGISTER
     opsave = op;
 #else
-    SAVEPPTR(op);
+    SAVEPPTR(PL_op);
 #endif
-    hints = 0;
+    PL_hints = 0;
 
-    op = &dummy;
-    op->op_type = 0;			/* Avoid uninit warning. */
-    op->op_flags = 0;			/* Avoid uninit warning. */
+    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);
     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 = opsave;
@@ -2297,27 +2297,27 @@ 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);
+    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 = compcv;
+    caller = PL_compcv;
     for (i = cxstack_ix - 1; i >= 0; i--) {
 	PERL_CONTEXT *cx = &cxstack[i];
 	if (cx->cx_type == CXt_EVAL)
@@ -2328,117 +2328,117 @@ doeval(int gimme, OP** startop)
 	}
     }
 
-    SAVESPTR(compcv);
-    compcv = (CV*)NEWSV(1104,0);
-    sv_upgrade((SV *)compcv, SVt_PVCV);
-    CvUNIQUE_on(compcv);
+    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());
 
@@ -2448,7 +2448,7 @@ doeval(int gimme, OP** startop)
 	if (cv) {
 	    dSP;
 	    PUSHMARK(SP);
-	    XPUSHs((SV*)compiling.cop_filegv);
+	    XPUSHs((SV*)PL_compiling.cop_filegv);
 	    PUTBACK;
 	    perl_call_sv((SV*)cv, G_DISCARD);
 	}
@@ -2456,17 +2456,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)
@@ -2485,18 +2485,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, 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, len, 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 */
@@ -2521,7 +2521,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;
@@ -2530,7 +2530,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)
@@ -2550,14 +2550,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?)");
@@ -2565,7 +2565,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);
 	    }
@@ -2578,39 +2578,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);
     SAVEHINTS();
-    hints = 0;
+    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);
 
-    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));
 }
@@ -2625,7 +2625,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;
@@ -2641,40 +2641,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 C<eval "...">s 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));
+    SAVEDELETE(PL_defstash, safestr, strlen(safestr));
     SAVEHINTS();
-    hints = op->op_targ;
+    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);
 
     /* 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);
@@ -2689,7 +2689,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);
@@ -2709,7 +2709,7 @@ PP(pp_leaveeval)
 	}
 	else {
 	    MEXTEND(mark,0);
-	    *MARK = &sv_undef;
+	    *MARK = &PL_sv_undef;
 	}
     }
     else {
@@ -2721,7 +2721,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
@@ -2729,16 +2729,16 @@ PP(pp_leaveeval)
      * (Note that the fact that compcv and friends are still set here
      * is, AFAIK, an accident.)  --Chip
      */
-    if (AvFILLp(comppad_name) >= 0) {
-	SV **svp = AvARRAY(comppad_name);
+    if (AvFILLp(PL_comppad_name) >= 0) {
+	SV **svp = AvARRAY(PL_comppad_name);
 	I32 ix;
-	for (ix = AvFILLp(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;
@@ -2747,16 +2747,16 @@ 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 &&
@@ -2764,7 +2764,7 @@ PP(pp_leaveeval)
     {
 	/* 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 */
     }
@@ -2789,12 +2789,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)
@@ -2824,7 +2824,7 @@ PP(pp_leavetry)
 	}
 	else {
 	    MEXTEND(mark,0);
-	    *MARK = &sv_undef;
+	    *MARK = &PL_sv_undef;
 	}
 	SP = MARK;
     }
@@ -2837,7 +2837,7 @@ 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,"");