Globals and structs via macros - part 1 of N

- introduce perlvars.h intrpvar.h and thrdvar.h
- change perl.h and thread.h to include them with
  appropriate macros defined
- result is status-quo but with macros
- next step is to tweak embed.* to capitalize on 
  new easy-to-find info.

p4raw-id: //depot/ansiperl@337

6 files changed, 527 insertions, 497 deletions

diff --git a/intrpvar.h b/intrpvar.h
new file mode 100644
index 0000000000..0393b8f4d2
--- /dev/null
+++ b/intrpvar.h
@@ -0,0 +1,193 @@
+/***********************************************/
+/* Global only to current interpreter instance */
+/***********************************************/
+
+/* pseudo environmental stuff */
+PERLVAR(Iorigargc,	int)		
+PERLVAR(Iorigargv,	char **)		
+PERLVAR(Ienvgv,	GV *)		
+PERLVAR(Isiggv,	GV *)		
+PERLVAR(Iincgv,	GV *)		
+PERLVAR(Iorigfilename,	char *)		
+PERLVAR(Idiehook,	SV *)		
+PERLVAR(Iwarnhook,	SV *)		
+PERLVAR(Iparsehook,	SV *)		
+/* switches */
+PERLVAR(Icddir,	char *)		
+PERLVAR(Iminus_c,	bool)		
+PERLVAR(Ipatchlevel[10],	char)		
+PERLVAR(Ilocalpatches,	char **)		
+PERLVAR(Inrs,	SV *)		
+PERLVARI(Isplitstr,	char *,	" ")	
+PERLVAR(Ipreprocess,	bool)		
+PERLVAR(Iminus_n,	bool)		
+PERLVAR(Iminus_p,	bool)		
+PERLVAR(Iminus_l,	bool)		
+PERLVAR(Iminus_a,	bool)		
+PERLVAR(Iminus_F,	bool)		
+PERLVAR(Idoswitches,	bool)		
+PERLVAR(Idowarn,	bool)		
+PERLVAR(Idoextract,	bool)		
+PERLVAR(Isawampersand,	bool)		/* must save all match strings */
+PERLVAR(Isawstudy,	bool)		/* do fbm_instr on all strings */
+PERLVAR(Isawvec,	bool)		
+PERLVAR(Iunsafe,	bool)		
+PERLVAR(Iinplace,	char *)		
+PERLVAR(Ie_tmpname,	char *)		
+PERLVAR(Ie_fp,	PerlIO *)		
+PERLVAR(Iperldb,	U32)		
+	/* This value may be raised by extensions for testing purposes */
+PERLVARI(Iperl_destruct_level,	int,	0)	/* 0=none, 1=full, 2=full with checks */
+
+/* magical thingies */
+PERLVAR(Ibasetime,	Time_t)		/* $^T */
+PERLVAR(Iformfeed,	SV *)		/* $^L */
+PERLVARI(Ichopset,	char *,	" \n-")	/* $: */
+PERLVAR(Irs,	SV *)		/* $/ */
+PERLVAR(Iofs,	char *)		/* $, */
+PERLVAR(Iofslen,	STRLEN)		
+PERLVAR(Iors,	char *)		/* $\ */
+PERLVAR(Iorslen,	STRLEN)		
+PERLVAR(Iofmt,	char *)		/* $# */
+PERLVARI(Imaxsysfd,	I32,	MAXSYSFD)	/* top fd to pass to subprocesses */
+PERLVAR(Imultiline,	int)		/* $*--do strings hold >1 line? */
+PERLVAR(Istatusvalue,	I32)		/* $? */
+#ifdef VMS
+PERLVAR(Istatusvalue_vms,	U32)		
+#endif
+
+PERLVAR(Istatcache,	struct stat)		/* _ */
+PERLVAR(Istatgv,	GV *)		
+PERLVARI(Istatname,	SV *,	Nullsv)	
+
+/* shortcuts to various I/O objects */
+PERLVAR(Istdingv,	GV *)		
+PERLVAR(Ilast_in_gv,	GV *)		
+PERLVAR(Idefgv,	GV *)		
+PERLVAR(Iargvgv,	GV *)		
+PERLVAR(Idefoutgv,	GV *)		
+PERLVAR(Iargvoutgv,	GV *)		
+
+/* shortcuts to regexp stuff */
+PERLVAR(Ileftgv,	GV *)		
+PERLVAR(Iampergv,	GV *)		
+PERLVAR(Irightgv,	GV *)		
+PERLVAR(Icurpm,	PMOP *)		/* what to do \ interps from */
+PERLVAR(Iscreamfirst,	I32 *)		
+PERLVAR(Iscreamnext,	I32 *)		
+PERLVARI(Imaxscream,	I32,	-1)	
+PERLVAR(Ilastscream,	SV *)		
+
+/* shortcuts to misc objects */
+PERLVAR(Ierrgv,	GV *)		
+
+/* shortcuts to debugging objects */
+PERLVAR(IDBgv,	GV *)		
+PERLVAR(IDBline,	GV *)		
+PERLVAR(IDBsub,	GV *)		
+PERLVAR(IDBsingle,	SV *)		
+PERLVAR(IDBtrace,	SV *)		
+PERLVAR(IDBsignal,	SV *)		
+PERLVAR(Ilineary,	AV *)		/* lines of script for debugger */
+PERLVAR(Idbargs,	AV *)		/* args to call listed by caller function */
+
+/* symbol tables */
+PERLVAR(Idefstash,	HV *)		/* main symbol table */
+PERLVAR(Icurstash,	HV *)		/* symbol table for current package */
+PERLVAR(Idebstash,	HV *)		/* symbol table for perldb package */
+PERLVAR(Iglobalstash,	HV *)		/* global keyword overrides imported here */
+PERLVAR(Icurstname,	SV *)		/* name of current package */
+PERLVAR(Ibeginav,	AV *)		/* names of BEGIN subroutines */
+PERLVAR(Iendav,	AV *)		/* names of END subroutines */
+PERLVAR(Iinitav,	AV *)		/* names of INIT subroutines */
+PERLVAR(Istrtab,	HV *)		/* shared string table */
+
+/* memory management */
+PERLVAR(Itmps_stack,	SV **)		
+PERLVARI(Itmps_ix,	I32,	-1)	
+PERLVARI(Itmps_floor,	I32,	-1)	
+PERLVAR(Itmps_max,	I32)		
+PERLVAR(Isv_count,	I32)		/* how many SV* are currently allocated */
+PERLVAR(Isv_objcount,	I32)		/* how many objects are currently allocated */
+PERLVAR(Isv_root,	SV*)		/* storage for SVs belonging to interp */
+PERLVAR(Isv_arenaroot,	SV*)		/* list of areas for garbage collection */
+
+/* funky return mechanisms */
+PERLVAR(Ilastspbase,	I32)		
+PERLVAR(Ilastsize,	I32)		
+PERLVAR(Iforkprocess,	int)		/* so do_open |- can return proc# */
+
+/* subprocess state */
+PERLVAR(Ifdpid,	AV *)		/* keep fd-to-pid mappings for my_popen */
+
+/* internal state */
+PERLVAR(Iin_eval,	VOL int)		/* trap "fatal" errors? */
+PERLVAR(Irestartop,	OP *)		/* Are we propagating an error from croak? */
+PERLVAR(Idelaymagic,	int)		/* ($<,$>) = ... */
+PERLVAR(Idirty,	bool)		/* In the middle of tearing things down? */
+PERLVAR(Ilocalizing,	U8)		/* are we processing a local() list? */
+PERLVAR(Itainted,	bool)		/* using variables controlled by $< */
+PERLVAR(Itainting,	bool)		/* doing taint checks */
+PERLVARI(Iop_mask,	char *,	NULL)	/* masked operations for safe evals */
+
+/* trace state */
+PERLVAR(Idlevel,	I32)		
+PERLVARI(Idlmax,	I32,	128)	
+PERLVAR(Idebname,	char *)		
+PERLVAR(Idebdelim,	char *)		
+
+/* current interpreter roots */
+PERLVAR(Imain_cv,	CV *)		
+PERLVAR(Imain_root,	OP *)		
+PERLVAR(Imain_start,	OP *)		
+PERLVAR(Ieval_root,	OP *)		
+PERLVAR(Ieval_start,	OP *)		
+
+/* runtime control stuff */
+PERLVARI(Icurcop,	COP * VOL,	&compiling)	
+PERLVARI(Icurcopdb,	COP *,	NULL)	
+PERLVARI(Icopline,	line_t,	NOLINE)	
+PERLVAR(Icxstack,	PERL_CONTEXT *)		
+PERLVARI(Icxstack_ix,	I32,	-1)	
+PERLVARI(Icxstack_max,	I32,	128)	
+PERLVAR(Istart_env,	JMPENV)		/* empty startup sigjmp() environment */
+PERLVAR(Itop_env,	JMPENV *)		/* ptr. to current sigjmp() environment */
+
+/* stack stuff */
+PERLVAR(Icurstack,	AV *)		/* THE STACK */
+PERLVAR(Imainstack,	AV *)		/* the stack when nothing funny is happening */
+
+/* format accumulators */
+PERLVAR(Iformtarget,	SV *)		
+PERLVAR(Ibodytarget,	SV *)		
+PERLVAR(Itoptarget,	SV *)		
+
+/* statics moved here for shared library purposes */
+PERLVAR(Istrchop,	SV)		/* return value from chop */
+PERLVAR(Ifilemode,	int)		/* so nextargv() can preserve mode */
+PERLVAR(Ilastfd,	int)		/* what to preserve mode on */
+PERLVAR(Ioldname,	char *)		/* what to preserve mode on */
+PERLVAR(IArgv,	char **)		/* stuff to free from do_aexec, vfork safe */
+PERLVAR(ICmd,	char *)		/* stuff to free from do_aexec, vfork safe */
+PERLVAR(Isortcop,	OP *)		/* user defined sort routine */
+PERLVAR(Isortstash,	HV *)		/* which is in some package or other */
+PERLVAR(Ifirstgv,	GV *)		/* $a */
+PERLVAR(Isecondgv,	GV *)		/* $b */
+PERLVAR(Isortstack,	AV *)		/* temp stack during pp_sort() */
+PERLVAR(Isignalstack,	AV *)		/* temp stack during sighandler() */
+PERLVAR(Imystrk,	SV *)		/* temp key string for do_each() */
+PERLVAR(Idumplvl,	I32)		/* indentation level on syntax tree dump */
+PERLVAR(Ioldlastpm,	PMOP *)		/* for saving regexp context during debugger */
+PERLVAR(Igensym,	I32)		/* next symbol for getsym() to define */
+PERLVAR(Ipreambled,	bool)		
+PERLVAR(Ipreambleav,	AV *)		
+PERLVARI(Ilaststatval,	int,	-1)	
+PERLVARI(Ilaststype,	I32,	OP_STAT)	
+PERLVAR(Imess_sv,	SV *)		
+
+#ifdef USE_THREADS
+/* threads stuff */
+PERLVAR(Ithrsv,	SV *)		/* holds struct perl_thread for main thread */
+#endif /* USE_THREADS */
+
+
diff --git a/perl.h b/perl.h
index 92f30bedbd..7761786496 100644
--- a/perl.h
+++ b/perl.h
@@ -1365,6 +1365,7 @@ typedef Sighandler_t Sigsave_t;
  * included until after runops is initialised.
  */
 
+typedef int runops_proc_t _((void));
 int runops_standard _((void));
 #ifdef DEBUGGING
 int runops_debug _((void));
@@ -1372,28 +1373,6 @@ int runops_debug _((void));
 
 #define THREADSV_NAMES "_123456789&`'+/.,\\\";^-%=|~:\001\005!@"
 
-/****************/
-/* Truly global */
-/****************/
-
-/* global state */
-EXT PerlInterpreter *	curinterp;	/* currently running interpreter */
-#ifdef USE_THREADS
-EXT perl_key		thr_key;	/* For per-thread struct perl_thread* */
-EXT perl_mutex		sv_mutex;	/* Mutex for allocating SVs in sv.c */
-EXT perl_mutex		malloc_mutex;	/* Mutex for malloc */
-EXT perl_mutex		eval_mutex;	/* Mutex for doeval */
-EXT perl_cond		eval_cond;	/* Condition variable for doeval */
-EXT struct perl_thread *	eval_owner;	/* Owner thread for doeval */
-EXT int			nthreads;	/* Number of threads currently */
-EXT perl_mutex		threads_mutex;	/* Mutex for nthreads and thread list */
-EXT perl_cond		nthreads_cond;	/* Condition variable for nthreads */
-EXT char *		threadsv_names INIT(THREADSV_NAMES);
-#ifdef FAKE_THREADS
-EXT struct perl_thread *	thr;	/* Currently executing (fake) thread */
-#endif
-#endif /* USE_THREADS */
-
 /* VMS doesn't use environ array and NeXT has problems with crt0.o globals */
 #if !defined(VMS) && !(defined(NeXT) && defined(__DYNAMIC__))
 #if !defined(DONT_DECLARE_STD) || (defined(__svr4__) && defined(__GNUC__) && defined(sun)) || defined(__sgi)
@@ -1408,78 +1387,6 @@ EXT char *** environ_pointer;
 #  endif
 #endif /* environ processing */
 
-EXT int		uid;		/* current real user id */
-EXT int		euid;		/* current effective user id */
-EXT int		gid;		/* current real group id */
-EXT int		egid;		/* current effective group id */
-EXT bool	nomemok;	/* let malloc context handle nomem */
-EXT U32		an;		/* malloc sequence number */
-EXT U32		cop_seqmax;	/* statement sequence number */
-EXT U16		op_seqmax;	/* op sequence number */
-EXT U32		evalseq;	/* eval sequence number */
-EXT U32		sub_generation;	/* inc to force methods to be looked up again */
-EXT char **	origenviron;
-EXT U32		origalen;
-EXT HV *	pidstatus;	/* pid-to-status mappings for waitpid */
-EXT U32 *	profiledata;
-EXT int		maxo INIT(MAXO);/* Number of ops */
-EXT char *	osname;		/* operating system */
-EXT char *	sh_path INIT(SH_PATH); /* full path of shell */
-EXT Sighandler_t	sighandlerp;
-
-EXT XPV*	xiv_arenaroot;	/* list of allocated xiv areas */
-EXT IV **	xiv_root;	/* free xiv list--shared by interpreters */
-EXT double *	xnv_root;	/* free xnv list--shared by interpreters */
-EXT XRV *	xrv_root;	/* free xrv list--shared by interpreters */
-EXT XPV *	xpv_root;	/* free xpv list--shared by interpreters */
-EXT HE *	he_root;	/* free he list--shared by interpreters */
-EXT char *	nice_chunk;	/* a nice chunk of memory to reuse */
-EXT U32		nice_chunk_size;/* how nice the chunk of memory is */
-
-/* Stack for currently executing thread--context switch must handle this.     */
-EXT SV **	stack_base;	/* stack->array_ary */
-EXT SV **	stack_sp;	/* stack pointer now */
-EXT SV **	stack_max;	/* stack->array_ary + stack->array_max */
-
-/* likewise for these */
-
-#ifdef OP_IN_REGISTER
-EXT OP *	opsave;		/* save current op register across longjmps */
-#else
-EXT OP *	op;		/* current op--when not in a global register */
-#endif
-EXT int		(*runops) _((void)) INIT(RUNOPS_DEFAULT);
-EXT I32 *	scopestack;	/* blocks we've entered */
-EXT I32		scopestack_ix;
-EXT I32		scopestack_max;
-
-EXT ANY*	savestack;	/* to save non-local values on */
-EXT I32		savestack_ix;
-EXT I32		savestack_max;
-
-EXT OP **	retstack;	/* returns we've pushed */
-EXT I32		retstack_ix;
-EXT I32		retstack_max;
-
-EXT I32 *	markstack;	/* stackmarks we're remembering */
-EXT I32 *	markstack_ptr;	/* stackmarks we're remembering */
-EXT I32 *	markstack_max;	/* stackmarks we're remembering */
-
-EXT SV **	curpad;
-
-/* temp space */
-EXT SV *	Sv;
-EXT XPV *	Xpv;
-EXT char	tokenbuf[256];
-EXT struct stat	statbuf;
-#ifdef HAS_TIMES
-EXT struct tms	timesbuf;
-#endif
-#if defined(WIN32) && defined(__GNUC__)
-static STRLEN na;
-#else
-EXT STRLEN na;		/* for use in SvPV when length is Not Applicable */
-#endif
 
 /* for tmp use in stupid debuggers */
 EXT int *	di;
@@ -1526,14 +1433,6 @@ EXTCONST char no_func[]
 EXTCONST char no_myglob[]
   INIT("\"my\" variable %s can't be in a package");
 
-EXT SV		sv_undef;
-EXT SV		sv_no;
-EXT SV		sv_yes;
-#ifdef CSH
-    EXT char *	cshname INIT(CSH);
-    EXT I32	cshlen;
-#endif
-
 #ifdef DOINIT
 EXT char *sig_name[] = { SIG_NAME };
 EXT int   sig_num[]  = { SIG_NUM };
@@ -1698,70 +1597,6 @@ typedef enum {
     XTERMBLOCK
 } expectation;
 
-EXT U32		lex_state;	/* next token is determined */
-EXT U32		lex_defer;	/* state after determined token */
-EXT expectation	lex_expect;	/* expect after determined token */
-EXT I32		lex_brackets;	/* bracket count */
-EXT I32		lex_formbrack;	/* bracket count at outer format level */
-EXT I32		lex_fakebrack;	/* outer bracket is mere delimiter */
-EXT I32		lex_casemods;	/* casemod count */
-EXT I32		lex_dojoin;	/* doing an array interpolation */
-EXT I32		lex_starts;	/* how many interps done on level */
-EXT SV *	lex_stuff;	/* runtime pattern from m// or s/// */
-EXT SV *	lex_repl;	/* runtime replacement from s/// */
-EXT OP *	lex_op;		/* extra info to pass back on op */
-EXT OP *	lex_inpat;	/* in pattern $) and $| are special */
-EXT I32		lex_inwhat;	/* what kind of quoting are we in */
-EXT char *	lex_brackstack;	/* what kind of brackets to pop */
-EXT char *	lex_casestack;	/* what kind of case mods in effect */
-
-/* What we know when we're in LEX_KNOWNEXT state. */
-EXT YYSTYPE	nextval[5];	/* value of next token, if any */
-EXT I32		nexttype[5];	/* type of next token */
-EXT I32		nexttoke;
-
-EXT PerlIO * VOL	rsfp INIT(Nullfp);
-EXT SV *	linestr;
-EXT char *	bufptr;
-EXT char *	oldbufptr;
-EXT char *	oldoldbufptr;
-EXT char *	bufend;
-EXT expectation expect INIT(XSTATE);	/* how to interpret ambiguous tokens */
-EXT AV * 	rsfp_filters;
-
-EXT I32		multi_start;	/* 1st line of multi-line string */
-EXT I32		multi_end;	/* last line of multi-line string */
-EXT I32		multi_open;	/* delimiter of said string */
-EXT I32		multi_close;	/* delimiter of said string */
-
-EXT GV *	scrgv;
-EXT I32		error_count;	/* how many errors so far, max 10 */
-EXT I32		subline;	/* line this subroutine began on */
-EXT SV *	subname;	/* name of current subroutine */
-
-EXT CV *	compcv;		/* currently compiling subroutine */
-EXT AV *	comppad;	/* storage for lexically scoped temporaries */
-EXT AV *	comppad_name;	/* variable names for "my" variables */
-EXT I32		comppad_name_fill;/* last "introduced" variable offset */
-EXT I32		comppad_name_floor;/* start of vars in innermost block */
-EXT I32		min_intro_pending;/* start of vars to introduce */
-EXT I32		max_intro_pending;/* end of vars to introduce */
-EXT I32		padix;		/* max used index in current "register" pad */
-EXT I32		padix_floor;	/* how low may inner block reset padix */
-EXT I32		pad_reset_pending; /* reset pad on next attempted alloc */
-EXT COP		compiling;
-
-EXT I32		thisexpr;	/* name id for nothing_in_common() */
-EXT char *	last_uni;	/* position of last named-unary operator */
-EXT char *	last_lop;	/* position of last list operator */
-EXT OPCODE	last_lop_op;	/* last list operator */
-EXT bool	in_my;		/* we're compiling a "my" declaration */
-EXT HV *	in_my_stash;	/* declared class of this "my" declaration */
-#ifdef FCRYPT
-EXT I32		cryptseen;	/* has fast crypt() been initialized? */
-#endif
-
-EXT U32		hints;		/* various compilation flags */
 
 				/* Note: the lowest 8 bits are reserved for
 				   stuffing into op->op_private */
@@ -1773,8 +1608,6 @@ EXT U32		hints;		/* various compilation flags */
 #define HINT_STRICT_VARS	0x00000400
 #define HINT_LOCALE		0x00000800
 
-EXT bool	do_undump;	/* -u or dump seen? */
-EXT VOL U32	debug;
 
 /***********************************************/
 /* Global only to current interpreter instance */
@@ -1784,221 +1617,47 @@ EXT VOL U32	debug;
 #define IEXT
 #define IINIT(x)
 struct interpreter {
+#include "interpvar.h"
+};
+#undef IEXT
+#undef IINIT
 #else
-#define IEXT EXT
-#define IINIT(x) INIT(x)
+struct interpreter {
+    char broiled;
+};
 #endif
 
-/* pseudo environmental stuff */
-IEXT int	Iorigargc;
-IEXT char **	Iorigargv;
-IEXT GV *	Ienvgv;
-IEXT GV *	Isiggv;
-IEXT GV *	Iincgv;
-IEXT char *	Iorigfilename;
-IEXT SV *	Idiehook;
-IEXT SV *	Iwarnhook;
-IEXT SV *	Iparsehook;
 
 /* Various states of an input record separator SV (rs, nrs) */
 #define RsSNARF(sv)   (! SvOK(sv))
 #define RsSIMPLE(sv)  (SvOK(sv) && SvCUR(sv))
 #define RsPARA(sv)    (SvOK(sv) && ! SvCUR(sv))
 
-/* switches */
-IEXT char *	Icddir;
-IEXT bool	Iminus_c;
-IEXT char	Ipatchlevel[10];
-IEXT char **	Ilocalpatches;
-IEXT SV *	Inrs;
-IEXT char *	Isplitstr IINIT(" ");
-IEXT bool	Ipreprocess;
-IEXT bool	Iminus_n;
-IEXT bool	Iminus_p;
-IEXT bool	Iminus_l;
-IEXT bool	Iminus_a;
-IEXT bool	Iminus_F;
-IEXT bool	Idoswitches;
-IEXT bool	Idowarn;
-IEXT bool	Idoextract;
-IEXT bool	Isawampersand;	/* must save all match strings */
-IEXT bool	Isawstudy;	/* do fbm_instr on all strings */
-IEXT bool	Isawvec;
-IEXT bool	Iunsafe;
-IEXT char *	Iinplace;
-IEXT char *	Ie_tmpname;
-IEXT PerlIO *	Ie_fp;
-IEXT U32	Iperldb;
-	/* This value may be raised by extensions for testing purposes */
-IEXT int	Iperl_destruct_level IINIT(0);	/* 0=none, 1=full, 2=full with checks */
-
-/* magical thingies */
-IEXT Time_t	Ibasetime;		/* $^T */
-IEXT SV *	Iformfeed;		/* $^L */
-IEXT char *	Ichopset IINIT(" \n-");	/* $: */
-IEXT SV *	Irs;			/* $/ */
-IEXT char *	Iofs;			/* $, */
-IEXT STRLEN	Iofslen;
-IEXT char *	Iors;			/* $\ */
-IEXT STRLEN	Iorslen;
-IEXT char *	Iofmt;			/* $# */
-IEXT I32	Imaxsysfd IINIT(MAXSYSFD); /* top fd to pass to subprocesses */
-IEXT int	Imultiline;		/* $*--do strings hold >1 line? */
-IEXT I32	Istatusvalue;		/* $? */
-#ifdef VMS
-IEXT U32	Istatusvalue_vms;
-#endif
-
-IEXT struct stat Istatcache;		/* _ */
-IEXT GV *	Istatgv;
-IEXT SV *	Istatname IINIT(Nullsv);
-
-/* shortcuts to various I/O objects */
-IEXT GV *	Istdingv;
-IEXT GV *	Ilast_in_gv;
-IEXT GV *	Idefgv;
-IEXT GV *	Iargvgv;
-IEXT GV *	Idefoutgv;
-IEXT GV *	Iargvoutgv;
-
-/* shortcuts to regexp stuff */
-IEXT GV *	Ileftgv;
-IEXT GV *	Iampergv;
-IEXT GV *	Irightgv;
-IEXT PMOP *	Icurpm;		/* what to do \ interps from */
-IEXT I32 *	Iscreamfirst;
-IEXT I32 *	Iscreamnext;
-IEXT I32	Imaxscream IINIT(-1);
-IEXT SV *	Ilastscream;
-
-/* shortcuts to misc objects */
-IEXT GV *	Ierrgv;
-
-/* shortcuts to debugging objects */
-IEXT GV *	IDBgv;
-IEXT GV *	IDBline;
-IEXT GV *	IDBsub;
-IEXT SV *	IDBsingle;
-IEXT SV *	IDBtrace;
-IEXT SV *	IDBsignal;
-IEXT AV *	Ilineary;	/* lines of script for debugger */
-IEXT AV *	Idbargs;	/* args to call listed by caller function */
-
-/* symbol tables */
-IEXT HV *	Idefstash;	/* main symbol table */
-IEXT HV *	Icurstash;	/* symbol table for current package */
-IEXT HV *	Idebstash;	/* symbol table for perldb package */
-IEXT HV *	Iglobalstash;	/* global keyword overrides imported here */
-IEXT SV *	Icurstname;	/* name of current package */
-IEXT AV *	Ibeginav;	/* names of BEGIN subroutines */
-IEXT AV *	Iendav;		/* names of END subroutines */
-IEXT AV *	Iinitav;	/* names of INIT subroutines */
-IEXT HV *	Istrtab;	/* shared string table */
-
-/* memory management */
-IEXT SV **	Itmps_stack;
-IEXT I32	Itmps_ix IINIT(-1);
-IEXT I32	Itmps_floor IINIT(-1);
-IEXT I32	Itmps_max;
-IEXT I32	Isv_count;	/* how many SV* are currently allocated */
-IEXT I32	Isv_objcount;	/* how many objects are currently allocated */
-IEXT SV*	Isv_root;	/* storage for SVs belonging to interp */
-IEXT SV*	Isv_arenaroot;	/* list of areas for garbage collection */
-
-/* funky return mechanisms */
-IEXT I32	Ilastspbase;
-IEXT I32	Ilastsize;
-IEXT int	Iforkprocess;	/* so do_open |- can return proc# */
-
-/* subprocess state */
-IEXT AV *	Ifdpid;		/* keep fd-to-pid mappings for my_popen */
-
-/* internal state */
-IEXT VOL int	Iin_eval;	/* trap "fatal" errors? */
-IEXT OP *	Irestartop;	/* Are we propagating an error from croak? */
-IEXT int	Idelaymagic;	/* ($<,$>) = ... */
-IEXT bool	Idirty;		/* In the middle of tearing things down? */
-IEXT U8		Ilocalizing;	/* are we processing a local() list? */
-IEXT bool	Itainted;	/* using variables controlled by $< */
-IEXT bool	Itainting;	/* doing taint checks */
-IEXT char *	Iop_mask IINIT(NULL);	/* masked operations for safe evals */
-
-/* trace state */
-IEXT I32	Idlevel;
-IEXT I32	Idlmax IINIT(128);
-IEXT char *	Idebname;
-IEXT char *	Idebdelim;
-
-/* current interpreter roots */
-IEXT CV *	Imain_cv;
-IEXT OP *	Imain_root;
-IEXT OP *	Imain_start;
-IEXT OP *	Ieval_root;
-IEXT OP *	Ieval_start;
-
-/* runtime control stuff */
-IEXT COP * VOL	Icurcop IINIT(&compiling);
-IEXT COP *	Icurcopdb IINIT(NULL);
-IEXT line_t	Icopline IINIT(NOLINE);
-IEXT PERL_CONTEXT *	Icxstack;
-IEXT I32	Icxstack_ix IINIT(-1);
-IEXT I32	Icxstack_max IINIT(128);
-IEXT JMPENV 	Istart_env;	/* empty startup sigjmp() environment */
-IEXT JMPENV *	Itop_env;	/* ptr. to current sigjmp() environment */
-
-/* stack stuff */
-IEXT AV *	Icurstack;		/* THE STACK */
-IEXT AV *	Imainstack;	/* the stack when nothing funny is happening */
-
-/* format accumulators */
-IEXT SV *	Iformtarget;
-IEXT SV *	Ibodytarget;
-IEXT SV *	Itoptarget;
-
-/* statics moved here for shared library purposes */
-IEXT SV		Istrchop;	/* return value from chop */
-IEXT int	Ifilemode;	/* so nextargv() can preserve mode */
-IEXT int	Ilastfd;	/* what to preserve mode on */
-IEXT char *	Ioldname;	/* what to preserve mode on */
-IEXT char **	IArgv;		/* stuff to free from do_aexec, vfork safe */
-IEXT char *	ICmd;		/* stuff to free from do_aexec, vfork safe */
-IEXT OP *	Isortcop;	/* user defined sort routine */
-IEXT HV *	Isortstash;	/* which is in some package or other */
-IEXT GV *	Ifirstgv;	/* $a */
-IEXT GV *	Isecondgv;	/* $b */
-IEXT AV *	Isortstack;	/* temp stack during pp_sort() */
-IEXT AV *	Isignalstack;	/* temp stack during sighandler() */
-IEXT SV *	Imystrk;	/* temp key string for do_each() */
-IEXT I32	Idumplvl;	/* indentation level on syntax tree dump */
-IEXT PMOP *	Ioldlastpm;	/* for saving regexp context during debugger */
-IEXT I32	Igensym;	/* next symbol for getsym() to define */
-IEXT bool	Ipreambled;
-IEXT AV *	Ipreambleav;
-IEXT int	Ilaststatval IINIT(-1);
-IEXT I32	Ilaststype IINIT(OP_STAT);
-IEXT SV *	Imess_sv;
-
-#ifdef USE_THREADS
-/* threads stuff */
-IEXT SV *	Ithrsv;		/* holds struct perl_thread for main thread */
-#endif /* USE_THREADS */
+/* perlvars needs to be before thread.h until we sort out
+   thread.h's #define stuff
+ */
+#define PERLVAR(var,type) EXT type var;
+#define PERLVARI(var,type,init) EXT type var INIT(init);
+#include "perlvars.h"
+#undef PERLVAR
+#undef PERLVARI
 
-#undef IEXT
-#undef IINIT
+typedef struct perl_thread *Thread;
+#include "thread.h"
 
-#ifdef MULTIPLICITY
-};
-#else
-struct interpreter {
-    char broiled;
+#ifdef USE_THREADS
+struct perl_thread {
+#define PERLVAR(var,type) type var;
+#include "thrdvar.h"
+#undef PERLVAR
 };
 #endif
 
-#include "thread.h"
 #include "pp.h"
 
 START_EXTERN_C
 #include "proto.h"
+END_EXTERN_C
 
 #ifdef EMBED
 #define Perl_sv_setptrobj(rv,ptr,name) Perl_sv_setref_iv(rv,name,(IV)ptr)
@@ -2008,8 +1667,6 @@ START_EXTERN_C
 #define sv_setptrref(rv,ptr) sv_setref_iv(rv,Nullch,(IV)ptr)
 #endif
 
-END_EXTERN_C
-
 /* The following must follow proto.h */
 
 #if defined(HASATTRIBUTE) && defined(WIN32)
@@ -2022,18 +1679,6 @@ END_EXTERN_C
 #  include <win32iop.h>
 #endif	/* WIN32 */
 
-
-#if defined(HASATTRIBUTE) && defined(WIN32)
-/*
- * This provides a layer of functions and macros to ensure extensions will
- * get to use the same RTL functions as the core.
- * It has to go here or #define of printf messes up __attribute__
- * stuff in proto.h  
- */
-#  include <win32iop.h>
-#endif	/* WIN32 */
-
-
 #ifdef DOINIT
 
 EXT MGVTBL vtbl_sv =	{magic_get,
@@ -2155,8 +1800,6 @@ EXT MGVTBL vtbl_amagicelem;
 
 #ifdef OVERLOAD
 
-EXT long amagic_generation;
-
 #define NofAMmeth 58
 #ifdef DOINIT
 EXTCONST char * AMG_names[NofAMmeth] = {
@@ -2299,20 +1942,9 @@ enum {
 #define PERLDB_SUBLINE	(perldb && (perldb & PERLDBf_SUBLINE))
 #define PERLDB_SINGLE	(perldb && (perldb & PERLDBf_SINGLE))
 
-#ifdef USE_LOCALE_COLLATE
-EXT U32		collation_ix;		/* Collation generation index */
-EXT char *	collation_name;		/* Name of current collation */
-EXT bool	collation_standard INIT(TRUE); /* Assume simple collation */
-EXT Size_t	collxfrm_base;		/* Basic overhead in *xfrm() */
-EXT Size_t	collxfrm_mult INIT(2);	/* Expansion factor in *xfrm() */
-#endif /* USE_LOCALE_COLLATE */
 
 #ifdef USE_LOCALE_NUMERIC
 
-EXT char *	numeric_name;		/* Name of current numeric locale */
-EXT bool	numeric_standard INIT(TRUE); /* Assume simple numerics */
-EXT bool	numeric_local INIT(TRUE);    /* Assume local numerics */
-
 #define SET_NUMERIC_STANDARD() \
     STMT_START {				\
 	if (! numeric_standard)			\
@@ -2344,10 +1976,6 @@ EXT bool	numeric_local INIT(TRUE);    /* Assume local numerics */
 #define PERL_SCRIPT_MODE "r"
 #endif
 
-#ifndef PERL_SCRIPT_MODE
-#define PERL_SCRIPT_MODE "r"
-#endif
-
 /*
  * nice_chunk and nice_chunk size need to be set
  * and queried under the protection of sv_mutex
@@ -2361,5 +1989,6 @@ EXT bool	numeric_local INIT(TRUE);    /* Assume local numerics */
 	MUTEX_UNLOCK(&sv_mutex);			\
     } while (0)
 
+
 #endif /* Include guard */
 
diff --git a/perlvars.h b/perlvars.h
new file mode 100644
index 0000000000..97b199f5b3
--- /dev/null
+++ b/perlvars.h
@@ -0,0 +1,206 @@
+/* This file describes the "global" variables used by perl  */
+/* This used to be in perl.h directly but we want to        */
+/* abstract out which are per-thread per-interpreter really */
+/* global and how initialized into one file                 */
+
+/****************/
+/* Truly global */
+/****************/
+
+/* global state */
+PERLVAR(curinterp,	PerlInterpreter *)		/* currently running interpreter */
+#ifdef USE_THREADS
+PERLVAR(thr_key,	perl_key)		/* For per-thread struct perl_thread* */
+PERLVAR(sv_mutex,	perl_mutex)		/* Mutex for allocating SVs in sv.c */
+PERLVAR(malloc_mutex,	perl_mutex)		/* Mutex for malloc */
+PERLVAR(eval_mutex,	perl_mutex)		/* Mutex for doeval */
+PERLVAR(eval_cond,	perl_cond)		/* Condition variable for doeval */
+PERLVAR(eval_owner,	struct perl_thread *)		/* Owner thread for doeval */
+PERLVAR(nthreads,	int)		/* Number of threads currently */
+PERLVAR(threads_mutex,	perl_mutex)		/* Mutex for nthreads and thread list */
+PERLVAR(nthreads_cond,	perl_cond)		/* Condition variable for nthreads */
+PERLVARI(threadsv_names,	char *,	THREADSV_NAMES)	
+#ifdef FAKE_THREADS
+PERLVAR(thr,	struct perl_thread *)		/* Currently executing (fake) thread */
+#endif
+#endif /* USE_THREADS */
+
+PERLVAR(uid,	int)		/* current real user id */
+PERLVAR(euid,	int)		/* current effective user id */
+PERLVAR(gid,	int)		/* current real group id */
+PERLVAR(egid,	int)		/* current effective group id */
+PERLVAR(nomemok,	bool)		/* let malloc context handle nomem */
+PERLVAR(an,	U32)		/* malloc sequence number */
+PERLVAR(cop_seqmax,	U32)		/* statement sequence number */
+PERLVAR(op_seqmax,	U16)		/* op sequence number */
+PERLVAR(evalseq,	U32)		/* eval sequence number */
+PERLVAR(sub_generation,	U32)		/* inc to force methods to be looked up again */
+PERLVAR(origenviron,	char **)		
+PERLVAR(origalen,	U32)		
+PERLVAR(pidstatus,	HV *)		/* pid-to-status mappings for waitpid */
+PERLVAR(profiledata,	U32 *)		
+PERLVARI(maxo,	int,	MAXO)	/* Number of ops */
+PERLVAR(osname,	char *)		/* operating system */
+PERLVARI(sh_path,	char *,	SH_PATH)	/* full path of shell */
+PERLVAR(sighandlerp,	Sighandler_t)		
+
+PERLVAR(xiv_arenaroot,	XPV*)		/* list of allocated xiv areas */
+PERLVAR(xiv_root,	IV **)		/* free xiv list--shared by interpreters */
+PERLVAR(xnv_root,	double *)		/* free xnv list--shared by interpreters */
+PERLVAR(xrv_root,	XRV *)		/* free xrv list--shared by interpreters */
+PERLVAR(xpv_root,	XPV *)		/* free xpv list--shared by interpreters */
+PERLVAR(he_root,	HE *)		/* free he list--shared by interpreters */
+PERLVAR(nice_chunk,	char *)		/* a nice chunk of memory to reuse */
+PERLVAR(nice_chunk_size,	U32)		/* how nice the chunk of memory is */
+
+/* Stack for currently executing thread--context switch must handle this.     */
+PERLVAR(stack_base,	SV **)		/* stack->array_ary */
+PERLVAR(stack_sp,	SV **)		/* stack pointer now */
+PERLVAR(stack_max,	SV **)		/* stack->array_ary + stack->array_max */
+
+/* likewise for these */
+
+#ifdef OP_IN_REGISTER
+PERLVAR(opsave,	OP *)		/* save current op register across longjmps */
+#else
+PERLVAR(op,	OP *)		/* current op--when not in a global register */
+#endif
+PERLVARI(runops,	runops_proc_t *,	RUNOPS_DEFAULT)	
+PERLVAR(scopestack,	I32 *)		/* blocks we've entered */
+PERLVAR(scopestack_ix,	I32)		
+PERLVAR(scopestack_max,	I32)		
+
+PERLVAR(savestack,	ANY*)		/* to save non-local values on */
+PERLVAR(savestack_ix,	I32)		
+PERLVAR(savestack_max,	I32)		
+
+PERLVAR(retstack,	OP **)		/* returns we've pushed */
+PERLVAR(retstack_ix,	I32)		
+PERLVAR(retstack_max,	I32)		
+
+PERLVAR(markstack,	I32 *)		/* stackmarks we're remembering */
+PERLVAR(markstack_ptr,	I32 *)		/* stackmarks we're remembering */
+PERLVAR(markstack_max,	I32 *)		/* stackmarks we're remembering */
+
+PERLVAR(curpad,	SV **)		
+
+/* temp space */
+PERLVAR(Sv,	SV *)		
+PERLVAR(Xpv,	XPV *)		
+PERLVAR(tokenbuf[256],	char)		
+PERLVAR(statbuf,	struct stat)		
+#ifdef HAS_TIMES
+PERLVAR(timesbuf,	struct tms)		
+#endif
+#if defined(WIN32) && defined(__GNUC__)
+PERLVAR(na,	static STRLEN)		
+#else
+PERLVAR(na,	STRLEN)		/* for use in SvPV when length is Not Applicable */
+#endif
+
+PERLVAR(sv_undef,	SV)		
+PERLVAR(sv_no,	SV)		
+PERLVAR(sv_yes,	SV)		
+#ifdef CSH
+PERLVARI(cshname,	char *,	CSH)	
+PERLVAR(cshlen,	I32)		
+#endif
+
+PERLVAR(lex_state,	U32)		/* next token is determined */
+PERLVAR(lex_defer,	U32)		/* state after determined token */
+PERLVAR(lex_expect,	expectation)		/* expect after determined token */
+PERLVAR(lex_brackets,	I32)		/* bracket count */
+PERLVAR(lex_formbrack,	I32)		/* bracket count at outer format level */
+PERLVAR(lex_fakebrack,	I32)		/* outer bracket is mere delimiter */
+PERLVAR(lex_casemods,	I32)		/* casemod count */
+PERLVAR(lex_dojoin,	I32)		/* doing an array interpolation */
+PERLVAR(lex_starts,	I32)		/* how many interps done on level */
+PERLVAR(lex_stuff,	SV *)		/* runtime pattern from m// or s/// */
+PERLVAR(lex_repl,	SV *)		/* runtime replacement from s/// */
+PERLVAR(lex_op,	OP *)		/* extra info to pass back on op */
+PERLVAR(lex_inpat,	OP *)		/* in pattern $) and $| are special */
+PERLVAR(lex_inwhat,	I32)		/* what kind of quoting are we in */
+PERLVAR(lex_brackstack,	char *)		/* what kind of brackets to pop */
+PERLVAR(lex_casestack,	char *)		/* what kind of case mods in effect */
+
+/* What we know when we're in LEX_KNOWNEXT state. */
+PERLVAR(nextval[5],	YYSTYPE)		/* value of next token, if any */
+PERLVAR(nexttype[5],	I32)		/* type of next token */
+PERLVAR(nexttoke,	I32)		
+
+PERLVARI(rsfp,	PerlIO * VOL,	Nullfp)	
+PERLVAR(linestr,	SV *)		
+PERLVAR(bufptr,	char *)		
+PERLVAR(oldbufptr,	char *)		
+PERLVAR(oldoldbufptr,	char *)		
+PERLVAR(bufend,	char *)		
+PERLVARI(expect,	expectation,	XSTATE)	/* how to interpret ambiguous tokens */
+PERLVAR(rsfp_filters,	AV *)		
+
+PERLVAR(multi_start,	I32)		/* 1st line of multi-line string */
+PERLVAR(multi_end,	I32)		/* last line of multi-line string */
+PERLVAR(multi_open,	I32)		/* delimiter of said string */
+PERLVAR(multi_close,	I32)		/* delimiter of said string */
+
+PERLVAR(scrgv,	GV *)		
+PERLVAR(error_count,	I32)		/* how many errors so far, max 10 */
+PERLVAR(subline,	I32)		/* line this subroutine began on */
+PERLVAR(subname,	SV *)		/* name of current subroutine */
+
+PERLVAR(compcv,	CV *)		/* currently compiling subroutine */
+PERLVAR(comppad,	AV *)		/* storage for lexically scoped temporaries */
+PERLVAR(comppad_name,	AV *)		/* variable names for "my" variables */
+PERLVAR(comppad_name_fill,	I32)		/* last "introduced" variable offset */
+PERLVAR(comppad_name_floor,	I32)		/* start of vars in innermost block */
+PERLVAR(min_intro_pending,	I32)		/* start of vars to introduce */
+PERLVAR(max_intro_pending,	I32)		/* end of vars to introduce */
+PERLVAR(padix,	I32)		/* max used index in current "register" pad */
+PERLVAR(padix_floor,	I32)		/* how low may inner block reset padix */
+PERLVAR(pad_reset_pending,	I32)		/* reset pad on next attempted alloc */
+PERLVAR(compiling,	COP)		
+
+PERLVAR(thisexpr,	I32)		/* name id for nothing_in_common() */
+PERLVAR(last_uni,	char *)		/* position of last named-unary operator */
+PERLVAR(last_lop,	char *)		/* position of last list operator */
+PERLVAR(last_lop_op,	OPCODE)		/* last list operator */
+PERLVAR(in_my,	bool)		/* we're compiling a "my" declaration */
+PERLVAR(in_my_stash,	HV *)		/* declared class of this "my" declaration */
+#ifdef FCRYPT
+PERLVAR(cryptseen,	I32)		/* has fast crypt() been initialized? */
+#endif
+
+PERLVAR(hints,	U32)		/* various compilation flags */
+
+PERLVAR(do_undump,	bool)		/* -u or dump seen? */
+PERLVAR(debug,	VOL U32)		
+
+
+#ifdef OVERLOAD
+
+PERLVAR(amagic_generation,	long)		
+
+#endif
+
+#ifdef USE_LOCALE_COLLATE
+PERLVAR(collation_ix,	U32)		/* Collation generation index */
+PERLVAR(collation_name,	char *)		/* Name of current collation */
+PERLVARI(collation_standard,	bool,	TRUE)	/* Assume simple collation */
+PERLVAR(collxfrm_base,	Size_t)		/* Basic overhead in *xfrm() */
+PERLVARI(collxfrm_mult,	Size_t,	2)	/* Expansion factor in *xfrm() */
+#endif /* USE_LOCALE_COLLATE */
+
+#ifdef USE_LOCALE_NUMERIC
+
+PERLVAR(numeric_name,	char *)		/* Name of current numeric locale */
+PERLVARI(numeric_standard,	bool,	TRUE)	/* Assume simple numerics */
+PERLVARI(numeric_local,	bool,	TRUE)	/* Assume local numerics */
+
+#endif /* !USE_LOCALE_NUMERIC */
+
+#ifndef MULTIPLICITY
+#define IEXT EXT
+#define IINIT(x) INIT(x)
+#include "intrpvar.h"
+#undef IEXT
+#undef IINIT
+#endif
\ No newline at end of file
diff --git a/thrdvar.h b/thrdvar.h
new file mode 100644
index 0000000000..8f61950416
--- /dev/null
+++ b/thrdvar.h
@@ -0,0 +1,101 @@
+/* Per-thread variables */
+/* Important ones in the first cache line (if alignment is done right) */
+PERLVAR(Tstack_sp,	SV **)		
+#ifdef OP_IN_REGISTER
+PERLVAR(Topsave,	OP *)		
+#else
+PERLVAR(Top,		OP *)		
+#endif
+PERLVAR(Tcurpad,	SV **)		
+PERLVAR(Tstack_base,	SV **)		
+
+PERLVAR(Tstack_max,	SV **)		
+
+PERLVAR(Tscopestack,	I32 *)		
+PERLVAR(Tscopestack_ix,	I32)		
+PERLVAR(Tscopestack_max,I32)		
+
+PERLVAR(Tsavestack,	ANY *)		
+PERLVAR(Tsavestack_ix,	I32)		
+PERLVAR(Tsavestack_max,	I32)		
+
+PERLVAR(Tretstack,	OP **)		
+PERLVAR(Tretstack_ix,	I32)		
+PERLVAR(Tretstack_max,	I32)		
+
+PERLVAR(Tmarkstack,	I32 *)		
+PERLVAR(Tmarkstack_ptr,	I32 *)		
+PERLVAR(Tmarkstack_max,	I32 *)		
+
+PERLVAR(TSv,	SV *)		
+PERLVAR(TXpv,	XPV *)		
+PERLVAR(Tstatbuf,	struct stat)		
+#ifdef HAS_TIMES
+PERLVAR(Ttimesbuf,	struct tms)		
+#endif
+    
+/* XXX What about regexp stuff? */
+
+/* Now the fields that used to be "per interpreter" (even when global) */
+
+/* Fields used by magic variables such as $@, $/ and so on */
+PERLVAR(Ttainted,	bool)		
+PERLVAR(Tcurpm,		PMOP *)		
+PERLVAR(Tnrs,		SV *)		
+PERLVAR(Trs,		SV *)		
+PERLVAR(Tlast_in_gv,	GV *)		
+PERLVAR(Tofs,		char *)		
+PERLVAR(Tofslen,	STRLEN)		
+PERLVAR(Tdefoutgv,	GV *)		
+PERLVAR(Tchopset,	char *)		
+PERLVAR(Tformtarget,	SV *)		
+PERLVAR(Tbodytarget,	SV *)		
+PERLVAR(Ttoptarget,	SV *)		
+
+    /* Stashes */
+PERLVAR(Tdefstash,	HV *)		
+PERLVAR(Tcurstash,	HV *)		
+
+    /* Stacks */
+PERLVAR(Ttmps_stack,	SV **)		
+PERLVAR(Ttmps_ix,	I32)		
+PERLVAR(Ttmps_floor,	I32)		
+PERLVAR(Ttmps_max,	I32)		
+
+PERLVAR(Tin_eval,	int)		
+PERLVAR(Trestartop,	OP *)		
+PERLVAR(Tdelaymagic,	int)		
+PERLVAR(Tdirty,		bool)		
+PERLVAR(Tlocalizing,	U8)		
+PERLVAR(Tcurcop,	COP *)		
+
+PERLVAR(Tcxstack,	PERL_CONTEXT *)		
+PERLVAR(Tcxstack_ix,	I32)		
+PERLVAR(Tcxstack_max,	I32)		
+
+PERLVAR(Tcurstack,	AV *)		
+PERLVAR(Tmainstack,	AV *)		
+PERLVAR(Ttop_env,	JMPENV *)		
+PERLVAR(Tstart_env,	JMPENV)			/* Top of top_env longjmp() chain */
+
+/* XXX Sort stuff, firstgv secongv and so on? */
+
+PERLVAR(oursv,		SV *)		
+PERLVAR(cvcache,	HV *)		
+PERLVAR(self,		perl_os_thread)		/* Underlying thread object */
+PERLVAR(flags,		U32)		
+PERLVAR(threadsv,	AV *)			/* Per-thread SVs ($_, $@ etc.) */
+PERLVAR(specific,	AV *)			/* Thread-specific user data */
+PERLVAR(errsv,		SV *)			/* Backing SV for $@ */
+PERLVAR(errhv,		HV *)			/* HV for what was %@ in pp_ctl.c */
+PERLVAR(mutex,		perl_mutex)		/* For the fields others can change */
+PERLVAR(tid,		U32)		
+PERLVAR(prev,		struct perl_thread *)
+PERLVAR(next,		struct perl_thread *)	/* Circular linked list of threads */
+
+#ifdef HAVE_THREAD_INTERN
+PERLVAR(i,		struct thread_intern)	/* Platform-dependent internals */
+#endif
+
+PERLVAR(trailing_nul,	char)			/* For the sake of thrsv and oursv */
+
diff --git a/thread.h b/thread.h
index e29f8add21..7e98c1d6e3 100644
--- a/thread.h
+++ b/thread.h
@@ -138,107 +138,6 @@ struct perl_thread *getTHR _((void));
 #  define THREAD_RET_CAST(p)	((void *)(p))
 #endif /* THREAD_RET */
 
-struct perl_thread {
-    /* The fields that used to be global */
-    /* Important ones in the first cache line (if alignment is done right) */
-    SV **	Tstack_sp;
-#ifdef OP_IN_REGISTER
-    OP *	Topsave;
-#else
-    OP *	Top;
-#endif
-    SV **	Tcurpad;
-    SV **	Tstack_base;
-
-    SV **	Tstack_max;
-
-    I32 *	Tscopestack;
-    I32		Tscopestack_ix;
-    I32		Tscopestack_max;
-
-    ANY *	Tsavestack;
-    I32		Tsavestack_ix;
-    I32		Tsavestack_max;
-
-    OP **	Tretstack;
-    I32		Tretstack_ix;
-    I32		Tretstack_max;
-
-    I32 *	Tmarkstack;
-    I32 *	Tmarkstack_ptr;
-    I32 *	Tmarkstack_max;
-
-    SV *	TSv;
-    XPV *	TXpv;
-    struct stat	Tstatbuf;
-#ifdef HAS_TIMES
-    struct tms	Ttimesbuf;
-#endif
-    
-    /* XXX What about regexp stuff? */
-
-    /* Now the fields that used to be "per interpreter" (even when global) */
-
-    /* Fields used by magic variables such as $@, $/ and so on */
-    bool	Ttainted;
-    PMOP *	Tcurpm;
-    SV *	Tnrs;
-    SV *	Trs;
-    GV *	Tlast_in_gv;
-    char *	Tofs;
-    STRLEN	Tofslen;
-    GV *	Tdefoutgv;
-    char *	Tchopset;
-    SV *	Tformtarget;
-    SV *	Tbodytarget;
-    SV *	Ttoptarget;
-
-    /* Stashes */
-    HV *	Tdefstash;
-    HV *	Tcurstash;
-
-    /* Stacks */
-    SV **	Ttmps_stack;
-    I32		Ttmps_ix;
-    I32		Ttmps_floor;
-    I32		Ttmps_max;
-
-    int		Tin_eval;
-    OP *	Trestartop;
-    int		Tdelaymagic;
-    bool	Tdirty;
-    U8		Tlocalizing;
-    COP *	Tcurcop;
-
-    PERL_CONTEXT *	Tcxstack;
-    I32		Tcxstack_ix;
-    I32		Tcxstack_max;
-
-    AV *	Tcurstack;
-    AV *	Tmainstack;
-    JMPENV *	Ttop_env;
-
-    /* XXX Sort stuff, firstgv, secongv and so on? */
-
-    SV *	oursv;
-    HV *	cvcache;
-    perl_os_thread	self;		/* Underlying thread object */
-    U32		flags;
-    AV *	threadsv;		/* Per-thread SVs ($_, $@ etc.) */
-    AV *	specific;		/* Thread-specific user data */
-    SV *	errsv;			/* Backing SV for $@ */
-    HV *	errhv;			/* HV for what was %@ in pp_ctl.c */
-    perl_mutex	mutex;			/* For the fields others can change */
-    U32		tid;
-    struct perl_thread *next, *prev;		/* Circular linked list of threads */
-    JMPENV	Tstart_env;	        /* Top of top_env longjmp() chain */ 
-#ifdef HAVE_THREAD_INTERN
-    struct thread_intern i;		/* Platform-dependent internals */
-#endif
-    char	trailing_nul;		/* For the sake of thrsv and oursv */
-};
-
-typedef struct perl_thread *Thread;
 
 /* Values and macros for thr->flags */
 #define THRf_STATE_MASK	7
diff --git a/win32/Makefile b/win32/Makefile
index b50c51e826..1505b140a9 100644
--- a/win32/Makefile
+++ b/win32/Makefile
@@ -241,6 +241,8 @@ CORE_H = ..\av.h	\
 	..\XSUB.h	\
 	.\config.h	\
 	..\EXTERN.h	\
+	..\perlvars.h	\
+	..\intrpvar.h	\
 	.\include\dirent.h	\
 	.\include\netdb.h	\
 	.\include\sys\socket.h	\