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