1 /* intrpvar.h 2 * 3 * Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 4 * 2006, 2007, 2008 by Larry Wall and others 5 * 6 * You may distribute under the terms of either the GNU General Public 7 * License or the Artistic License, as specified in the README file. 8 * 9 */ 10 11 #include "handy.h" 12 13 /* These variables are per-interpreter in threaded/multiplicity builds, 14 * global otherwise. 15 16 * Don't forget to re-run regen/embed.pl to propagate changes! */ 17 18 /* New variables must be added to the very end for binary compatibility. */ 19 20 /* DON'T FORGET to add your variable also to perl_clone()! (in sv.c) */ 21 22 /* The 'I' prefix is only needed for vars that need appropriate #defines 23 * generated when built with or without MULTIPLICITY. It is also used 24 * to generate the appropriate export list for win32. If the variable 25 * needs to be initialized, use PERLVARI. 26 * 27 * When building without MULTIPLICITY, these variables will be truly global. 28 * 29 * Important ones in the first cache line (if alignment is done right) */ 30 31 PERLVAR(I, stack_sp, SV **) /* top of the stack */ 32 PERLVAR(I, op, OP *) /* currently executing op */ 33 PERLVAR(I, curpad, SV **) /* active pad (lexicals+tmps) */ 34 35 PERLVAR(I, stack_base, SV **) 36 PERLVAR(I, stack_max, SV **) 37 38 PERLVAR(I, savestack, ANY *) /* items that need to be restored when 39 LEAVEing scopes we've ENTERed */ 40 PERLVAR(I, savestack_ix, I32) 41 PERLVAR(I, savestack_max, I32) 42 43 PERLVAR(I, scopestack, I32 *) /* scopes we've ENTERed */ 44 PERLVAR(I, scopestack_ix, I32) 45 PERLVAR(I, scopestack_max, I32) 46 47 PERLVAR(I, tmps_stack, SV **) /* mortals we've made */ 48 PERLVARI(I, tmps_ix, SSize_t, -1) 49 PERLVARI(I, tmps_floor, SSize_t, -1) 50 PERLVAR(I, tmps_max, SSize_t) /* first unalloced slot in tmps stack */ 51 52 PERLVAR(I, markstack, I32 *) /* stack_sp locations we're 53 remembering */ 54 PERLVAR(I, markstack_ptr, I32 *) 55 PERLVAR(I, markstack_max, I32 *) 56 57 PERLVARI(I, sub_generation, U32, 1) /* incr to invalidate method cache */ 58 59 #ifdef PERL_HASH_RANDOMIZE_KEYS 60 #ifdef USE_PERL_PERTURB_KEYS 61 PERLVARI(I, hash_rand_bits_enabled, U8, 1) /* used to randomize hash stuff 0 == no-random, 1 == random, 2 == determinsitic */ 62 #endif 63 PERLVARI(I, hash_rand_bits, UV, 0) /* used to randomize hash stuff */ 64 #endif 65 PERLVAR(I, strtab, HV *) /* shared string table */ 66 /* prog counter for the currently executing OP_MULTIDEREF Used to signal 67 * to S_find_uninit_var() where we are */ 68 PERLVAR(I, multideref_pc, UNOP_AUX_item *) 69 70 /* Fields used by magic variables such as $@, $/ and so on */ 71 PERLVAR(I, curpm, PMOP *) /* what to do \ interps in REs from */ 72 PERLVAR(I, curpm_under, PMOP *) /* what to do \ interps in REs from */ 73 74 PERLVAR(I, tainting, bool) /* ? doing taint checks */ 75 PERLVARI(I, tainted, bool, FALSE) /* using variables controlled by $< */ 76 77 /* PL_delaymagic is currently used for two purposes: to assure simultaneous 78 * updates in ($<,$>) = ..., and to assure atomic update in push/unshift 79 * @ISA, It works like this: a few places such as pp_push set the DM_DELAY 80 * flag; then various places such as av_store() skip mg_set(ary) if this 81 * flag is set, and various magic vtable methods set flags like 82 * DM_ARRAY_ISA if they've seen something of that ilk. Finally when 83 * control returns to pp_push or whatever, it sees if any of those flags 84 * have been set, and if so finally calls mg_set(). 85 * 86 * NB: PL_delaymagic is automatically saved and restored by JUMPENV_PUSH 87 * / POP. This removes the need to do ENTER/SAVEI16(PL_delaymagic)/LEAVE 88 * in hot code like pp_push. 89 */ 90 PERLVAR(I, delaymagic, U16) /* ($<,$>) = ... */ 91 92 /* 93 =for apidoc_section $warning 94 =for apidoc mn|U8|PL_dowarn 95 96 The C variable that roughly corresponds to Perl's C<$^W> warning variable. 97 However, C<$^W> is treated as a boolean, whereas C<PL_dowarn> is a 98 collection of flag bits. 99 100 On threaded perls, each thread has an independent copy of this variable; 101 each initialized at creation time with the current value of the creating 102 thread's copy. 103 104 =cut 105 */ 106 107 PERLVAR(I, dowarn, U8) 108 109 #if defined (PERL_UTF8_CACHE_ASSERT) || defined (DEBUGGING) 110 # define PERL___I -1 111 #else 112 # define PERL___I 1 113 #endif 114 PERLVARI(I, utf8cache, I8, PERL___I) /* Is the utf8 caching code enabled? */ 115 #undef PERL___I 116 117 /* 118 =for apidoc_section $GV 119 =for apidoc Amn|GV *|PL_defgv 120 121 The GV representing C<*_>. Useful for access to C<$_>. 122 123 On threaded perls, each thread has an independent copy of this variable; 124 each initialized at creation time with the current value of the creating 125 thread's copy. 126 127 =cut 128 */ 129 130 PERLVAR(I, localizing, U8) /* are we processing a local() list? */ 131 PERLVAR(I, in_eval, U8) /* trap "fatal" errors? */ 132 PERLVAR(I, defgv, GV *) /* the *_ glob */ 133 134 /* 135 =for apidoc_section $GV 136 =for apidoc Amn|HV*|PL_curstash 137 138 The stash for the package code will be compiled into. 139 140 On threaded perls, each thread has an independent copy of this variable; 141 each initialized at creation time with the current value of the creating 142 thread's copy. 143 144 =cut 145 */ 146 147 /* Stashes */ 148 PERLVAR(I, defstash, HV *) /* main symbol table */ 149 PERLVAR(I, curstash, HV *) /* symbol table for current package */ 150 151 /* 152 =for apidoc_section $COP 153 =for apidoc Amn|COP*|PL_curcop 154 155 The currently active COP (control op) roughly representing the current 156 statement in the source. 157 158 On threaded perls, each thread has an independent copy of this variable; 159 each initialized at creation time with the current value of the creating 160 thread's copy. 161 162 =cut 163 */ 164 165 PERLVAR(I, curcop, COP *) 166 PERLVAR(I, curstack, AV *) /* THE STACK */ 167 PERLVAR(I, curstackinfo, PERL_SI *) /* current stack + context */ 168 PERLVAR(I, mainstack, AV *) /* the stack when nothing funny is 169 happening */ 170 171 /* memory management */ 172 PERLVAR(I, sv_count, IV) /* how many SV* are currently allocated */ 173 174 PERLVAR(I, sv_root, SV *) /* storage for SVs belonging to interp */ 175 PERLVAR(I, sv_arenaroot, SV *) /* list of areas for garbage collection */ 176 177 /* fake PMOP that PL_curpm points to while in (?{}) so $1 et al are visible */ 178 PERLVARI(I, reg_curpm, PMOP*, NULL) 179 180 /* the currently active slab in a chain of slabs of regmatch states, 181 * and the currently active state within that slab. This stack of states 182 * is shared amongst re-entrant calls to the regex engine */ 183 184 PERLVARI(I, regmatch_slab, regmatch_slab *, NULL) 185 PERLVAR(I, regmatch_state, regmatch_state *) 186 187 PERLVAR(I, comppad, PAD *) /* storage for lexically scoped temporaries */ 188 189 /* 190 =for apidoc_section $SV 191 =for apidoc Amn|SV|PL_sv_undef 192 This is the C<undef> SV. It is readonly. Always refer to this as 193 C<&PL_sv_undef>. 194 195 =for apidoc Amn|SV|PL_sv_no 196 This is the C<false> SV. It is readonly. See C<L</PL_sv_yes>>. Always refer 197 to this as C<&PL_sv_no>. 198 199 =for apidoc Amn|SV|PL_sv_yes 200 This is the C<true> SV. It is readonly. See C<L</PL_sv_no>>. Always refer to 201 this as C<&PL_sv_yes>. 202 203 =for apidoc Amn|SV|PL_sv_zero 204 This readonly SV has a zero numeric value and a C<"0"> string value. It's 205 similar to C<L</PL_sv_no>> except for its string value. Can be used as a 206 cheap alternative to C<mXPUSHi(0)> for example. Always refer to this as 207 C<&PL_sv_zero>. Introduced in 5.28. 208 209 =cut 210 */ 211 212 #ifdef MULTIPLICITY 213 PERLVAR(I, sv_yes, SV) 214 PERLVAR(I, sv_undef, SV) 215 PERLVAR(I, sv_no, SV) 216 PERLVAR(I, sv_zero, SV) 217 #else 218 /* store the immortals as an array to ensure they are contiguous in 219 * memory: makes SvIMMORTAL_INTERP(sv) possible */ 220 PERLVARA(I, sv_immortals, 4, SV) 221 #endif 222 223 PERLVAR(I, padname_undef, PADNAME) 224 PERLVAR(I, padname_const, PADNAME) 225 226 /* 227 =for apidoc_section $SV 228 =for apidoc Cmn||PL_Sv 229 230 A scratch pad SV for whatever temporary use you need. Chiefly used as a 231 fallback by macros on platforms where L<perlapi/PERL_USE_GCC_BRACE_GROUPS>> is 232 unavailable, and which would otherwise evaluate their SV parameter more than 233 once. 234 235 =cut 236 */ 237 PERLVAR(I, Sv, SV *) 238 239 PERLVAR(I, parser, yy_parser *) /* current parser state */ 240 241 PERLVAR(I, stashcache, HV *) /* Cache to speed up S_method_common */ 242 243 244 /* 245 =for apidoc_section $string 246 =for apidoc Amn|STRLEN|PL_na 247 248 A scratch pad variable in which to store a C<STRLEN> value. If would have been 249 better named something like C<PL_temp_strlen>. 250 251 It is is typically used with C<SvPV> when one is actually planning to discard 252 the returned length, (hence the length is "Not Applicable", which is how this 253 variable got its name). 254 255 It is usually more efficient to either declare a local variable and use that 256 instead, or to use the C<SvPV_nolen> macro. 257 258 =cut 259 */ 260 261 PERLVAR(I, na, STRLEN) /* for use in SvPV when length is 262 Not Applicable */ 263 264 /* stat stuff */ 265 PERLVAR(I, statcache, Stat_t) /* _ */ 266 PERLVAR(I, statgv, GV *) 267 PERLVARI(I, statname, SV *, NULL) 268 269 /* 270 =for apidoc_section $io 271 =for apidoc mn|SV*|PL_rs 272 273 The input record separator - C<$/> in Perl space. 274 275 On threaded perls, each thread has an independent copy of this variable; 276 each initialized at creation time with the current value of the creating 277 thread's copy. 278 279 =for apidoc_section $io 280 =for apidoc mn|GV*|PL_last_in_gv 281 282 The GV which was last used for a filehandle input operation. (C<< <FH> >>) 283 284 On threaded perls, each thread has an independent copy of this variable; 285 each initialized at creation time with the current value of the creating 286 thread's copy. 287 288 =for apidoc_section $io 289 =for apidoc mn|GV*|PL_ofsgv 290 291 The glob containing the output field separator - C<*,> in Perl space. 292 293 On threaded perls, each thread has an independent copy of this variable; 294 each initialized at creation time with the current value of the creating 295 thread's copy. 296 297 =cut 298 */ 299 300 PERLVAR(I, rs, SV *) /* input record separator $/ */ 301 PERLVAR(I, last_in_gv, GV *) /* GV used in last <FH> */ 302 PERLVAR(I, ofsgv, GV *) /* GV of output field separator *, */ 303 PERLVAR(I, defoutgv, GV *) /* default FH for output */ 304 PERLVARI(I, chopset, const char *, " \n-") /* $: */ 305 PERLVAR(I, formtarget, SV *) 306 PERLVAR(I, bodytarget, SV *) 307 PERLVAR(I, toptarget, SV *) 308 309 310 PERLVAR(I, restartop, OP *) /* propagating an error from croak? */ 311 PERLVAR(I, restartjmpenv, JMPENV *) /* target frame for longjmp in die */ 312 313 PERLVAR(I, top_env, JMPENV *) /* ptr to current sigjmp environment */ 314 PERLVAR(I, start_env, JMPENV) /* empty startup sigjmp environment */ 315 PERLVARI(I, errors, SV *, NULL) /* outstanding queued errors */ 316 317 /* statics "owned" by various functions */ 318 PERLVAR(I, hv_fetch_ent_mh, HE*) /* owned by hv_fetch_ent() */ 319 320 PERLVAR(I, lastgotoprobe, OP*) /* from pp_ctl.c */ 321 322 /* sort stuff */ 323 PERLVAR(I, sortcop, OP *) /* user defined sort routine */ 324 PERLVAR(I, sortstash, HV *) /* which is in some package or other */ 325 PERLVAR(I, firstgv, GV *) /* $a */ 326 PERLVAR(I, secondgv, GV *) /* $b */ 327 328 /* float buffer */ 329 PERLVAR(I, efloatbuf, char *) 330 PERLVAR(I, efloatsize, STRLEN) 331 332 PERLVARI(I, dumpindent, U16, 4) /* number of blanks per dump 333 indentation level */ 334 335 /* 336 =for apidoc_section $embedding 337 =for apidoc Amn|U8|PL_exit_flags 338 339 Contains flags controlling perl's behaviour on exit(): 340 341 =over 342 343 =item * C<PERL_EXIT_DESTRUCT_END> 344 345 If set, END blocks are executed when the interpreter is destroyed. 346 This is normally set by perl itself after the interpreter is 347 constructed. 348 349 =item * C<PERL_EXIT_ABORT> 350 351 Call C<abort()> on exit. This is used internally by perl itself to 352 abort if exit is called while processing exit. 353 354 =item * C<PERL_EXIT_WARN> 355 356 Warn on exit. 357 358 =item * C<PERL_EXIT_EXPECTED> 359 360 Set by the L<perlfunc/exit> operator. 361 362 =back 363 364 =for apidoc Amnh||PERL_EXIT_EXPECTED 365 =for apidoc Amnh||PERL_EXIT_ABORT 366 =for apidoc Amnh||PERL_EXIT_DESTRUCT_END 367 =for apidoc Amnh||PERL_EXIT_WARN 368 369 On threaded perls, each thread has an independent copy of this variable; 370 each initialized at creation time with the current value of the creating 371 thread's copy. 372 373 =cut 374 */ 375 376 PERLVAR(I, exit_flags, U8) /* was exit() unexpected, etc. */ 377 378 PERLVAR(I, utf8locale, bool) /* utf8 locale detected */ 379 PERLVAR(I, in_utf8_CTYPE_locale, bool) 380 PERLVAR(I, in_utf8_COLLATE_locale, bool) 381 PERLVAR(I, in_utf8_turkic_locale, bool) 382 #if defined(USE_ITHREADS) && ! defined(USE_THREAD_SAFE_LOCALE) 383 PERLVARI(I, lc_numeric_mutex_depth, int, 0) /* Emulate general semaphore */ 384 #endif 385 PERLVARA(I, locale_utf8ness, 256, char) 386 387 #ifdef USE_LOCALE_CTYPE 388 PERLVAR(I, warn_locale, SV *) 389 #endif 390 391 PERLVARA(I, colors,6, char *) /* values from PERL_RE_COLORS env var */ 392 393 /* 394 =for apidoc_section $optree_construction 395 =for apidoc Amn|peep_t|PL_peepp 396 397 Pointer to the per-subroutine peephole optimiser. This is a function 398 that gets called at the end of compilation of a Perl subroutine (or 399 equivalently independent piece of Perl code) to perform fixups of 400 some ops and to perform small-scale optimisations. The function is 401 called once for each subroutine that is compiled, and is passed, as sole 402 parameter, a pointer to the op that is the entry point to the subroutine. 403 It modifies the op tree in place. 404 405 The peephole optimiser should never be completely replaced. Rather, 406 add code to it by wrapping the existing optimiser. The basic way to do 407 this can be seen in L<perlguts/Compile pass 3: peephole optimization>. 408 If the new code wishes to operate on ops throughout the subroutine's 409 structure, rather than just at the top level, it is likely to be more 410 convenient to wrap the L</PL_rpeepp> hook. 411 412 On threaded perls, each thread has an independent copy of this variable; 413 each initialized at creation time with the current value of the creating 414 thread's copy. 415 416 =cut 417 */ 418 419 PERLVARI(I, peepp, peep_t, Perl_peep) 420 421 /* 422 =for apidoc_section $optree_construction 423 =for apidoc Amn|peep_t|PL_rpeepp 424 425 Pointer to the recursive peephole optimiser. This is a function 426 that gets called at the end of compilation of a Perl subroutine (or 427 equivalently independent piece of Perl code) to perform fixups of some 428 ops and to perform small-scale optimisations. The function is called 429 once for each chain of ops linked through their C<op_next> fields; 430 it is recursively called to handle each side chain. It is passed, as 431 sole parameter, a pointer to the op that is at the head of the chain. 432 It modifies the op tree in place. 433 434 The peephole optimiser should never be completely replaced. Rather, 435 add code to it by wrapping the existing optimiser. The basic way to do 436 this can be seen in L<perlguts/Compile pass 3: peephole optimization>. 437 If the new code wishes to operate only on ops at a subroutine's top level, 438 rather than throughout the structure, it is likely to be more convenient 439 to wrap the L</PL_peepp> hook. 440 441 On threaded perls, each thread has an independent copy of this variable; 442 each initialized at creation time with the current value of the creating 443 thread's copy. 444 445 =cut 446 */ 447 448 PERLVARI(I, rpeepp, peep_t, Perl_rpeep) 449 450 /* 451 =for apidoc_section $optrees 452 =for apidoc Amn|Perl_ophook_t|PL_opfreehook 453 454 When non-C<NULL>, the function pointed by this variable will be called each time an OP is freed with the corresponding OP as the argument. 455 This allows extensions to free any extra attribute they have locally attached to an OP. 456 It is also assured to first fire for the parent OP and then for its kids. 457 458 When you replace this variable, it is considered a good practice to store the possibly previously installed hook and that you recall it inside your own. 459 460 On threaded perls, each thread has an independent copy of this variable; 461 each initialized at creation time with the current value of the creating 462 thread's copy. 463 464 =cut 465 */ 466 467 PERLVARI(I, opfreehook, Perl_ophook_t, 0) /* op_free() hook */ 468 469 PERLVARI(I, watchaddr, char **, 0) 470 PERLVAR(I, watchok, char *) 471 472 PERLVAR(I, perldb, U32) 473 474 PERLVAR(I, signals, U32) /* Using which pre-5.8 signals */ 475 476 PERLVAR(I, reentrant_retint, int) /* Integer return value from reentrant functions */ 477 478 /* pseudo environmental stuff */ 479 PERLVAR(I, origargc, int) 480 PERLVAR(I, origargv, char **) 481 PERLVAR(I, envgv, GV *) 482 PERLVAR(I, incgv, GV *) 483 PERLVAR(I, hintgv, GV *) 484 PERLVAR(I, origfilename, char *) 485 PERLVARI(I, xsubfilename, const char *, NULL) 486 PERLVAR(I, diehook, SV *) 487 PERLVAR(I, warnhook, SV *) 488 489 /* switches */ 490 PERLVAR(I, patchlevel, SV *) 491 PERLVAR(I, localpatches, const char * const *) 492 PERLVARI(I, splitstr, const char *, " ") 493 494 PERLVAR(I, minus_c, bool) 495 PERLVAR(I, minus_n, bool) 496 PERLVAR(I, minus_p, bool) 497 PERLVAR(I, minus_l, bool) 498 PERLVAR(I, minus_a, bool) 499 PERLVAR(I, minus_F, bool) 500 PERLVAR(I, doswitches, bool) 501 PERLVAR(I, minus_E, bool) 502 503 PERLVAR(I, inplace, char *) 504 PERLVAR(I, e_script, SV *) 505 506 PERLVAR(I, basetime, Time_t) /* $^T */ 507 508 PERLVARI(I, maxsysfd, I32, MAXSYSFD) 509 /* top fd to pass to subprocesses */ 510 PERLVAR(I, statusvalue, I32) /* $? */ 511 #ifdef VMS 512 PERLVAR(I, statusvalue_vms, U32) 513 #else 514 PERLVAR(I, statusvalue_posix, I32) 515 #endif 516 517 PERLVARI(I, sig_pending, int, 0) /* Number if highest signal pending */ 518 PERLVAR(I, psig_pend, int *) /* per-signal "count" of pending */ 519 520 /* shortcuts to various I/O objects */ 521 PERLVAR(I, stdingv, GV *) /* *STDIN */ 522 PERLVAR(I, stderrgv, GV *) /* *STDERR */ 523 PERLVAR(I, argvgv, GV *) /* *ARGV */ 524 PERLVAR(I, argvoutgv, GV *) /* *ARGVOUT */ 525 PERLVAR(I, argvout_stack, AV *) 526 527 /* shortcuts to regexp stuff */ 528 PERLVAR(I, replgv, GV *) /* *^R */ 529 530 /* shortcuts to misc objects */ 531 PERLVAR(I, errgv, GV *) /* *@ */ 532 533 /* shortcuts to debugging objects */ 534 PERLVAR(I, DBgv, GV *) /* *DB::DB */ 535 PERLVAR(I, DBline, GV *) /* *DB::line */ 536 537 /* 538 =for apidoc_section $debugging 539 =for apidoc mn|GV *|PL_DBsub 540 When Perl is run in debugging mode, with the B<-d> switch, this GV contains 541 the SV which holds the name of the sub being debugged. This is the C 542 variable which corresponds to Perl's $DB::sub variable. See 543 C<L</PL_DBsingle>>. 544 545 On threaded perls, each thread has an independent copy of this variable; 546 each initialized at creation time with the current value of the creating 547 thread's copy. 548 549 =for apidoc mn|SV *|PL_DBsingle 550 When Perl is run in debugging mode, with the B<-d> switch, this SV is a 551 boolean which indicates whether subs are being single-stepped. 552 Single-stepping is automatically turned on after every step. This is the C 553 variable which corresponds to Perl's $DB::single variable. See 554 C<L</PL_DBsub>>. 555 556 On threaded perls, each thread has an independent copy of this variable; 557 each initialized at creation time with the current value of the creating 558 thread's copy. 559 560 =for apidoc mn|SV *|PL_DBtrace 561 Trace variable used when Perl is run in debugging mode, with the B<-d> 562 switch. This is the C variable which corresponds to Perl's $DB::trace 563 variable. See C<L</PL_DBsingle>>. 564 565 On threaded perls, each thread has an independent copy of this variable; 566 each initialized at creation time with the current value of the creating 567 thread's copy. 568 569 =cut 570 */ 571 572 PERLVAR(I, DBsub, GV *) /* *DB::sub */ 573 PERLVAR(I, DBsingle, SV *) /* $DB::single */ 574 PERLVAR(I, DBtrace, SV *) /* $DB::trace */ 575 PERLVAR(I, DBsignal, SV *) /* $DB::signal */ 576 PERLVAR(I, dbargs, AV *) /* args to call listed by caller function */ 577 578 PERLVARA(I, DBcontrol, DBVARMG_COUNT, IV) /* IV versions of $DB::single, trace, signal */ 579 580 /* symbol tables */ 581 PERLVAR(I, debstash, HV *) /* symbol table for perldb package */ 582 PERLVAR(I, globalstash, HV *) /* global keyword overrides imported here */ 583 PERLVAR(I, curstname, SV *) /* name of current package */ 584 PERLVAR(I, beginav, AV *) /* names of BEGIN subroutines */ 585 PERLVAR(I, endav, AV *) /* names of END subroutines */ 586 PERLVAR(I, unitcheckav, AV *) /* names of UNITCHECK subroutines */ 587 PERLVAR(I, checkav, AV *) /* names of CHECK subroutines */ 588 PERLVAR(I, initav, AV *) /* names of INIT subroutines */ 589 590 /* subprocess state */ 591 PERLVAR(I, fdpid, AV *) /* keep fd-to-pid mappings for my_popen */ 592 593 /* internal state */ 594 PERLVARI(I, op_mask, char *, NULL) /* masked operations for safe evals */ 595 596 /* current interpreter roots */ 597 PERLVAR(I, main_cv, CV *) 598 PERLVAR(I, main_root, OP *) 599 PERLVAR(I, main_start, OP *) 600 PERLVAR(I, eval_root, OP *) 601 PERLVAR(I, eval_start, OP *) 602 603 /* runtime control stuff */ 604 PERLVARI(I, curcopdb, COP *, NULL) 605 606 PERLVAR(I, filemode, int) /* so nextargv() can preserve mode */ 607 PERLVAR(I, lastfd, int) /* what to preserve mode on */ 608 PERLVAR(I, oldname, char *) /* what to preserve mode on */ 609 /* Elements in this array have ';' appended and are injected as a single line 610 into the tokeniser. You can't put any (literal) newlines into any program 611 you stuff in into this array, as the point where it's injected is expecting 612 a single physical line. */ 613 PERLVAR(I, preambleav, AV *) 614 PERLVAR(I, mess_sv, SV *) 615 PERLVAR(I, ors_sv, SV *) /* output record separator $\ */ 616 617 /* funky return mechanisms */ 618 PERLVAR(I, forkprocess, int) /* so do_open |- can return proc# */ 619 620 /* statics moved here for shared library purposes */ 621 PERLVARI(I, gensym, I32, 0) /* next symbol for getsym() to define */ 622 PERLVARI(I, cv_has_eval, bool, FALSE) /* PL_compcv includes an entereval or similar */ 623 PERLVAR(I, taint_warn, bool) /* taint warns instead of dying */ 624 PERLVARI(I, laststype, U16, OP_STAT) 625 626 PERLVARI(I, laststatval, int, -1) 627 628 PERLVAR(I, modcount, I32) /* how much op_lvalue()ification in 629 assignment? */ 630 631 /* interpreter atexit processing */ 632 PERLVARI(I, exitlistlen, I32, 0) /* length of same */ 633 PERLVARI(I, exitlist, PerlExitListEntry *, NULL) 634 /* list of exit functions */ 635 636 /* 637 =for apidoc_section $HV 638 =for apidoc Amn|HV*|PL_modglobal 639 640 C<PL_modglobal> is a general purpose, interpreter global HV for use by 641 extensions that need to keep information on a per-interpreter basis. 642 In a pinch, it can also be used as a symbol table for extensions 643 to share data among each other. It is a good idea to use keys 644 prefixed by the package name of the extension that owns the data. 645 646 On threaded perls, each thread has an independent copy of this variable; 647 each initialized at creation time with the current value of the creating 648 thread's copy. 649 650 =cut 651 */ 652 653 PERLVAR(I, modglobal, HV *) /* per-interp module data */ 654 655 /* these used to be in global before 5.004_68 */ 656 PERLVARI(I, profiledata, U32 *, NULL) /* table of ops, counts */ 657 658 PERLVAR(I, compiling, COP) /* compiling/done executing marker */ 659 660 PERLVAR(I, compcv, CV *) /* currently compiling subroutine */ 661 PERLVAR(I, comppad_name, PADNAMELIST *) /* variable names for "my" variables */ 662 PERLVAR(I, comppad_name_fill, PADOFFSET)/* last "introduced" variable offset */ 663 PERLVAR(I, comppad_name_floor, PADOFFSET)/* start of vars in innermost block */ 664 665 #ifdef HAVE_INTERP_INTERN 666 PERLVAR(I, sys_intern, struct interp_intern) 667 /* platform internals */ 668 #endif 669 670 /* more statics moved here */ 671 PERLVAR(I, DBcv, CV *) /* from perl.c */ 672 PERLVARI(I, generation, int, 100) /* scan sequence# for OP_AASSIGN 673 compile-time common elem detection */ 674 675 PERLVAR(I, unicode, U32) /* Unicode features: $ENV{PERL_UNICODE} or -C */ 676 677 PERLVARI(I, in_clean_objs,bool, FALSE) /* from sv.c */ 678 PERLVARI(I, in_clean_all, bool, FALSE) /* ptrs to freed SVs now legal */ 679 PERLVAR(I, nomemok, bool) /* let malloc context handle nomem */ 680 PERLVARI(I, savebegin, bool, FALSE) /* save BEGINs for compiler */ 681 682 683 PERLVAR(I, delaymagic_uid, Uid_t) /* current real user id, only for delaymagic */ 684 PERLVAR(I, delaymagic_euid, Uid_t) /* current effective user id, only for delaymagic */ 685 PERLVAR(I, delaymagic_gid, Gid_t) /* current real group id, only for delaymagic */ 686 PERLVAR(I, delaymagic_egid, Gid_t) /* current effective group id, only for delaymagic */ 687 PERLVARI(I, an, U32, 0) /* malloc sequence number */ 688 689 /* Perl_Ibreakable_sub_generation_ptr was too long for VMS, hence "gen" */ 690 PERLVARI(I, breakable_sub_gen, U32, 0) 691 692 #ifdef DEBUGGING 693 /* exercise wrap-around */ 694 #define PERL_COP_SEQMAX (U32_MAX-50) 695 #else 696 #define PERL_COP_SEQMAX 0 697 #endif 698 PERLVARI(I, cop_seqmax, U32, PERL_COP_SEQMAX) /* statement sequence number */ 699 #undef PERL_COP_SEQMAX 700 701 PERLVARI(I, evalseq, U32, 0) /* eval sequence number */ 702 PERLVAR(I, origalen, U32) 703 PERLVAR(I, origenviron, char **) 704 #ifdef PERL_USES_PL_PIDSTATUS 705 PERLVAR(I, pidstatus, HV *) /* pid-to-status mappings for waitpid */ 706 #endif 707 PERLVAR(I, osname, char *) /* operating system */ 708 709 PERLVAR(I, sighandlerp, Sighandler_t) 710 /* these two are provided only to solve library linkage issues; they 711 * should not be hooked by user code */ 712 PERLVAR(I, sighandler1p, Sighandler1_t) 713 PERLVAR(I, sighandler3p, Sighandler3_t) 714 715 PERLVARA(I, body_roots, PERL_ARENA_ROOTS_SIZE, void*) /* array of body roots */ 716 717 PERLVAR(I, debug, volatile U32) /* flags given to -D switch */ 718 719 PERLVARI(I, padlist_generation, U32, 1) /* id to identify padlist clones */ 720 721 PERLVARI(I, runops, runops_proc_t, RUNOPS_DEFAULT) 722 723 PERLVAR(I, subname, SV *) /* name of current subroutine */ 724 725 PERLVAR(I, subline, I32) /* line this subroutine began on */ 726 PERLVAR(I, min_intro_pending, PADOFFSET)/* start of vars to introduce */ 727 728 PERLVAR(I, max_intro_pending, PADOFFSET)/* end of vars to introduce */ 729 PERLVAR(I, padix, PADOFFSET) /* lowest unused index - 1 730 in current "register" pad */ 731 PERLVAR(I, constpadix, PADOFFSET) /* lowest unused for constants */ 732 733 PERLVAR(I, padix_floor, PADOFFSET) /* how low may inner block reset padix */ 734 735 #if defined(USE_POSIX_2008_LOCALE) \ 736 && defined(USE_THREAD_SAFE_LOCALE) \ 737 && ! defined(HAS_QUERYLOCALE) 738 739 /* This is the most number of categories we've encountered so far on any 740 * platform */ 741 PERLVARA(I, curlocales, 12, char *) 742 743 #endif 744 #ifdef USE_LOCALE_COLLATE 745 746 PERLVAR(I, collation_name, char *) /* Name of current collation */ 747 PERLVAR(I, collxfrm_base, Size_t) /* Basic overhead in *xfrm() */ 748 PERLVARI(I, collxfrm_mult,Size_t, 2) /* Expansion factor in *xfrm() */ 749 PERLVARI(I, collation_ix, U32, 0) /* Collation generation index */ 750 PERLVARI(I, strxfrm_NUL_replacement, U8, 0) /* Code point to replace NULs */ 751 PERLVARI(I, strxfrm_is_behaved, bool, TRUE) 752 /* Assume until proven otherwise that it works */ 753 PERLVARI(I, strxfrm_max_cp, U8, 0) /* Highest collating cp in locale */ 754 PERLVARI(I, collation_standard, bool, TRUE) 755 /* Assume simple collation */ 756 #endif /* USE_LOCALE_COLLATE */ 757 758 PERLVARI(I, langinfo_buf, char *, NULL) 759 PERLVARI(I, langinfo_bufsize, Size_t, 0) 760 PERLVARI(I, setlocale_buf, char *, NULL) 761 PERLVARI(I, setlocale_bufsize, Size_t, 0) 762 763 #ifdef PERL_SAWAMPERSAND 764 PERLVAR(I, sawampersand, U8) /* must save all match strings */ 765 #endif 766 767 /* current phase the interpreter is in 768 for ordering this structure to remove holes, we're assuming that this is 4 769 bytes. */ 770 PERLVARI(I, phase, enum perl_phase, PERL_PHASE_CONSTRUCT) 771 772 PERLVARI(I, in_load_module, bool, FALSE) /* to prevent recursions in PerlIO_find_layer */ 773 774 PERLVAR(I, unsafe, bool) 775 PERLVAR(I, colorset, bool) /* PERL_RE_COLORS env var is in use */ 776 777 /* 778 =for apidoc_section $embedding 779 =for apidoc Amn|signed char|PL_perl_destruct_level 780 781 This value may be set when embedding for full cleanup. 782 783 Possible values: 784 785 =over 786 787 =item * 0 - none 788 789 =item * 1 - full 790 791 =item * 2 or greater - full with checks. 792 793 =back 794 795 If C<$ENV{PERL_DESTRUCT_LEVEL}> is set to an integer greater than the 796 value of C<PL_perl_destruct_level> its value is used instead. 797 798 On threaded perls, each thread has an independent copy of this variable; 799 each initialized at creation time with the current value of the creating 800 thread's copy. 801 802 =cut 803 */ 804 /* mod_perl is special, and also assigns a meaning -1 */ 805 PERLVARI(I, perl_destruct_level, signed char, 0) 806 807 PERLVAR(I, pad_reset_pending, bool) /* reset pad on next attempted alloc */ 808 809 PERLVAR(I, srand_called, bool) 810 811 #ifdef USE_LOCALE_NUMERIC 812 813 PERLVARI(I, numeric_underlying, bool, TRUE) 814 /* Assume underlying locale numerics */ 815 PERLVARI(I, numeric_underlying_is_standard, bool, TRUE) 816 817 PERLVARI(I, numeric_standard, int, TRUE) 818 /* Assume C locale numerics */ 819 PERLVAR(I, numeric_name, char *) /* Name of current numeric locale */ 820 PERLVAR(I, numeric_radix_sv, SV *) /* The radix separator if not '.' */ 821 822 # ifdef HAS_POSIX_2008_LOCALE 823 824 PERLVARI(I, underlying_numeric_obj, locale_t, NULL) 825 826 # endif 827 #endif /* !USE_LOCALE_NUMERIC */ 828 829 /* Array of signal handlers, indexed by signal number, through which the C 830 signal handler dispatches. */ 831 PERLVAR(I, psig_ptr, SV **) 832 /* Array of names of signals, indexed by signal number, for (re)use as the first 833 argument to a signal handler. Only one block of memory is allocated for 834 both psig_name and psig_ptr. */ 835 PERLVAR(I, psig_name, SV **) 836 837 #if defined(PERL_IMPLICIT_SYS) 838 PERLVAR(I, Mem, struct IPerlMem *) 839 PERLVAR(I, MemShared, struct IPerlMem *) 840 PERLVAR(I, MemParse, struct IPerlMem *) 841 PERLVAR(I, Env, struct IPerlEnv *) 842 PERLVAR(I, StdIO, struct IPerlStdIO *) 843 PERLVAR(I, LIO, struct IPerlLIO *) 844 PERLVAR(I, Dir, struct IPerlDir *) 845 PERLVAR(I, Sock, struct IPerlSock *) 846 PERLVAR(I, Proc, struct IPerlProc *) 847 #endif 848 849 PERLVAR(I, ptr_table, PTR_TBL_t *) 850 PERLVARI(I, beginav_save, AV *, NULL) /* save BEGIN{}s when compiling */ 851 852 PERLVAR(I, body_arenas, void *) /* pointer to list of body-arenas */ 853 854 855 #if defined(USE_ITHREADS) 856 PERLVAR(I, regex_pad, SV **) /* Shortcut into the array of 857 regex_padav */ 858 PERLVAR(I, regex_padav, AV *) /* All regex objects, indexed via the 859 values in op_pmoffset of pmop. 860 Entry 0 is an SV whose PV is a 861 "packed" list of IVs listing 862 the now-free slots in the array */ 863 PERLVAR(I, stashpad, HV **) /* for CopSTASH */ 864 PERLVARI(I, stashpadmax, PADOFFSET, 64) 865 PERLVARI(I, stashpadix, PADOFFSET, 0) 866 #endif 867 868 #ifdef USE_REENTRANT_API 869 PERLVAR(I, reentrant_buffer, REENTR *) /* here we store the _r buffers */ 870 #endif 871 872 PERLVAR(I, custom_op_names, HV *) /* Names of user defined ops */ 873 PERLVAR(I, custom_op_descs, HV *) /* Descriptions of user defined ops */ 874 875 #ifdef PERLIO_LAYERS 876 PERLVARI(I, perlio, PerlIOl *, NULL) 877 PERLVARI(I, known_layers, PerlIO_list_t *, NULL) 878 PERLVARI(I, def_layerlist, PerlIO_list_t *, NULL) 879 #endif 880 881 PERLVARI(I, checkav_save, AV *, NULL) /* save CHECK{}s when compiling */ 882 PERLVARI(I, unitcheckav_save, AV *, NULL) 883 /* save UNITCHECK{}s when compiling */ 884 885 PERLVARI(I, clocktick, long, 0) /* this many times() ticks in a second */ 886 887 /* Hooks to shared SVs and locks. */ 888 PERLVARI(I, sharehook, share_proc_t, Perl_sv_nosharing) 889 PERLVARI(I, lockhook, share_proc_t, Perl_sv_nosharing) 890 891 GCC_DIAG_IGNORE(-Wdeprecated-declarations) 892 #ifdef NO_MATHOMS 893 # define PERL_UNLOCK_HOOK Perl_sv_nosharing 894 #else 895 /* This reference ensures that the mathoms are linked with perl */ 896 # define PERL_UNLOCK_HOOK Perl_sv_nounlocking 897 #endif 898 PERLVARI(I, unlockhook, share_proc_t, PERL_UNLOCK_HOOK) 899 900 GCC_DIAG_RESTORE 901 902 PERLVARI(I, threadhook, thrhook_proc_t, Perl_nothreadhook) 903 904 /* Can shared object be destroyed */ 905 PERLVARI(I, destroyhook, destroyable_proc_t, Perl_sv_destroyable) 906 907 #ifndef PERL_MICRO 908 PERLVARI(I, signalhook, despatch_signals_proc_t, Perl_despatch_signals) 909 #endif 910 911 PERLVARI(I, isarev, HV *, NULL) /* Reverse map of @ISA dependencies */ 912 913 /* Register of known Method Resolution Orders. 914 What this actually points to is an implementation detail (it may change to 915 a structure incorporating a reference count - use mro_get_from_name to 916 retrieve a C<struct mro_alg *> */ 917 PERLVAR(I, registered_mros, HV *) 918 919 /* Compile-time block start/end hooks */ 920 PERLVAR(I, blockhooks, AV *) 921 922 PERLVAR(I, custom_ops, HV *) /* custom op registrations */ 923 924 PERLVAR(I, Xpv, XPV *) /* (unused) held temporary value */ 925 926 /* name of the scopes we've ENTERed. Only used with -DDEBUGGING, but needs to be 927 present always, as -DDEBUGGING must be binary compatible with non. */ 928 PERLVARI(I, scopestack_name, const char * *, NULL) 929 930 PERLVAR(I, debug_pad, struct perl_debug_pad) /* always needed because of the re extension */ 931 932 /* Hook for File::Glob */ 933 PERLVARI(I, globhook, globhook_t, NULL) 934 935 #if defined(MULTIPLICITY) 936 /* The last unconditional member of the interpreter structure when 5.18.0 was 937 released. The offset of the end of this is baked into a global variable in 938 any shared perl library which will allow a sanity test in future perl 939 releases. */ 940 # define PERL_LAST_5_18_0_INTERP_MEMBER Iglobhook 941 #endif 942 943 #ifdef MULTIPLICITY 944 PERLVARI(I, my_cxt_list, void **, NULL) /* per-module array of MY_CXT pointers */ 945 PERLVARI(I, my_cxt_size, int, 0) /* size of PL_my_cxt_list */ 946 #endif 947 948 #if defined(MULTIPLICITY) || defined(PERL_DEBUG_READONLY_COW) 949 /* For use with the memory debugging code in util.c. This is used only in 950 * DEBUGGING builds (as long as the relevant structure is defined), but 951 * defining it in non-debug builds too means that we retain binary 952 * compatibility between otherwise-compatible plain and debug builds. */ 953 PERLVAR(I, memory_debug_header, struct perl_memory_debug_header) 954 #endif 955 956 #ifdef DEBUG_LEAKING_SCALARS_FORK_DUMP 957 /* File descriptor to talk to the child which dumps scalars. */ 958 PERLVARI(I, dumper_fd, int, -1) 959 #endif 960 961 962 #ifdef DEBUG_LEAKING_SCALARS 963 PERLVARI(I, sv_serial, U32, 0) /* SV serial number, used in sv.c */ 964 #endif 965 966 PERLVARA(I, sv_consts, SV_CONSTS_COUNT, SV*) /* constant SVs with precomputed hash value */ 967 968 #ifdef PERL_TRACE_OPS 969 PERLVARA(I, op_exec_cnt, OP_max+2, UV) /* Counts of executed OPs of the given type. 970 If PERL_TRACE_OPS is enabled, we'll dump 971 a summary count of all ops executed in the 972 program at perl_destruct time. For 973 profiling/debugging only. Works only if 974 DEBUGGING is enabled, too. */ 975 #endif 976 977 PERLVAR(I, random_state, PL_RANDOM_STATE_TYPE) 978 979 PERLVARI(I, dump_re_max_len, STRLEN, 60) 980 981 /* For internal uses of randomness, this ensures the sequence of 982 * random numbers returned by rand() isn't modified by perl's internal 983 * use of randomness. 984 * This is important if the user has called srand() with a seed. 985 */ 986 987 PERLVAR(I, internal_random_state, PL_RANDOM_STATE_TYPE) 988 989 PERLVARA(I, TR_SPECIAL_HANDLING_UTF8, UTF8_MAXBYTES, char) 990 991 PERLVAR(I, AboveLatin1, SV *) 992 PERLVAR(I, Assigned_invlist, SV *) 993 PERLVAR(I, GCB_invlist, SV *) 994 PERLVAR(I, HasMultiCharFold, SV *) 995 PERLVAR(I, InMultiCharFold, SV *) 996 PERLVAR(I, Latin1, SV *) 997 PERLVAR(I, LB_invlist, SV *) 998 PERLVAR(I, SB_invlist, SV *) 999 PERLVAR(I, SCX_invlist, SV *) 1000 PERLVAR(I, UpperLatin1, SV *) /* Code points 128 - 255 */ 1001 1002 /* List of characters that participate in any fold defined by Unicode */ 1003 PERLVAR(I, in_some_fold, SV *) 1004 1005 /* Everything that folds to a given character, for case insensitivity regex 1006 * matching */ 1007 PERLVAR(I, utf8_foldclosures, SV *) 1008 1009 PERLVAR(I, utf8_idcont, SV *) 1010 PERLVAR(I, utf8_idstart, SV *) 1011 PERLVAR(I, utf8_perl_idcont, SV *) 1012 PERLVAR(I, utf8_perl_idstart, SV *) 1013 PERLVAR(I, utf8_xidcont, SV *) 1014 PERLVAR(I, utf8_xidstart, SV *) 1015 PERLVAR(I, WB_invlist, SV *) 1016 PERLVARA(I, XPosix_ptrs, POSIX_CC_COUNT, SV *) 1017 PERLVARA(I, Posix_ptrs, POSIX_CC_COUNT, SV *) 1018 PERLVAR(I, utf8_toupper, SV *) 1019 PERLVAR(I, utf8_totitle, SV *) 1020 PERLVAR(I, utf8_tolower, SV *) 1021 PERLVAR(I, utf8_tofold, SV *) 1022 PERLVAR(I, utf8_tosimplefold, SV *) 1023 PERLVAR(I, utf8_charname_begin, SV *) 1024 PERLVAR(I, utf8_charname_continue, SV *) 1025 PERLVAR(I, utf8_mark, SV *) 1026 PERLVARI(I, InBitmap, SV *, NULL) 1027 PERLVAR(I, CCC_non0_non230, SV *) 1028 PERLVAR(I, Private_Use, SV *) 1029 1030 #ifdef HAS_MBRLEN 1031 PERLVAR(I, mbrlen_ps, mbstate_t) 1032 #endif 1033 #ifdef HAS_MBRTOWC 1034 PERLVAR(I, mbrtowc_ps, mbstate_t) 1035 #endif 1036 #ifdef HAS_WCRTOMB 1037 PERLVAR(I, wcrtomb_ps, mbstate_t) 1038 #endif 1039 #ifdef PERL_MEM_LOG 1040 /* Enough space for the reserved byte, 1 for a potential leading 0, then enough 1041 * for the longest representable integer plus an extra, the 3 flag characters, 1042 * and NUL */ 1043 PERLVARA(I, mem_log, 1 + 1 + TYPE_DIGITS(UV) + 1 + 3 + 1, char) 1044 #endif 1045 1046 /* The most recently seen `use VERSION` declaration, encoded in a single 1047 * U16 as (major << 8) | minor. We do this rather than store an entire SV 1048 * version object so we can fit the U16 into the uv of a SAVEHINTS and not 1049 * have to worry about SV refcounts during scope enter/exit. */ 1050 PERLVAR(I, prevailing_version, U16) 1051 1052 /* If you are adding a U8 or U16, check to see if there are 'Space' comments 1053 * above on where there are gaps which currently will be structure padding. */ 1054 1055 /* Within a stable branch, new variables must be added to the very end, before 1056 * this comment, for binary compatibility (the offsets of the old members must 1057 * not change). 1058 * (Don't forget to add your variable also to perl_clone()!) 1059 */ 1060