This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Globals and structs via macros - part 1 of N
authorNick Ing-Simmons <nik@tiuk.ti.com>
Sat, 29 Nov 1997 23:55:31 +0000 (23:55 +0000)
committerNick Ing-Simmons <nik@tiuk.ti.com>
Sat, 29 Nov 1997 23:55:31 +0000 (23:55 +0000)
- 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

intrpvar.h [new file with mode: 0644]
perl.h
perlvars.h [new file with mode: 0644]
thrdvar.h [new file with mode: 0644]
thread.h
win32/Makefile

diff --git a/intrpvar.h b/intrpvar.h
new file mode 100644 (file)
index 0000000..0393b8f
--- /dev/null
@@ -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 92f30be..7761786 100644 (file)
--- 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 (file)
index 0000000..97b199f
--- /dev/null
@@ -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 (file)
index 0000000..8f61950
--- /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 */
+
index e29f8ad..7e98c1d 100644 (file)
--- 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
index b50c51e..1505b14 100644 (file)
@@ -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  \