home *** CD-ROM | disk | FTP | other *** search
/ PC World 2005 June / PCWorld_2005-06_cd.bin / software / vyzkuste / firewally / firewally.exe / framework-2.3.exe / intrpvar.h < prev    next >
C/C++ Source or Header  |  2003-11-07  |  20KB  |  574 lines
  1. /***********************************************/
  2. /* Global only to current interpreter instance */
  3. /***********************************************/
  4.  
  5. /* Don't forget to re-run embed.pl to propagate changes! */
  6.  
  7. /* New variables must be added to the very end for binary compatibility.
  8.  * XSUB.h provides wrapper functions via perlapi.h that make this
  9.  * irrelevant, but not all code may be expected to #include XSUB.h. */
  10.  
  11. /* Don't forget to add your variable also to perl_clone()! */
  12.  
  13. /* The 'I' prefix is only needed for vars that need appropriate #defines
  14.  * generated when built with or without MULTIPLICITY.  It is also used
  15.  * to generate the appropriate export list for win32.
  16.  *
  17.  * When building without MULTIPLICITY, these variables will be truly global. */
  18.  
  19. /* pseudo environmental stuff */
  20. PERLVAR(Iorigargc,    int)
  21. PERLVAR(Iorigargv,    char **)
  22. PERLVAR(Ienvgv,        GV *)
  23. PERLVAR(Iincgv,        GV *)
  24. PERLVAR(Ihintgv,    GV *)
  25. PERLVAR(Iorigfilename,    char *)
  26. PERLVAR(Idiehook,    SV *)
  27. PERLVAR(Iwarnhook,    SV *)
  28.  
  29. /* switches */
  30. PERLVAR(Iminus_c,    bool)
  31. PERLVAR(Ipatchlevel,    SV *)
  32. PERLVAR(Ilocalpatches,    char **)
  33. PERLVARI(Isplitstr,    char *,    " ")
  34. PERLVAR(Ipreprocess,    bool)
  35. PERLVAR(Iminus_n,    bool)
  36. PERLVAR(Iminus_p,    bool)
  37. PERLVAR(Iminus_l,    bool)
  38. PERLVAR(Iminus_a,    bool)
  39. PERLVAR(Iminus_F,    bool)
  40. PERLVAR(Idoswitches,    bool)
  41.  
  42. /*
  43. =head1 Global Variables
  44.  
  45. =for apidoc mn|bool|PL_dowarn
  46.  
  47. The C variable which corresponds to Perl's $^W warning variable.
  48.  
  49. =cut
  50. */
  51.  
  52. PERLVAR(Idowarn,    U8)
  53. PERLVAR(Iwidesyscalls,    bool)        /* unused since 5.8.1 */
  54. PERLVAR(Idoextract,    bool)
  55. PERLVAR(Isawampersand,    bool)        /* must save all match strings */
  56. PERLVAR(Iunsafe,    bool)
  57. PERLVAR(Iinplace,    char *)
  58. PERLVAR(Ie_script,    SV *)
  59. PERLVAR(Iperldb,    U32)
  60.  
  61. /* This value may be set when embedding for full cleanup  */
  62. /* 0=none, 1=full, 2=full with checks */
  63. PERLVARI(Iperl_destruct_level,    int,    0)
  64.  
  65. /* magical thingies */
  66. PERLVAR(Ibasetime,    Time_t)        /* $^T */
  67. PERLVAR(Iformfeed,    SV *)        /* $^L */
  68.  
  69.  
  70. PERLVARI(Imaxsysfd,    I32,    MAXSYSFD)
  71.                     /* top fd to pass to subprocesses */
  72. PERLVAR(Imultiline,    int)        /* $*--do strings hold >1 line? */
  73. PERLVAR(Istatusvalue,    I32)        /* $? */
  74. PERLVAR(Iexit_flags,    U8)        /* was exit() unexpected, etc. */
  75. #ifdef VMS
  76. PERLVAR(Istatusvalue_vms,U32)
  77. #endif
  78.  
  79. /* shortcuts to various I/O objects */
  80. PERLVAR(Istdingv,    GV *)
  81. PERLVAR(Istderrgv,    GV *)
  82. PERLVAR(Idefgv,        GV *)
  83. PERLVAR(Iargvgv,    GV *)
  84. PERLVAR(Iargvoutgv,    GV *)
  85. PERLVAR(Iargvout_stack,    AV *)
  86.  
  87. /* shortcuts to regexp stuff */
  88. /* this one needs to be moved to thrdvar.h and accessed via
  89.  * find_threadsv() when USE_5005THREADS */
  90. PERLVAR(Ireplgv,    GV *)
  91.  
  92. /* shortcuts to misc objects */
  93. PERLVAR(Ierrgv,        GV *)
  94.  
  95. /* shortcuts to debugging objects */
  96. PERLVAR(IDBgv,        GV *)
  97. PERLVAR(IDBline,    GV *)
  98.  
  99. /*
  100. =for apidoc mn|GV *|PL_DBsub
  101. When Perl is run in debugging mode, with the B<-d> switch, this GV contains
  102. the SV which holds the name of the sub being debugged.  This is the C
  103. variable which corresponds to Perl's $DB::sub variable.  See
  104. C<PL_DBsingle>.
  105.  
  106. =for apidoc mn|SV *|PL_DBsingle
  107. When Perl is run in debugging mode, with the B<-d> switch, this SV is a
  108. boolean which indicates whether subs are being single-stepped.
  109. Single-stepping is automatically turned on after every step.  This is the C
  110. variable which corresponds to Perl's $DB::single variable.  See
  111. C<PL_DBsub>.
  112.  
  113. =for apidoc mn|SV *|PL_DBtrace
  114. Trace variable used when Perl is run in debugging mode, with the B<-d>
  115. switch.  This is the C variable which corresponds to Perl's $DB::trace
  116. variable.  See C<PL_DBsingle>.
  117.  
  118. =cut
  119. */
  120.  
  121. PERLVAR(IDBsub,        GV *)
  122. PERLVAR(IDBsingle,    SV *)
  123. PERLVAR(IDBtrace,    SV *)
  124. PERLVAR(IDBsignal,    SV *)
  125. PERLVAR(Ilineary,    AV *)        /* lines of script for debugger */
  126. PERLVAR(Idbargs,    AV *)        /* args to call listed by caller function */
  127.  
  128. /* symbol tables */
  129. PERLVAR(Idebstash,    HV *)        /* symbol table for perldb package */
  130. PERLVAR(Iglobalstash,    HV *)        /* global keyword overrides imported here */
  131. PERLVAR(Icurstname,    SV *)        /* name of current package */
  132. PERLVAR(Ibeginav,    AV *)        /* names of BEGIN subroutines */
  133. PERLVAR(Iendav,        AV *)        /* names of END subroutines */
  134. PERLVAR(Icheckav,    AV *)        /* names of CHECK subroutines */
  135. PERLVAR(Iinitav,    AV *)        /* names of INIT subroutines */
  136. PERLVAR(Istrtab,    HV *)        /* shared string table */
  137. PERLVARI(Isub_generation,U32,1)        /* incr to invalidate method cache */
  138.  
  139. /* memory management */
  140. PERLVAR(Isv_count,    I32)        /* how many SV* are currently allocated */
  141. PERLVAR(Isv_objcount,    I32)        /* how many objects are currently allocated */
  142. PERLVAR(Isv_root,    SV*)        /* storage for SVs belonging to interp */
  143. PERLVAR(Isv_arenaroot,    SV*)        /* list of areas for garbage collection */
  144.  
  145. /* funky return mechanisms */
  146. PERLVAR(Iforkprocess,    int)        /* so do_open |- can return proc# */
  147.  
  148. /* subprocess state */
  149. PERLVAR(Ifdpid,        AV *)        /* keep fd-to-pid mappings for my_popen */
  150.  
  151. /* internal state */
  152. PERLVAR(Itainting,    bool)        /* doing taint checks */
  153. PERLVARI(Iop_mask,    char *,    NULL)    /* masked operations for safe evals */
  154.  
  155. /* current interpreter roots */
  156. PERLVAR(Imain_cv,    CV *)
  157. PERLVAR(Imain_root,    OP *)
  158. PERLVAR(Imain_start,    OP *)
  159. PERLVAR(Ieval_root,    OP *)
  160. PERLVAR(Ieval_start,    OP *)
  161.  
  162. /* runtime control stuff */
  163. PERLVARI(Icurcopdb,    COP *,    NULL)
  164. PERLVARI(Icopline,    line_t,    NOLINE)
  165.  
  166. /* statics moved here for shared library purposes */
  167. PERLVAR(Ifilemode,    int)        /* so nextargv() can preserve mode */
  168. PERLVAR(Ilastfd,    int)        /* what to preserve mode on */
  169. PERLVAR(Ioldname,    char *)        /* what to preserve mode on */
  170. PERLVAR(IArgv,        char **)    /* stuff to free from do_aexec, vfork safe */
  171. PERLVAR(ICmd,        char *)        /* stuff to free from do_aexec, vfork safe */
  172. PERLVARI(Igensym,    I32,    0)    /* next symbol for getsym() to define */
  173. PERLVAR(Ipreambled,    bool)
  174. PERLVAR(Ipreambleav,    AV *)
  175. PERLVARI(Ilaststatval,    int,    -1)
  176. PERLVARI(Ilaststype,    I32,    OP_STAT)
  177. PERLVAR(Imess_sv,    SV *)
  178.  
  179. /* XXX shouldn't these be per-thread? --GSAR */
  180. PERLVAR(Iors_sv,    SV *)        /* output record separator $\ */
  181. PERLVAR(Iofmt,        char *)        /* output format for numbers $# */
  182.  
  183. /* interpreter atexit processing */
  184. PERLVARI(Iexitlist,    PerlExitListEntry *, NULL)
  185.                     /* list of exit functions */
  186. PERLVARI(Iexitlistlen,    I32, 0)        /* length of same */
  187.  
  188. /*
  189. =for apidoc Amn|HV*|PL_modglobal
  190.  
  191. C<PL_modglobal> is a general purpose, interpreter global HV for use by
  192. extensions that need to keep information on a per-interpreter basis.
  193. In a pinch, it can also be used as a symbol table for extensions
  194. to share data among each other.  It is a good idea to use keys
  195. prefixed by the package name of the extension that owns the data.
  196.  
  197. =cut
  198. */
  199.  
  200. PERLVAR(Imodglobal,    HV *)        /* per-interp module data */
  201.  
  202. /* these used to be in global before 5.004_68 */
  203. PERLVARI(Iprofiledata,    U32 *,    NULL)    /* table of ops, counts */
  204. PERLVARI(Irsfp,    PerlIO * VOL,    Nullfp) /* current source file pointer */
  205. PERLVARI(Irsfp_filters,    AV *,    Nullav)    /* keeps active source filters */
  206.  
  207. PERLVAR(Icompiling,    COP)        /* compiling/done executing marker */
  208.  
  209. PERLVAR(Icompcv,    CV *)        /* currently compiling subroutine */
  210. PERLVAR(IBINCOMPAT0,    AV *)        /* filler for binary compatibility */
  211. PERLVAR(Icomppad_name,    AV *)        /* variable names for "my" variables */
  212. PERLVAR(Icomppad_name_fill,    I32)    /* last "introduced" variable offset */
  213. PERLVAR(Icomppad_name_floor,    I32)    /* start of vars in innermost block */
  214.  
  215. #ifdef HAVE_INTERP_INTERN
  216. PERLVAR(Isys_intern,    struct interp_intern)
  217.                     /* platform internals */
  218. #endif
  219.  
  220. /* more statics moved here */
  221. PERLVARI(Igeneration,    int,    100)    /* from op.c */
  222. PERLVAR(IDBcv,        CV *)        /* from perl.c */
  223.  
  224. PERLVARI(Iin_clean_objs,bool,    FALSE)    /* from sv.c */
  225. PERLVARI(Iin_clean_all,    bool,    FALSE)    /* from sv.c */
  226.  
  227. PERLVAR(Ilinestart,    char *)        /* beg. of most recently read line */
  228. PERLVAR(Ipending_ident,    char)        /* pending identifier lookup */
  229. PERLVAR(Isublex_info,    SUBLEXINFO)    /* from toke.c */
  230.  
  231. #ifdef USE_5005THREADS
  232. PERLVAR(Ithrsv,        SV *)        /* struct perl_thread for main thread */
  233. PERLVARI(Ithreadnum,    U32,    0)    /* incremented each thread creation */
  234. PERLVAR(Istrtab_mutex,    perl_mutex)    /* Mutex for string table access */
  235. #endif /* USE_5005THREADS */
  236.  
  237. PERLVAR(Iuid,        Uid_t)        /* current real user id */
  238. PERLVAR(Ieuid,        Uid_t)        /* current effective user id */
  239. PERLVAR(Igid,        Gid_t)        /* current real group id */
  240. PERLVAR(Iegid,        Gid_t)        /* current effective group id */
  241. PERLVAR(Inomemok,    bool)        /* let malloc context handle nomem */
  242. PERLVARI(Ian,        U32,    0)    /* malloc sequence number */
  243. PERLVARI(Icop_seqmax,    U32,    0)    /* statement sequence number */
  244. PERLVARI(Iop_seqmax,    U16,    0)    /* op sequence number */
  245. PERLVARI(Ievalseq,    U32,    0)    /* eval sequence number */
  246. PERLVAR(Iorigenviron,    char **)
  247. PERLVAR(Iorigalen,    U32)
  248. PERLVAR(Ipidstatus,    HV *)        /* pid-to-status mappings for waitpid */
  249. PERLVARI(Imaxo,    int,    MAXO)        /* maximum number of ops */
  250. PERLVAR(Iosname,    char *)        /* operating system */
  251.  
  252. /* For binary compatibility with older versions only */
  253. PERLVARI(Ish_path_compat,    char *,    SH_PATH)/* full path of shell */
  254.  
  255. PERLVAR(Isighandlerp,    Sighandler_t)
  256.  
  257. PERLVAR(Ixiv_arenaroot,    XPV*)        /* list of allocated xiv areas */
  258. PERLVAR(Ixiv_root,    IV *)        /* free xiv list */
  259. PERLVAR(Ixnv_root,    NV *)        /* free xnv list */
  260. PERLVAR(Ixrv_root,    XRV *)        /* free xrv list */
  261. PERLVAR(Ixpv_root,    XPV *)        /* free xpv list */
  262. PERLVAR(Ixpviv_root,    XPVIV *)    /* free xpviv list */
  263. PERLVAR(Ixpvnv_root,    XPVNV *)    /* free xpvnv list */
  264. PERLVAR(Ixpvcv_root,    XPVCV *)    /* free xpvcv list */
  265. PERLVAR(Ixpvav_root,    XPVAV *)    /* free xpvav list */
  266. PERLVAR(Ixpvhv_root,    XPVHV *)    /* free xpvhv list */
  267. PERLVAR(Ixpvmg_root,    XPVMG *)    /* free xpvmg list */
  268. PERLVAR(Ixpvlv_root,    XPVLV *)    /* free xpvlv list */
  269. PERLVAR(Ixpvbm_root,    XPVBM *)    /* free xpvbm list */
  270. PERLVAR(Ihe_root,    HE *)        /* free he list */
  271. PERLVAR(Inice_chunk,    char *)        /* a nice chunk of memory to reuse */
  272. PERLVAR(Inice_chunk_size,    U32)    /* how nice the chunk of memory is */
  273.  
  274. PERLVARI(Irunops,    runops_proc_t,    MEMBER_TO_FPTR(RUNOPS_DEFAULT))
  275.  
  276. PERLVARA(Itokenbuf,256,    char)
  277.  
  278. /*
  279. =for apidoc Amn|SV|PL_sv_undef
  280. This is the C<undef> SV.  Always refer to this as C<&PL_sv_undef>.
  281.  
  282. =for apidoc Amn|SV|PL_sv_no
  283. This is the C<false> SV.  See C<PL_sv_yes>.  Always refer to this as
  284. C<&PL_sv_no>.
  285.  
  286. =for apidoc Amn|SV|PL_sv_yes
  287. This is the C<true> SV.  See C<PL_sv_no>.  Always refer to this as
  288. C<&PL_sv_yes>.
  289.  
  290. =cut
  291. */
  292.  
  293. PERLVAR(Isv_undef,    SV)
  294. PERLVAR(Isv_no,        SV)
  295. PERLVAR(Isv_yes,    SV)
  296.  
  297. #ifdef CSH
  298. PERLVARI(Icshname,    char *,    CSH)
  299. PERLVARI(Icshlen,    I32,    0)
  300. #endif
  301.  
  302. PERLVAR(Ilex_state,    U32)        /* next token is determined */
  303. PERLVAR(Ilex_defer,    U32)        /* state after determined token */
  304. PERLVAR(Ilex_expect,    int)        /* expect after determined token */
  305. PERLVAR(Ilex_brackets,    I32)        /* bracket count */
  306. PERLVAR(Ilex_formbrack,    I32)        /* bracket count at outer format level */
  307. PERLVAR(Ilex_casemods,    I32)        /* casemod count */
  308. PERLVAR(Ilex_dojoin,    I32)        /* doing an array interpolation */
  309. PERLVAR(Ilex_starts,    I32)        /* how many interps done on level */
  310. PERLVAR(Ilex_stuff,    SV *)        /* runtime pattern from m// or s/// */
  311. PERLVAR(Ilex_repl,    SV *)        /* runtime replacement from s/// */
  312. PERLVAR(Ilex_op,    OP *)        /* extra info to pass back on op */
  313. PERLVAR(Ilex_inpat,    OP *)        /* in pattern $) and $| are special */
  314. PERLVAR(Ilex_inwhat,    I32)        /* what kind of quoting are we in */
  315. PERLVAR(Ilex_brackstack,char *)        /* what kind of brackets to pop */
  316. PERLVAR(Ilex_casestack,    char *)        /* what kind of case mods in effect */
  317.  
  318. /* What we know when we're in LEX_KNOWNEXT state. */
  319. PERLVARA(Inextval,5,    YYSTYPE)    /* value of next token, if any */
  320. PERLVARA(Inexttype,5,    I32)        /* type of next token */
  321. PERLVAR(Inexttoke,    I32)
  322.  
  323. PERLVAR(Ilinestr,    SV *)
  324. PERLVAR(Ibufptr,    char *)
  325. PERLVAR(Ioldbufptr,    char *)
  326. PERLVAR(Ioldoldbufptr,    char *)
  327. PERLVAR(Ibufend,    char *)
  328. PERLVARI(Iexpect,int,    XSTATE)        /* how to interpret ambiguous tokens */
  329.  
  330. PERLVAR(Imulti_start,    I32)        /* 1st line of multi-line string */
  331. PERLVAR(Imulti_end,    I32)        /* last line of multi-line string */
  332. PERLVAR(Imulti_open,    I32)        /* delimiter of said string */
  333. PERLVAR(Imulti_close,    I32)        /* delimiter of said string */
  334.  
  335. PERLVAR(Ierror_count,    I32)        /* how many errors so far, max 10 */
  336. PERLVAR(Isubline,    I32)        /* line this subroutine began on */
  337. PERLVAR(Isubname,    SV *)        /* name of current subroutine */
  338.  
  339. PERLVAR(Imin_intro_pending,    I32)    /* start of vars to introduce */
  340. PERLVAR(Imax_intro_pending,    I32)    /* end of vars to introduce */
  341. PERLVAR(Ipadix,        I32)        /* max used index in current "register" pad */
  342. PERLVAR(Ipadix_floor,    I32)        /* how low may inner block reset padix */
  343. PERLVAR(Ipad_reset_pending,    I32)    /* reset pad on next attempted alloc */
  344.  
  345. PERLVAR(Ilast_uni,    char *)        /* position of last named-unary op */
  346. PERLVAR(Ilast_lop,    char *)        /* position of last list operator */
  347. PERLVAR(Ilast_lop_op,    OPCODE)        /* last list operator */
  348. PERLVAR(Iin_my,        I32)        /* we're compiling a "my" (or "our") declaration */
  349. PERLVAR(Iin_my_stash,    HV *)        /* declared class of this "my" declaration */
  350. #ifdef FCRYPT
  351. PERLVARI(Icryptseen,    bool,    FALSE)    /* has fast crypt() been initialized? */
  352. #endif
  353.  
  354. PERLVAR(Ihints,        U32)        /* pragma-tic compile-time flags */
  355.  
  356. PERLVAR(Idebug,        VOL U32)    /* flags given to -D switch */
  357.  
  358. PERLVARI(Iamagic_generation,    long,    0)
  359.  
  360. #ifdef USE_LOCALE_COLLATE
  361. PERLVARI(Icollation_ix,    U32,    0)    /* Collation generation index */
  362. PERLVAR(Icollation_name,char *)        /* Name of current collation */
  363. PERLVARI(Icollation_standard, bool,    TRUE)
  364.                     /* Assume simple collation */
  365. PERLVAR(Icollxfrm_base,    Size_t)        /* Basic overhead in *xfrm() */
  366. PERLVARI(Icollxfrm_mult,Size_t,    2)    /* Expansion factor in *xfrm() */
  367. #endif /* USE_LOCALE_COLLATE */
  368.  
  369. #ifdef USE_LOCALE_NUMERIC
  370.  
  371. PERLVAR(Inumeric_name,    char *)        /* Name of current numeric locale */
  372. PERLVARI(Inumeric_standard,    bool,    TRUE)
  373.                     /* Assume simple numerics */
  374. PERLVARI(Inumeric_local,    bool,    TRUE)
  375.                     /* Assume local numerics */
  376.  
  377. PERLVAR(Inumeric_compat1,        char)
  378.                     /* Used to be numeric_radix */
  379. #endif /* !USE_LOCALE_NUMERIC */
  380.  
  381. /* utf8 character classes */
  382. PERLVAR(Iutf8_alnum,    SV *)
  383. PERLVAR(Iutf8_alnumc,    SV *)
  384. PERLVAR(Iutf8_ascii,    SV *)
  385. PERLVAR(Iutf8_alpha,    SV *)
  386. PERLVAR(Iutf8_space,    SV *)
  387. PERLVAR(Iutf8_cntrl,    SV *)
  388. PERLVAR(Iutf8_graph,    SV *)
  389. PERLVAR(Iutf8_digit,    SV *)
  390. PERLVAR(Iutf8_upper,    SV *)
  391. PERLVAR(Iutf8_lower,    SV *)
  392. PERLVAR(Iutf8_print,    SV *)
  393. PERLVAR(Iutf8_punct,    SV *)
  394. PERLVAR(Iutf8_xdigit,    SV *)
  395. PERLVAR(Iutf8_mark,    SV *)
  396. PERLVAR(Iutf8_toupper,    SV *)
  397. PERLVAR(Iutf8_totitle,    SV *)
  398. PERLVAR(Iutf8_tolower,    SV *)
  399. PERLVAR(Iutf8_tofold,    SV *)
  400. PERLVAR(Ilast_swash_hv,    HV *)
  401. PERLVAR(Ilast_swash_klen,    U32)
  402. PERLVARA(Ilast_swash_key,10,    U8)
  403. PERLVAR(Ilast_swash_tmps,    U8 *)
  404. PERLVAR(Ilast_swash_slen,    STRLEN)
  405.  
  406. /* perly.c globals */
  407. PERLVAR(Iyydebug,    int)
  408. PERLVAR(Iyynerrs,    int)
  409. PERLVAR(Iyyerrflag,    int)
  410. PERLVAR(Iyychar,    int)
  411. PERLVAR(Iyyval,        YYSTYPE)
  412. PERLVAR(Iyylval,    YYSTYPE)
  413.  
  414. PERLVARI(Iglob_index,    int,    0)
  415. PERLVAR(Isrand_called,    bool)
  416. PERLVARA(Iuudmap,256,    char)
  417. PERLVAR(Ibitcount,    char *)
  418.  
  419. #ifdef USE_5005THREADS
  420. PERLVAR(Isv_mutex,    perl_mutex)    /* Mutex for allocating SVs in sv.c */
  421. PERLVAR(Ieval_mutex,    perl_mutex)    /* Mutex for doeval */
  422. PERLVAR(Ieval_cond,    perl_cond)    /* Condition variable for doeval */
  423. PERLVAR(Ieval_owner,    struct perl_thread *)
  424.                     /* Owner thread for doeval */
  425. PERLVAR(Inthreads,    int)        /* Number of threads currently */
  426. PERLVAR(Ithreads_mutex,    perl_mutex)    /* Mutex for nthreads and thread list */
  427. PERLVAR(Inthreads_cond,    perl_cond)    /* Condition variable for nthreads */
  428. PERLVAR(Isvref_mutex,    perl_mutex)    /* Mutex for SvREFCNT_{inc,dec} */
  429. PERLVARI(Ithreadsv_names,char *,    THREADSV_NAMES)
  430. #ifdef FAKE_THREADS
  431. PERLVAR(Icurthr,    struct perl_thread *)
  432.                     /* Currently executing (fake) thread */
  433. #endif
  434.  
  435. PERLVAR(Icred_mutex,    perl_mutex)    /* altered credentials in effect */
  436.  
  437. #endif /* USE_5005THREADS */
  438.  
  439. PERLVAR(Ipsig_ptr, SV**)
  440. PERLVAR(Ipsig_name, SV**)
  441.  
  442. #if defined(PERL_IMPLICIT_SYS)
  443. PERLVAR(IMem,        struct IPerlMem*)
  444. PERLVAR(IMemShared,    struct IPerlMem*)
  445. PERLVAR(IMemParse,    struct IPerlMem*)
  446. PERLVAR(IEnv,        struct IPerlEnv*)
  447. PERLVAR(IStdIO,        struct IPerlStdIO*)
  448. PERLVAR(ILIO,        struct IPerlLIO*)
  449. PERLVAR(IDir,        struct IPerlDir*)
  450. PERLVAR(ISock,        struct IPerlSock*)
  451. PERLVAR(IProc,        struct IPerlProc*)
  452. #endif
  453.  
  454. #if defined(USE_ITHREADS)
  455. PERLVAR(Iptr_table,    PTR_TBL_t*)
  456. #endif
  457. PERLVARI(Ibeginav_save, AV*, Nullav)    /* save BEGIN{}s when compiling */
  458.  
  459. #ifdef USE_5005THREADS
  460. PERLVAR(Ifdpid_mutex,    perl_mutex)    /* mutex for fdpid array */
  461. PERLVAR(Isv_lock_mutex,    perl_mutex)    /* mutex for SvLOCK macro */
  462. #endif
  463.  
  464. PERLVAR(Inullstash,    HV *)        /* illegal symbols end up here */
  465.  
  466. PERLVAR(Ixnv_arenaroot,    XPV*)        /* list of allocated xnv areas */
  467. PERLVAR(Ixrv_arenaroot,    XPV*)        /* list of allocated xrv areas */
  468. PERLVAR(Ixpv_arenaroot,    XPV*)        /* list of allocated xpv areas */
  469. PERLVAR(Ixpviv_arenaroot,XPVIV*)    /* list of allocated xpviv areas */
  470. PERLVAR(Ixpvnv_arenaroot,XPVNV*)    /* list of allocated xpvnv areas */
  471. PERLVAR(Ixpvcv_arenaroot,XPVCV*)    /* list of allocated xpvcv areas */
  472. PERLVAR(Ixpvav_arenaroot,XPVAV*)    /* list of allocated xpvav areas */
  473. PERLVAR(Ixpvhv_arenaroot,XPVHV*)    /* list of allocated xpvhv areas */
  474. PERLVAR(Ixpvmg_arenaroot,XPVMG*)    /* list of allocated xpvmg areas */
  475. PERLVAR(Ixpvlv_arenaroot,XPVLV*)    /* list of allocated xpvlv areas */
  476. PERLVAR(Ixpvbm_arenaroot,XPVBM*)    /* list of allocated xpvbm areas */
  477. PERLVAR(Ihe_arenaroot,    XPV*)        /* list of allocated he areas */
  478.  
  479.      /* 5.6.0 stopped here */
  480.  
  481. PERLVAR(Ipsig_pend, int *)        /* per-signal "count" of pending */
  482. PERLVARI(Isig_pending, int,0)           /* Number if highest signal pending */
  483.  
  484. #ifdef USE_LOCALE_NUMERIC
  485.  
  486. PERLVAR(Inumeric_radix_sv,    SV *)    /* The radix separator if not '.' */
  487.  
  488. #endif
  489.  
  490. #if defined(USE_ITHREADS)
  491. PERLVAR(Iregex_pad,     SV**)        /* All regex objects */
  492. PERLVAR(Iregex_padav,   AV*)        /* All regex objects */
  493.  
  494. #ifdef USE_REENTRANT_API
  495. PERLVAR(Ireentrant_buffer, REENTR*)    /* here we store the _r buffers */
  496. #endif
  497.  
  498. #endif
  499.  
  500. PERLVARI(Isavebegin,     bool,    FALSE)    /* save BEGINs for compiler    */
  501.  
  502. PERLVAR(Icustom_op_names, HV*)  /* Names of user defined ops */
  503. PERLVAR(Icustom_op_descs, HV*)  /* Descriptions of user defined ops */
  504.  
  505. #ifdef PERLIO_LAYERS
  506. PERLVARI(Iperlio, PerlIO *,NULL)
  507. PERLVARI(Iknown_layers, PerlIO_list_t *,NULL)
  508. PERLVARI(Idef_layerlist, PerlIO_list_t *,NULL)
  509. #endif
  510.  
  511. PERLVARI(Iencoding,    SV*, Nullsv)        /* character encoding */
  512.  
  513. PERLVAR(Idebug_pad,    struct perl_debug_pad)    /* always needed because of the re extension */
  514.  
  515. PERLVAR(Itaint_warn, bool)      /* taint warns instead of dying */
  516.  
  517. #ifdef PL_OP_SLAB_ALLOC
  518. PERLVAR(IOpPtr,I32 **)
  519. PERLVARI(IOpSpace,I32,0)
  520. PERLVAR(IOpSlab,I32 *)
  521. #endif
  522.  
  523. PERLVAR(Iutf8locale,    bool)        /* utf8 locale detected */
  524.  
  525. PERLVAR(Iutf8_idstart,    SV *)
  526. PERLVAR(Iutf8_idcont,    SV *)
  527.  
  528. PERLVAR(Isort_RealCmp,  SVCOMPARE_t)
  529.  
  530. PERLVARI(Icheckav_save, AV*, Nullav)    /* save CHECK{}s when compiling */
  531.  
  532. PERLVARI(Iclocktick, long, 0)    /* this many times() ticks in a second */
  533.  
  534. PERLVARI(Iin_load_module, int, 0)    /* to prevent recursions in PerlIO_find_layer */
  535.  
  536. PERLVAR(Iunicode, U32)    /* Unicode features: $ENV{PERL_UNICODE} or -C */
  537.  
  538. PERLVAR(Isignals, U32)    /* Using which pre-5.8 signals */
  539.  
  540. PERLVAR(Istashcache,    HV *)        /* Cache to speed up S_method_common */
  541.  
  542. PERLVAR(Ireentrant_retint, int)    /* Integer return value from reentrant functions */
  543.  
  544. /* Hooks to shared SVs and locks. */
  545. PERLVARI(Isharehook,    share_proc_t,    MEMBER_TO_FPTR(Perl_sv_nosharing))
  546. PERLVARI(Ilockhook,    share_proc_t,    MEMBER_TO_FPTR(Perl_sv_nolocking))
  547. PERLVARI(Iunlockhook,    share_proc_t,    MEMBER_TO_FPTR(Perl_sv_nounlocking))
  548. PERLVARI(Ithreadhook,    thrhook_proc_t,    MEMBER_TO_FPTR(Perl_nothreadhook))
  549.  
  550. /* Force inclusion of both runops options */
  551. PERLVARI(Irunops_std,    runops_proc_t,    MEMBER_TO_FPTR(Perl_runops_standard))
  552. PERLVARI(Irunops_dbg,    runops_proc_t,    MEMBER_TO_FPTR(Perl_runops_debug))
  553.  
  554. /* Stores the PPID */
  555. #ifdef THREADS_HAVE_PIDS
  556. PERLVARI(Ippid,        IV,        0)
  557. #endif
  558.  
  559. PERLVARI(Ihash_seed, UV, 0)        /* Hash initializer */
  560.  
  561. PERLVARI(Ihash_seed_set, bool, FALSE)        /* Hash initialized? */
  562.  
  563. PERLVARI(Irehash_seed, UV, 0)        /* 582 hash initializer */
  564.  
  565. PERLVARI(Irehash_seed_set, bool, FALSE)    /* 582 hash initialized? */
  566.  
  567. /* New variables must be added to the very end, before this comment,
  568.  * for binary compatibility (the offsets of the old members must not change).
  569.  * (Don't forget to add your variable also to perl_clone()!)
  570.  * XSUB.h provides wrapper functions via perlapi.h that make this
  571.  * irrelevant, but not all code may be expected to #include XSUB.h.
  572.  */
  573.  
  574.