{
opindex arg;
BGET_opindex(arg);
- op = arg;
+ PL_op = arg;
break;
}
case INSN_STSV: /* 3 */
{
U32 arg;
BGET_U32(arg);
- BSET_OBJ_STORE(op, arg);
+ BSET_OBJ_STORE(PL_op, arg);
break;
}
case INSN_LDSPECSV: /* 5 */
{
U8 arg;
BGET_U8(arg);
- BSET_newop(op, arg);
+ BSET_newop(PL_op, arg);
break;
}
case INSN_NEWOPN: /* 8 */
{
U8 arg;
BGET_U8(arg);
- BSET_newopn(op, arg);
+ BSET_newopn(PL_op, arg);
break;
}
case INSN_NEWPV: /* 9 */
{
opindex arg;
BGET_opindex(arg);
- op->op_next = arg;
+ PL_op->op_next = arg;
break;
}
case INSN_OP_SIBLING: /* 83 */
{
opindex arg;
BGET_opindex(arg);
- op->op_sibling = arg;
+ PL_op->op_sibling = arg;
break;
}
case INSN_OP_PPADDR: /* 84 */
{
PADOFFSET arg;
BGET_U32(arg);
- op->op_targ = arg;
+ PL_op->op_targ = arg;
break;
}
case INSN_OP_TYPE: /* 86 */
{
OPCODE arg;
BGET_U16(arg);
- BSET_op_type(op, arg);
+ BSET_op_type(PL_op, arg);
break;
}
case INSN_OP_SEQ: /* 87 */
{
U16 arg;
BGET_U16(arg);
- op->op_seq = arg;
+ PL_op->op_seq = arg;
break;
}
case INSN_OP_FLAGS: /* 88 */
{
U8 arg;
BGET_U8(arg);
- op->op_flags = arg;
+ PL_op->op_flags = arg;
break;
}
case INSN_OP_PRIVATE: /* 89 */
{
U8 arg;
BGET_U8(arg);
- op->op_private = arg;
+ PL_op->op_private = arg;
break;
}
case INSN_OP_FIRST: /* 90 */
{
pvcontents arg;
BGET_pvcontents(arg);
- BSET_pregcomp(op, arg);
+ BSET_pregcomp(PL_op, arg);
break;
}
case INSN_OP_PMFLAGS: /* 101 */
#define PUSHEVAL(cx,n,fgv) \
cx->blk_eval.old_in_eval = PL_in_eval; \
- cx->blk_eval.old_op_type = op->op_type; \
+ cx->blk_eval.old_op_type = PL_op->op_type; \
cx->blk_eval.old_name = n; \
cx->blk_eval.old_eval_root = PL_eval_root; \
cx->blk_eval.cur_text = PL_linestr;
PerlIO_printf(Perl_debug_log, "0x%lx (%s:%ld)\t",
(unsigned long) thr,
SvTYPE(gv) == SVt_PVGV ? SvPVX(GvSV(gv)) : "<free>",
- (long)curcop->cop_line);
+ (long)PL_curcop->cop_line);
#else
PerlIO_printf(Perl_debug_log, "(%s:%ld)\t",
SvTYPE(gv) == SVt_PVGV ? SvPVX(GvSV(gv)) : "<free>",
if (PerlIO_get_cnt(IoIFP(io)) < -1)
PerlIO_set_cnt(IoIFP(io),-1);
}
- if (op->op_flags & OPf_SPECIAL) { /* not necessarily a real EOF yet? */
+ if (PL_op->op_flags & OPf_SPECIAL) { /* not necessarily a real EOF yet? */
if (!nextargv(PL_argvgv)) /* get another fp handy */
return TRUE;
}
IO *io;
GV* tmpgv;
- if (op->op_flags & OPf_REF) {
+ if (PL_op->op_flags & OPf_REF) {
EXTEND(SP,1);
tmpgv = cGVOP->op_gv;
do_fstat:
{
djSP;
SV *sv;
- if (op->op_flags & OPf_REF) {
+ if (PL_op->op_flags & OPf_REF) {
EXTEND(SP,1);
if (cGVOP->op_gv == PL_defgv) {
if (PL_laststype != OP_LSTAT)
register U8 *d;
register I32 ch;
register I32 matches = 0;
- register I32 squash = op->op_private & OPpTRANS_SQUASH;
+ register I32 squash = PL_op->op_private & OPpTRANS_SQUASH;
register U8 *p;
STRLEN len;
- if (SvREADONLY(sv) && !(op->op_private & OPpTRANS_COUNTONLY))
+ if (SvREADONLY(sv) && !(PL_op->op_private & OPpTRANS_COUNTONLY))
croak(no_modify);
tbl = (short*)cPVOP->op_pv;
s = (U8*)SvPV(sv, len);
if (!tbl || !s)
croak("panic: do_trans");
DEBUG_t( deb("2.TBL\n"));
- if (!op->op_private) {
+ if (!PL_op->op_private) {
while (s < send) {
if ((ch = tbl[*s]) >= 0) {
matches++;
}
SvSETMAGIC(sv);
}
- else if (op->op_private & OPpTRANS_COUNTONLY) {
+ else if (PL_op->op_private & OPpTRANS_COUNTONLY) {
while (s < send) {
if (tbl[*s] >= 0)
matches++;
register HE *entry;
SV *tmpstr;
I32 gimme = GIMME_V;
- I32 dokeys = (op->op_type == OP_KEYS);
- I32 dovalues = (op->op_type == OP_VALUES);
+ I32 dokeys = (PL_op->op_type == OP_KEYS);
+ I32 dovalues = (PL_op->op_type == OP_VALUES);
I32 realhv = (SvTYPE(hv) == SVt_PVHV);
- if (op->op_type == OP_RV2HV || op->op_type == OP_PADHV)
+ if (PL_op->op_type == OP_RV2HV || PL_op->op_type == OP_PADHV)
dokeys = dovalues = TRUE;
if (!hv) {
- if (op->op_flags & OPf_MOD) { /* lvalue */
+ if (PL_op->op_flags & OPf_MOD) { /* lvalue */
dTARGET; /* make sure to clear its target here */
if (SvTYPE(TARG) == SVt_PVLV)
LvTARG(TARG) = Nullsv;
IV i;
dTARGET;
- if (op->op_flags & OPf_MOD) { /* lvalue */
+ if (PL_op->op_flags & OPf_MOD) { /* lvalue */
if (SvTYPE(TARG) < SVt_PVLV) {
sv_upgrade(TARG, SVt_PVLV);
sv_magic(TARG, Nullsv, 'k', Nullch, 0);
}
sub multoff ($$) {
my ($sym,$pre) = @_;
-# hide("$pre$sym", "PL_$sym");
- return '';
+ return hide("PL_$pre$sym", "PL_$sym");
}
unlink 'embed.h';
END
for $sym (sort keys %globvar) {
- print EM multon($sym,'G','Perl_Vars.');
+ print EM multon($sym,'G','PL_Vars.');
}
print EM <<'END';
#ifndef USE_THREADS
/* If we do not have threads then per-thread vars are per-interpreter */
-#define PL_Sv (curinterp->TSv)
-#define PL_Xpv (curinterp->TXpv)
-#define PL_av_fetch_sv (curinterp->Tav_fetch_sv)
-#define PL_bodytarget (curinterp->Tbodytarget)
-#define PL_bostr (curinterp->Tbostr)
-#define PL_chopset (curinterp->Tchopset)
-#define PL_colors (curinterp->Tcolors)
-#define PL_colorset (curinterp->Tcolorset)
-#define PL_curcop (curinterp->Tcurcop)
-#define PL_curpad (curinterp->Tcurpad)
-#define PL_curpm (curinterp->Tcurpm)
-#define PL_curstack (curinterp->Tcurstack)
-#define PL_curstackinfo (curinterp->Tcurstackinfo)
-#define PL_curstash (curinterp->Tcurstash)
-#define PL_defoutgv (curinterp->Tdefoutgv)
-#define PL_defstash (curinterp->Tdefstash)
-#define PL_delaymagic (curinterp->Tdelaymagic)
-#define PL_dirty (curinterp->Tdirty)
-#define PL_extralen (curinterp->Textralen)
-#define PL_firstgv (curinterp->Tfirstgv)
-#define PL_formtarget (curinterp->Tformtarget)
-#define PL_hv_fetch_ent_mh (curinterp->Thv_fetch_ent_mh)
-#define PL_hv_fetch_sv (curinterp->Thv_fetch_sv)
-#define PL_in_eval (curinterp->Tin_eval)
-#define PL_last_in_gv (curinterp->Tlast_in_gv)
-#define PL_lastgotoprobe (curinterp->Tlastgotoprobe)
-#define PL_lastscream (curinterp->Tlastscream)
-#define PL_localizing (curinterp->Tlocalizing)
-#define PL_mainstack (curinterp->Tmainstack)
-#define PL_markstack (curinterp->Tmarkstack)
-#define PL_markstack_max (curinterp->Tmarkstack_max)
-#define PL_markstack_ptr (curinterp->Tmarkstack_ptr)
-#define PL_maxscream (curinterp->Tmaxscream)
-#define PL_modcount (curinterp->Tmodcount)
-#define PL_nrs (curinterp->Tnrs)
-#define PL_ofs (curinterp->Tofs)
-#define PL_ofslen (curinterp->Tofslen)
-#define PL_op (curinterp->Top)
-#define PL_opsave (curinterp->Topsave)
-#define PL_reg_eval_set (curinterp->Treg_eval_set)
-#define PL_reg_flags (curinterp->Treg_flags)
-#define PL_reg_start_tmp (curinterp->Treg_start_tmp)
-#define PL_reg_start_tmpl (curinterp->Treg_start_tmpl)
-#define PL_regbol (curinterp->Tregbol)
-#define PL_regcc (curinterp->Tregcc)
-#define PL_regcode (curinterp->Tregcode)
-#define PL_regcomp_parse (curinterp->Tregcomp_parse)
-#define PL_regcomp_rx (curinterp->Tregcomp_rx)
-#define PL_regcompp (curinterp->Tregcompp)
-#define PL_regdata (curinterp->Tregdata)
-#define PL_regdummy (curinterp->Tregdummy)
-#define PL_regendp (curinterp->Tregendp)
-#define PL_regeol (curinterp->Tregeol)
-#define PL_regexecp (curinterp->Tregexecp)
-#define PL_regflags (curinterp->Tregflags)
-#define PL_regindent (curinterp->Tregindent)
-#define PL_reginput (curinterp->Treginput)
-#define PL_reginterp_cnt (curinterp->Treginterp_cnt)
-#define PL_reglastparen (curinterp->Treglastparen)
-#define PL_regnarrate (curinterp->Tregnarrate)
-#define PL_regnaughty (curinterp->Tregnaughty)
-#define PL_regnpar (curinterp->Tregnpar)
-#define PL_regprecomp (curinterp->Tregprecomp)
-#define PL_regprev (curinterp->Tregprev)
-#define PL_regprogram (curinterp->Tregprogram)
-#define PL_regsawback (curinterp->Tregsawback)
-#define PL_regseen (curinterp->Tregseen)
-#define PL_regsize (curinterp->Tregsize)
-#define PL_regstartp (curinterp->Tregstartp)
-#define PL_regtill (curinterp->Tregtill)
-#define PL_regxend (curinterp->Tregxend)
-#define PL_restartop (curinterp->Trestartop)
-#define PL_retstack (curinterp->Tretstack)
-#define PL_retstack_ix (curinterp->Tretstack_ix)
-#define PL_retstack_max (curinterp->Tretstack_max)
-#define PL_rs (curinterp->Trs)
-#define PL_savestack (curinterp->Tsavestack)
-#define PL_savestack_ix (curinterp->Tsavestack_ix)
-#define PL_savestack_max (curinterp->Tsavestack_max)
-#define PL_scopestack (curinterp->Tscopestack)
-#define PL_scopestack_ix (curinterp->Tscopestack_ix)
-#define PL_scopestack_max (curinterp->Tscopestack_max)
-#define PL_screamfirst (curinterp->Tscreamfirst)
-#define PL_screamnext (curinterp->Tscreamnext)
-#define PL_secondgv (curinterp->Tsecondgv)
-#define PL_seen_evals (curinterp->Tseen_evals)
-#define PL_seen_zerolen (curinterp->Tseen_zerolen)
-#define PL_sortcop (curinterp->Tsortcop)
-#define PL_sortcxix (curinterp->Tsortcxix)
-#define PL_sortstash (curinterp->Tsortstash)
-#define PL_stack_base (curinterp->Tstack_base)
-#define PL_stack_max (curinterp->Tstack_max)
-#define PL_stack_sp (curinterp->Tstack_sp)
-#define PL_start_env (curinterp->Tstart_env)
-#define PL_statbuf (curinterp->Tstatbuf)
-#define PL_statcache (curinterp->Tstatcache)
-#define PL_statgv (curinterp->Tstatgv)
-#define PL_statname (curinterp->Tstatname)
-#define PL_tainted (curinterp->Ttainted)
-#define PL_timesbuf (curinterp->Ttimesbuf)
-#define PL_tmps_floor (curinterp->Ttmps_floor)
-#define PL_tmps_ix (curinterp->Ttmps_ix)
-#define PL_tmps_max (curinterp->Ttmps_max)
-#define PL_tmps_stack (curinterp->Ttmps_stack)
-#define PL_top_env (curinterp->Ttop_env)
-#define PL_toptarget (curinterp->Ttoptarget)
+#define PL_Sv (PL_curinterp->TSv)
+#define PL_Xpv (PL_curinterp->TXpv)
+#define PL_av_fetch_sv (PL_curinterp->Tav_fetch_sv)
+#define PL_bodytarget (PL_curinterp->Tbodytarget)
+#define PL_bostr (PL_curinterp->Tbostr)
+#define PL_chopset (PL_curinterp->Tchopset)
+#define PL_colors (PL_curinterp->Tcolors)
+#define PL_colorset (PL_curinterp->Tcolorset)
+#define PL_curcop (PL_curinterp->Tcurcop)
+#define PL_curpad (PL_curinterp->Tcurpad)
+#define PL_curpm (PL_curinterp->Tcurpm)
+#define PL_curstack (PL_curinterp->Tcurstack)
+#define PL_curstackinfo (PL_curinterp->Tcurstackinfo)
+#define PL_curstash (PL_curinterp->Tcurstash)
+#define PL_defoutgv (PL_curinterp->Tdefoutgv)
+#define PL_defstash (PL_curinterp->Tdefstash)
+#define PL_delaymagic (PL_curinterp->Tdelaymagic)
+#define PL_dirty (PL_curinterp->Tdirty)
+#define PL_extralen (PL_curinterp->Textralen)
+#define PL_firstgv (PL_curinterp->Tfirstgv)
+#define PL_formtarget (PL_curinterp->Tformtarget)
+#define PL_hv_fetch_ent_mh (PL_curinterp->Thv_fetch_ent_mh)
+#define PL_hv_fetch_sv (PL_curinterp->Thv_fetch_sv)
+#define PL_in_eval (PL_curinterp->Tin_eval)
+#define PL_last_in_gv (PL_curinterp->Tlast_in_gv)
+#define PL_lastgotoprobe (PL_curinterp->Tlastgotoprobe)
+#define PL_lastscream (PL_curinterp->Tlastscream)
+#define PL_localizing (PL_curinterp->Tlocalizing)
+#define PL_mainstack (PL_curinterp->Tmainstack)
+#define PL_markstack (PL_curinterp->Tmarkstack)
+#define PL_markstack_max (PL_curinterp->Tmarkstack_max)
+#define PL_markstack_ptr (PL_curinterp->Tmarkstack_ptr)
+#define PL_maxscream (PL_curinterp->Tmaxscream)
+#define PL_modcount (PL_curinterp->Tmodcount)
+#define PL_nrs (PL_curinterp->Tnrs)
+#define PL_ofs (PL_curinterp->Tofs)
+#define PL_ofslen (PL_curinterp->Tofslen)
+#define PL_op (PL_curinterp->Top)
+#define PL_opsave (PL_curinterp->Topsave)
+#define PL_reg_eval_set (PL_curinterp->Treg_eval_set)
+#define PL_reg_flags (PL_curinterp->Treg_flags)
+#define PL_reg_start_tmp (PL_curinterp->Treg_start_tmp)
+#define PL_reg_start_tmpl (PL_curinterp->Treg_start_tmpl)
+#define PL_regbol (PL_curinterp->Tregbol)
+#define PL_regcc (PL_curinterp->Tregcc)
+#define PL_regcode (PL_curinterp->Tregcode)
+#define PL_regcomp_parse (PL_curinterp->Tregcomp_parse)
+#define PL_regcomp_rx (PL_curinterp->Tregcomp_rx)
+#define PL_regcompp (PL_curinterp->Tregcompp)
+#define PL_regdata (PL_curinterp->Tregdata)
+#define PL_regdummy (PL_curinterp->Tregdummy)
+#define PL_regendp (PL_curinterp->Tregendp)
+#define PL_regeol (PL_curinterp->Tregeol)
+#define PL_regexecp (PL_curinterp->Tregexecp)
+#define PL_regflags (PL_curinterp->Tregflags)
+#define PL_regindent (PL_curinterp->Tregindent)
+#define PL_reginput (PL_curinterp->Treginput)
+#define PL_reginterp_cnt (PL_curinterp->Treginterp_cnt)
+#define PL_reglastparen (PL_curinterp->Treglastparen)
+#define PL_regnarrate (PL_curinterp->Tregnarrate)
+#define PL_regnaughty (PL_curinterp->Tregnaughty)
+#define PL_regnpar (PL_curinterp->Tregnpar)
+#define PL_regprecomp (PL_curinterp->Tregprecomp)
+#define PL_regprev (PL_curinterp->Tregprev)
+#define PL_regprogram (PL_curinterp->Tregprogram)
+#define PL_regsawback (PL_curinterp->Tregsawback)
+#define PL_regseen (PL_curinterp->Tregseen)
+#define PL_regsize (PL_curinterp->Tregsize)
+#define PL_regstartp (PL_curinterp->Tregstartp)
+#define PL_regtill (PL_curinterp->Tregtill)
+#define PL_regxend (PL_curinterp->Tregxend)
+#define PL_restartop (PL_curinterp->Trestartop)
+#define PL_retstack (PL_curinterp->Tretstack)
+#define PL_retstack_ix (PL_curinterp->Tretstack_ix)
+#define PL_retstack_max (PL_curinterp->Tretstack_max)
+#define PL_rs (PL_curinterp->Trs)
+#define PL_savestack (PL_curinterp->Tsavestack)
+#define PL_savestack_ix (PL_curinterp->Tsavestack_ix)
+#define PL_savestack_max (PL_curinterp->Tsavestack_max)
+#define PL_scopestack (PL_curinterp->Tscopestack)
+#define PL_scopestack_ix (PL_curinterp->Tscopestack_ix)
+#define PL_scopestack_max (PL_curinterp->Tscopestack_max)
+#define PL_screamfirst (PL_curinterp->Tscreamfirst)
+#define PL_screamnext (PL_curinterp->Tscreamnext)
+#define PL_secondgv (PL_curinterp->Tsecondgv)
+#define PL_seen_evals (PL_curinterp->Tseen_evals)
+#define PL_seen_zerolen (PL_curinterp->Tseen_zerolen)
+#define PL_sortcop (PL_curinterp->Tsortcop)
+#define PL_sortcxix (PL_curinterp->Tsortcxix)
+#define PL_sortstash (PL_curinterp->Tsortstash)
+#define PL_stack_base (PL_curinterp->Tstack_base)
+#define PL_stack_max (PL_curinterp->Tstack_max)
+#define PL_stack_sp (PL_curinterp->Tstack_sp)
+#define PL_start_env (PL_curinterp->Tstart_env)
+#define PL_statbuf (PL_curinterp->Tstatbuf)
+#define PL_statcache (PL_curinterp->Tstatcache)
+#define PL_statgv (PL_curinterp->Tstatgv)
+#define PL_statname (PL_curinterp->Tstatname)
+#define PL_tainted (PL_curinterp->Ttainted)
+#define PL_timesbuf (PL_curinterp->Ttimesbuf)
+#define PL_tmps_floor (PL_curinterp->Ttmps_floor)
+#define PL_tmps_ix (PL_curinterp->Ttmps_ix)
+#define PL_tmps_max (PL_curinterp->Ttmps_max)
+#define PL_tmps_stack (PL_curinterp->Ttmps_stack)
+#define PL_top_env (PL_curinterp->Ttop_env)
+#define PL_toptarget (PL_curinterp->Ttoptarget)
#endif /* !USE_THREADS */
/* These are always per-interpreter if there is more than one */
-#define PL_Argv (curinterp->IArgv)
-#define PL_Cmd (curinterp->ICmd)
-#define PL_DBcv (curinterp->IDBcv)
-#define PL_DBgv (curinterp->IDBgv)
-#define PL_DBline (curinterp->IDBline)
-#define PL_DBsignal (curinterp->IDBsignal)
-#define PL_DBsingle (curinterp->IDBsingle)
-#define PL_DBsub (curinterp->IDBsub)
-#define PL_DBtrace (curinterp->IDBtrace)
-#define PL_ampergv (curinterp->Iampergv)
-#define PL_archpat_auto (curinterp->Iarchpat_auto)
-#define PL_argvgv (curinterp->Iargvgv)
-#define PL_argvoutgv (curinterp->Iargvoutgv)
-#define PL_basetime (curinterp->Ibasetime)
-#define PL_beginav (curinterp->Ibeginav)
-#define PL_cddir (curinterp->Icddir)
-#define PL_compcv (curinterp->Icompcv)
-#define PL_compiling (curinterp->Icompiling)
-#define PL_comppad (curinterp->Icomppad)
-#define PL_comppad_name (curinterp->Icomppad_name)
-#define PL_comppad_name_fill (curinterp->Icomppad_name_fill)
-#define PL_comppad_name_floor (curinterp->Icomppad_name_floor)
-#define PL_copline (curinterp->Icopline)
-#define PL_curcopdb (curinterp->Icurcopdb)
-#define PL_curstname (curinterp->Icurstname)
-#define PL_dbargs (curinterp->Idbargs)
-#define PL_debdelim (curinterp->Idebdelim)
-#define PL_debname (curinterp->Idebname)
-#define PL_debstash (curinterp->Idebstash)
-#define PL_defgv (curinterp->Idefgv)
-#define PL_diehook (curinterp->Idiehook)
-#define PL_dlevel (curinterp->Idlevel)
-#define PL_dlmax (curinterp->Idlmax)
-#define PL_doextract (curinterp->Idoextract)
-#define PL_doswitches (curinterp->Idoswitches)
-#define PL_dowarn (curinterp->Idowarn)
-#define PL_dumplvl (curinterp->Idumplvl)
-#define PL_e_script (curinterp->Ie_script)
-#define PL_endav (curinterp->Iendav)
-#define PL_envgv (curinterp->Ienvgv)
-#define PL_errgv (curinterp->Ierrgv)
-#define PL_eval_root (curinterp->Ieval_root)
-#define PL_eval_start (curinterp->Ieval_start)
-#define PL_exitlist (curinterp->Iexitlist)
-#define PL_exitlistlen (curinterp->Iexitlistlen)
-#define PL_fdpid (curinterp->Ifdpid)
-#define PL_filemode (curinterp->Ifilemode)
-#define PL_forkprocess (curinterp->Iforkprocess)
-#define PL_formfeed (curinterp->Iformfeed)
-#define PL_generation (curinterp->Igeneration)
-#define PL_gensym (curinterp->Igensym)
-#define PL_globalstash (curinterp->Iglobalstash)
-#define PL_hintgv (curinterp->Ihintgv)
-#define PL_in_clean_all (curinterp->Iin_clean_all)
-#define PL_in_clean_objs (curinterp->Iin_clean_objs)
-#define PL_incgv (curinterp->Iincgv)
-#define PL_initav (curinterp->Iinitav)
-#define PL_inplace (curinterp->Iinplace)
-#define PL_last_proto (curinterp->Ilast_proto)
-#define PL_lastfd (curinterp->Ilastfd)
-#define PL_lastsize (curinterp->Ilastsize)
-#define PL_lastspbase (curinterp->Ilastspbase)
-#define PL_laststatval (curinterp->Ilaststatval)
-#define PL_laststype (curinterp->Ilaststype)
-#define PL_leftgv (curinterp->Ileftgv)
-#define PL_lineary (curinterp->Ilineary)
-#define PL_linestart (curinterp->Ilinestart)
-#define PL_localpatches (curinterp->Ilocalpatches)
-#define PL_main_cv (curinterp->Imain_cv)
-#define PL_main_root (curinterp->Imain_root)
-#define PL_main_start (curinterp->Imain_start)
-#define PL_maxsysfd (curinterp->Imaxsysfd)
-#define PL_mess_sv (curinterp->Imess_sv)
-#define PL_minus_F (curinterp->Iminus_F)
-#define PL_minus_a (curinterp->Iminus_a)
-#define PL_minus_c (curinterp->Iminus_c)
-#define PL_minus_l (curinterp->Iminus_l)
-#define PL_minus_n (curinterp->Iminus_n)
-#define PL_minus_p (curinterp->Iminus_p)
-#define PL_modglobal (curinterp->Imodglobal)
-#define PL_multiline (curinterp->Imultiline)
-#define PL_mystrk (curinterp->Imystrk)
-#define PL_ofmt (curinterp->Iofmt)
-#define PL_oldlastpm (curinterp->Ioldlastpm)
-#define PL_oldname (curinterp->Ioldname)
-#define PL_op_mask (curinterp->Iop_mask)
-#define PL_origargc (curinterp->Iorigargc)
-#define PL_origargv (curinterp->Iorigargv)
-#define PL_origfilename (curinterp->Iorigfilename)
-#define PL_ors (curinterp->Iors)
-#define PL_orslen (curinterp->Iorslen)
-#define PL_parsehook (curinterp->Iparsehook)
-#define PL_patchlevel (curinterp->Ipatchlevel)
-#define PL_pending_ident (curinterp->Ipending_ident)
-#define PL_perl_destruct_level (curinterp->Iperl_destruct_level)
-#define PL_perldb (curinterp->Iperldb)
-#define PL_preambleav (curinterp->Ipreambleav)
-#define PL_preambled (curinterp->Ipreambled)
-#define PL_preprocess (curinterp->Ipreprocess)
-#define PL_profiledata (curinterp->Iprofiledata)
-#define PL_replgv (curinterp->Ireplgv)
-#define PL_rightgv (curinterp->Irightgv)
-#define PL_rsfp (curinterp->Irsfp)
-#define PL_rsfp_filters (curinterp->Irsfp_filters)
-#define PL_sawampersand (curinterp->Isawampersand)
-#define PL_sawstudy (curinterp->Isawstudy)
-#define PL_sawvec (curinterp->Isawvec)
-#define PL_siggv (curinterp->Isiggv)
-#define PL_splitstr (curinterp->Isplitstr)
-#define PL_statusvalue (curinterp->Istatusvalue)
-#define PL_statusvalue_vms (curinterp->Istatusvalue_vms)
-#define PL_stdingv (curinterp->Istdingv)
-#define PL_strchop (curinterp->Istrchop)
-#define PL_strtab (curinterp->Istrtab)
-#define PL_sub_generation (curinterp->Isub_generation)
-#define PL_sublex_info (curinterp->Isublex_info)
-#define PL_sv_arenaroot (curinterp->Isv_arenaroot)
-#define PL_sv_count (curinterp->Isv_count)
-#define PL_sv_objcount (curinterp->Isv_objcount)
-#define PL_sv_root (curinterp->Isv_root)
-#define PL_sys_intern (curinterp->Isys_intern)
-#define PL_tainting (curinterp->Itainting)
-#define PL_threadnum (curinterp->Ithreadnum)
-#define PL_thrsv (curinterp->Ithrsv)
-#define PL_unsafe (curinterp->Iunsafe)
-#define PL_warnhook (curinterp->Iwarnhook)
+#define PL_Argv (PL_curinterp->IArgv)
+#define PL_Cmd (PL_curinterp->ICmd)
+#define PL_DBcv (PL_curinterp->IDBcv)
+#define PL_DBgv (PL_curinterp->IDBgv)
+#define PL_DBline (PL_curinterp->IDBline)
+#define PL_DBsignal (PL_curinterp->IDBsignal)
+#define PL_DBsingle (PL_curinterp->IDBsingle)
+#define PL_DBsub (PL_curinterp->IDBsub)
+#define PL_DBtrace (PL_curinterp->IDBtrace)
+#define PL_ampergv (PL_curinterp->Iampergv)
+#define PL_archpat_auto (PL_curinterp->Iarchpat_auto)
+#define PL_argvgv (PL_curinterp->Iargvgv)
+#define PL_argvoutgv (PL_curinterp->Iargvoutgv)
+#define PL_basetime (PL_curinterp->Ibasetime)
+#define PL_beginav (PL_curinterp->Ibeginav)
+#define PL_cddir (PL_curinterp->Icddir)
+#define PL_compcv (PL_curinterp->Icompcv)
+#define PL_compiling (PL_curinterp->Icompiling)
+#define PL_comppad (PL_curinterp->Icomppad)
+#define PL_comppad_name (PL_curinterp->Icomppad_name)
+#define PL_comppad_name_fill (PL_curinterp->Icomppad_name_fill)
+#define PL_comppad_name_floor (PL_curinterp->Icomppad_name_floor)
+#define PL_copline (PL_curinterp->Icopline)
+#define PL_curcopdb (PL_curinterp->Icurcopdb)
+#define PL_curstname (PL_curinterp->Icurstname)
+#define PL_dbargs (PL_curinterp->Idbargs)
+#define PL_debdelim (PL_curinterp->Idebdelim)
+#define PL_debname (PL_curinterp->Idebname)
+#define PL_debstash (PL_curinterp->Idebstash)
+#define PL_defgv (PL_curinterp->Idefgv)
+#define PL_diehook (PL_curinterp->Idiehook)
+#define PL_dlevel (PL_curinterp->Idlevel)
+#define PL_dlmax (PL_curinterp->Idlmax)
+#define PL_doextract (PL_curinterp->Idoextract)
+#define PL_doswitches (PL_curinterp->Idoswitches)
+#define PL_dowarn (PL_curinterp->Idowarn)
+#define PL_dumplvl (PL_curinterp->Idumplvl)
+#define PL_e_script (PL_curinterp->Ie_script)
+#define PL_endav (PL_curinterp->Iendav)
+#define PL_envgv (PL_curinterp->Ienvgv)
+#define PL_errgv (PL_curinterp->Ierrgv)
+#define PL_eval_root (PL_curinterp->Ieval_root)
+#define PL_eval_start (PL_curinterp->Ieval_start)
+#define PL_exitlist (PL_curinterp->Iexitlist)
+#define PL_exitlistlen (PL_curinterp->Iexitlistlen)
+#define PL_fdpid (PL_curinterp->Ifdpid)
+#define PL_filemode (PL_curinterp->Ifilemode)
+#define PL_forkprocess (PL_curinterp->Iforkprocess)
+#define PL_formfeed (PL_curinterp->Iformfeed)
+#define PL_generation (PL_curinterp->Igeneration)
+#define PL_gensym (PL_curinterp->Igensym)
+#define PL_globalstash (PL_curinterp->Iglobalstash)
+#define PL_hintgv (PL_curinterp->Ihintgv)
+#define PL_in_clean_all (PL_curinterp->Iin_clean_all)
+#define PL_in_clean_objs (PL_curinterp->Iin_clean_objs)
+#define PL_incgv (PL_curinterp->Iincgv)
+#define PL_initav (PL_curinterp->Iinitav)
+#define PL_inplace (PL_curinterp->Iinplace)
+#define PL_last_proto (PL_curinterp->Ilast_proto)
+#define PL_lastfd (PL_curinterp->Ilastfd)
+#define PL_lastsize (PL_curinterp->Ilastsize)
+#define PL_lastspbase (PL_curinterp->Ilastspbase)
+#define PL_laststatval (PL_curinterp->Ilaststatval)
+#define PL_laststype (PL_curinterp->Ilaststype)
+#define PL_leftgv (PL_curinterp->Ileftgv)
+#define PL_lineary (PL_curinterp->Ilineary)
+#define PL_linestart (PL_curinterp->Ilinestart)
+#define PL_localpatches (PL_curinterp->Ilocalpatches)
+#define PL_main_cv (PL_curinterp->Imain_cv)
+#define PL_main_root (PL_curinterp->Imain_root)
+#define PL_main_start (PL_curinterp->Imain_start)
+#define PL_maxsysfd (PL_curinterp->Imaxsysfd)
+#define PL_mess_sv (PL_curinterp->Imess_sv)
+#define PL_minus_F (PL_curinterp->Iminus_F)
+#define PL_minus_a (PL_curinterp->Iminus_a)
+#define PL_minus_c (PL_curinterp->Iminus_c)
+#define PL_minus_l (PL_curinterp->Iminus_l)
+#define PL_minus_n (PL_curinterp->Iminus_n)
+#define PL_minus_p (PL_curinterp->Iminus_p)
+#define PL_modglobal (PL_curinterp->Imodglobal)
+#define PL_multiline (PL_curinterp->Imultiline)
+#define PL_mystrk (PL_curinterp->Imystrk)
+#define PL_ofmt (PL_curinterp->Iofmt)
+#define PL_oldlastpm (PL_curinterp->Ioldlastpm)
+#define PL_oldname (PL_curinterp->Ioldname)
+#define PL_op_mask (PL_curinterp->Iop_mask)
+#define PL_origargc (PL_curinterp->Iorigargc)
+#define PL_origargv (PL_curinterp->Iorigargv)
+#define PL_origfilename (PL_curinterp->Iorigfilename)
+#define PL_ors (PL_curinterp->Iors)
+#define PL_orslen (PL_curinterp->Iorslen)
+#define PL_parsehook (PL_curinterp->Iparsehook)
+#define PL_patchlevel (PL_curinterp->Ipatchlevel)
+#define PL_pending_ident (PL_curinterp->Ipending_ident)
+#define PL_perl_destruct_level (PL_curinterp->Iperl_destruct_level)
+#define PL_perldb (PL_curinterp->Iperldb)
+#define PL_preambleav (PL_curinterp->Ipreambleav)
+#define PL_preambled (PL_curinterp->Ipreambled)
+#define PL_preprocess (PL_curinterp->Ipreprocess)
+#define PL_profiledata (PL_curinterp->Iprofiledata)
+#define PL_replgv (PL_curinterp->Ireplgv)
+#define PL_rightgv (PL_curinterp->Irightgv)
+#define PL_rsfp (PL_curinterp->Irsfp)
+#define PL_rsfp_filters (PL_curinterp->Irsfp_filters)
+#define PL_sawampersand (PL_curinterp->Isawampersand)
+#define PL_sawstudy (PL_curinterp->Isawstudy)
+#define PL_sawvec (PL_curinterp->Isawvec)
+#define PL_siggv (PL_curinterp->Isiggv)
+#define PL_splitstr (PL_curinterp->Isplitstr)
+#define PL_statusvalue (PL_curinterp->Istatusvalue)
+#define PL_statusvalue_vms (PL_curinterp->Istatusvalue_vms)
+#define PL_stdingv (PL_curinterp->Istdingv)
+#define PL_strchop (PL_curinterp->Istrchop)
+#define PL_strtab (PL_curinterp->Istrtab)
+#define PL_sub_generation (PL_curinterp->Isub_generation)
+#define PL_sublex_info (PL_curinterp->Isublex_info)
+#define PL_sv_arenaroot (PL_curinterp->Isv_arenaroot)
+#define PL_sv_count (PL_curinterp->Isv_count)
+#define PL_sv_objcount (PL_curinterp->Isv_objcount)
+#define PL_sv_root (PL_curinterp->Isv_root)
+#define PL_sys_intern (PL_curinterp->Isys_intern)
+#define PL_tainting (PL_curinterp->Itainting)
+#define PL_threadnum (PL_curinterp->Ithreadnum)
+#define PL_thrsv (PL_curinterp->Ithrsv)
+#define PL_unsafe (PL_curinterp->Iunsafe)
+#define PL_warnhook (PL_curinterp->Iwarnhook)
#else /* !MULTIPLICITY */
-#define IArgv PL_Argv
-#define ICmd PL_Cmd
-#define IDBcv PL_DBcv
-#define IDBgv PL_DBgv
-#define IDBline PL_DBline
-#define IDBsignal PL_DBsignal
-#define IDBsingle PL_DBsingle
-#define IDBsub PL_DBsub
-#define IDBtrace PL_DBtrace
-#define Iampergv PL_ampergv
-#define Iarchpat_auto PL_archpat_auto
-#define Iargvgv PL_argvgv
-#define Iargvoutgv PL_argvoutgv
-#define Ibasetime PL_basetime
-#define Ibeginav PL_beginav
-#define Icddir PL_cddir
-#define Icompcv PL_compcv
-#define Icompiling PL_compiling
-#define Icomppad PL_comppad
-#define Icomppad_name PL_comppad_name
-#define Icomppad_name_fill PL_comppad_name_fill
-#define Icomppad_name_floor PL_comppad_name_floor
-#define Icopline PL_copline
-#define Icurcopdb PL_curcopdb
-#define Icurstname PL_curstname
-#define Idbargs PL_dbargs
-#define Idebdelim PL_debdelim
-#define Idebname PL_debname
-#define Idebstash PL_debstash
-#define Idefgv PL_defgv
-#define Idiehook PL_diehook
-#define Idlevel PL_dlevel
-#define Idlmax PL_dlmax
-#define Idoextract PL_doextract
-#define Idoswitches PL_doswitches
-#define Idowarn PL_dowarn
-#define Idumplvl PL_dumplvl
-#define Ie_script PL_e_script
-#define Iendav PL_endav
-#define Ienvgv PL_envgv
-#define Ierrgv PL_errgv
-#define Ieval_root PL_eval_root
-#define Ieval_start PL_eval_start
-#define Iexitlist PL_exitlist
-#define Iexitlistlen PL_exitlistlen
-#define Ifdpid PL_fdpid
-#define Ifilemode PL_filemode
-#define Iforkprocess PL_forkprocess
-#define Iformfeed PL_formfeed
-#define Igeneration PL_generation
-#define Igensym PL_gensym
-#define Iglobalstash PL_globalstash
-#define Ihintgv PL_hintgv
-#define Iin_clean_all PL_in_clean_all
-#define Iin_clean_objs PL_in_clean_objs
-#define Iincgv PL_incgv
-#define Iinitav PL_initav
-#define Iinplace PL_inplace
-#define Ilast_proto PL_last_proto
-#define Ilastfd PL_lastfd
-#define Ilastsize PL_lastsize
-#define Ilastspbase PL_lastspbase
-#define Ilaststatval PL_laststatval
-#define Ilaststype PL_laststype
-#define Ileftgv PL_leftgv
-#define Ilineary PL_lineary
-#define Ilinestart PL_linestart
-#define Ilocalpatches PL_localpatches
-#define Imain_cv PL_main_cv
-#define Imain_root PL_main_root
-#define Imain_start PL_main_start
-#define Imaxsysfd PL_maxsysfd
-#define Imess_sv PL_mess_sv
-#define Iminus_F PL_minus_F
-#define Iminus_a PL_minus_a
-#define Iminus_c PL_minus_c
-#define Iminus_l PL_minus_l
-#define Iminus_n PL_minus_n
-#define Iminus_p PL_minus_p
-#define Imodglobal PL_modglobal
-#define Imultiline PL_multiline
-#define Imystrk PL_mystrk
-#define Iofmt PL_ofmt
-#define Ioldlastpm PL_oldlastpm
-#define Ioldname PL_oldname
-#define Iop_mask PL_op_mask
-#define Iorigargc PL_origargc
-#define Iorigargv PL_origargv
-#define Iorigfilename PL_origfilename
-#define Iors PL_ors
-#define Iorslen PL_orslen
-#define Iparsehook PL_parsehook
-#define Ipatchlevel PL_patchlevel
-#define Ipending_ident PL_pending_ident
-#define Iperl_destruct_level PL_perl_destruct_level
-#define Iperldb PL_perldb
-#define Ipreambleav PL_preambleav
-#define Ipreambled PL_preambled
-#define Ipreprocess PL_preprocess
-#define Iprofiledata PL_profiledata
-#define Ireplgv PL_replgv
-#define Irightgv PL_rightgv
-#define Irsfp PL_rsfp
-#define Irsfp_filters PL_rsfp_filters
-#define Isawampersand PL_sawampersand
-#define Isawstudy PL_sawstudy
-#define Isawvec PL_sawvec
-#define Isiggv PL_siggv
-#define Isplitstr PL_splitstr
-#define Istatusvalue PL_statusvalue
-#define Istatusvalue_vms PL_statusvalue_vms
-#define Istdingv PL_stdingv
-#define Istrchop PL_strchop
-#define Istrtab PL_strtab
-#define Isub_generation PL_sub_generation
-#define Isublex_info PL_sublex_info
-#define Isv_arenaroot PL_sv_arenaroot
-#define Isv_count PL_sv_count
-#define Isv_objcount PL_sv_objcount
-#define Isv_root PL_sv_root
-#define Isys_intern PL_sys_intern
-#define Itainting PL_tainting
-#define Ithreadnum PL_threadnum
-#define Ithrsv PL_thrsv
-#define Iunsafe PL_unsafe
-#define Iwarnhook PL_warnhook
+#define PL_IArgv PL_Argv
+#define PL_ICmd PL_Cmd
+#define PL_IDBcv PL_DBcv
+#define PL_IDBgv PL_DBgv
+#define PL_IDBline PL_DBline
+#define PL_IDBsignal PL_DBsignal
+#define PL_IDBsingle PL_DBsingle
+#define PL_IDBsub PL_DBsub
+#define PL_IDBtrace PL_DBtrace
+#define PL_Iampergv PL_ampergv
+#define PL_Iarchpat_auto PL_archpat_auto
+#define PL_Iargvgv PL_argvgv
+#define PL_Iargvoutgv PL_argvoutgv
+#define PL_Ibasetime PL_basetime
+#define PL_Ibeginav PL_beginav
+#define PL_Icddir PL_cddir
+#define PL_Icompcv PL_compcv
+#define PL_Icompiling PL_compiling
+#define PL_Icomppad PL_comppad
+#define PL_Icomppad_name PL_comppad_name
+#define PL_Icomppad_name_fill PL_comppad_name_fill
+#define PL_Icomppad_name_floor PL_comppad_name_floor
+#define PL_Icopline PL_copline
+#define PL_Icurcopdb PL_curcopdb
+#define PL_Icurstname PL_curstname
+#define PL_Idbargs PL_dbargs
+#define PL_Idebdelim PL_debdelim
+#define PL_Idebname PL_debname
+#define PL_Idebstash PL_debstash
+#define PL_Idefgv PL_defgv
+#define PL_Idiehook PL_diehook
+#define PL_Idlevel PL_dlevel
+#define PL_Idlmax PL_dlmax
+#define PL_Idoextract PL_doextract
+#define PL_Idoswitches PL_doswitches
+#define PL_Idowarn PL_dowarn
+#define PL_Idumplvl PL_dumplvl
+#define PL_Ie_script PL_e_script
+#define PL_Iendav PL_endav
+#define PL_Ienvgv PL_envgv
+#define PL_Ierrgv PL_errgv
+#define PL_Ieval_root PL_eval_root
+#define PL_Ieval_start PL_eval_start
+#define PL_Iexitlist PL_exitlist
+#define PL_Iexitlistlen PL_exitlistlen
+#define PL_Ifdpid PL_fdpid
+#define PL_Ifilemode PL_filemode
+#define PL_Iforkprocess PL_forkprocess
+#define PL_Iformfeed PL_formfeed
+#define PL_Igeneration PL_generation
+#define PL_Igensym PL_gensym
+#define PL_Iglobalstash PL_globalstash
+#define PL_Ihintgv PL_hintgv
+#define PL_Iin_clean_all PL_in_clean_all
+#define PL_Iin_clean_objs PL_in_clean_objs
+#define PL_Iincgv PL_incgv
+#define PL_Iinitav PL_initav
+#define PL_Iinplace PL_inplace
+#define PL_Ilast_proto PL_last_proto
+#define PL_Ilastfd PL_lastfd
+#define PL_Ilastsize PL_lastsize
+#define PL_Ilastspbase PL_lastspbase
+#define PL_Ilaststatval PL_laststatval
+#define PL_Ilaststype PL_laststype
+#define PL_Ileftgv PL_leftgv
+#define PL_Ilineary PL_lineary
+#define PL_Ilinestart PL_linestart
+#define PL_Ilocalpatches PL_localpatches
+#define PL_Imain_cv PL_main_cv
+#define PL_Imain_root PL_main_root
+#define PL_Imain_start PL_main_start
+#define PL_Imaxsysfd PL_maxsysfd
+#define PL_Imess_sv PL_mess_sv
+#define PL_Iminus_F PL_minus_F
+#define PL_Iminus_a PL_minus_a
+#define PL_Iminus_c PL_minus_c
+#define PL_Iminus_l PL_minus_l
+#define PL_Iminus_n PL_minus_n
+#define PL_Iminus_p PL_minus_p
+#define PL_Imodglobal PL_modglobal
+#define PL_Imultiline PL_multiline
+#define PL_Imystrk PL_mystrk
+#define PL_Iofmt PL_ofmt
+#define PL_Ioldlastpm PL_oldlastpm
+#define PL_Ioldname PL_oldname
+#define PL_Iop_mask PL_op_mask
+#define PL_Iorigargc PL_origargc
+#define PL_Iorigargv PL_origargv
+#define PL_Iorigfilename PL_origfilename
+#define PL_Iors PL_ors
+#define PL_Iorslen PL_orslen
+#define PL_Iparsehook PL_parsehook
+#define PL_Ipatchlevel PL_patchlevel
+#define PL_Ipending_ident PL_pending_ident
+#define PL_Iperl_destruct_level PL_perl_destruct_level
+#define PL_Iperldb PL_perldb
+#define PL_Ipreambleav PL_preambleav
+#define PL_Ipreambled PL_preambled
+#define PL_Ipreprocess PL_preprocess
+#define PL_Iprofiledata PL_profiledata
+#define PL_Ireplgv PL_replgv
+#define PL_Irightgv PL_rightgv
+#define PL_Irsfp PL_rsfp
+#define PL_Irsfp_filters PL_rsfp_filters
+#define PL_Isawampersand PL_sawampersand
+#define PL_Isawstudy PL_sawstudy
+#define PL_Isawvec PL_sawvec
+#define PL_Isiggv PL_siggv
+#define PL_Isplitstr PL_splitstr
+#define PL_Istatusvalue PL_statusvalue
+#define PL_Istatusvalue_vms PL_statusvalue_vms
+#define PL_Istdingv PL_stdingv
+#define PL_Istrchop PL_strchop
+#define PL_Istrtab PL_strtab
+#define PL_Isub_generation PL_sub_generation
+#define PL_Isublex_info PL_sublex_info
+#define PL_Isv_arenaroot PL_sv_arenaroot
+#define PL_Isv_count PL_sv_count
+#define PL_Isv_objcount PL_sv_objcount
+#define PL_Isv_root PL_sv_root
+#define PL_Isys_intern PL_sys_intern
+#define PL_Itainting PL_tainting
+#define PL_Ithreadnum PL_threadnum
+#define PL_Ithrsv PL_thrsv
+#define PL_Iunsafe PL_unsafe
+#define PL_Iwarnhook PL_warnhook
#ifndef USE_THREADS
-#define TSv PL_Sv
-#define TXpv PL_Xpv
-#define Tav_fetch_sv PL_av_fetch_sv
-#define Tbodytarget PL_bodytarget
-#define Tbostr PL_bostr
-#define Tchopset PL_chopset
-#define Tcolors PL_colors
-#define Tcolorset PL_colorset
-#define Tcurcop PL_curcop
-#define Tcurpad PL_curpad
-#define Tcurpm PL_curpm
-#define Tcurstack PL_curstack
-#define Tcurstackinfo PL_curstackinfo
-#define Tcurstash PL_curstash
-#define Tdefoutgv PL_defoutgv
-#define Tdefstash PL_defstash
-#define Tdelaymagic PL_delaymagic
-#define Tdirty PL_dirty
-#define Textralen PL_extralen
-#define Tfirstgv PL_firstgv
-#define Tformtarget PL_formtarget
-#define Thv_fetch_ent_mh PL_hv_fetch_ent_mh
-#define Thv_fetch_sv PL_hv_fetch_sv
-#define Tin_eval PL_in_eval
-#define Tlast_in_gv PL_last_in_gv
-#define Tlastgotoprobe PL_lastgotoprobe
-#define Tlastscream PL_lastscream
-#define Tlocalizing PL_localizing
-#define Tmainstack PL_mainstack
-#define Tmarkstack PL_markstack
-#define Tmarkstack_max PL_markstack_max
-#define Tmarkstack_ptr PL_markstack_ptr
-#define Tmaxscream PL_maxscream
-#define Tmodcount PL_modcount
-#define Tnrs PL_nrs
-#define Tofs PL_ofs
-#define Tofslen PL_ofslen
-#define Top PL_op
-#define Topsave PL_opsave
-#define Treg_eval_set PL_reg_eval_set
-#define Treg_flags PL_reg_flags
-#define Treg_start_tmp PL_reg_start_tmp
-#define Treg_start_tmpl PL_reg_start_tmpl
-#define Tregbol PL_regbol
-#define Tregcc PL_regcc
-#define Tregcode PL_regcode
-#define Tregcomp_parse PL_regcomp_parse
-#define Tregcomp_rx PL_regcomp_rx
-#define Tregcompp PL_regcompp
-#define Tregdata PL_regdata
-#define Tregdummy PL_regdummy
-#define Tregendp PL_regendp
-#define Tregeol PL_regeol
-#define Tregexecp PL_regexecp
-#define Tregflags PL_regflags
-#define Tregindent PL_regindent
-#define Treginput PL_reginput
-#define Treginterp_cnt PL_reginterp_cnt
-#define Treglastparen PL_reglastparen
-#define Tregnarrate PL_regnarrate
-#define Tregnaughty PL_regnaughty
-#define Tregnpar PL_regnpar
-#define Tregprecomp PL_regprecomp
-#define Tregprev PL_regprev
-#define Tregprogram PL_regprogram
-#define Tregsawback PL_regsawback
-#define Tregseen PL_regseen
-#define Tregsize PL_regsize
-#define Tregstartp PL_regstartp
-#define Tregtill PL_regtill
-#define Tregxend PL_regxend
-#define Trestartop PL_restartop
-#define Tretstack PL_retstack
-#define Tretstack_ix PL_retstack_ix
-#define Tretstack_max PL_retstack_max
-#define Trs PL_rs
-#define Tsavestack PL_savestack
-#define Tsavestack_ix PL_savestack_ix
-#define Tsavestack_max PL_savestack_max
-#define Tscopestack PL_scopestack
-#define Tscopestack_ix PL_scopestack_ix
-#define Tscopestack_max PL_scopestack_max
-#define Tscreamfirst PL_screamfirst
-#define Tscreamnext PL_screamnext
-#define Tsecondgv PL_secondgv
-#define Tseen_evals PL_seen_evals
-#define Tseen_zerolen PL_seen_zerolen
-#define Tsortcop PL_sortcop
-#define Tsortcxix PL_sortcxix
-#define Tsortstash PL_sortstash
-#define Tstack_base PL_stack_base
-#define Tstack_max PL_stack_max
-#define Tstack_sp PL_stack_sp
-#define Tstart_env PL_start_env
-#define Tstatbuf PL_statbuf
-#define Tstatcache PL_statcache
-#define Tstatgv PL_statgv
-#define Tstatname PL_statname
-#define Ttainted PL_tainted
-#define Ttimesbuf PL_timesbuf
-#define Ttmps_floor PL_tmps_floor
-#define Ttmps_ix PL_tmps_ix
-#define Ttmps_max PL_tmps_max
-#define Ttmps_stack PL_tmps_stack
-#define Ttop_env PL_top_env
-#define Ttoptarget PL_toptarget
+#define PL_TSv PL_Sv
+#define PL_TXpv PL_Xpv
+#define PL_Tav_fetch_sv PL_av_fetch_sv
+#define PL_Tbodytarget PL_bodytarget
+#define PL_Tbostr PL_bostr
+#define PL_Tchopset PL_chopset
+#define PL_Tcolors PL_colors
+#define PL_Tcolorset PL_colorset
+#define PL_Tcurcop PL_curcop
+#define PL_Tcurpad PL_curpad
+#define PL_Tcurpm PL_curpm
+#define PL_Tcurstack PL_curstack
+#define PL_Tcurstackinfo PL_curstackinfo
+#define PL_Tcurstash PL_curstash
+#define PL_Tdefoutgv PL_defoutgv
+#define PL_Tdefstash PL_defstash
+#define PL_Tdelaymagic PL_delaymagic
+#define PL_Tdirty PL_dirty
+#define PL_Textralen PL_extralen
+#define PL_Tfirstgv PL_firstgv
+#define PL_Tformtarget PL_formtarget
+#define PL_Thv_fetch_ent_mh PL_hv_fetch_ent_mh
+#define PL_Thv_fetch_sv PL_hv_fetch_sv
+#define PL_Tin_eval PL_in_eval
+#define PL_Tlast_in_gv PL_last_in_gv
+#define PL_Tlastgotoprobe PL_lastgotoprobe
+#define PL_Tlastscream PL_lastscream
+#define PL_Tlocalizing PL_localizing
+#define PL_Tmainstack PL_mainstack
+#define PL_Tmarkstack PL_markstack
+#define PL_Tmarkstack_max PL_markstack_max
+#define PL_Tmarkstack_ptr PL_markstack_ptr
+#define PL_Tmaxscream PL_maxscream
+#define PL_Tmodcount PL_modcount
+#define PL_Tnrs PL_nrs
+#define PL_Tofs PL_ofs
+#define PL_Tofslen PL_ofslen
+#define PL_Top PL_op
+#define PL_Topsave PL_opsave
+#define PL_Treg_eval_set PL_reg_eval_set
+#define PL_Treg_flags PL_reg_flags
+#define PL_Treg_start_tmp PL_reg_start_tmp
+#define PL_Treg_start_tmpl PL_reg_start_tmpl
+#define PL_Tregbol PL_regbol
+#define PL_Tregcc PL_regcc
+#define PL_Tregcode PL_regcode
+#define PL_Tregcomp_parse PL_regcomp_parse
+#define PL_Tregcomp_rx PL_regcomp_rx
+#define PL_Tregcompp PL_regcompp
+#define PL_Tregdata PL_regdata
+#define PL_Tregdummy PL_regdummy
+#define PL_Tregendp PL_regendp
+#define PL_Tregeol PL_regeol
+#define PL_Tregexecp PL_regexecp
+#define PL_Tregflags PL_regflags
+#define PL_Tregindent PL_regindent
+#define PL_Treginput PL_reginput
+#define PL_Treginterp_cnt PL_reginterp_cnt
+#define PL_Treglastparen PL_reglastparen
+#define PL_Tregnarrate PL_regnarrate
+#define PL_Tregnaughty PL_regnaughty
+#define PL_Tregnpar PL_regnpar
+#define PL_Tregprecomp PL_regprecomp
+#define PL_Tregprev PL_regprev
+#define PL_Tregprogram PL_regprogram
+#define PL_Tregsawback PL_regsawback
+#define PL_Tregseen PL_regseen
+#define PL_Tregsize PL_regsize
+#define PL_Tregstartp PL_regstartp
+#define PL_Tregtill PL_regtill
+#define PL_Tregxend PL_regxend
+#define PL_Trestartop PL_restartop
+#define PL_Tretstack PL_retstack
+#define PL_Tretstack_ix PL_retstack_ix
+#define PL_Tretstack_max PL_retstack_max
+#define PL_Trs PL_rs
+#define PL_Tsavestack PL_savestack
+#define PL_Tsavestack_ix PL_savestack_ix
+#define PL_Tsavestack_max PL_savestack_max
+#define PL_Tscopestack PL_scopestack
+#define PL_Tscopestack_ix PL_scopestack_ix
+#define PL_Tscopestack_max PL_scopestack_max
+#define PL_Tscreamfirst PL_screamfirst
+#define PL_Tscreamnext PL_screamnext
+#define PL_Tsecondgv PL_secondgv
+#define PL_Tseen_evals PL_seen_evals
+#define PL_Tseen_zerolen PL_seen_zerolen
+#define PL_Tsortcop PL_sortcop
+#define PL_Tsortcxix PL_sortcxix
+#define PL_Tsortstash PL_sortstash
+#define PL_Tstack_base PL_stack_base
+#define PL_Tstack_max PL_stack_max
+#define PL_Tstack_sp PL_stack_sp
+#define PL_Tstart_env PL_start_env
+#define PL_Tstatbuf PL_statbuf
+#define PL_Tstatcache PL_statcache
+#define PL_Tstatgv PL_statgv
+#define PL_Tstatname PL_statname
+#define PL_Ttainted PL_tainted
+#define PL_Ttimesbuf PL_timesbuf
+#define PL_Ttmps_floor PL_tmps_floor
+#define PL_Ttmps_ix PL_tmps_ix
+#define PL_Ttmps_max PL_tmps_max
+#define PL_Ttmps_stack PL_tmps_stack
+#define PL_Ttop_env PL_top_env
+#define PL_Ttoptarget PL_toptarget
#endif /* USE_THREADS */
#ifdef PERL_GLOBAL_STRUCT
-#define PL_No (Perl_Vars.GNo)
-#define PL_Yes (Perl_Vars.GYes)
-#define PL_amagic_generation (Perl_Vars.Gamagic_generation)
-#define PL_an (Perl_Vars.Gan)
-#define PL_bufend (Perl_Vars.Gbufend)
-#define PL_bufptr (Perl_Vars.Gbufptr)
-#define PL_collation_ix (Perl_Vars.Gcollation_ix)
-#define PL_collation_name (Perl_Vars.Gcollation_name)
-#define PL_collation_standard (Perl_Vars.Gcollation_standard)
-#define PL_collxfrm_base (Perl_Vars.Gcollxfrm_base)
-#define PL_collxfrm_mult (Perl_Vars.Gcollxfrm_mult)
-#define PL_cop_seqmax (Perl_Vars.Gcop_seqmax)
-#define PL_cryptseen (Perl_Vars.Gcryptseen)
-#define PL_cshlen (Perl_Vars.Gcshlen)
-#define PL_cshname (Perl_Vars.Gcshname)
-#define PL_curinterp (Perl_Vars.Gcurinterp)
-#define PL_curthr (Perl_Vars.Gcurthr)
-#define PL_debug (Perl_Vars.Gdebug)
-#define PL_do_undump (Perl_Vars.Gdo_undump)
-#define PL_egid (Perl_Vars.Gegid)
-#define PL_error_count (Perl_Vars.Gerror_count)
-#define PL_euid (Perl_Vars.Geuid)
-#define PL_eval_cond (Perl_Vars.Geval_cond)
-#define PL_eval_mutex (Perl_Vars.Geval_mutex)
-#define PL_eval_owner (Perl_Vars.Geval_owner)
-#define PL_evalseq (Perl_Vars.Gevalseq)
-#define PL_expect (Perl_Vars.Gexpect)
-#define PL_gid (Perl_Vars.Ggid)
-#define PL_he_root (Perl_Vars.Ghe_root)
-#define PL_hexdigit (Perl_Vars.Ghexdigit)
-#define PL_hints (Perl_Vars.Ghints)
-#define PL_in_my (Perl_Vars.Gin_my)
-#define PL_in_my_stash (Perl_Vars.Gin_my_stash)
-#define PL_last_lop (Perl_Vars.Glast_lop)
-#define PL_last_lop_op (Perl_Vars.Glast_lop_op)
-#define PL_last_uni (Perl_Vars.Glast_uni)
-#define PL_lex_brackets (Perl_Vars.Glex_brackets)
-#define PL_lex_brackstack (Perl_Vars.Glex_brackstack)
-#define PL_lex_casemods (Perl_Vars.Glex_casemods)
-#define PL_lex_casestack (Perl_Vars.Glex_casestack)
-#define PL_lex_defer (Perl_Vars.Glex_defer)
-#define PL_lex_dojoin (Perl_Vars.Glex_dojoin)
-#define PL_lex_expect (Perl_Vars.Glex_expect)
-#define PL_lex_fakebrack (Perl_Vars.Glex_fakebrack)
-#define PL_lex_formbrack (Perl_Vars.Glex_formbrack)
-#define PL_lex_inpat (Perl_Vars.Glex_inpat)
-#define PL_lex_inwhat (Perl_Vars.Glex_inwhat)
-#define PL_lex_op (Perl_Vars.Glex_op)
-#define PL_lex_repl (Perl_Vars.Glex_repl)
-#define PL_lex_starts (Perl_Vars.Glex_starts)
-#define PL_lex_state (Perl_Vars.Glex_state)
-#define PL_lex_stuff (Perl_Vars.Glex_stuff)
-#define PL_linestr (Perl_Vars.Glinestr)
-#define PL_malloc_mutex (Perl_Vars.Gmalloc_mutex)
-#define PL_max_intro_pending (Perl_Vars.Gmax_intro_pending)
-#define PL_maxo (Perl_Vars.Gmaxo)
-#define PL_min_intro_pending (Perl_Vars.Gmin_intro_pending)
-#define PL_multi_close (Perl_Vars.Gmulti_close)
-#define PL_multi_end (Perl_Vars.Gmulti_end)
-#define PL_multi_open (Perl_Vars.Gmulti_open)
-#define PL_multi_start (Perl_Vars.Gmulti_start)
-#define PL_na (Perl_Vars.Gna)
-#define PL_nexttoke (Perl_Vars.Gnexttoke)
-#define PL_nexttype (Perl_Vars.Gnexttype)
-#define PL_nextval (Perl_Vars.Gnextval)
-#define PL_nice_chunk (Perl_Vars.Gnice_chunk)
-#define PL_nice_chunk_size (Perl_Vars.Gnice_chunk_size)
-#define PL_ninterps (Perl_Vars.Gninterps)
-#define PL_nomemok (Perl_Vars.Gnomemok)
-#define PL_nthreads (Perl_Vars.Gnthreads)
-#define PL_nthreads_cond (Perl_Vars.Gnthreads_cond)
-#define PL_numeric_local (Perl_Vars.Gnumeric_local)
-#define PL_numeric_name (Perl_Vars.Gnumeric_name)
-#define PL_numeric_standard (Perl_Vars.Gnumeric_standard)
-#define PL_oldbufptr (Perl_Vars.Goldbufptr)
-#define PL_oldoldbufptr (Perl_Vars.Goldoldbufptr)
-#define PL_op_seqmax (Perl_Vars.Gop_seqmax)
-#define PL_origalen (Perl_Vars.Gorigalen)
-#define PL_origenviron (Perl_Vars.Gorigenviron)
-#define PL_osname (Perl_Vars.Gosname)
-#define PL_pad_reset_pending (Perl_Vars.Gpad_reset_pending)
-#define PL_padix (Perl_Vars.Gpadix)
-#define PL_padix_floor (Perl_Vars.Gpadix_floor)
-#define PL_patleave (Perl_Vars.Gpatleave)
-#define PL_pidstatus (Perl_Vars.Gpidstatus)
-#define PL_runops (Perl_Vars.Grunops)
-#define PL_sh_path (Perl_Vars.Gsh_path)
-#define PL_sighandlerp (Perl_Vars.Gsighandlerp)
-#define PL_specialsv_list (Perl_Vars.Gspecialsv_list)
-#define PL_subline (Perl_Vars.Gsubline)
-#define PL_subname (Perl_Vars.Gsubname)
-#define PL_sv_mutex (Perl_Vars.Gsv_mutex)
-#define PL_sv_no (Perl_Vars.Gsv_no)
-#define PL_sv_undef (Perl_Vars.Gsv_undef)
-#define PL_sv_yes (Perl_Vars.Gsv_yes)
-#define PL_svref_mutex (Perl_Vars.Gsvref_mutex)
-#define PL_thisexpr (Perl_Vars.Gthisexpr)
-#define PL_thr_key (Perl_Vars.Gthr_key)
-#define PL_threads_mutex (Perl_Vars.Gthreads_mutex)
-#define PL_threadsv_names (Perl_Vars.Gthreadsv_names)
-#define PL_tokenbuf (Perl_Vars.Gtokenbuf)
-#define PL_uid (Perl_Vars.Guid)
-#define PL_xiv_arenaroot (Perl_Vars.Gxiv_arenaroot)
-#define PL_xiv_root (Perl_Vars.Gxiv_root)
-#define PL_xnv_root (Perl_Vars.Gxnv_root)
-#define PL_xpv_root (Perl_Vars.Gxpv_root)
-#define PL_xrv_root (Perl_Vars.Gxrv_root)
+#define PL_No (PL_Vars.GNo)
+#define PL_Yes (PL_Vars.GYes)
+#define PL_amagic_generation (PL_Vars.Gamagic_generation)
+#define PL_an (PL_Vars.Gan)
+#define PL_bufend (PL_Vars.Gbufend)
+#define PL_bufptr (PL_Vars.Gbufptr)
+#define PL_collation_ix (PL_Vars.Gcollation_ix)
+#define PL_collation_name (PL_Vars.Gcollation_name)
+#define PL_collation_standard (PL_Vars.Gcollation_standard)
+#define PL_collxfrm_base (PL_Vars.Gcollxfrm_base)
+#define PL_collxfrm_mult (PL_Vars.Gcollxfrm_mult)
+#define PL_cop_seqmax (PL_Vars.Gcop_seqmax)
+#define PL_cryptseen (PL_Vars.Gcryptseen)
+#define PL_cshlen (PL_Vars.Gcshlen)
+#define PL_cshname (PL_Vars.Gcshname)
+#define PL_curinterp (PL_Vars.Gcurinterp)
+#define PL_curthr (PL_Vars.Gcurthr)
+#define PL_debug (PL_Vars.Gdebug)
+#define PL_do_undump (PL_Vars.Gdo_undump)
+#define PL_egid (PL_Vars.Gegid)
+#define PL_error_count (PL_Vars.Gerror_count)
+#define PL_euid (PL_Vars.Geuid)
+#define PL_eval_cond (PL_Vars.Geval_cond)
+#define PL_eval_mutex (PL_Vars.Geval_mutex)
+#define PL_eval_owner (PL_Vars.Geval_owner)
+#define PL_evalseq (PL_Vars.Gevalseq)
+#define PL_expect (PL_Vars.Gexpect)
+#define PL_gid (PL_Vars.Ggid)
+#define PL_he_root (PL_Vars.Ghe_root)
+#define PL_hexdigit (PL_Vars.Ghexdigit)
+#define PL_hints (PL_Vars.Ghints)
+#define PL_in_my (PL_Vars.Gin_my)
+#define PL_in_my_stash (PL_Vars.Gin_my_stash)
+#define PL_last_lop (PL_Vars.Glast_lop)
+#define PL_last_lop_op (PL_Vars.Glast_lop_op)
+#define PL_last_uni (PL_Vars.Glast_uni)
+#define PL_lex_brackets (PL_Vars.Glex_brackets)
+#define PL_lex_brackstack (PL_Vars.Glex_brackstack)
+#define PL_lex_casemods (PL_Vars.Glex_casemods)
+#define PL_lex_casestack (PL_Vars.Glex_casestack)
+#define PL_lex_defer (PL_Vars.Glex_defer)
+#define PL_lex_dojoin (PL_Vars.Glex_dojoin)
+#define PL_lex_expect (PL_Vars.Glex_expect)
+#define PL_lex_fakebrack (PL_Vars.Glex_fakebrack)
+#define PL_lex_formbrack (PL_Vars.Glex_formbrack)
+#define PL_lex_inpat (PL_Vars.Glex_inpat)
+#define PL_lex_inwhat (PL_Vars.Glex_inwhat)
+#define PL_lex_op (PL_Vars.Glex_op)
+#define PL_lex_repl (PL_Vars.Glex_repl)
+#define PL_lex_starts (PL_Vars.Glex_starts)
+#define PL_lex_state (PL_Vars.Glex_state)
+#define PL_lex_stuff (PL_Vars.Glex_stuff)
+#define PL_linestr (PL_Vars.Glinestr)
+#define PL_malloc_mutex (PL_Vars.Gmalloc_mutex)
+#define PL_max_intro_pending (PL_Vars.Gmax_intro_pending)
+#define PL_maxo (PL_Vars.Gmaxo)
+#define PL_min_intro_pending (PL_Vars.Gmin_intro_pending)
+#define PL_multi_close (PL_Vars.Gmulti_close)
+#define PL_multi_end (PL_Vars.Gmulti_end)
+#define PL_multi_open (PL_Vars.Gmulti_open)
+#define PL_multi_start (PL_Vars.Gmulti_start)
+#define PL_na (PL_Vars.Gna)
+#define PL_nexttoke (PL_Vars.Gnexttoke)
+#define PL_nexttype (PL_Vars.Gnexttype)
+#define PL_nextval (PL_Vars.Gnextval)
+#define PL_nice_chunk (PL_Vars.Gnice_chunk)
+#define PL_nice_chunk_size (PL_Vars.Gnice_chunk_size)
+#define PL_ninterps (PL_Vars.Gninterps)
+#define PL_nomemok (PL_Vars.Gnomemok)
+#define PL_nthreads (PL_Vars.Gnthreads)
+#define PL_nthreads_cond (PL_Vars.Gnthreads_cond)
+#define PL_numeric_local (PL_Vars.Gnumeric_local)
+#define PL_numeric_name (PL_Vars.Gnumeric_name)
+#define PL_numeric_standard (PL_Vars.Gnumeric_standard)
+#define PL_oldbufptr (PL_Vars.Goldbufptr)
+#define PL_oldoldbufptr (PL_Vars.Goldoldbufptr)
+#define PL_op_seqmax (PL_Vars.Gop_seqmax)
+#define PL_origalen (PL_Vars.Gorigalen)
+#define PL_origenviron (PL_Vars.Gorigenviron)
+#define PL_osname (PL_Vars.Gosname)
+#define PL_pad_reset_pending (PL_Vars.Gpad_reset_pending)
+#define PL_padix (PL_Vars.Gpadix)
+#define PL_padix_floor (PL_Vars.Gpadix_floor)
+#define PL_patleave (PL_Vars.Gpatleave)
+#define PL_pidstatus (PL_Vars.Gpidstatus)
+#define PL_runops (PL_Vars.Grunops)
+#define PL_sh_path (PL_Vars.Gsh_path)
+#define PL_sighandlerp (PL_Vars.Gsighandlerp)
+#define PL_specialsv_list (PL_Vars.Gspecialsv_list)
+#define PL_subline (PL_Vars.Gsubline)
+#define PL_subname (PL_Vars.Gsubname)
+#define PL_sv_mutex (PL_Vars.Gsv_mutex)
+#define PL_sv_no (PL_Vars.Gsv_no)
+#define PL_sv_undef (PL_Vars.Gsv_undef)
+#define PL_sv_yes (PL_Vars.Gsv_yes)
+#define PL_svref_mutex (PL_Vars.Gsvref_mutex)
+#define PL_thisexpr (PL_Vars.Gthisexpr)
+#define PL_thr_key (PL_Vars.Gthr_key)
+#define PL_threads_mutex (PL_Vars.Gthreads_mutex)
+#define PL_threadsv_names (PL_Vars.Gthreadsv_names)
+#define PL_tokenbuf (PL_Vars.Gtokenbuf)
+#define PL_uid (PL_Vars.Guid)
+#define PL_xiv_arenaroot (PL_Vars.Gxiv_arenaroot)
+#define PL_xiv_root (PL_Vars.Gxiv_root)
+#define PL_xnv_root (PL_Vars.Gxnv_root)
+#define PL_xpv_root (PL_Vars.Gxpv_root)
+#define PL_xrv_root (PL_Vars.Gxrv_root)
#else /* !PERL_GLOBAL_STRUCT */
-#define GNo PL_No
-#define GYes PL_Yes
-#define Gamagic_generation PL_amagic_generation
-#define Gan PL_an
-#define Gbufend PL_bufend
-#define Gbufptr PL_bufptr
-#define Gcollation_ix PL_collation_ix
-#define Gcollation_name PL_collation_name
-#define Gcollation_standard PL_collation_standard
-#define Gcollxfrm_base PL_collxfrm_base
-#define Gcollxfrm_mult PL_collxfrm_mult
-#define Gcop_seqmax PL_cop_seqmax
-#define Gcryptseen PL_cryptseen
-#define Gcshlen PL_cshlen
-#define Gcshname PL_cshname
-#define Gcurinterp PL_curinterp
-#define Gcurthr PL_curthr
-#define Gdebug PL_debug
-#define Gdo_undump PL_do_undump
-#define Gegid PL_egid
-#define Gerror_count PL_error_count
-#define Geuid PL_euid
-#define Geval_cond PL_eval_cond
-#define Geval_mutex PL_eval_mutex
-#define Geval_owner PL_eval_owner
-#define Gevalseq PL_evalseq
-#define Gexpect PL_expect
-#define Ggid PL_gid
-#define Ghe_root PL_he_root
-#define Ghexdigit PL_hexdigit
-#define Ghints PL_hints
-#define Gin_my PL_in_my
-#define Gin_my_stash PL_in_my_stash
-#define Glast_lop PL_last_lop
-#define Glast_lop_op PL_last_lop_op
-#define Glast_uni PL_last_uni
-#define Glex_brackets PL_lex_brackets
-#define Glex_brackstack PL_lex_brackstack
-#define Glex_casemods PL_lex_casemods
-#define Glex_casestack PL_lex_casestack
-#define Glex_defer PL_lex_defer
-#define Glex_dojoin PL_lex_dojoin
-#define Glex_expect PL_lex_expect
-#define Glex_fakebrack PL_lex_fakebrack
-#define Glex_formbrack PL_lex_formbrack
-#define Glex_inpat PL_lex_inpat
-#define Glex_inwhat PL_lex_inwhat
-#define Glex_op PL_lex_op
-#define Glex_repl PL_lex_repl
-#define Glex_starts PL_lex_starts
-#define Glex_state PL_lex_state
-#define Glex_stuff PL_lex_stuff
-#define Glinestr PL_linestr
-#define Gmalloc_mutex PL_malloc_mutex
-#define Gmax_intro_pending PL_max_intro_pending
-#define Gmaxo PL_maxo
-#define Gmin_intro_pending PL_min_intro_pending
-#define Gmulti_close PL_multi_close
-#define Gmulti_end PL_multi_end
-#define Gmulti_open PL_multi_open
-#define Gmulti_start PL_multi_start
-#define Gna PL_na
-#define Gnexttoke PL_nexttoke
-#define Gnexttype PL_nexttype
-#define Gnextval PL_nextval
-#define Gnice_chunk PL_nice_chunk
-#define Gnice_chunk_size PL_nice_chunk_size
-#define Gninterps PL_ninterps
-#define Gnomemok PL_nomemok
-#define Gnthreads PL_nthreads
-#define Gnthreads_cond PL_nthreads_cond
-#define Gnumeric_local PL_numeric_local
-#define Gnumeric_name PL_numeric_name
-#define Gnumeric_standard PL_numeric_standard
-#define Goldbufptr PL_oldbufptr
-#define Goldoldbufptr PL_oldoldbufptr
-#define Gop_seqmax PL_op_seqmax
-#define Gorigalen PL_origalen
-#define Gorigenviron PL_origenviron
-#define Gosname PL_osname
-#define Gpad_reset_pending PL_pad_reset_pending
-#define Gpadix PL_padix
-#define Gpadix_floor PL_padix_floor
-#define Gpatleave PL_patleave
-#define Gpidstatus PL_pidstatus
-#define Grunops PL_runops
-#define Gsh_path PL_sh_path
-#define Gsighandlerp PL_sighandlerp
-#define Gspecialsv_list PL_specialsv_list
-#define Gsubline PL_subline
-#define Gsubname PL_subname
-#define Gsv_mutex PL_sv_mutex
-#define Gsv_no PL_sv_no
-#define Gsv_undef PL_sv_undef
-#define Gsv_yes PL_sv_yes
-#define Gsvref_mutex PL_svref_mutex
-#define Gthisexpr PL_thisexpr
-#define Gthr_key PL_thr_key
-#define Gthreads_mutex PL_threads_mutex
-#define Gthreadsv_names PL_threadsv_names
-#define Gtokenbuf PL_tokenbuf
-#define Guid PL_uid
-#define Gxiv_arenaroot PL_xiv_arenaroot
-#define Gxiv_root PL_xiv_root
-#define Gxnv_root PL_xnv_root
-#define Gxpv_root PL_xpv_root
-#define Gxrv_root PL_xrv_root
+#define PL_GNo PL_No
+#define PL_GYes PL_Yes
+#define PL_Gamagic_generation PL_amagic_generation
+#define PL_Gan PL_an
+#define PL_Gbufend PL_bufend
+#define PL_Gbufptr PL_bufptr
+#define PL_Gcollation_ix PL_collation_ix
+#define PL_Gcollation_name PL_collation_name
+#define PL_Gcollation_standard PL_collation_standard
+#define PL_Gcollxfrm_base PL_collxfrm_base
+#define PL_Gcollxfrm_mult PL_collxfrm_mult
+#define PL_Gcop_seqmax PL_cop_seqmax
+#define PL_Gcryptseen PL_cryptseen
+#define PL_Gcshlen PL_cshlen
+#define PL_Gcshname PL_cshname
+#define PL_Gcurinterp PL_curinterp
+#define PL_Gcurthr PL_curthr
+#define PL_Gdebug PL_debug
+#define PL_Gdo_undump PL_do_undump
+#define PL_Gegid PL_egid
+#define PL_Gerror_count PL_error_count
+#define PL_Geuid PL_euid
+#define PL_Geval_cond PL_eval_cond
+#define PL_Geval_mutex PL_eval_mutex
+#define PL_Geval_owner PL_eval_owner
+#define PL_Gevalseq PL_evalseq
+#define PL_Gexpect PL_expect
+#define PL_Ggid PL_gid
+#define PL_Ghe_root PL_he_root
+#define PL_Ghexdigit PL_hexdigit
+#define PL_Ghints PL_hints
+#define PL_Gin_my PL_in_my
+#define PL_Gin_my_stash PL_in_my_stash
+#define PL_Glast_lop PL_last_lop
+#define PL_Glast_lop_op PL_last_lop_op
+#define PL_Glast_uni PL_last_uni
+#define PL_Glex_brackets PL_lex_brackets
+#define PL_Glex_brackstack PL_lex_brackstack
+#define PL_Glex_casemods PL_lex_casemods
+#define PL_Glex_casestack PL_lex_casestack
+#define PL_Glex_defer PL_lex_defer
+#define PL_Glex_dojoin PL_lex_dojoin
+#define PL_Glex_expect PL_lex_expect
+#define PL_Glex_fakebrack PL_lex_fakebrack
+#define PL_Glex_formbrack PL_lex_formbrack
+#define PL_Glex_inpat PL_lex_inpat
+#define PL_Glex_inwhat PL_lex_inwhat
+#define PL_Glex_op PL_lex_op
+#define PL_Glex_repl PL_lex_repl
+#define PL_Glex_starts PL_lex_starts
+#define PL_Glex_state PL_lex_state
+#define PL_Glex_stuff PL_lex_stuff
+#define PL_Glinestr PL_linestr
+#define PL_Gmalloc_mutex PL_malloc_mutex
+#define PL_Gmax_intro_pending PL_max_intro_pending
+#define PL_Gmaxo PL_maxo
+#define PL_Gmin_intro_pending PL_min_intro_pending
+#define PL_Gmulti_close PL_multi_close
+#define PL_Gmulti_end PL_multi_end
+#define PL_Gmulti_open PL_multi_open
+#define PL_Gmulti_start PL_multi_start
+#define PL_Gna PL_na
+#define PL_Gnexttoke PL_nexttoke
+#define PL_Gnexttype PL_nexttype
+#define PL_Gnextval PL_nextval
+#define PL_Gnice_chunk PL_nice_chunk
+#define PL_Gnice_chunk_size PL_nice_chunk_size
+#define PL_Gninterps PL_ninterps
+#define PL_Gnomemok PL_nomemok
+#define PL_Gnthreads PL_nthreads
+#define PL_Gnthreads_cond PL_nthreads_cond
+#define PL_Gnumeric_local PL_numeric_local
+#define PL_Gnumeric_name PL_numeric_name
+#define PL_Gnumeric_standard PL_numeric_standard
+#define PL_Goldbufptr PL_oldbufptr
+#define PL_Goldoldbufptr PL_oldoldbufptr
+#define PL_Gop_seqmax PL_op_seqmax
+#define PL_Gorigalen PL_origalen
+#define PL_Gorigenviron PL_origenviron
+#define PL_Gosname PL_osname
+#define PL_Gpad_reset_pending PL_pad_reset_pending
+#define PL_Gpadix PL_padix
+#define PL_Gpadix_floor PL_padix_floor
+#define PL_Gpatleave PL_patleave
+#define PL_Gpidstatus PL_pidstatus
+#define PL_Grunops PL_runops
+#define PL_Gsh_path PL_sh_path
+#define PL_Gsighandlerp PL_sighandlerp
+#define PL_Gspecialsv_list PL_specialsv_list
+#define PL_Gsubline PL_subline
+#define PL_Gsubname PL_subname
+#define PL_Gsv_mutex PL_sv_mutex
+#define PL_Gsv_no PL_sv_no
+#define PL_Gsv_undef PL_sv_undef
+#define PL_Gsv_yes PL_sv_yes
+#define PL_Gsvref_mutex PL_svref_mutex
+#define PL_Gthisexpr PL_thisexpr
+#define PL_Gthr_key PL_thr_key
+#define PL_Gthreads_mutex PL_threads_mutex
+#define PL_Gthreadsv_names PL_threadsv_names
+#define PL_Gtokenbuf PL_tokenbuf
+#define PL_Guid PL_uid
+#define PL_Gxiv_arenaroot PL_xiv_arenaroot
+#define PL_Gxiv_root PL_xiv_root
+#define PL_Gxnv_root PL_xnv_root
+#define PL_Gxpv_root PL_xpv_root
+#define PL_Gxrv_root PL_xrv_root
#ifdef EMBED
PPCODE:
#ifdef USE_THREADS
int i;
- STRLEN len = strlen(threadsv_names);
+ STRLEN len = strlen(PL_threadsv_names);
EXTEND(sp, len);
for (i = 0; i < len; i++)
- PUSHs(sv_2mortal(newSVpv(&threadsv_names[i], 1)));
+ PUSHs(sv_2mortal(newSVpv(&PL_threadsv_names[i], 1)));
#endif
#ifdef USE_THREADS
DEBUG_L(WITH_THR(PerlIO_printf(PerlIO_stderr(),
"%p: remove_thread %p\n", thr, t)));
- MUTEX_LOCK(&threads_mutex);
+ MUTEX_LOCK(&PL_threads_mutex);
MUTEX_DESTROY(&t->mutex);
- nthreads--;
+ PL_nthreads--;
t->prev->next = t->next;
t->next->prev = t->prev;
- COND_BROADCAST(&nthreads_cond);
- MUTEX_UNLOCK(&threads_mutex);
+ COND_BROADCAST(&PL_nthreads_cond);
+ MUTEX_UNLOCK(&PL_threads_mutex);
#endif
}
LOGOP myop;
djSP;
I32 oldmark = TOPMARK;
- I32 oldscope = scopestack_ix;
+ I32 oldscope = PL_scopestack_ix;
I32 retval;
SV *sv;
AV *av = newAV();
PUTBACK;
perl_call_sv(sv, G_ARRAY|G_EVAL);
SPAGAIN;
- retval = SP - (stack_base + oldmark);
- SP = stack_base + oldmark + 1;
+ retval = SP - (PL_stack_base + oldmark);
+ SP = PL_stack_base + oldmark + 1;
if (SvCUR(thr->errsv)) {
MUTEX_LOCK(&thr->mutex);
thr->flags |= THRf_DID_DIE;
SvREFCNT_dec(thr->errsv);
SvREFCNT_dec(thr->errhv);
- Safefree(markstack);
- Safefree(scopestack);
- Safefree(savestack);
- Safefree(retstack);
+ Safefree(PL_markstack);
+ Safefree(PL_scopestack);
+ Safefree(PL_savestack);
+ Safefree(PL_retstack);
Safefree(cxstack);
- Safefree(tmps_stack);
- Safefree(ofs);
+ Safefree(PL_tmps_stack);
+ Safefree(PL_ofs);
- SvREFCNT_dec(rs);
- SvREFCNT_dec(nrs);
- SvREFCNT_dec(statname);
- Safefree(screamfirst);
- Safefree(screamnext);
- Safefree(reg_start_tmp);
- SvREFCNT_dec(lastscream);
+ SvREFCNT_dec(PL_rs);
+ SvREFCNT_dec(PL_nrs);
+ SvREFCNT_dec(PL_statname);
+ Safefree(PL_screamfirst);
+ Safefree(PL_screamnext);
+ Safefree(PL_reg_start_tmp);
+ SvREFCNT_dec(PL_lastscream);
MUTEX_LOCK(&thr->mutex);
DEBUG_L(PerlIO_printf(PerlIO_stderr(),
* Iterate until we have enough dynamic storage for all threads.
* We mustn't do any allocation while holding threads_mutex though.
*/
- MUTEX_LOCK(&threads_mutex);
+ MUTEX_LOCK(&PL_threads_mutex);
do {
- n = nthreads;
- MUTEX_UNLOCK(&threads_mutex);
+ n = PL_nthreads;
+ MUTEX_UNLOCK(&PL_threads_mutex);
if (AvFILL(av) < n - 1) {
int i = AvFILL(av);
for (i = AvFILL(av); i < n - 1; i++) {
}
}
- MUTEX_LOCK(&threads_mutex);
- } while (n < nthreads);
- n = nthreads; /* Get the final correct value */
+ MUTEX_LOCK(&PL_threads_mutex);
+ } while (n < PL_nthreads);
+ n = PL_nthreads; /* Get the final correct value */
/*
* At this point, there's enough room to fill in av.
svp++;
} while (t != thr);
/* */
- MUTEX_UNLOCK(&threads_mutex);
+ MUTEX_UNLOCK(&PL_threads_mutex);
/* Truncate any unneeded slots in av */
av_fill(av, n - 1);
/* Finally, push all the new objects onto the stack and drop av */
void
init_thread_signals()
PPCODE:
- sighandlerp = handle_thread_signal;
+ PL_sighandlerp = handle_thread_signal;
if (pipe(sig_pipe) == -1)
XSRETURN_UNDEF;
PUSHs(&sv_yes);
PUSHSTACKi(PERLSI_OVERLOAD);
ENTER;
SAVEOP();
- op = (OP *) &myop;
+ PL_op = (OP *) &myop;
if (PERLDB_SUB && PL_curstash != PL_debstash)
- op->op_private |= OPpENTERSUB_DB;
+ PL_op->op_private |= OPpENTERSUB_DB;
PUTBACK;
pp_pushmark(ARGS);
PUSHs((SV*)cv);
PUTBACK;
- if (op = pp_entersub(ARGS))
+ if (PL_op = pp_entersub(ARGS))
CALLRUNOPS();
LEAVE;
SPAGAIN;
HV *st;
SV *sv, *tSv = PL_Sv;
CV *cv = Nullcv;
- OP *myop = op;
+ OP *myop = PL_op;
U32 flags = 0;
I32 o_save_i = PL_savestack_ix, type;
XPV *tXpv = PL_Xpv;
PL_scopestack_ix -= 1;
if (flags & 64)
SvREFCNT_dec(sv);
- op = myop; /* Apparently not needed... */
+ PL_op = myop; /* Apparently not needed... */
PL_Sv = tSv; /* Restore global temporaries. */
PL_Xpv = tXpv;
#ifdef PERL_GLOBAL_STRUCT
#define PERLVAR(var,type) /**/
-#define PERLVARI(var,type,init) Perl_Vars.var = init;
-#define PERLVARIC(var,type,init) Perl_Vars.var = init;
+#define PERLVARI(var,type,init) PL_Vars.var = init;
+#define PERLVARIC(var,type,init) PL_Vars.var = init;
#include "perlvars.h"
#undef PERLVAR
#undef PERLVARI
PL_curpad = AvARRAY(PL_comppad);
#ifdef USE_THREADS
DEBUG_X(PerlIO_printf(Perl_debug_log, "0x%lx Pad 0x%lx alloc %ld for %s\n",
- (unsigned long) thr, (unsigned long) curpad,
+ (unsigned long) thr, (unsigned long) PL_curpad,
(long) retval, op_name[optype]));
#else
DEBUG_X(PerlIO_printf(Perl_debug_log, "Pad 0x%lx alloc %ld for %s\n",
dTHR;
#ifdef USE_THREADS
DEBUG_X(PerlIO_printf(Perl_debug_log, "0x%lx Pad 0x%lx sv %d\n",
- (unsigned long) thr, (unsigned long) curpad, po));
+ (unsigned long) thr, (unsigned long) PL_curpad, po));
#else
if (!po)
croak("panic: pad_sv po");
croak("panic: pad_free po");
#ifdef USE_THREADS
DEBUG_X(PerlIO_printf(Perl_debug_log, "0x%lx Pad 0x%lx free %d\n",
- (unsigned long) thr, (unsigned long) curpad, po));
+ (unsigned long) thr, (unsigned long) PL_curpad, po));
#else
DEBUG_X(PerlIO_printf(Perl_debug_log, "Pad 0x%lx free %d\n",
(unsigned long) PL_curpad, po));
croak("panic: pad_swipe po");
#ifdef USE_THREADS
DEBUG_X(PerlIO_printf(Perl_debug_log, "0x%lx Pad 0x%lx swipe %d\n",
- (unsigned long) thr, (unsigned long) curpad, po));
+ (unsigned long) thr, (unsigned long) PL_curpad, po));
#else
DEBUG_X(PerlIO_printf(Perl_debug_log, "Pad 0x%lx swipe %d\n",
(unsigned long) PL_curpad, po));
PADOFFSET key;
SV **svp;
/* We currently only handle names of a single character */
- p = strchr(threadsv_names, *name);
+ p = strchr(PL_threadsv_names, *name);
if (!p)
return NOT_IN_PAD;
- key = p - threadsv_names;
+ key = p - PL_threadsv_names;
svp = av_fetch(thr->threadsv, key, FALSE);
if (!svp) {
SV *sv = NEWSV(0, 0);
case '&':
case '`':
case '\'':
- sawampersand = TRUE;
+ PL_sawampersand = TRUE;
SvREADONLY_on(sv);
/* FALL THROUGH */
#ifdef USE_THREADS
case OP_THREADSV:
- modcount++; /* XXX ??? */
+ PL_modcount++; /* XXX ??? */
break;
#endif /* USE_THREADS */
curop = LINKLIST(o);
o->op_next = 0;
- op = curop;
+ PL_op = curop;
CALLRUNOPS();
sv = *(PL_stack_sp--);
if (o->op_targ && sv == PAD_SV(o->op_targ)) /* grab pad temp? */
if (PL_error_count)
return o; /* Don't attempt to run with errors */
- op = curop = LINKLIST(o);
+ PL_op = curop = LINKLIST(o);
o->op_next = 0;
pp_pushmark(ARGS);
CALLRUNOPS();
- op = curop;
+ PL_op = curop;
pp_anonlist(ARGS);
PL_tmps_floor = oldtmps_floor;
#ifdef USE_THREADS
else if (repl->op_type == OP_THREADSV
&& strchr("&`'123456789+",
- threadsv_names[repl->op_targ]))
+ PL_threadsv_names[repl->op_targ]))
{
curop = 0;
}
op_free(o);
#ifdef USE_THREADS
- if (!CvUNIQUE(compcv)) {
+ if (!CvUNIQUE(PL_compcv)) {
argop = newOP(OP_PADAV, OPf_REF);
argop->op_targ = 0; /* curpad[0] is @_ */
}
break;
if (!PL_op_seqmax)
PL_op_seqmax++;
- op = o;
+ PL_op = o;
switch (o->op_type) {
case OP_NEXTSTATE:
case OP_DBSTATE:
OP* pop = o->op_next->op_next;
IV i;
if (pop->op_type == OP_CONST &&
- (op = pop->op_next) &&
+ (PL_op = pop->op_next) &&
pop->op_next->op_type == OP_AELEM &&
!(pop->op_next->op_private &
(OPpLVAL_INTRO|OPpLVAL_DEFER|OPpDEREF)) &&
((op)->op_flags & OPf_WANT) == OPf_WANT_LIST ? G_ARRAY : \
dfl)
-#define GIMME_V OP_GIMME(op, block_gimme())
+#define GIMME_V OP_GIMME(PL_op, block_gimme())
/* Public flags */
#define OPf_LIST 1
#define OPf_KNOW 2
#define GIMME \
- (op->op_flags & OPf_KNOW ? op->op_flags & OPf_LIST : dowantarray())
+ (PL_op->op_flags & OPf_KNOW ? PL_op->op_flags & OPf_LIST : dowantarray())
/* Private for lvalues */
#define OPpLVAL_INTRO 128 /* Lvalue must be localized */
OP * op_lastop;
};
-#define cUNOP ((UNOP*)op)
-#define cBINOP ((BINOP*)op)
-#define cLISTOP ((LISTOP*)op)
-#define cLOGOP ((LOGOP*)op)
-#define cCONDOP ((CONDOP*)op)
-#define cPMOP ((PMOP*)op)
-#define cSVOP ((SVOP*)op)
-#define cGVOP ((GVOP*)op)
-#define cPVOP ((PVOP*)op)
-#define cCOP ((COP*)op)
-#define cLOOP ((LOOP*)op)
+#define cUNOP ((UNOP*)PL_op)
+#define cBINOP ((BINOP*)PL_op)
+#define cLISTOP ((LISTOP*)PL_op)
+#define cLOGOP ((LOGOP*)PL_op)
+#define cCONDOP ((CONDOP*)PL_op)
+#define cPMOP ((PMOP*)PL_op)
+#define cSVOP ((SVOP*)PL_op)
+#define cGVOP ((GVOP*)PL_op)
+#define cPVOP ((PVOP*)PL_op)
+#define cCOP ((COP*)PL_op)
+#define cLOOP ((LOOP*)PL_op)
#define cUNOPo ((UNOP*)o)
#define cBINOPo ((BINOP*)o)
#ifdef ALLOC_THREAD_KEY
ALLOC_THREAD_KEY;
#else
- if (pthread_key_create(&thr_key, 0))
+ if (pthread_key_create(&PL_thr_key, 0))
croak("panic: pthread_key_create");
#endif
- MUTEX_INIT(&sv_mutex);
+ MUTEX_INIT(&PL_sv_mutex);
/*
* Safe to use basic SV functions from now on (though
* not things like mortals or tainting yet).
*/
- MUTEX_INIT(&eval_mutex);
- COND_INIT(&eval_cond);
- MUTEX_INIT(&threads_mutex);
- COND_INIT(&nthreads_cond);
+ MUTEX_INIT(&PL_eval_mutex);
+ COND_INIT(&PL_eval_cond);
+ MUTEX_INIT(&PL_threads_mutex);
+ COND_INIT(&PL_nthreads_cond);
#ifdef EMULATE_ATOMIC_REFCOUNTS
- MUTEX_INIT(&svref_mutex);
+ MUTEX_INIT(&PL_svref_mutex);
#endif /* EMULATE_ATOMIC_REFCOUNTS */
thr = init_main_thread();
#ifndef FAKE_THREADS
/* Pass 1 on any remaining threads: detach joinables, join zombies */
retry_cleanup:
- MUTEX_LOCK(&threads_mutex);
+ MUTEX_LOCK(&PL_threads_mutex);
DEBUG_L(PerlIO_printf(PerlIO_stderr(),
"perl_destruct: waiting for %d threads...\n",
- nthreads - 1));
+ PL_nthreads - 1));
for (t = thr->next; t != thr; t = t->next) {
MUTEX_LOCK(&t->mutex);
switch (ThrSTATE(t)) {
"perl_destruct: joining zombie %p\n", t));
ThrSETSTATE(t, THRf_DEAD);
MUTEX_UNLOCK(&t->mutex);
- nthreads--;
+ PL_nthreads--;
/*
* The SvREFCNT_dec below may take a long time (e.g. av
* may contain an object scalar whose destructor gets
* called) so we have to unlock threads_mutex and start
* all over again.
*/
- MUTEX_UNLOCK(&threads_mutex);
+ MUTEX_UNLOCK(&PL_threads_mutex);
JOIN(t, &av);
SvREFCNT_dec((SV*)av);
DEBUG_L(PerlIO_printf(PerlIO_stderr(),
* deadlock if it panics. It's only a breach of good style
* not a bug since they are unlocks not locks.
*/
- MUTEX_UNLOCK(&threads_mutex);
+ MUTEX_UNLOCK(&PL_threads_mutex);
DETACH(t);
MUTEX_UNLOCK(&t->mutex);
goto retry_cleanup;
/* We leave the above "Pass 1" loop with threads_mutex still locked */
/* Pass 2 on remaining threads: wait for the thread count to drop to one */
- while (nthreads > 1)
+ while (PL_nthreads > 1)
{
DEBUG_L(PerlIO_printf(PerlIO_stderr(),
"perl_destruct: final wait for %d threads\n",
- nthreads - 1));
- COND_WAIT(&nthreads_cond, &threads_mutex);
+ PL_nthreads - 1));
+ COND_WAIT(&PL_nthreads_cond, &PL_threads_mutex);
}
/* At this point, we're the last thread */
- MUTEX_UNLOCK(&threads_mutex);
+ MUTEX_UNLOCK(&PL_threads_mutex);
DEBUG_L(PerlIO_printf(PerlIO_stderr(), "perl_destruct: armageddon has arrived\n"));
- MUTEX_DESTROY(&threads_mutex);
- COND_DESTROY(&nthreads_cond);
+ MUTEX_DESTROY(&PL_threads_mutex);
+ COND_DESTROY(&PL_nthreads_cond);
#endif /* !defined(FAKE_THREADS) */
#endif /* USE_THREADS */
DEBUG_P(debprofdump());
#ifdef USE_THREADS
- MUTEX_DESTROY(&sv_mutex);
- MUTEX_DESTROY(&eval_mutex);
- COND_DESTROY(&eval_cond);
+ MUTEX_DESTROY(&PL_sv_mutex);
+ MUTEX_DESTROY(&PL_eval_mutex);
+ COND_DESTROY(&PL_eval_cond);
/* As the penultimate thing, free the non-arena SV for thrsv */
- Safefree(SvPVX(thrsv));
- Safefree(SvANY(thrsv));
- Safefree(thrsv);
- thrsv = Nullsv;
+ Safefree(SvPVX(PL_thrsv));
+ Safefree(SvANY(PL_thrsv));
+ Safefree(PL_thrsv);
+ PL_thrsv = Nullsv;
#endif /* USE_THREADS */
/* As the absolutely last thing, free the non-arena SV for mess() */
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? */
- CvOWNER(compcv) = 0;
- New(666, CvMUTEXP(compcv), 1, perl_mutex);
- MUTEX_INIT(CvMUTEXP(compcv));
+ av_store(PL_comppad_name, 0, newSVpv("@_", 2));
+ PL_curpad[0] = (SV*)newAV();
+ SvPADMY_on(PL_curpad[0]); /* XXX Needed? */
+ CvOWNER(PL_compcv) = 0;
+ New(666, CvMUTEXP(PL_compcv), 1, perl_mutex);
+ MUTEX_INIT(CvMUTEXP(PL_compcv));
#endif /* USE_THREADS */
comppadlist = newAV();
/* do it */
if (PL_restartop) {
- op = PL_restartop;
+ PL_op = PL_restartop;
PL_restartop = 0;
CALLRUNOPS();
}
else if (PL_main_start) {
CvDEPTH(PL_main_cv) = 1;
- op = PL_main_start;
+ PL_op = PL_main_start;
CALLRUNOPS();
}
{
dSP;
OP myop;
- if (!op)
- op = &myop;
+ if (!PL_op)
+ PL_op = &myop;
XPUSHs(sv_2mortal(newSVpv(methname,0)));
PUTBACK;
pp_method(ARGS);
- if(op == &myop)
- op = Nullop;
+ if(PL_op == &myop)
+ PL_op = Nullop;
return perl_call_sv(*PL_stack_sp--, flags);
}
bool oldcatch = CATCH_GET;
dJMPENV;
int ret;
- OP* oldop = op;
+ OP* oldop = PL_op;
if (flags & G_DISCARD) {
ENTER;
(flags & G_ARRAY) ? OPf_WANT_LIST :
OPf_WANT_SCALAR);
SAVEOP();
- op = (OP*)&myop;
+ PL_op = (OP*)&myop;
EXTEND(PL_stack_sp, 1);
*++PL_stack_sp = sv;
* curstash may be meaningless. */
&& (SvTYPE(sv) != SVt_PVCV || CvSTASH((CV*)sv) != PL_debstash)
&& !(flags & G_NODEBUG))
- op->op_private |= OPpENTERSUB_DB;
+ PL_op->op_private |= OPpENTERSUB_DB;
if (flags & G_EVAL) {
- cLOGOP->op_other = op;
+ cLOGOP->op_other = PL_op;
PL_markstack_ptr--;
/* we're trying to emulate pp_entertry() here */
{
ENTER;
SAVETMPS;
- push_return(op->op_next);
+ push_return(PL_op->op_next);
PUSHBLOCK(cx, CXt_EVAL, PL_stack_sp);
PUSHEVAL(cx, 0, 0);
- PL_eval_root = op; /* Only needed so that goto works right. */
+ PL_eval_root = PL_op; /* Only needed so that goto works right. */
PL_in_eval = 1;
if (flags & G_KEEPERR)
/* NOTREACHED */
case 3:
if (PL_restartop) {
- op = PL_restartop;
+ PL_op = PL_restartop;
PL_restartop = 0;
break;
}
else
CATCH_SET(TRUE);
- if (op == (OP*)&myop)
- op = pp_entersub(ARGS);
- if (op)
+ if (PL_op == (OP*)&myop)
+ PL_op = pp_entersub(ARGS);
+ if (PL_op)
CALLRUNOPS();
retval = PL_stack_sp - (PL_stack_base + oldmark);
if ((flags & G_EVAL) && !(flags & G_KEEPERR))
FREETMPS;
LEAVE;
}
- op = oldop;
+ PL_op = oldop;
return retval;
}
I32 oldscope;
dJMPENV;
int ret;
- OP* oldop = op;
+ OP* oldop = PL_op;
if (flags & G_DISCARD) {
ENTER;
}
SAVEOP();
- op = (OP*)&myop;
- Zero(op, 1, UNOP);
+ PL_op = (OP*)&myop;
+ Zero(PL_op, 1, UNOP);
EXTEND(PL_stack_sp, 1);
*++PL_stack_sp = sv;
oldscope = PL_scopestack_ix;
/* NOTREACHED */
case 3:
if (PL_restartop) {
- op = PL_restartop;
+ PL_op = PL_restartop;
PL_restartop = 0;
break;
}
goto cleanup;
}
- if (op == (OP*)&myop)
- op = pp_entereval(ARGS);
- if (op)
+ if (PL_op == (OP*)&myop)
+ PL_op = pp_entereval(ARGS);
+ if (PL_op)
CALLRUNOPS();
retval = PL_stack_sp - (PL_stack_base + oldmark);
if (!(flags & G_KEEPERR))
FREETMPS;
LEAVE;
}
- op = oldop;
+ PL_op = oldop;
return retval;
}
# undef PERLVARIC
# else
# define PERLVAR(var,type)
-# define PERLVARI(var,type,init) var = init;
-# define PERLVARIC(var,type,init) var = init;
+# define PERLVARI(var,type,init) PL_##var = init;
+# define PERLVARIC(var,type,init) PL_##var = init;
# include "intrpvar.h"
# ifndef USE_THREADS
# include "thrdvar.h"
XPV *xpv;
Newz(53, thr, 1, struct perl_thread);
- curcop = &compiling;
+ PL_curcop = &PL_compiling;
thr->cvcache = newHV();
thr->threadsv = newAV();
/* thr->threadsvp is set when find_threadsv is called */
thr->flags = THRf_R_JOINABLE;
MUTEX_INIT(&thr->mutex);
/* Handcraft thrsv similarly to mess_sv */
- New(53, thrsv, 1, SV);
+ New(53, PL_thrsv, 1, SV);
Newz(53, xpv, 1, XPV);
- SvFLAGS(thrsv) = SVt_PV;
- SvANY(thrsv) = (void*)xpv;
- SvREFCNT(thrsv) = 1 << 30; /* practically infinite */
- SvPVX(thrsv) = (char*)thr;
- SvCUR_set(thrsv, sizeof(thr));
- SvLEN_set(thrsv, sizeof(thr));
- *SvEND(thrsv) = '\0'; /* in the trailing_nul field */
- thr->oursv = thrsv;
- chopset = " \n-";
-
- MUTEX_LOCK(&threads_mutex);
- nthreads++;
+ SvFLAGS(PL_thrsv) = SVt_PV;
+ SvANY(PL_thrsv) = (void*)xpv;
+ SvREFCNT(PL_thrsv) = 1 << 30; /* practically infinite */
+ SvPVX(PL_thrsv) = (char*)thr;
+ SvCUR_set(PL_thrsv, sizeof(thr));
+ SvLEN_set(PL_thrsv, sizeof(thr));
+ *SvEND(PL_thrsv) = '\0'; /* in the trailing_nul field */
+ thr->oursv = PL_thrsv;
+ PL_chopset = " \n-";
+
+ MUTEX_LOCK(&PL_threads_mutex);
+ PL_nthreads++;
thr->tid = 0;
thr->next = thr;
thr->prev = thr;
- MUTEX_UNLOCK(&threads_mutex);
+ MUTEX_UNLOCK(&PL_threads_mutex);
#ifdef HAVE_THREAD_INTERN
init_thread_intern(thr);
* These must come after the SET_THR because sv_setpvn does
* SvTAINT and the taint fields require dTHR.
*/
- toptarget = NEWSV(0,0);
- sv_upgrade(toptarget, SVt_PVFM);
- sv_setpvn(toptarget, "", 0);
- bodytarget = NEWSV(0,0);
- sv_upgrade(bodytarget, SVt_PVFM);
- sv_setpvn(bodytarget, "", 0);
- formtarget = bodytarget;
+ PL_toptarget = NEWSV(0,0);
+ sv_upgrade(PL_toptarget, SVt_PVFM);
+ sv_setpvn(PL_toptarget, "", 0);
+ PL_bodytarget = NEWSV(0,0);
+ sv_upgrade(PL_bodytarget, SVt_PVFM);
+ sv_setpvn(PL_bodytarget, "", 0);
+ PL_formtarget = PL_bodytarget;
thr->errsv = newSVpv("", 0);
(void) find_threadsv("@"); /* Ensure $@ is initialised early */
- maxscream = -1;
- regcompp = FUNC_NAME_TO_PTR(pregcomp);
- regexecp = FUNC_NAME_TO_PTR(regexec_flags);
- regindent = 0;
- reginterp_cnt = 0;
+ PL_maxscream = -1;
+ PL_regcompp = FUNC_NAME_TO_PTR(pregcomp);
+ PL_regexecp = FUNC_NAME_TO_PTR(regexec_flags);
+ PL_regindent = 0;
+ PL_reginterp_cnt = 0;
return thr;
}
};
#ifdef PERL_CORE
-EXT struct perl_vars Perl_Vars;
-EXT struct perl_vars *Perl_VarsPtr INIT(&Perl_Vars);
-#else
+EXT struct perl_vars PL_Vars;
+EXT struct perl_vars *PL_VarsPtr INIT(&PL_Vars);
+#else /* PERL_CORE */
#if !defined(__GNUC__) || !defined(WIN32)
EXT
-#endif
-struct perl_vars *Perl_VarsPtr;
-#define Perl_Vars (*((Perl_VarsPtr) ? Perl_VarsPtr : (Perl_VarsPtr = Perl_GetVars())))
-#endif
+#endif /* WIN32 */
+struct perl_vars *PL_VarsPtr;
+#define PL_Vars (*((PL_VarsPtr) ? PL_VarsPtr : (PL_VarsPtr = Perl_GetVars())))
+#endif /* PERL_CORE */
#endif /* PERL_GLOBAL_STRUCT */
#ifdef MULTIPLICITY
* If we don't have threads or multiple interpreters
* these include variables that would have been their struct-s
*/
-
-#define PERLVAR(var,type) EXT type var;
-#define PERLVARI(var,type,init) EXT type var INIT(init);
-#define PERLVARIC(var,type,init) EXTCONST type var INIT(init);
+
+#define PERLVAR(var,type) EXT type PL_##var;
+#define PERLVARI(var,type,init) EXT type PL_##var INIT(init);
+#define PERLVARIC(var,type,init) EXTCONST type PL_##var INIT(init);
#ifndef PERL_GLOBAL_STRUCT
#include "perlvars.h"
PP(pp_padav)
{
djSP; dTARGET;
- if (op->op_private & OPpLVAL_INTRO)
- SAVECLEARSV(PL_curpad[op->op_targ]);
+ if (PL_op->op_private & OPpLVAL_INTRO)
+ SAVECLEARSV(PL_curpad[PL_op->op_targ]);
EXTEND(SP, 1);
- if (op->op_flags & OPf_REF) {
+ if (PL_op->op_flags & OPf_REF) {
PUSHs(TARG);
RETURN;
}
I32 gimme;
XPUSHs(TARG);
- if (op->op_private & OPpLVAL_INTRO)
- SAVECLEARSV(PL_curpad[op->op_targ]);
- if (op->op_flags & OPf_REF)
+ if (PL_op->op_private & OPpLVAL_INTRO)
+ SAVECLEARSV(PL_curpad[PL_op->op_targ]);
+ if (PL_op->op_flags & OPf_REF)
RETURN;
gimme = GIMME_V;
if (gimme == G_ARRAY) {
goto wasref;
}
if (!SvOK(sv)) {
- if (op->op_flags & OPf_REF ||
- op->op_private & HINT_STRICT_REFS)
+ if (PL_op->op_flags & OPf_REF ||
+ PL_op->op_private & HINT_STRICT_REFS)
DIE(no_usym, "a symbol");
if (PL_dowarn)
warn(warn_uninit);
RETSETUNDEF;
}
sym = SvPV(sv, PL_na);
- if (op->op_private & HINT_STRICT_REFS)
+ if (PL_op->op_private & HINT_STRICT_REFS)
DIE(no_symref, sym, "a symbol");
sv = (SV*)gv_fetchpv(sym, TRUE, SVt_PVGV);
}
}
- if (op->op_private & OPpLVAL_INTRO)
- save_gp((GV*)sv, !(op->op_flags & OPf_SPECIAL));
+ if (PL_op->op_private & OPpLVAL_INTRO)
+ save_gp((GV*)sv, !(PL_op->op_flags & OPf_SPECIAL));
SETs(sv);
RETURN;
}
goto wasref;
}
if (!SvOK(sv)) {
- if (op->op_flags & OPf_REF ||
- op->op_private & HINT_STRICT_REFS)
+ if (PL_op->op_flags & OPf_REF ||
+ PL_op->op_private & HINT_STRICT_REFS)
DIE(no_usym, "a SCALAR");
if (PL_dowarn)
warn(warn_uninit);
RETSETUNDEF;
}
sym = SvPV(sv, PL_na);
- if (op->op_private & HINT_STRICT_REFS)
+ if (PL_op->op_private & HINT_STRICT_REFS)
DIE(no_symref, sym, "a SCALAR");
gv = (GV*)gv_fetchpv(sym, TRUE, SVt_PV);
}
sv = GvSV(gv);
}
- if (op->op_flags & OPf_MOD) {
- if (op->op_private & OPpLVAL_INTRO)
+ if (PL_op->op_flags & OPf_MOD) {
+ if (PL_op->op_private & OPpLVAL_INTRO)
sv = save_scalar((GV*)TOPs);
- else if (op->op_private & OPpDEREF)
- vivify_ref(sv, op->op_private & OPpDEREF);
+ else if (PL_op->op_private & OPpDEREF)
+ vivify_ref(sv, PL_op->op_private & OPpDEREF);
}
SETs(sv);
RETURN;
{
djSP; dTARGET; dPOPss;
- if (op->op_flags & OPf_MOD) {
+ if (PL_op->op_flags & OPf_MOD) {
if (SvTYPE(TARG) < SVt_PVLV) {
sv_upgrade(TARG, SVt_PVLV);
sv_magic(TARG, Nullsv, '.', Nullch, 0);
/* We usually try to add a non-existent subroutine in case of AUTOLOAD. */
/* (But not in defined().) */
- CV *cv = sv_2cv(TOPs, &stash, &gv, !(op->op_flags & OPf_SPECIAL));
+ CV *cv = sv_2cv(TOPs, &stash, &gv, !(PL_op->op_flags & OPf_SPECIAL));
if (cv) {
if (CvCLONE(cv))
cv = (CV*)sv_2mortal((SV*)cv_clone(cv));
PP(pp_anoncode)
{
djSP;
- CV* cv = (CV*)PL_curpad[op->op_targ];
+ CV* cv = (CV*)PL_curpad[PL_op->op_targ];
if (CvCLONE(cv))
cv = (CV*)sv_2mortal((SV*)cv_clone(cv));
EXTEND(SP,1);
djSP; dTARG;
SV *sv;
- if (op->op_flags & OPf_STACKED)
+ if (PL_op->op_flags & OPf_STACKED)
sv = POPs;
else {
sv = DEFSV;
EXTEND(SP,1);
}
TARG = sv_newmortal();
- PUSHi(do_trans(sv, op));
+ PUSHi(do_trans(sv, PL_op));
RETURN;
}
djSP;
SV *sv;
- if (!op->op_private) {
+ if (!PL_op->op_private) {
EXTEND(SP, 1);
RETPUSHUNDEF;
}
djSP; dATARGET; tryAMAGICbin(repeat,opASSIGN);
{
register I32 count = POPi;
- if (GIMME == G_ARRAY && op->op_private & OPpREPEAT_DOLIST) {
+ if (GIMME == G_ARRAY && PL_op->op_private & OPpREPEAT_DOLIST) {
dMARK;
I32 items = SP - MARK;
I32 max;
djSP; dATARGET; tryAMAGICbin(lshift,opASSIGN);
{
IBW shift = POPi;
- if (op->op_private & HINT_INTEGER) {
+ if (PL_op->op_private & HINT_INTEGER) {
IBW i = TOPi;
i = BWi(i) << shift;
SETi(BWi(i));
djSP; dATARGET; tryAMAGICbin(rshift,opASSIGN);
{
IBW shift = POPi;
- if (op->op_private & HINT_INTEGER) {
+ if (PL_op->op_private & HINT_INTEGER) {
IBW i = TOPi;
i = BWi(i) >> shift;
SETi(BWi(i));
djSP; tryAMAGICbinSET(slt,0);
{
dPOPTOPssrl;
- int cmp = ((op->op_private & OPpLOCALE)
+ int cmp = ((PL_op->op_private & OPpLOCALE)
? sv_cmp_locale(left, right)
: sv_cmp(left, right));
SETs(boolSV(cmp < 0));
djSP; tryAMAGICbinSET(sgt,0);
{
dPOPTOPssrl;
- int cmp = ((op->op_private & OPpLOCALE)
+ int cmp = ((PL_op->op_private & OPpLOCALE)
? sv_cmp_locale(left, right)
: sv_cmp(left, right));
SETs(boolSV(cmp > 0));
djSP; tryAMAGICbinSET(sle,0);
{
dPOPTOPssrl;
- int cmp = ((op->op_private & OPpLOCALE)
+ int cmp = ((PL_op->op_private & OPpLOCALE)
? sv_cmp_locale(left, right)
: sv_cmp(left, right));
SETs(boolSV(cmp <= 0));
djSP; tryAMAGICbinSET(sge,0);
{
dPOPTOPssrl;
- int cmp = ((op->op_private & OPpLOCALE)
+ int cmp = ((PL_op->op_private & OPpLOCALE)
? sv_cmp_locale(left, right)
: sv_cmp(left, right));
SETs(boolSV(cmp >= 0));
djSP; dTARGET; tryAMAGICbin(scmp,0);
{
dPOPTOPssrl;
- int cmp = ((op->op_private & OPpLOCALE)
+ int cmp = ((PL_op->op_private & OPpLOCALE)
? sv_cmp_locale(left, right)
: sv_cmp(left, right));
SETi( cmp );
{
dPOPTOPssrl;
if (SvNIOKp(left) || SvNIOKp(right)) {
- if (op->op_private & HINT_INTEGER) {
+ if (PL_op->op_private & HINT_INTEGER) {
IBW value = SvIV(left) & SvIV(right);
SETi(BWi(value));
}
}
}
else {
- do_vop(op->op_type, TARG, left, right);
+ do_vop(PL_op->op_type, TARG, left, right);
SETTARG;
}
RETURN;
{
dPOPTOPssrl;
if (SvNIOKp(left) || SvNIOKp(right)) {
- if (op->op_private & HINT_INTEGER) {
+ if (PL_op->op_private & HINT_INTEGER) {
IBW value = (USE_LEFT(left) ? SvIV(left) : 0) ^ SvIV(right);
SETi(BWi(value));
}
}
}
else {
- do_vop(op->op_type, TARG, left, right);
+ do_vop(PL_op->op_type, TARG, left, right);
SETTARG;
}
RETURN;
{
dPOPTOPssrl;
if (SvNIOKp(left) || SvNIOKp(right)) {
- if (op->op_private & HINT_INTEGER) {
+ if (PL_op->op_private & HINT_INTEGER) {
IBW value = (USE_LEFT(left) ? SvIV(left) : 0) | SvIV(right);
SETi(BWi(value));
}
}
}
else {
- do_vop(op->op_type, TARG, left, right);
+ do_vop(PL_op->op_type, TARG, left, right);
SETTARG;
}
RETURN;
{
dTOPss;
if (SvNIOKp(sv)) {
- if (op->op_private & HINT_INTEGER) {
+ if (PL_op->op_private & HINT_INTEGER) {
IBW value = ~SvIV(sv);
SETi(BWi(value));
}
I32 pos;
I32 rem;
I32 fail;
- I32 lvalue = op->op_flags & OPf_MOD;
+ I32 lvalue = PL_op->op_flags & OPf_MOD;
char *tmps;
I32 arybase = PL_curcop->cop_arybase;
char *repl = 0;
register I32 size = POPi;
register I32 offset = POPi;
register SV *src = POPs;
- I32 lvalue = op->op_flags & OPf_MOD;
+ I32 lvalue = PL_op->op_flags & OPf_MOD;
STRLEN srclen;
unsigned char *s = (unsigned char*)SvPV(src, srclen);
unsigned long retnum;
{
djSP; dMARK; dORIGMARK; dTARGET;
#ifdef USE_LOCALE_NUMERIC
- if (op->op_private & OPpLOCALE)
+ if (PL_op->op_private & OPpLOCALE)
SET_NUMERIC_LOCAL();
else
SET_NUMERIC_STANDARD();
}
s = SvPV_force(sv, PL_na);
if (*s) {
- if (op->op_private & OPpLOCALE) {
+ if (PL_op->op_private & OPpLOCALE) {
TAINT;
SvTAINTED_on(sv);
*s = toUPPER_LC(*s);
}
s = SvPV_force(sv, PL_na);
if (*s) {
- if (op->op_private & OPpLOCALE) {
+ if (PL_op->op_private & OPpLOCALE) {
TAINT;
SvTAINTED_on(sv);
*s = toLOWER_LC(*s);
if (len) {
register char *send = s + len;
- if (op->op_private & OPpLOCALE) {
+ if (PL_op->op_private & OPpLOCALE) {
TAINT;
SvTAINTED_on(sv);
for (; s < send; s++)
if (len) {
register char *send = s + len;
- if (op->op_private & OPpLOCALE) {
+ if (PL_op->op_private & OPpLOCALE) {
TAINT;
SvTAINTED_on(sv);
for (; s < send; s++)
djSP; dMARK; dORIGMARK;
register SV** svp;
register AV* av = (AV*)POPs;
- register I32 lval = op->op_flags & OPf_MOD;
+ register I32 lval = PL_op->op_flags & OPf_MOD;
I32 arybase = PL_curcop->cop_arybase;
I32 elem;
if (SvTYPE(av) == SVt_PVAV) {
- if (lval && op->op_private & OPpLVAL_INTRO) {
+ if (lval && PL_op->op_private & OPpLVAL_INTRO) {
I32 max = -1;
for (svp = MARK + 1; svp <= SP; svp++) {
elem = SvIVx(*svp);
if (lval) {
if (!svp || *svp == &PL_sv_undef)
DIE(no_aelem, elem);
- if (op->op_private & OPpLVAL_INTRO)
+ if (PL_op->op_private & OPpLVAL_INTRO)
save_aelem(av, elem, svp);
}
*MARK = svp ? *svp : &PL_sv_undef;
SV *sv;
HV *hv;
- if (op->op_private & OPpSLICE) {
+ if (PL_op->op_private & OPpSLICE) {
dMARK; dORIGMARK;
U32 hvtype;
hv = (HV*)POPs;
{
djSP; dMARK; dORIGMARK;
register HV *hv = (HV*)POPs;
- register I32 lval = op->op_flags & OPf_MOD;
+ register I32 lval = PL_op->op_flags & OPf_MOD;
I32 realhv = (SvTYPE(hv) == SVt_PVHV);
if (realhv || SvTYPE(hv) == SVt_PVAV) {
if (lval) {
if (!svp || *svp == &PL_sv_undef)
DIE(no_helem, SvPV(keysv, PL_na));
- if (op->op_private & OPpLVAL_INTRO)
+ if (PL_op->op_private & OPpLVAL_INTRO)
save_helem(hv, keysv, svp);
}
*MARK = svp ? *svp : &PL_sv_undef;
SV **firstlelem = PL_stack_base + POPMARK + 1;
register SV **firstrelem = lastlelem + 1;
I32 arybase = PL_curcop->cop_arybase;
- I32 lval = op->op_flags & OPf_MOD;
+ I32 lval = PL_op->op_flags & OPf_MOD;
I32 is_something_there = lval;
register I32 max = lastrelem - lastlelem;
ary = GvAVn((GV*)pm->op_pmreplroot);
else if (gimme != G_ARRAY)
#ifdef USE_THREADS
- ary = (AV*)curpad[0];
+ ary = (AV*)PL_curpad[0];
#else
ary = GvAVn(PL_defgv);
#endif /* USE_THREADS */
djSP;
#ifdef USE_THREADS
EXTEND(SP, 1);
- if (op->op_private & OPpLVAL_INTRO)
- PUSHs(*save_threadsv(op->op_targ));
+ if (PL_op->op_private & OPpLVAL_INTRO)
+ PUSHs(*save_threadsv(PL_op->op_targ));
else
- PUSHs(THREADSV(op->op_targ));
+ PUSHs(THREADSV(PL_op->op_targ));
RETURN;
#else
DIE("tried to access per-thread data in non-threaded perl");
#define SPAGAIN sp = PL_stack_sp
#define MSPAGAIN sp = PL_stack_sp; mark = ORIGMARK
-#define GETTARGETSTACKED targ = (op->op_flags & OPf_STACKED ? POPs : PAD_SV(op->op_targ))
+#define GETTARGETSTACKED targ = (PL_op->op_flags & OPf_STACKED ? POPs : PAD_SV(PL_op->op_targ))
#define dTARGETSTACKED SV * GETTARGETSTACKED
-#define GETTARGET targ = PAD_SV(op->op_targ)
+#define GETTARGET targ = PAD_SV(PL_op->op_targ)
#define dTARGET SV * GETTARGET
-#define GETATARGET targ = (op->op_flags & OPf_STACKED ? sp[-1] : PAD_SV(op->op_targ))
+#define GETATARGET targ = (PL_op->op_flags & OPf_STACKED ? sp[-1] : PAD_SV(PL_op->op_targ))
#define dATARGET SV * GETATARGET
#define dTARG SV *targ
-#define NORMAL op->op_next
+#define NORMAL PL_op->op_next
#define DIE return die
#define PUTBACK PL_stack_sp = sp
#define dPOPXiirl(X) IV right = POPi; IV left = CAT2(X,i)
#define USE_LEFT(sv) \
- (SvOK(sv) || SvGMAGICAL(sv) || !(op->op_flags & OPf_STACKED))
+ (SvOK(sv) || SvGMAGICAL(sv) || !(PL_op->op_flags & OPf_STACKED))
#define dPOPXnnrl_ul(X) \
double right = POPn; \
SV *leftsv = CAT2(X,s); \
#define RETSETNO RETURNX(SETs(&PL_sv_no))
#define RETSETUNDEF RETURNX(SETs(&PL_sv_undef))
-#define ARGTARG op->op_targ
-#define MAXARG op->op_private
+#define ARGTARG PL_op->op_targ
+#define MAXARG PL_op->op_private
#define SWITCHSTACK(f,t) \
STMT_START { \
#define tryAMAGICun tryAMAGICunSET
#define tryAMAGICunSET(meth) tryAMAGICunW(meth,SETs)
-#define opASSIGN (op->op_flags & OPf_STACKED)
+#define opASSIGN (PL_op->op_flags & OPf_STACKED)
#define SETsv(sv) STMT_START { \
if (opASSIGN) { sv_setsv(TARG, (sv)); SETTARG; } \
else SETs(sv); } STMT_END
#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));
ReREFCNT_dec(pm->op_pmregexp);
pm->op_pmregexp = Null(REGEXP*); /* crucial if regcomp aborts */
}
- if (op->op_flags & OPf_SPECIAL)
+ if (PL_op->op_flags & OPf_SPECIAL)
PL_reginterp_cnt = I32_MAX; /* Mark as safe. */
pm->op_pmflags = pm->op_pmpermflags; /* reset case sensitivity */
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;
}
(void)POPMARK;
if (GIMME_V == G_SCALAR)
XPUSHs(&PL_sv_no);
- RETURNOP(op->op_next->op_next);
+ RETURNOP(PL_op->op_next->op_next);
}
PL_stack_sp = PL_stack_base + *PL_markstack_ptr + 1;
pp_pushmark(ARGS); /* push dst */
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)
GV *gv;
CV *cv;
I32 gimme = GIMME;
- OP* nextop = op->op_next;
+ OP* nextop = PL_op->op_next;
if (gimme != G_ARRAY) {
SP = MARK;
ENTER;
SAVEPPTR(PL_sortcop);
- if (op->op_flags & OPf_STACKED) {
- if (op->op_flags & OPf_SPECIAL) {
+ 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 */
SAVESPTR(GvSV(PL_secondgv));
PUSHBLOCK(cx, CXt_NULL, PL_stack_base);
- if (!(op->op_flags & OPf_SPECIAL)) {
+ if (!(PL_op->op_flags & OPf_SPECIAL)) {
bool hasargs = FALSE;
cx->cx_type = CXt_SUB;
cx->blk_gimme = G_SCALAR;
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));
}
{
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)
}
else {
dTOPss;
- SV *targ = PAD_SV(op->op_targ);
+ SV *targ = PAD_SV(PL_op->op_targ);
- if ((op->op_private & OPpFLIP_LINENUM)
+ 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;
dTOPss;
SV *targ = PAD_SV(cUNOP->op_first->op_targ);
sv_inc(targ);
- if ((op->op_private & OPpFLIP_LINENUM)
+ 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);
switch (cx->cx_type) {
case CXt_SUBST:
if (PL_dowarn)
- warn("Exiting substitution via %s", op_name[op->op_type]);
+ warn("Exiting substitution via %s", op_name[PL_op->op_type]);
break;
case CXt_SUB:
if (PL_dowarn)
- warn("Exiting subroutine via %s", op_name[op->op_type]);
+ warn("Exiting subroutine via %s", op_name[PL_op->op_type]);
break;
case CXt_EVAL:
if (PL_dowarn)
- warn("Exiting eval via %s", op_name[op->op_type]);
+ warn("Exiting eval via %s", op_name[PL_op->op_type]);
break;
case CXt_NULL:
if (PL_dowarn)
- warn("Exiting pseudo-block via %s", op_name[op->op_type]);
+ warn("Exiting pseudo-block via %s", op_name[PL_op->op_type]);
return -1;
case CXt_LOOP:
if (!cx->blk_loop.label ||
switch (cx->cx_type) {
case CXt_SUBST:
if (PL_dowarn)
- warn("Exiting substitution via %s", op_name[op->op_type]);
+ warn("Exiting substitution via %s", op_name[PL_op->op_type]);
break;
case CXt_SUB:
if (PL_dowarn)
- warn("Exiting subroutine via %s", op_name[op->op_type]);
+ warn("Exiting subroutine via %s", op_name[PL_op->op_type]);
break;
case CXt_EVAL:
if (PL_dowarn)
- warn("Exiting eval via %s", op_name[op->op_type]);
+ warn("Exiting eval via %s", op_name[PL_op->op_type]);
break;
case CXt_NULL:
if (PL_dowarn)
- warn("Exiting pseudo-block via %s", op_name[op->op_type]);
+ 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));
GvSV(PL_firstgv) = a;
GvSV(PL_secondgv) = b;
PL_stack_sp = PL_stack_base;
- op = PL_sortcop;
+ PL_op = PL_sortcop;
CALLRUNOPS();
if (PL_stack_sp != PL_stack_base + 1)
croak("Sort subroutine didn't return single value");
PP(pp_dbstate)
{
- PL_curcop = (COP*)op;
+ PL_curcop = (COP*)PL_op;
TAINT_NOT; /* Each statement is presumed innocent */
PL_stack_sp = PL_stack_base + cxstack[cxstack_ix].blk_oldsp;
FREETMPS;
- if (op->op_private || SvIV(PL_DBsingle) || SvIV(PL_DBsignal) || SvIV(PL_DBtrace))
+ if (PL_op->op_private || SvIV(PL_DBsingle) || SvIV(PL_DBsignal) || SvIV(PL_DBtrace))
{
djSP;
register CV *cv;
hasargs = 0;
SPAGAIN;
- push_return(op->op_next);
+ push_return(PL_op->op_next);
PUSHBLOCK(cx, CXt_SUB, SP);
PUSHSUB(cx);
CvDEPTH(cv)++;
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 = &PL_curpad[op->op_targ]; /* "my" variable */
+ if (PL_op->op_targ) {
+ svp = &PL_curpad[PL_op->op_targ]; /* "my" variable */
SAVESPTR(*svp);
}
else {
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;
PMOP *newpm;
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");
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");
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");
#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 */
AV* av;
int i;
#ifdef USE_THREADS
- av = (AV*)curpad[0];
+ av = (AV*)PL_curpad[0];
#else
av = GvAV(PL_defgv);
#endif
}
#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) {
else
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");
}
/* 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;
}
}
{
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, PL_top_env));
switch (ret) {
default: /* topmost level handles it */
JMPENV_POP;
- op = oldop;
+ PL_op = oldop;
JMPENV_JUMP(ret);
/* NOTREACHED */
case 3:
PerlIO_printf(PerlIO_stderr(), "panic: restartop\n");
break;
}
- op = PL_restartop;
+ PL_op = PL_restartop;
PL_restartop = 0;
/* FALL THROUGH */
case 0:
break;
}
JMPENV_POP;
- op = oldop;
+ PL_op = oldop;
return Nullop;
}
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;
#ifdef OP_IN_REGISTER
opsave = op;
#else
- SAVEPPTR(op);
+ SAVEPPTR(PL_op);
#endif
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);
doeval(int gimme, OP** startop)
{
dSP;
- OP *saveop = op;
+ OP *saveop = PL_op;
HV *newstash;
CV *caller;
AV* comppadlist;
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 */
PL_comppad = newAV();
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();
PERL_CONTEXT *cx;
I32 optype = 0; /* Might be reset by POPEVAL. */
- op = saveop;
+ PL_op = saveop;
if (PL_eval_root) {
op_free(PL_eval_root);
PL_eval_root = Nullop;
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;
}
CvDEPTH(PL_compcv) = 1;
SP = PL_stack_base + POPMARK; /* pop original mark */
- op = saveop; /* The caller may need it. */
+ 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(PL_eval_start);
if (!(name && len > 0 && *name))
DIE("Null filename used");
TAINT_PROPER("require");
- if (op->op_type == OP_REQUIRE &&
+ if (PL_op->op_type == OP_REQUIRE &&
(svp = hv_fetch(GvHVn(PL_incgv), name, len, 0)) &&
*svp != &PL_sv_undef)
RETPUSHYES;
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(PL_incgv);
/* 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);
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));
}
safestr = savepv(tmpbuf);
SAVEDELETE(PL_defstash, safestr, strlen(safestr));
SAVEHINTS();
- PL_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);
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 != PL_sub_generation /* Some subs defined here. */
- && ret != op->op_next) { /* Successive compilation. */
+ && ret != PL_op->op_next) { /* Successive compilation. */
strcpy(safestr, "_<(eval )"); /* Anything fake and short. */
}
return DOCATCH(ret);
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);
push_return(cLOGOP->op_other->op_next);
PUSHBLOCK(cx, CXt_EVAL, SP);
PUSHEVAL(cx, 0, 0);
- PL_eval_root = op; /* Only needed so that goto works right. */
+ PL_eval_root = PL_op; /* Only needed so that goto works right. */
PL_in_eval = 1;
sv_setpv(ERRSV,"");
PUTBACK;
- return DOCATCH(op->op_next);
+ return DOCATCH(PL_op->op_next);
}
PP(pp_leavetry)
PP(pp_nextstate)
{
- PL_curcop = (COP*)op;
+ PL_curcop = (COP*)PL_op;
TAINT_NOT; /* Each statement is presumed innocent */
PL_stack_sp = PL_stack_base + cxstack[cxstack_ix].blk_oldsp;
FREETMPS;
{
djSP;
EXTEND(SP,1);
- if (op->op_private & OPpLVAL_INTRO)
+ if (PL_op->op_private & OPpLVAL_INTRO)
PUSHs(save_scalar(cGVOP->op_gv));
else
PUSHs(GvSV(cGVOP->op_gv));
djSP; dPOPTOPssrl;
MAGIC *mg;
- if (op->op_private & OPpASSIGN_BACKWARDS) {
+ if (PL_op->op_private & OPpASSIGN_BACKWARDS) {
SV *temp;
temp = left; left = right; right = temp;
}
{
djSP; dTARGET;
XPUSHs(TARG);
- if (op->op_flags & OPf_MOD) {
- if (op->op_private & OPpLVAL_INTRO)
- SAVECLEARSV(PL_curpad[op->op_targ]);
- else if (op->op_private & OPpDEREF) {
+ if (PL_op->op_flags & OPf_MOD) {
+ if (PL_op->op_private & OPpLVAL_INTRO)
+ SAVECLEARSV(PL_curpad[PL_op->op_targ]);
+ else if (PL_op->op_private & OPpDEREF) {
PUTBACK;
- vivify_ref(PL_curpad[op->op_targ], op->op_private & OPpDEREF);
+ vivify_ref(PL_curpad[PL_op->op_targ], PL_op->op_private & OPpDEREF);
SPAGAIN;
}
}
{
djSP;
AV *av = GvAV((GV*)cSVOP->op_sv);
- U32 lval = op->op_flags & OPf_MOD;
- SV** svp = av_fetch(av, op->op_private, lval);
+ U32 lval = PL_op->op_flags & OPf_MOD;
+ SV** svp = av_fetch(av, PL_op->op_private, lval);
SV *sv = (svp ? *svp : &PL_sv_undef);
EXTEND(SP, 1);
if (!lval && SvGMAGICAL(sv)) /* see note in pp_helem() */
SV* sv = sv_newmortal();
sv_upgrade(sv, SVt_PVLV);
LvTYPE(sv) = '/';
- Copy(&op, &LvTARGOFF(sv), 1, OP*);
+ Copy(&PL_op, &LvTARGOFF(sv), 1, OP*);
XPUSHs(sv);
#else
XPUSHs((SV*)op);
register PerlIO *fp;
MAGIC *mg;
- if (op->op_flags & OPf_STACKED)
+ if (PL_op->op_flags & OPf_STACKED)
gv = (GV*)*++MARK;
else
gv = PL_defoutgv;
av = (AV*)SvRV(sv);
if (SvTYPE(av) != SVt_PVAV)
DIE("Not an ARRAY reference");
- if (op->op_flags & OPf_REF) {
+ if (PL_op->op_flags & OPf_REF) {
PUSHs((SV*)av);
RETURN;
}
else {
if (SvTYPE(sv) == SVt_PVAV) {
av = (AV*)sv;
- if (op->op_flags & OPf_REF) {
+ if (PL_op->op_flags & OPf_REF) {
PUSHs((SV*)av);
RETURN;
}
goto wasref;
}
if (!SvOK(sv)) {
- if (op->op_flags & OPf_REF ||
- op->op_private & HINT_STRICT_REFS)
+ if (PL_op->op_flags & OPf_REF ||
+ PL_op->op_private & HINT_STRICT_REFS)
DIE(no_usym, "an ARRAY");
if (PL_dowarn)
warn(warn_uninit);
RETPUSHUNDEF;
}
sym = SvPV(sv,PL_na);
- if (op->op_private & HINT_STRICT_REFS)
+ if (PL_op->op_private & HINT_STRICT_REFS)
DIE(no_symref, sym, "an ARRAY");
gv = (GV*)gv_fetchpv(sym, TRUE, SVt_PVAV);
} else {
gv = (GV*)sv;
}
av = GvAVn(gv);
- if (op->op_private & OPpLVAL_INTRO)
+ if (PL_op->op_private & OPpLVAL_INTRO)
av = save_ary(gv);
- if (op->op_flags & OPf_REF) {
+ if (PL_op->op_flags & OPf_REF) {
PUSHs((SV*)av);
RETURN;
}
hv = (HV*)SvRV(sv);
if (SvTYPE(hv) != SVt_PVHV && SvTYPE(hv) != SVt_PVAV)
DIE("Not a HASH reference");
- if (op->op_flags & OPf_REF) {
+ if (PL_op->op_flags & OPf_REF) {
SETs((SV*)hv);
RETURN;
}
else {
if (SvTYPE(sv) == SVt_PVHV || SvTYPE(sv) == SVt_PVAV) {
hv = (HV*)sv;
- if (op->op_flags & OPf_REF) {
+ if (PL_op->op_flags & OPf_REF) {
SETs((SV*)hv);
RETURN;
}
goto wasref;
}
if (!SvOK(sv)) {
- if (op->op_flags & OPf_REF ||
- op->op_private & HINT_STRICT_REFS)
+ if (PL_op->op_flags & OPf_REF ||
+ PL_op->op_private & HINT_STRICT_REFS)
DIE(no_usym, "a HASH");
if (PL_dowarn)
warn(warn_uninit);
RETSETUNDEF;
}
sym = SvPV(sv,PL_na);
- if (op->op_private & HINT_STRICT_REFS)
+ if (PL_op->op_private & HINT_STRICT_REFS)
DIE(no_symref, sym, "a HASH");
gv = (GV*)gv_fetchpv(sym, TRUE, SVt_PVHV);
} else {
gv = (GV*)sv;
}
hv = GvHVn(gv);
- if (op->op_private & OPpLVAL_INTRO)
+ if (PL_op->op_private & OPpLVAL_INTRO)
hv = save_hash(gv);
- if (op->op_flags & OPf_REF) {
+ if (PL_op->op_flags & OPf_REF) {
SETs((SV*)hv);
RETURN;
}
* special care that assigning the identifier on the left doesn't
* clobber a value on the right that's used later in the list.
*/
- if (op->op_private & OPpASSIGN_COMMON) {
+ if (PL_op->op_private & OPpASSIGN_COMMON) {
for (relem = firstrelem; relem <= lastrelem; relem++) {
/*SUPPRESS 560*/
if (sv = *relem) {
I32 update_minmatch = 1;
SV *screamer;
- if (op->op_flags & OPf_STACKED)
+ if (PL_op->op_flags & OPf_STACKED)
TARG = POPs;
else {
TARG = DEFSV;
STRLEN offset;
PerlIO *fp;
register IO *io = GvIO(PL_last_in_gv);
- register I32 type = op->op_type;
+ register I32 type = PL_op->op_type;
I32 gimme = GIMME_V;
MAGIC *mg;
{
djSP;
register PERL_CONTEXT *cx;
- I32 gimme = OP_GIMME(op, -1);
+ I32 gimme = OP_GIMME(PL_op, -1);
if (gimme == -1) {
if (cxstack_ix >= 0)
SV **svp;
SV *keysv = POPs;
HV *hv = (HV*)POPs;
- U32 lval = op->op_flags & OPf_MOD;
- U32 defer = op->op_private & OPpLVAL_DEFER;
+ U32 lval = PL_op->op_flags & OPf_MOD;
+ U32 defer = PL_op->op_private & OPpLVAL_DEFER;
SV *sv;
if (SvTYPE(hv) == SVt_PVHV) {
PUSHs(lv);
RETURN;
}
- if (op->op_private & OPpLVAL_INTRO) {
+ if (PL_op->op_private & OPpLVAL_INTRO) {
if (HvNAME(hv) && isGV(*svp))
- save_gp((GV*)*svp, !(op->op_flags & OPf_SPECIAL));
+ save_gp((GV*)*svp, !(PL_op->op_flags & OPf_SPECIAL));
else
save_helem(hv, keysv, svp);
}
- else if (op->op_private & OPpDEREF)
- vivify_ref(*svp, op->op_private & OPpDEREF);
+ else if (PL_op->op_private & OPpDEREF)
+ vivify_ref(*svp, PL_op->op_private & OPpDEREF);
}
sv = (svp ? *svp : &PL_sv_undef);
/* This makes C<local $tied{foo} = $tied{foo}> possible.
PMOP *newpm;
I32 gimme;
- if (op->op_flags & OPf_SPECIAL) {
+ if (PL_op->op_flags & OPf_SPECIAL) {
cx = &cxstack[cxstack_ix];
cx->blk_oldpm = PL_curpm; /* fake block should preserve $1 et al */
}
POPBLOCK(cx,newpm);
- gimme = OP_GIMME(op, -1);
+ gimme = OP_GIMME(PL_op, -1);
if (gimme == -1) {
if (cxstack_ix >= 0)
gimme = cxstack[cxstack_ix].blk_gimme;
/* known replacement string? */
dstr = (pm->op_pmflags & PMf_CONST) ? POPs : Nullsv;
- if (op->op_flags & OPf_STACKED)
+ if (PL_op->op_flags & OPf_STACKED)
TARG = POPs;
else {
TARG = DEFSV;
register CV *cv;
register PERL_CONTEXT *cx;
I32 gimme;
- bool hasargs = (op->op_flags & OPf_STACKED) != 0;
+ bool hasargs = (PL_op->op_flags & OPf_STACKED) != 0;
if (!sv)
DIE("Not a CODE reference");
sym = SvPV(sv, PL_na);
if (!sym)
DIE(no_usym, "a subroutine");
- if (op->op_private & HINT_STRICT_REFS)
+ if (PL_op->op_private & HINT_STRICT_REFS)
DIE(no_symref, sym, "a subroutine");
cv = perl_get_cv(sym, TRUE);
break;
}
gimme = GIMME_V;
- if ((op->op_private & OPpENTERSUB_DB) && GvCV(PL_DBsub) && !CvNODEBUG(cv))
+ if ((PL_op->op_private & OPpENTERSUB_DB) && GvCV(PL_DBsub) && !CvNODEBUG(cv))
cv = get_db_sub(&sv, cv);
if (!cv)
DIE("No DBsub routine");
if (CvFLAGS(cv) & CVf_LOCKED) {
MAGIC *mg;
if (CvFLAGS(cv) & CVf_METHOD) {
- if (SP > stack_base + TOPMARK)
- sv = *(stack_base + TOPMARK + 1);
+ if (SP > PL_stack_base + TOPMARK)
+ sv = *(PL_stack_base + TOPMARK + 1);
else {
MUTEX_UNLOCK(CvMUTEXP(cv));
croak("no argument for locked method call");
* (3) instead of (2) so we'd have to clone. Would the fact
* that we released the mutex more quickly make up for this?
*/
- if (threadnum &&
+ if (PL_threadnum &&
(svp = hv_fetch(thr->cvcache, (char *)cv, sizeof(cv), FALSE)))
{
/* We already have a clone to use */
AV* av;
I32 items;
#ifdef USE_THREADS
- av = (AV*)curpad[0];
+ av = (AV*)PL_curpad[0];
#else
av = GvAV(PL_defgv);
#endif /* USE_THREADS */
register I32 items = SP - MARK;
AV* padlist = CvPADLIST(cv);
SV** svp = AvARRAY(padlist);
- push_return(op->op_next);
+ push_return(PL_op->op_next);
PUSHBLOCK(cx, CXt_SUB, MARK);
PUSHSUB(cx);
CvDEPTH(cv)++;
}
#ifdef USE_THREADS
if (!hasargs) {
- AV* av = (AV*)curpad[0];
+ AV* av = (AV*)PL_curpad[0];
items = AvFILLp(av) + 1;
if (items) {
SV** svp;
I32 elem = POPi;
AV* av = (AV*)POPs;
- U32 lval = op->op_flags & OPf_MOD;
- U32 defer = (op->op_private & OPpLVAL_DEFER) && (elem > AvFILL(av));
+ U32 lval = PL_op->op_flags & OPf_MOD;
+ U32 defer = (PL_op->op_private & OPpLVAL_DEFER) && (elem > AvFILL(av));
SV *sv;
if (elem > 0)
PUSHs(lv);
RETURN;
}
- if (op->op_private & OPpLVAL_INTRO)
+ if (PL_op->op_private & OPpLVAL_INTRO)
save_aelem(av, elem, svp);
- else if (op->op_private & OPpDEREF)
- vivify_ref(*svp, op->op_private & OPpDEREF);
+ else if (PL_op->op_private & OPpDEREF)
+ vivify_ref(*svp, PL_op->op_private & OPpDEREF);
}
sv = (svp ? *svp : &PL_sv_undef);
if (!lval && SvGMAGICAL(sv)) /* see note in pp_helem() */
GV *newdefout, *egv;
HV *hv;
- newdefout = (op->op_private > 0) ? ((GV *) POPs) : (GV *) NULL;
+ newdefout = (PL_op->op_private > 0) ? ((GV *) POPs) : (GV *) NULL;
egv = GvEGV(PL_defoutgv);
if (!egv)
cv = (CV*)sv_2mortal((SV*)cv_clone(cv));
IoFLAGS(io) &= ~IOf_DIDTOP;
- return doform(cv,gv,op->op_next);
+ return doform(cv,gv,PL_op->op_next);
}
PP(pp_leavewrite)
}
if (CvCLONE(cv))
cv = (CV*)sv_2mortal((SV*)cv_clone(cv));
- return doform(cv,gv,op);
+ return doform(cv,gv,PL_op);
}
forget_top:
SV *sv;
MAGIC *mg;
- if (op->op_flags & OPf_STACKED)
+ if (PL_op->op_flags & OPf_STACKED)
gv = (GV*)*++MARK;
else
gv = PL_defoutgv;
}
else {
#ifdef USE_LOCALE_NUMERIC
- if (op->op_private & OPpLOCALE)
+ if (PL_op->op_private & OPpLOCALE)
SET_NUMERIC_LOCAL();
else
SET_NUMERIC_STANDARD();
MAGIC *mg;
gv = (GV*)*++MARK;
- if ((op->op_type == OP_READ || op->op_type == OP_SYSREAD) &&
+ if ((PL_op->op_type == OP_READ || PL_op->op_type == OP_SYSREAD) &&
SvRMAGICAL(gv) && (mg = mg_find((SV*)gv, 'q')))
{
SV *sv;
if (!io || !IoIFP(io))
goto say_undef;
#ifdef HAS_SOCKET
- if (op->op_type == OP_RECV) {
+ if (PL_op->op_type == OP_RECV) {
char namebuf[MAXPATHLEN];
#if (defined(VMS_DO_SOCKETS) && defined(DECCRTL_SOCKETS)) || defined(MPE)
bufsize = sizeof (struct sockaddr_in);
if (offset > bufsize) { /* Zero any newly allocated space */
Zero(buffer+bufsize, offset-bufsize, char);
}
- if (op->op_type == OP_SYSREAD) {
+ if (PL_op->op_type == OP_SYSREAD) {
length = PerlLIO_read(PerlIO_fileno(IoIFP(io)), buffer+offset, length);
}
else
MAGIC *mg;
gv = (GV*)*++MARK;
- if (op->op_type == OP_SYSWRITE &&
+ if (PL_op->op_type == OP_SYSWRITE &&
SvRMAGICAL(gv) && (mg = mg_find((SV*)gv, 'q')))
{
SV *sv;
if (!io || !IoIFP(io)) {
length = -1;
if (PL_dowarn) {
- if (op->op_type == OP_SYSWRITE)
+ if (PL_op->op_type == OP_SYSWRITE)
warn("Syswrite on closed filehandle");
else
warn("Send on closed socket");
}
}
- else if (op->op_type == OP_SYSWRITE) {
+ else if (PL_op->op_type == OP_SYSWRITE) {
if (MARK < SP) {
offset = SvIVx(*++MARK);
if (offset < 0) {
long offset = POPl;
gv = PL_last_in_gv = (GV*)POPs;
- if (op->op_type == OP_SEEK)
+ if (PL_op->op_type == OP_SEEK)
PUSHs(boolSV(do_seek(gv, offset, whence)));
else {
long n = do_sysseek(gv, offset, whence);
SETERRNO(0,0);
#if defined(HAS_TRUNCATE) || defined(HAS_CHSIZE) || defined(F_FREESP)
- if (op->op_flags & OPf_SPECIAL) {
+ if (PL_op->op_flags & OPf_SPECIAL) {
tmpgv = gv_fetchpv(POPp, FALSE, SVt_PVIO);
do_ftruncate:
TAINT_PROPER("truncate");
djSP; dTARGET;
SV *argsv = POPs;
unsigned int func = U_I(POPn);
- int optype = op->op_type;
+ int optype = PL_op->op_type;
char *s;
IV retval;
GV *gv = (GV*)POPs;
{
djSP;
#ifdef HAS_SOCKET
- int optype = op->op_type;
+ int optype = PL_op->op_type;
SV *sv;
int fd;
unsigned int optname;
{
djSP;
#ifdef HAS_SOCKET
- int optype = op->op_type;
+ int optype = PL_op->op_type;
SV *sv;
int fd;
GV *gv = (GV*)POPs;
I32 gimme;
I32 max = 13;
- if (op->op_flags & OPf_REF) {
+ if (PL_op->op_flags & OPf_REF) {
tmpgv = cGVOP->op_gv;
do_fstat:
if (tmpgv != PL_defgv) {
sv_setpv(PL_statname, SvPV(sv,PL_na));
PL_statgv = Nullgv;
#ifdef HAS_LSTAT
- PL_laststype = op->op_type;
- if (op->op_type == OP_LSTAT)
+ PL_laststype = PL_op->op_type;
+ if (PL_op->op_type == OP_LSTAT)
PL_laststatval = PerlLIO_lstat(SvPV(PL_statname, PL_na), &PL_statcache);
else
#endif
djSP;
if (result < 0)
RETPUSHUNDEF;
- if (PL_statcache.st_uid == (op->op_type == OP_FTEOWNED ? PL_euid : PL_uid) )
+ if (PL_statcache.st_uid == (PL_op->op_type == OP_FTEOWNED ? PL_euid : PL_uid) )
RETPUSHYES;
RETPUSHNO;
}
GV *gv;
char *tmps = Nullch;
- if (op->op_flags & OPf_REF)
+ if (PL_op->op_flags & OPf_REF)
gv = cGVOP->op_gv;
else if (isGV(TOPs))
gv = (GV*)POPs;
register SV *sv;
GV *gv;
- if (op->op_flags & OPf_REF)
+ if (PL_op->op_flags & OPf_REF)
gv = cGVOP->op_gv;
else if (isGV(TOPs))
gv = (GV*)POPs;
if (PL_laststatval < 0)
RETPUSHUNDEF;
if (S_ISDIR(PL_statcache.st_mode)) /* handle NFS glitch */
- if (op->op_type == OP_FTTEXT)
+ if (PL_op->op_type == OP_FTTEXT)
RETPUSHNO;
else
RETPUSHYES;
len = PerlLIO_read(i, tbuf, 512);
(void)PerlLIO_close(i);
if (len <= 0) {
- if (S_ISDIR(PL_statcache.st_mode) && op->op_type == OP_FTTEXT)
+ if (S_ISDIR(PL_statcache.st_mode) && PL_op->op_type == OP_FTTEXT)
RETPUSHNO; /* special case NFS directories */
RETPUSHYES; /* null file is anything */
}
odd++;
}
- if ((odd * 3 > len) == (op->op_type == OP_FTTEXT)) /* allow 1/3 odd */
+ if ((odd * 3 > len) == (PL_op->op_type == OP_FTTEXT)) /* allow 1/3 odd */
RETPUSHNO;
else
RETPUSHYES;
djSP; dMARK; dTARGET;
I32 value;
#ifdef HAS_CHOWN
- value = (I32)apply(op->op_type, MARK, SP);
+ value = (I32)apply(PL_op->op_type, MARK, SP);
SP = MARK;
PUSHi(value);
RETURN;
{
djSP; dMARK; dTARGET;
I32 value;
- value = (I32)apply(op->op_type, MARK, SP);
+ value = (I32)apply(PL_op->op_type, MARK, SP);
SP = MARK;
PUSHi(value);
RETURN;
{
djSP; dMARK; dTARGET;
I32 value;
- value = (I32)apply(op->op_type, MARK, SP);
+ value = (I32)apply(PL_op->op_type, MARK, SP);
SP = MARK;
PUSHi(value);
RETURN;
{
djSP; dMARK; dTARGET;
I32 value;
- value = (I32)apply(op->op_type, MARK, SP);
+ value = (I32)apply(PL_op->op_type, MARK, SP);
SP = MARK;
PUSHi(value);
RETURN;
PUSHi(STATUS_CURRENT);
RETURN;
}
- if (op->op_flags & OPf_STACKED) {
+ if (PL_op->op_flags & OPf_STACKED) {
SV *really = *++MARK;
value = (I32)do_aexec(really, MARK, SP);
}
djSP; dMARK; dORIGMARK; dTARGET;
I32 value;
- if (op->op_flags & OPf_STACKED) {
+ if (PL_op->op_flags & OPf_STACKED) {
SV *really = *++MARK;
value = (I32)do_aexec(really, MARK, SP);
}
djSP; dMARK; dTARGET;
I32 value;
#ifdef HAS_KILL
- value = (I32)apply(op->op_type, MARK, SP);
+ value = (I32)apply(PL_op->op_type, MARK, SP);
SP = MARK;
PUSHi(value);
RETURN;
when = (Time_t)SvIVx(POPs);
#endif
- if (op->op_type == OP_LOCALTIME)
+ if (PL_op->op_type == OP_LOCALTIME)
tmbuf = localtime(&when);
else
tmbuf = gmtime(&when);
{
#if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
djSP; dMARK; dTARGET;
- I32 value = (I32)(do_shmio(op->op_type, MARK, SP) >= 0);
+ I32 value = (I32)(do_shmio(PL_op->op_type, MARK, SP) >= 0);
SP = MARK;
PUSHi(value);
RETURN;
{
#if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
djSP; dMARK; dTARGET;
- int anum = do_ipcget(op->op_type, MARK, SP);
+ int anum = do_ipcget(PL_op->op_type, MARK, SP);
SP = MARK;
if (anum == -1)
RETPUSHUNDEF;
{
#if defined(HAS_MSG) || defined(HAS_SEM) || defined(HAS_SHM)
djSP; dMARK; dTARGET;
- int anum = do_ipcctl(op->op_type, MARK, SP);
+ int anum = do_ipcctl(PL_op->op_type, MARK, SP);
SP = MARK;
if (anum == -1)
RETSETUNDEF;
{
djSP;
#if defined(HAS_GETHOSTBYNAME) || defined(HAS_GETHOSTBYADDR) || defined(HAS_GETHOSTENT)
- I32 which = op->op_type;
+ I32 which = PL_op->op_type;
register char **elem;
register SV *sv;
#ifndef HAS_GETHOST_PROTOS /* XXX Do we need individual probes? */
{
djSP;
#if defined(HAS_GETNETBYNAME) || defined(HAS_GETNETBYADDR) || defined(HAS_GETNETENT)
- I32 which = op->op_type;
+ I32 which = PL_op->op_type;
register char **elem;
register SV *sv;
#ifndef HAS_GETNET_PROTOS /* XXX Do we need individual probes? */
{
djSP;
#if defined(HAS_GETPROTOBYNAME) || defined(HAS_GETPROTOBYNUMBER) || defined(HAS_GETPROTOENT)
- I32 which = op->op_type;
+ I32 which = PL_op->op_type;
register char **elem;
register SV *sv;
#ifndef HAS_GETPROTO_PROTOS /* XXX Do we need individual probes? */
{
djSP;
#if defined(HAS_GETSERVBYNAME) || defined(HAS_GETSERVBYPORT) || defined(HAS_GETSERVENT)
- I32 which = op->op_type;
+ I32 which = PL_op->op_type;
register char **elem;
register SV *sv;
#ifndef HAS_GETSERV_PROTOS /* XXX Do we need individual probes? */
{
djSP;
#if defined(HAS_PASSWD) && defined(HAS_GETPWENT)
- I32 which = op->op_type;
+ I32 which = PL_op->op_type;
register SV *sv;
struct passwd *pwent;
{
djSP;
#if defined(HAS_GROUP) && defined(HAS_GETGRENT)
- I32 which = op->op_type;
+ I32 which = PL_op->op_type;
register char **elem;
register SV *sv;
struct group *grent;
case EVAL:
{
dSP;
- OP_4tree *oop = op;
+ OP_4tree *oop = PL_op;
COP *ocurcop = PL_curcop;
SV **ocurpad = PL_curpad;
SV *ret;
n = ARG(scan);
- op = (OP_4tree*)PL_regdata->data[n];
- DEBUG_r( PerlIO_printf(Perl_debug_log, " re_eval 0x%x\n", op) );
+ PL_op = (OP_4tree*)PL_regdata->data[n];
+ DEBUG_r( PerlIO_printf(Perl_debug_log, " re_eval 0x%x\n", PL_op) );
PL_curpad = AvARRAY((AV*)PL_regdata->data[n + 1]);
CALLRUNOPS(); /* Scalar context. */
sw = SvTRUE(ret);
} else
sv_setsv(save_scalar(PL_replgv), ret);
- op = oop;
+ PL_op = oop;
PL_curpad = ocurpad;
PL_curcop = ocurcop;
break;
#ifdef PERL_OBJECT
#define CALLOP this->*op
#else
-#define CALLOP *op
+#define CALLOP *PL_op
#endif
int
{
dTHR;
- while ( op = (CALLOP->op_ppaddr)(ARGS) ) ;
+ while ( PL_op = (CALLOP->op_ppaddr)(ARGS) ) ;
TAINT_NOT;
return 0;
{
#ifdef DEBUGGING
dTHR;
- if (!op) {
+ if (!PL_op) {
warn("NULL OP IN RUN");
return 0;
}
PerlIO_printf(Perl_debug_log, "WARNING: %lx changed from %lx to %lx\n",
(long)watchaddr, (long)watchok, (long)*watchaddr);
DEBUG_s(debstack());
- DEBUG_t(debop(op));
- DEBUG_P(debprof(op));
+ DEBUG_t(debop(PL_op));
+ DEBUG_P(debprof(PL_op));
}
- } while ( op = (CALLOP->op_ppaddr)(ARGS) );
+ } while ( PL_op = (CALLOP->op_ppaddr)(ARGS) );
TAINT_NOT;
return 0;
{
dTHR;
SSCHECK(2);
- SSPUSHPTR(op);
+ SSPUSHPTR(PL_op);
SSPUSHINT(SAVEt_OP);
}
SvREFCNT_dec(value);
break;
case SAVEt_OP:
- op = (OP*)SSPOPPTR;
+ PL_op = (OP*)SSPOPPTR;
break;
case SAVEt_HINTS:
if (GvHV(PL_hintgv)) {
{
dTHR;
croak("Can't coerce %s to integer in %s", sv_reftype(sv,0),
- op_desc[op->op_type]);
+ op_desc[PL_op->op_type]);
}
}
(void)SvIOK_only(sv); /* validate number */
{
dTHR;
croak("Can't coerce %s to number in %s", sv_reftype(sv,0),
- op_name[op->op_type]);
+ op_name[PL_op->op_type]);
}
}
SvNVX(sv) = num;
}
*d = '\0';
- if (op)
+ if (PL_op)
warn("Argument \"%s\" isn't numeric in %s", tmpbuf,
- op_name[op->op_type]);
+ op_name[PL_op->op_type]);
else
warn("Argument \"%s\" isn't numeric", tmpbuf);
}
case SVt_PVHV:
case SVt_PVCV:
case SVt_PVIO:
- if (op)
+ if (PL_op)
croak("Bizarre copy of %s in %s", sv_reftype(sstr, 0),
- op_name[op->op_type]);
+ op_name[PL_op->op_type]);
else
croak("Bizarre copy of %s", sv_reftype(sstr, 0));
break;
else {
dTHR;
croak("Can't coerce %s to string in %s", sv_reftype(sv,0),
- op_name[op->op_type]);
+ op_name[PL_op->op_type]);
}
}
else
default:
unknown:
if (!args && PL_dowarn &&
- (op->op_type == OP_PRTF || op->op_type == OP_SPRINTF)) {
+ (PL_op->op_type == OP_PRTF || PL_op->op_type == OP_SPRINTF)) {
SV *msg = sv_newmortal();
sv_setpvf(msg, "Invalid conversion in %s: ",
- (op->op_type == OP_PRTF) ? "printf" : "sprintf");
+ (PL_op->op_type == OP_PRTF) ? "printf" : "sprintf");
if (c)
sv_catpvf(msg, isPRINT(c) ? "\"%%%c\"" : "\"%%\\%03o\"",
c & 0xFF);
# ifdef EMULATE_ATOMIC_REFCOUNTS
# define ATOMIC_INC(count) STMT_START { \
- MUTEX_LOCK(&svref_mutex); \
+ MUTEX_LOCK(&PL_svref_mutex); \
++count; \
- MUTEX_UNLOCK(&svref_mutex); \
+ MUTEX_UNLOCK(&PL_svref_mutex); \
} STMT_END
# define ATOMIC_DEC_AND_TEST(res,count) STMT_START { \
- MUTEX_LOCK(&svref_mutex); \
+ MUTEX_LOCK(&PL_svref_mutex); \
res = (--count == 0); \
- MUTEX_UNLOCK(&svref_mutex); \
+ MUTEX_UNLOCK(&PL_svref_mutex); \
} STMT_END
# else
# define ATOMIC_INC(count) atomic_inc(&count)
#ifndef SET_THR
#define SET_THR(t) \
STMT_START { \
- if (pthread_setspecific(thr_key, (void *) (t))) \
+ if (pthread_setspecific(PL_thr_key, (void *) (t))) \
croak("panic: pthread_setspecific"); \
} STMT_END
#endif /* SET_THR */
struct perl_thread *getTHR _((void));
# define THR getTHR()
# else
-# define THR ((struct perl_thread *) pthread_getspecific(thr_key))
+# define THR ((struct perl_thread *) pthread_getspecific(PL_thr_key))
# endif /* OLD_PTHREADS_API */
#endif /* THR */
*/
#ifndef dTHR
# define dTHR \
- struct perl_thread *thr = threadnum? THR : (struct perl_thread*)SvPVX(thrsv)
+ struct perl_thread *thr = PL_threadnum? THR : (struct perl_thread*)SvPVX(PL_thrsv)
#endif /* dTHR */
#ifndef INIT_THREADS
*/
#define LOCK_SV_MUTEX \
STMT_START { \
- if (threadnum) \
- MUTEX_LOCK(&sv_mutex); \
+ if (PL_threadnum) \
+ MUTEX_LOCK(&PL_sv_mutex); \
} STMT_END
#define UNLOCK_SV_MUTEX \
STMT_START { \
- if (threadnum) \
- MUTEX_UNLOCK(&sv_mutex); \
+ if (PL_threadnum) \
+ MUTEX_UNLOCK(&PL_sv_mutex); \
} STMT_END
#ifndef THREAD_RET_TYPE
PL_nextval[PL_nexttoke].ival = 0;
force_next(',');
#ifdef USE_THREADS
- nextval[nexttoke].opval = newOP(OP_THREADSV, 0);
- nextval[nexttoke].opval->op_targ = find_threadsv("\"");
+ PL_nextval[PL_nexttoke].opval = newOP(OP_THREADSV, 0);
+ PL_nextval[PL_nexttoke].opval->op_targ = find_threadsv("\"");
force_next(PRIVATEREF);
#else
force_ident("\"", '$');
PUSHSTACKi(PERLSI_OVERLOAD);
ENTER;
SAVEOP();
- op = (OP *) &myop;
+ PL_op = (OP *) &myop;
if (PERLDB_SUB && PL_curstash != PL_debstash)
- op->op_private |= OPpENTERSUB_DB;
+ PL_op->op_private |= OPpENTERSUB_DB;
PUTBACK;
pp_pushmark(ARGS);
PUSHs(cv);
PUTBACK;
- if (op = pp_entersub(ARGS))
+ if (PL_op = pp_entersub(ARGS))
CALLRUNOPS();
LEAVE;
SPAGAIN;
PL_padix = 0;
PL_subline = PL_curcop->cop_line;
#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();
CvPADLIST(PL_compcv) = comppadlist;
CvOUTSIDE(PL_compcv) = (CV*)SvREFCNT_inc(outsidecv);
#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 */
return oldsavestack_ix;
#ifdef USE_THREADS
DEBUG_L(PerlIO_printf(PerlIO_stderr(),
"%p: die: curstack = %p, mainstack = %p\n",
- thr, curstack, mainstack));
+ thr, PL_curstack, PL_mainstack));
#endif /* USE_THREADS */
va_start(args, pat);
#ifdef USE_THREADS
DEBUG_L(PerlIO_printf(PerlIO_stderr(),
"%p: die: message = %s\ndiehook = %p\n",
- thr, message, diehook));
+ thr, message, PL_diehook));
#endif /* USE_THREADS */
if (PL_diehook) {
/* sv_2cv might call croak() */
#ifdef USE_THREADS
DEBUG_L(PerlIO_printf(PerlIO_stderr(),
"%p: die: restartop = %p, was_in_eval = %d, top_env = %p\n",
- thr, restartop, was_in_eval, top_env));
+ thr, PL_restartop, was_in_eval, PL_top_env));
#endif /* USE_THREADS */
if ((!PL_restartop && was_in_eval) || PL_top_env->je_prev)
JMPENV_JUMP(3);
thr = (Thread) SvPVX(sv);
/* debug */
memset(thr, 0xab, sizeof(struct perl_thread));
- markstack = 0;
- scopestack = 0;
- savestack = 0;
- retstack = 0;
- dirty = 0;
- localizing = 0;
+ PL_markstack = 0;
+ PL_scopestack = 0;
+ PL_savestack = 0;
+ PL_retstack = 0;
+ PL_dirty = 0;
+ PL_localizing = 0;
/* end debug */
thr->oursv = sv;
init_stacks(ARGS);
- curcop = &compiling;
+ PL_curcop = &PL_compiling;
thr->cvcache = newHV();
thr->threadsv = newAV();
thr->specific = newAV();
thr->flags = THRf_R_JOINABLE;
MUTEX_INIT(&thr->mutex);
- curcop = t->Tcurcop; /* XXX As good a guess as any? */
- defstash = t->Tdefstash; /* XXX maybe these should */
- curstash = t->Tcurstash; /* always be set to main? */
+ PL_curcop = t->Tcurcop; /* XXX As good a guess as any? */
+ PL_defstash = t->Tdefstash; /* XXX maybe these should */
+ PL_curstash = t->Tcurstash; /* always be set to main? */
/* top_env needs to be non-zero. It points to an area
See comments in scope.h
Initialize top entry (as in perl.c for main thread)
*/
- start_env.je_prev = NULL;
- start_env.je_ret = -1;
- start_env.je_mustcatch = TRUE;
- top_env = &start_env;
-
- in_eval = FALSE;
- restartop = 0;
-
- tainted = t->Ttainted;
- curpm = t->Tcurpm; /* XXX No PMOP ref count */
- nrs = newSVsv(t->Tnrs);
- rs = SvREFCNT_inc(nrs);
- last_in_gv = (GV*)SvREFCNT_inc(t->Tlast_in_gv);
- ofslen = t->Tofslen;
- ofs = savepvn(t->Tofs, ofslen);
- defoutgv = (GV*)SvREFCNT_inc(t->Tdefoutgv);
- chopset = t->Tchopset;
- formtarget = newSVsv(t->Tformtarget);
- bodytarget = newSVsv(t->Tbodytarget);
- toptarget = newSVsv(t->Ttoptarget);
-
- statname = NEWSV(66,0);
- maxscream = -1;
- regcompp = FUNC_NAME_TO_PTR(pregcomp);
- regexecp = FUNC_NAME_TO_PTR(regexec_flags);
- regindent = 0;
- reginterp_cnt = 0;
- lastscream = Nullsv;
- screamfirst = 0;
- screamnext = 0;
- reg_start_tmp = 0;
- reg_start_tmpl = 0;
+ PL_start_env.je_prev = NULL;
+ PL_start_env.je_ret = -1;
+ PL_start_env.je_mustcatch = TRUE;
+ PL_top_env = &PL_start_env;
+
+ PL_in_eval = FALSE;
+ PL_restartop = 0;
+
+ PL_tainted = t->Ttainted;
+ PL_curpm = t->Tcurpm; /* XXX No PMOP ref count */
+ PL_nrs = newSVsv(t->Tnrs);
+ PL_rs = SvREFCNT_inc(PL_nrs);
+ PL_last_in_gv = (GV*)SvREFCNT_inc(t->Tlast_in_gv);
+ PL_ofslen = t->Tofslen;
+ PL_ofs = savepvn(t->Tofs, PL_ofslen);
+ PL_defoutgv = (GV*)SvREFCNT_inc(t->Tdefoutgv);
+ PL_chopset = t->Tchopset;
+ PL_formtarget = newSVsv(t->Tformtarget);
+ PL_bodytarget = newSVsv(t->Tbodytarget);
+ PL_toptarget = newSVsv(t->Ttoptarget);
+
+ PL_statname = NEWSV(66,0);
+ PL_maxscream = -1;
+ PL_regcompp = FUNC_NAME_TO_PTR(pregcomp);
+ PL_regexecp = FUNC_NAME_TO_PTR(regexec_flags);
+ PL_regindent = 0;
+ PL_reginterp_cnt = 0;
+ PL_lastscream = Nullsv;
+ PL_screamfirst = 0;
+ PL_screamnext = 0;
+ PL_reg_start_tmp = 0;
+ PL_reg_start_tmpl = 0;
/* Initialise all per-thread SVs that the template thread used */
svp = AvARRAY(t->threadsv);
for (i = 0; i <= AvFILLp(t->threadsv); i++, svp++) {
- if (*svp && *svp != &sv_undef) {
+ if (*svp && *svp != &PL_sv_undef) {
SV *sv = newSVsv(*svp);
av_store(thr->threadsv, i, sv);
- sv_magic(sv, 0, 0, &threadsv_names[i], 1);
+ sv_magic(sv, 0, 0, &PL_threadsv_names[i], 1);
DEBUG_L(PerlIO_printf(PerlIO_stderr(),
"new_struct_thread: copied threadsv %d %p->%p\n",i, t, thr));
}
}
thr->threadsvp = AvARRAY(thr->threadsv);
- MUTEX_LOCK(&threads_mutex);
- nthreads++;
- thr->tid = ++threadnum;
+ MUTEX_LOCK(&PL_threads_mutex);
+ PL_nthreads++;
+ thr->tid = ++PL_threadnum;
thr->next = t->next;
thr->prev = t;
t->next = thr;
thr->next->prev = thr;
- MUTEX_UNLOCK(&threads_mutex);
+ MUTEX_UNLOCK(&PL_threads_mutex);
#ifdef HAVE_THREAD_INTERN
init_thread_intern(thr);
struct perl_vars *
Perl_GetVars(void)
{
- return &Perl_Vars;
+ return &PL_Vars;
}
#endif
#ifdef PERL_GLOBAL_STRUCT
#define PERLVAR(var,type) /**/
-#define PERLVARI(var,type,init) Perl_Vars.var = init;
-#define PERLVARIC(var,type,init) Perl_Vars.var = init;
+#define PERLVARI(var,type,init) PL_Vars.var = init;
+#define PERLVARIC(var,type,init) PL_Vars.var = init;
#include "perlvars.h"
#undef PERLVAR
#undef PERLVARI
projects / p5sagit/p5-mst-13.2.git / commitdiff