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