From: Nick Ing-Simmons Date: Sat, 29 Nov 1997 23:55:31 +0000 (+0000) Subject: Globals and structs via macros - part 1 of N X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=commitdiff_plain;h=49f531dad558d800dbb0a247178a2e50ad834fae;p=p5sagit%2Fp5-mst-13.2.git 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 --- diff --git a/intrpvar.h b/intrpvar.h new file mode 100644 index 0000000..0393b8f --- /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 92f30be..7761786 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 #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 -#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 0000000..97b199f5 --- /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 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 */ + diff --git a/thread.h b/thread.h index e29f8ad..7e98c1d 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 b50c51e..1505b14 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 \