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