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, const char * const *) 33 ###### PERLVARI(Isplitstr, const 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 #else 78 PERLVAR(Istatusvalue_posix,I32) 79 #endif 80 81 /* shortcuts to various I/O objects */ 82 PERLVAR(Istdingv, GV *) 83 PERLVAR(Istderrgv, GV *) 84 PERLVAR(Idefgv, GV *) 85 PERLVAR(Iargvgv, GV *) 86 PERLVAR(Iargvoutgv, GV *) 87 PERLVAR(Iargvout_stack, AV *) 88 89 /* shortcuts to regexp stuff */ 90 /* this one needs to be moved to thrdvar.h and accessed via 91 * find_threadsv() when USE_5005THREADS */ 92 PERLVAR(Ireplgv, GV *) 93 94 /* shortcuts to misc objects */ 95 PERLVAR(Ierrgv, GV *) 96 97 /* shortcuts to debugging objects */ 98 PERLVAR(IDBgv, GV *) 99 PERLVAR(IDBline, GV *) 100 101 /* 102 =for apidoc mn|GV *|PL_DBsub 103 When Perl is run in debugging mode, with the B<-d> switch, this GV contains 104 the SV which holds the name of the sub being debugged. This is the C 105 variable which corresponds to Perl's $DB::sub variable. See 106 C. 107 108 =for apidoc mn|SV *|PL_DBsingle 109 When Perl is run in debugging mode, with the B<-d> switch, this SV is a 110 boolean which indicates whether subs are being single-stepped. 111 Single-stepping is automatically turned on after every step. This is the C 112 variable which corresponds to Perl's $DB::single variable. See 113 C. 114 115 =for apidoc mn|SV *|PL_DBtrace 116 Trace variable used when Perl is run in debugging mode, with the B<-d> 117 switch. This is the C variable which corresponds to Perl's $DB::trace 118 variable. See C. 119 120 =cut 121 */ 122 123 PERLVAR(IDBsub, GV *) 124 PERLVAR(IDBsingle, SV *) 125 PERLVAR(IDBtrace, SV *) 126 PERLVAR(IDBsignal, SV *) 127 PERLVAR(Ilineary, AV *) /* lines of script for debugger */ 128 PERLVAR(Idbargs, AV *) /* args to call listed by caller function */ 129 130 /* symbol tables */ 131 PERLVAR(Idebstash, HV *) /* symbol table for perldb package */ 132 PERLVAR(Iglobalstash, HV *) /* global keyword overrides imported here */ 133 PERLVAR(Icurstname, SV *) /* name of current package */ 134 PERLVAR(Ibeginav, AV *) /* names of BEGIN subroutines */ 135 PERLVAR(Iendav, AV *) /* names of END subroutines */ 136 PERLVAR(Icheckav, AV *) /* names of CHECK subroutines */ 137 PERLVAR(Iinitav, AV *) /* names of INIT subroutines */ 138 PERLVAR(Istrtab, HV *) /* shared string table */ 139 ###### PERLVARI(Isub_generation,U32,1) /* incr to invalidate method cache */ 140 141 /* memory management */ 142 PERLVAR(Isv_count, I32) /* how many SV* are currently allocated */ 143 PERLVAR(Isv_objcount, I32) /* how many objects are currently allocated */ 144 PERLVAR(Isv_root, SV*) /* storage for SVs belonging to interp */ 145 PERLVAR(Isv_arenaroot, SV*) /* list of areas for garbage collection */ 146 147 /* funky return mechanisms */ 148 PERLVAR(Iforkprocess, int) /* so do_open |- can return proc# */ 149 150 /* subprocess state */ 151 PERLVAR(Ifdpid, AV *) /* keep fd-to-pid mappings for my_popen */ 152 153 /* internal state */ 154 PERLVAR(Itainting, bool) /* doing taint checks */ 155 ###### PERLVARI(Iop_mask, char *, NULL) /* masked operations for safe evals */ 156 157 /* current interpreter roots */ 158 PERLVAR(Imain_cv, CV *) 159 PERLVAR(Imain_root, OP *) 160 PERLVAR(Imain_start, OP *) 161 PERLVAR(Ieval_root, OP *) 162 PERLVAR(Ieval_start, OP *) 163 164 /* runtime control stuff */ 165 ###### PERLVARI(Icurcopdb, COP *, NULL) 166 ###### PERLVARI(Icopline, line_t, NOLINE) 167 168 /* statics moved here for shared library purposes */ 169 PERLVAR(Ifilemode, int) /* so nextargv() can preserve mode */ 170 PERLVAR(Ilastfd, int) /* what to preserve mode on */ 171 PERLVAR(Ioldname, char *) /* what to preserve mode on */ 172 PERLVAR(IArgv, char **) /* stuff to free from do_aexec, vfork safe */ 173 PERLVAR(ICmd, char *) /* stuff to free from do_aexec, vfork safe */ 174 ###### PERLVARI(Igensym, I32, 0) /* next symbol for getsym() to define */ 175 PERLVAR(Ipreambled, bool) 176 PERLVAR(Ipreambleav, AV *) 177 ###### PERLVARI(Ilaststatval, int, -1) 178 ###### PERLVARI(Ilaststype, I32, OP_STAT) 179 PERLVAR(Imess_sv, SV *) 180 181 /* XXX shouldn't these be per-thread? --GSAR */ 182 PERLVAR(Iors_sv, SV *) /* output record separator $\ */ 183 184 /* interpreter atexit processing */ 185 ###### PERLVARI(Iexitlist, PerlExitListEntry *, NULL) 186 /* list of exit functions */ 187 ###### PERLVARI(Iexitlistlen, I32, 0) /* length of same */ 188 189 /* 190 =for apidoc Amn|HV*|PL_modglobal 191 192 C is a general purpose, interpreter global HV for use by 193 extensions that need to keep information on a per-interpreter basis. 194 In a pinch, it can also be used as a symbol table for extensions 195 to share data among each other. It is a good idea to use keys 196 prefixed by the package name of the extension that owns the data. 197 198 =cut 199 */ 200 201 PERLVAR(Imodglobal, HV *) /* per-interp module data */ 202 203 /* these used to be in global before 5.004_68 */ 204 ###### PERLVARI(Iprofiledata, U32 *, NULL) /* table of ops, counts */ 205 ###### PERLVARI(Irsfp, PerlIO * VOL, Nullfp) /* current source file pointer */ 206 ###### PERLVARI(Irsfp_filters, AV *, Nullav) /* keeps active source filters */ 207 208 PERLVAR(Icompiling, COP) /* compiling/done executing marker */ 209 210 PERLVAR(Icompcv, CV *) /* currently compiling subroutine */ 211 PERLVAR(Icomppad, AV *) /* storage for lexically scoped temporaries */ 212 PERLVAR(Icomppad_name, AV *) /* variable names for "my" variables */ 213 PERLVAR(Icomppad_name_fill, I32) /* last "introduced" variable offset */ 214 PERLVAR(Icomppad_name_floor, I32) /* start of vars in innermost block */ 215 216 #ifdef HAVE_INTERP_INTERN 217 PERLVAR(Isys_intern, struct interp_intern) 218 /* platform internals */ 219 #endif 220 221 /* more statics moved here */ 222 ###### PERLVARI(Igeneration, int, 100) /* from op.c */ 223 PERLVAR(IDBcv, CV *) /* from perl.c */ 224 225 ###### PERLVARI(Iin_clean_objs,bool, FALSE) /* from sv.c */ 226 ###### PERLVARI(Iin_clean_all, bool, FALSE) /* from sv.c */ 227 228 PERLVAR(Ilinestart, char *) /* beg. of most recently read line */ 229 PERLVAR(Ipending_ident, char) /* pending identifier lookup */ 230 PERLVAR(Isublex_info, SUBLEXINFO) /* from toke.c */ 231 232 PERLVAR(Iuid, Uid_t) /* current real user id */ 233 PERLVAR(Ieuid, Uid_t) /* current effective user id */ 234 PERLVAR(Igid, Gid_t) /* current real group id */ 235 PERLVAR(Iegid, Gid_t) /* current effective group id */ 236 PERLVAR(Inomemok, bool) /* let malloc context handle nomem */ 237 ###### PERLVARI(Ian, U32, 0) /* malloc sequence number */ 238 ###### PERLVARI(Icop_seqmax, U32, 0) /* statement sequence number */ 239 ###### PERLVARI(Ievalseq, U32, 0) /* eval sequence number */ 240 PERLVAR(Iorigenviron, char **) 241 PERLVAR(Iorigalen, U32) 242 PERLVAR(Ipidstatus, HV *) /* pid-to-status mappings for waitpid */ 243 ###### PERLVARI(Imaxo, int, MAXO) /* maximum number of ops */ 244 PERLVAR(Iosname, char *) /* operating system */ 245 246 PERLVAR(Isighandlerp, Sighandler_t) 247 248 PERLVAR(Ixnv_root, NV *) /* free xnv list */ 249 PERLVAR(Ixpv_root, xpv_allocated *) /* free xpv list */ 250 PERLVAR(Ixpviv_root, xpviv_allocated *) /* free xpviv list */ 251 PERLVAR(Ixpvnv_root, XPVNV *) /* free xpvnv list */ 252 PERLVAR(Ixpvcv_root, XPVCV *) /* free xpvcv list */ 253 PERLVAR(Ixpvav_root, xpvav_allocated *) /* free xpvav list */ 254 PERLVAR(Ixpvhv_root, xpvhv_allocated *) /* free xpvhv list */ 255 PERLVAR(Ixpvmg_root, XPVMG *) /* free xpvmg list */ 256 PERLVAR(Ixpvgv_root, XPVGV *) /* free xpvgv list */ 257 PERLVAR(Ixpvlv_root, XPVLV *) /* free xpvlv list */ 258 PERLVAR(Ixpvbm_root, XPVBM *) /* free xpvbm list */ 259 PERLVAR(Ihe_root, HE *) /* free he list */ 260 #if defined(USE_ITHREADS) 261 PERLVAR(Ipte_root, struct ptr_tbl_ent *) /* free ptr_tbl_ent list */ 262 #endif 263 PERLVAR(Inice_chunk, char *) /* a nice chunk of memory to reuse */ 264 PERLVAR(Inice_chunk_size, U32) /* how nice the chunk of memory is */ 265 266 ###### PERLVARI(Irunops, runops_proc_t, MEMBER_TO_FPTR(RUNOPS_DEFAULT)) 267 268 PERLVARA(Itokenbuf,256, char) 269 270 /* 271 =for apidoc Amn|SV|PL_sv_undef 272 This is the C SV. Always refer to this as C<&PL_sv_undef>. 273 274 =for apidoc Amn|SV|PL_sv_no 275 This is the C SV. See C. Always refer to this as 276 C<&PL_sv_no>. 277 278 =for apidoc Amn|SV|PL_sv_yes 279 This is the C SV. See C. Always refer to this as 280 C<&PL_sv_yes>. 281 282 =cut 283 */ 284 285 PERLVAR(Isv_undef, SV) 286 PERLVAR(Isv_no, SV) 287 PERLVAR(Isv_yes, SV) 288 289 #ifdef CSH 290 ###### PERLVARI(Icshname, const char *, CSH) 291 ###### PERLVARI(Icshlen, I32, 0) 292 #endif 293 294 PERLVAR(Ilex_state, U32) /* next token is determined */ 295 PERLVAR(Ilex_defer, U32) /* state after determined token */ 296 PERLVAR(Ilex_expect, int) /* expect after determined token */ 297 PERLVAR(Ilex_brackets, I32) /* bracket count */ 298 PERLVAR(Ilex_formbrack, I32) /* bracket count at outer format level */ 299 PERLVAR(Ilex_casemods, I32) /* casemod count */ 300 PERLVAR(Ilex_dojoin, I32) /* doing an array interpolation */ 301 PERLVAR(Ilex_starts, I32) /* how many interps done on level */ 302 PERLVAR(Ilex_stuff, SV *) /* runtime pattern from m// or s/// */ 303 PERLVAR(Ilex_repl, SV *) /* runtime replacement from s/// */ 304 PERLVAR(Ilex_op, OP *) /* extra info to pass back on op */ 305 PERLVAR(Ilex_inpat, OP *) /* in pattern $) and $| are special */ 306 PERLVAR(Ilex_inwhat, I32) /* what kind of quoting are we in */ 307 PERLVAR(Ilex_brackstack,char *) /* what kind of brackets to pop */ 308 PERLVAR(Ilex_casestack, char *) /* what kind of case mods in effect */ 309 310 /* What we know when we're in LEX_KNOWNEXT state. */ 311 PERLVARA(Inextval,5, YYSTYPE) /* value of next token, if any */ 312 PERLVARA(Inexttype,5, I32) /* type of next token */ 313 PERLVAR(Inexttoke, I32) 314 315 PERLVAR(Ilinestr, SV *) 316 PERLVAR(Ibufptr, char *) 317 PERLVAR(Ioldbufptr, char *) 318 PERLVAR(Ioldoldbufptr, char *) 319 PERLVAR(Ibufend, char *) 320 ###### PERLVARI(Iexpect,int, XSTATE) /* how to interpret ambiguous tokens */ 321 322 PERLVAR(Imulti_start, I32) /* 1st line of multi-line string */ 323 PERLVAR(Imulti_end, I32) /* last line of multi-line string */ 324 PERLVAR(Imulti_open, I32) /* delimiter of said string */ 325 PERLVAR(Imulti_close, I32) /* delimiter of said string */ 326 327 PERLVAR(Ierror_count, I32) /* how many errors so far, max 10 */ 328 PERLVAR(Isubline, I32) /* line this subroutine began on */ 329 PERLVAR(Isubname, SV *) /* name of current subroutine */ 330 331 PERLVAR(Imin_intro_pending, I32) /* start of vars to introduce */ 332 PERLVAR(Imax_intro_pending, I32) /* end of vars to introduce */ 333 PERLVAR(Ipadix, I32) /* max used index in current "register" pad */ 334 PERLVAR(Ipadix_floor, I32) /* how low may inner block reset padix */ 335 PERLVAR(Ipad_reset_pending, I32) /* reset pad on next attempted alloc */ 336 337 PERLVAR(Ilast_uni, char *) /* position of last named-unary op */ 338 PERLVAR(Ilast_lop, char *) /* position of last list operator */ 339 PERLVAR(Ilast_lop_op, OPCODE) /* last list operator */ 340 PERLVAR(Iin_my, I32) /* we're compiling a "my" (or "our") declaration */ 341 PERLVAR(Iin_my_stash, HV *) /* declared class of this "my" declaration */ 342 #ifdef FCRYPT 343 PERLVARI(Icryptseen, bool, FALSE) /* has fast crypt() been initialized? */ 344 #endif 345 346 PERLVAR(Ihints, U32) /* pragma-tic compile-time flags */ 347 348 PERLVAR(Idebug, VOL U32) /* flags given to -D switch */ 349 350 ###### PERLVARI(Iamagic_generation, long, 0) 351 352 #ifdef USE_LOCALE_COLLATE 353 ###### PERLVARI(Icollation_ix, U32, 0) /* Collation generation index */ 354 PERLVAR(Icollation_name,char *) /* Name of current collation */ 355 ###### PERLVARI(Icollation_standard, bool, TRUE) 356 /* Assume simple collation */ 357 PERLVAR(Icollxfrm_base, Size_t) /* Basic overhead in *xfrm() */ 358 ###### PERLVARI(Icollxfrm_mult,Size_t, 2) /* Expansion factor in *xfrm() */ 359 #endif /* USE_LOCALE_COLLATE */ 360 361 #ifdef USE_LOCALE_NUMERIC 362 363 PERLVAR(Inumeric_name, char *) /* Name of current numeric locale */ 364 ###### PERLVARI(Inumeric_standard, bool, TRUE) 365 /* Assume simple numerics */ 366 ###### PERLVARI(Inumeric_local, bool, TRUE) 367 /* Assume local numerics */ 368 369 PERLVAR(Inumeric_compat1, char) 370 /* Used to be numeric_radix */ 371 #endif /* !USE_LOCALE_NUMERIC */ 372 373 /* utf8 character classes */ 374 PERLVAR(Iutf8_alnum, SV *) 375 PERLVAR(Iutf8_alnumc, SV *) 376 PERLVAR(Iutf8_ascii, SV *) 377 PERLVAR(Iutf8_alpha, SV *) 378 PERLVAR(Iutf8_space, SV *) 379 PERLVAR(Iutf8_cntrl, SV *) 380 PERLVAR(Iutf8_graph, SV *) 381 PERLVAR(Iutf8_digit, SV *) 382 PERLVAR(Iutf8_upper, SV *) 383 PERLVAR(Iutf8_lower, SV *) 384 PERLVAR(Iutf8_print, SV *) 385 PERLVAR(Iutf8_punct, SV *) 386 PERLVAR(Iutf8_xdigit, SV *) 387 PERLVAR(Iutf8_mark, SV *) 388 PERLVAR(Iutf8_toupper, SV *) 389 PERLVAR(Iutf8_totitle, SV *) 390 PERLVAR(Iutf8_tolower, SV *) 391 PERLVAR(Iutf8_tofold, SV *) 392 PERLVAR(Ilast_swash_hv, HV *) 393 PERLVAR(Ilast_swash_klen, U32) 394 PERLVARA(Ilast_swash_key,10, U8) 395 PERLVAR(Ilast_swash_tmps, U8 *) 396 PERLVAR(Ilast_swash_slen, STRLEN) 397 398 /* perly.c globals */ 399 PERLVAR(Iyycharp, int *) 400 PERLVAR(Iyylvalp, YYSTYPE *) 401 402 ###### PERLVARI(Iglob_index, int, 0) 403 PERLVAR(Isrand_called, bool) 404 PERLVARA(Iuudmap,256, char) 405 PERLVAR(Ibitcount, char *) 406 407 PERLVAR(Ipsig_ptr, SV**) 408 PERLVAR(Ipsig_name, SV**) 409 410 #if defined(PERL_IMPLICIT_SYS) 411 PERLVAR(IMem, struct IPerlMem*) 412 PERLVAR(IMemShared, struct IPerlMem*) 413 PERLVAR(IMemParse, struct IPerlMem*) 414 PERLVAR(IEnv, struct IPerlEnv*) 415 PERLVAR(IStdIO, struct IPerlStdIO*) 416 PERLVAR(ILIO, struct IPerlLIO*) 417 PERLVAR(IDir, struct IPerlDir*) 418 PERLVAR(ISock, struct IPerlSock*) 419 PERLVAR(IProc, struct IPerlProc*) 420 #endif 421 422 #if defined(USE_ITHREADS) 423 PERLVAR(Iptr_table, PTR_TBL_t*) 424 #endif 425 ###### PERLVARI(Ibeginav_save, AV*, Nullav) /* save BEGIN{}s when compiling */ 426 427 PERLVAR(Ixnv_arenaroot, XPV*) /* list of allocated xnv areas */ 428 PERLVAR(Ixpv_arenaroot, xpv_allocated *) /* list of allocated xpv areas */ 429 PERLVAR(Ixpviv_arenaroot,xpviv_allocated*) /* list of allocated xpviv areas */ 430 PERLVAR(Ixpvnv_arenaroot,XPVNV*) /* list of allocated xpvnv areas */ 431 PERLVAR(Ixpvcv_arenaroot,XPVCV*) /* list of allocated xpvcv areas */ 432 PERLVAR(Ixpvav_arenaroot,xpvav_allocated*) /* list of allocated xpvav areas */ 433 PERLVAR(Ixpvhv_arenaroot,xpvhv_allocated*) /* list of allocated xpvhv areas */ 434 PERLVAR(Ixpvmg_arenaroot,XPVMG*) /* list of allocated xpvmg areas */ 435 PERLVAR(Ixpvgv_arenaroot,XPVGV*) /* list of allocated xpvgv areas */ 436 PERLVAR(Ixpvlv_arenaroot,XPVLV*) /* list of allocated xpvlv areas */ 437 PERLVAR(Ixpvbm_arenaroot,XPVBM*) /* list of allocated xpvbm areas */ 438 PERLVAR(Ihe_arenaroot, HE *) /* list of allocated he areas */ 439 #if defined(USE_ITHREADS) 440 PERLVAR(Ipte_arenaroot, struct ptr_tbl_ent *) /* list of allocated pte areas */ 441 #endif 442 /* 5.6.0 stopped here */ 443 444 PERLVAR(Ipsig_pend, int *) /* per-signal "count" of pending */ 445 ###### PERLVARI(Isig_pending, int,0) /* Number if highest signal pending */ 446 447 #ifdef USE_LOCALE_NUMERIC 448 449 PERLVAR(Inumeric_radix_sv, SV *) /* The radix separator if not '.' */ 450 451 #endif 452 453 #if defined(USE_ITHREADS) 454 PERLVAR(Iregex_pad, SV**) /* All regex objects */ 455 PERLVAR(Iregex_padav, AV*) /* All regex objects */ 456 457 #endif 458 459 #ifdef USE_REENTRANT_API 460 PERLVAR(Ireentrant_buffer, REENTR*) /* here we store the _r buffers */ 461 #endif 462 463 ###### PERLVARI(Isavebegin, bool, FALSE) /* save BEGINs for compiler */ 464 465 PERLVAR(Icustom_op_names, HV*) /* Names of user defined ops */ 466 PERLVAR(Icustom_op_descs, HV*) /* Descriptions of user defined ops */ 467 468 #ifdef PERLIO_LAYERS 469 ###### PERLVARI(Iperlio, PerlIO *,NULL) 470 ###### PERLVARI(Iknown_layers, PerlIO_list_t *,NULL) 471 ###### PERLVARI(Idef_layerlist, PerlIO_list_t *,NULL) 472 #endif 473 474 ###### PERLVARI(Iencoding, SV*, Nullsv) /* character encoding */ 475 476 PERLVAR(Idebug_pad, struct perl_debug_pad) /* always needed because of the re extension */ 477 478 PERLVAR(Itaint_warn, bool) /* taint warns instead of dying */ 479 480 #ifdef PL_OP_SLAB_ALLOC 481 PERLVAR(IOpPtr,I32 **) 482 PERLVARI(IOpSpace,I32,0) 483 PERLVAR(IOpSlab,I32 *) 484 #endif 485 486 PERLVAR(Iutf8locale, bool) /* utf8 locale detected */ 487 488 PERLVAR(Iutf8_idstart, SV *) 489 PERLVAR(Iutf8_idcont, SV *) 490 491 PERLVAR(Isort_RealCmp, SVCOMPARE_t) 492 493 ###### PERLVARI(Icheckav_save, AV*, Nullav) /* save CHECK{}s when compiling */ 494 495 ###### PERLVARI(Iclocktick, long, 0) /* this many times() ticks in a second */ 496 497 ###### PERLVARI(Iin_load_module, int, 0) /* to prevent recursions in PerlIO_find_layer */ 498 499 PERLVAR(Iunicode, U32) /* Unicode features: $ENV{PERL_UNICODE} or -C */ 500 501 PERLVAR(Isignals, U32) /* Using which pre-5.8 signals */ 502 503 PERLVAR(Istashcache, HV *) /* Cache to speed up S_method_common */ 504 505 PERLVAR(Ireentrant_retint, int) /* Integer return value from reentrant functions */ 506 507 /* Hooks to shared SVs and locks. */ 508 ###### PERLVARI(Isharehook, share_proc_t, MEMBER_TO_FPTR(Perl_sv_nosharing)) 509 ###### PERLVARI(Ilockhook, share_proc_t, MEMBER_TO_FPTR(Perl_sv_nolocking)) 510 ###### PERLVARI(Iunlockhook, share_proc_t, MEMBER_TO_FPTR(Perl_sv_nounlocking)) 511 ###### PERLVARI(Ithreadhook, thrhook_proc_t, MEMBER_TO_FPTR(Perl_nothreadhook)) 512 513 /* Force inclusion of both runops options */ 514 ###### PERLVARI(Irunops_std, runops_proc_t, MEMBER_TO_FPTR(Perl_runops_standard)) 515 ###### PERLVARI(Irunops_dbg, runops_proc_t, MEMBER_TO_FPTR(Perl_runops_debug)) 516 517 /* Stores the PPID */ 518 #ifdef THREADS_HAVE_PIDS 519 PERLVARI(Ippid, IV, 0) 520 #endif 521 522 ###### PERLVARI(Ihash_seed, UV, 0) /* Hash initializer */ 523 524 ###### PERLVARI(Ihash_seed_set, bool, FALSE) /* Hash initialized? */ 525 526 PERLVAR(IDBassertion, SV *) 527 528 ###### PERLVARI(Icv_has_eval, I32, 0) /* PL_compcv includes an entereval or similar */ 529 530 ###### PERLVARI(Irehash_seed, UV, 0) /* 582 hash initializer */ 531 532 ###### PERLVARI(Irehash_seed_set, bool, FALSE) /* 582 hash initialized? */ 533 534 /* These two variables are needed to preserve 5.8.x bincompat because we can't 535 change function prototypes of two exported functions. Probably should be 536 taken out of blead soon, and relevant prototypes changed. */ 537 ###### PERLVARI(Ifdscript, int, -1) /* fd for script */ 538 ###### PERLVARI(Isuidscript, int, -1) /* fd for suid script */ 539 #ifdef DEBUG_LEAKING_SCALARS_FORK_DUMP 540 /* File descriptor to talk to the child which dumps scalars. */ 541 PERLVARI(Idumper_fd, int, -1) 542 #endif 543 /* New variables must be added to the very end, before this comment, 544 * for binary compatibility (the offsets of the old members must not change). 545 * (Don't forget to add your variable also to perl_clone()!) 546 * XSUB.h provides wrapper functions via perlapi.h that make this 547 * irrelevant, but not all code may be expected to #include XSUB.h. 548 */