home *** CD-ROM | disk | FTP | other *** search
/ PC World 2005 December (Special) / PCWorld_2005-12_Special_cd.bin / Bezpecnost / lsti / lsti.exe / framework-2.5.exe / intrpvar.h < prev    next >
C/C++ Source or Header  |  2005-01-27  |  21KB  |  579 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. #endif
  495.  
  496. #ifdef USE_REENTRANT_API
  497. PERLVAR(Ireentrant_buffer, REENTR*)    /* here we store the _r buffers */
  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. /* These two variables are needed to preserve 5.8.x bincompat because we can't
  568.    change function prototypes of two exported functions.  Probably should be
  569.    taken out of blead soon, and relevant prototypes changed.  */
  570. PERLVARI(Ifdscript, int, -1)    /* fd for script */
  571. PERLVARI(Isuidscript, int, -1)    /* fd for suid script */
  572. /* New variables must be added to the very end, before this comment,
  573.  * for binary compatibility (the offsets of the old members must not change).
  574.  * (Don't forget to add your variable also to perl_clone()!)
  575.  * XSUB.h provides wrapper functions via perlapi.h that make this
  576.  * irrelevant, but not all code may be expected to #include XSUB.h.
  577.  */
  578.  
  579.