3 * Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
4 * 2006, 2007, 2008 by Larry Wall and others
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.
13 /* These variables are per-interpreter in threaded/multiplicity builds,
16 * Don't forget to re-run regen/embed.pl to propagate changes! */
18 /* New variables must be added to the very end for binary compatibility. */
20 /* DON'T FORGET to add your variable also to perl_clone()! (in sv.c) */
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.
27 * When building without MULTIPLICITY, these variables will be truly global.
29 * Important ones in the first cache line (if alignment is done right) */
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) */
35 PERLVAR(I, stack_base, SV **)
36 PERLVAR(I, stack_max, SV **)
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)
43 PERLVAR(I, scopestack, I32 *) /* scopes we've ENTERed */
44 PERLVAR(I, scopestack_ix, I32)
45 PERLVAR(I, scopestack_max, I32)
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 */
52 PERLVAR(I, markstack, I32 *) /* stack_sp locations we're
54 PERLVAR(I, markstack_ptr, I32 *)
55 PERLVAR(I, markstack_max, I32 *)
57 PERLVARI(I, sub_generation, U32, 1) /* incr to invalidate method cache */
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
66 PERLVARI(I, hash_rand_bits, UV, 0) /* used to randomize hash stuff */
68 PERLVAR(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 */
71 PERLVAR(I, multideref_pc, UNOP_AUX_item *)
73 /* Fields used by magic variables such as $@, $/ and so on */
74 PERLVAR(I, curpm, PMOP *) /* what to do \ interps in REs from */
75 PERLVAR(I, curpm_under, PMOP *) /* what to do \ interps in REs from */
77 PERLVAR(I, tainting, bool) /* ? doing taint checks */
78 PERLVARI(I, tainted, bool, FALSE) /* using variables controlled by $< */
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().
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.
93 PERLVAR(I, delaymagic, U16) /* ($<,$>) = ... */
96 =for apidoc_section $warning
97 =for apidoc mn|U8|PL_dowarn
99 The C variable that roughly corresponds to Perl's C<$^W> warning variable.
100 However, C<$^W> is treated as a boolean, whereas C<PL_dowarn> is a
101 collection of flag bits.
103 On threaded perls, each thread has an independent copy of this variable;
104 each initialized at creation time with the current value of the creating
110 PERLVAR(I, dowarn, U8)
112 #if defined (PERL_UTF8_CACHE_ASSERT) || defined (DEBUGGING)
117 PERLVARI(I, utf8cache, I8, PERL___I) /* Is the utf8 caching code enabled? */
121 =for apidoc_section $GV
122 =for apidoc Amn|GV *|PL_defgv
124 The GV representing C<*_>. Useful for access to C<$_>.
126 On threaded perls, each thread has an independent copy of this variable;
127 each initialized at creation time with the current value of the creating
133 PERLVAR(I, localizing, U8) /* are we processing a local() list? */
134 PERLVAR(I, in_eval, U8) /* trap "fatal" errors? */
135 PERLVAR(I, defgv, GV *) /* the *_ glob */
138 =for apidoc_section $GV
139 =for apidoc Amn|HV*|PL_curstash
141 The stash for the package code will be compiled into.
143 On threaded perls, each thread has an independent copy of this variable;
144 each initialized at creation time with the current value of the creating
151 PERLVAR(I, defstash, HV *) /* main symbol table */
152 PERLVAR(I, curstash, HV *) /* symbol table for current package */
155 =for apidoc_section $COP
156 =for apidoc Amn|COP*|PL_curcop
158 The currently active COP (control op) roughly representing the current
159 statement in the source.
161 On threaded perls, each thread has an independent copy of this variable;
162 each initialized at creation time with the current value of the creating
168 PERLVAR(I, curcop, COP *)
169 PERLVAR(I, curstack, AV *) /* THE STACK */
170 PERLVAR(I, curstackinfo, PERL_SI *) /* current stack + context */
171 PERLVAR(I, mainstack, AV *) /* the stack when nothing funny is
174 /* memory management */
175 PERLVAR(I, sv_count, IV) /* how many SV* are currently allocated */
177 PERLVAR(I, sv_root, SV *) /* storage for SVs belonging to interp */
178 PERLVAR(I, sv_arenaroot, SV *) /* list of areas for garbage collection */
180 /* fake PMOP that PL_curpm points to while in (?{}) so $1 et al are visible */
181 PERLVARI(I, reg_curpm, PMOP*, NULL)
183 /* the currently active slab in a chain of slabs of regmatch states,
184 * and the currently active state within that slab. This stack of states
185 * is shared amongst re-entrant calls to the regex engine */
187 PERLVARI(I, regmatch_slab, regmatch_slab *, NULL)
188 PERLVAR(I, regmatch_state, regmatch_state *)
190 PERLVAR(I, comppad, PAD *) /* storage for lexically scoped temporaries */
193 =for apidoc_section $SV
194 =for apidoc Amn|SV|PL_sv_undef
195 This is the C<undef> SV. It is readonly. Always refer to this as
198 =for apidoc Amn|SV|PL_sv_no
199 This is the C<false> SV. It is readonly. See C<L</PL_sv_yes>>. Always refer
200 to this as C<&PL_sv_no>.
202 =for apidoc Amn|SV|PL_sv_yes
203 This is the C<true> SV. It is readonly. See C<L</PL_sv_no>>. Always refer to
204 this as C<&PL_sv_yes>.
206 =for apidoc Amn|SV|PL_sv_zero
207 This readonly SV has a zero numeric value and a C<"0"> string value. It's
208 similar to C<L</PL_sv_no>> except for its string value. Can be used as a
209 cheap alternative to C<mXPUSHi(0)> for example. Always refer to this as
210 C<&PL_sv_zero>. Introduced in 5.28.
216 PERLVAR(I, sv_yes, SV)
217 PERLVAR(I, sv_undef, SV)
218 PERLVAR(I, sv_no, SV)
219 PERLVAR(I, sv_zero, SV)
221 /* store the immortals as an array to ensure they are contiguous in
222 * memory: makes SvIMMORTAL_INTERP(sv) possible */
223 PERLVARA(I, sv_immortals, 4, SV)
226 PERLVAR(I, padname_undef, PADNAME)
227 PERLVAR(I, padname_const, PADNAME)
230 =for apidoc_section $SV
231 =for apidoc Cmn||PL_Sv
233 A scratch pad SV for whatever temporary use you need. Chiefly used as a
234 fallback by macros on platforms where L<perlapi/PERL_USE_GCC_BRACE_GROUPS>> is
235 unavailable, and which would otherwise evaluate their SV parameter more than
238 B<BUT BEWARE>, if this is used in a situation where something that is using it
239 is in a call stack with something else that is using it, this variable would
240 get zapped, leading to hard-to-diagnose errors.
246 PERLVAR(I, parser, yy_parser *) /* current parser state */
248 PERLVAR(I, stashcache, HV *) /* Cache to speed up S_method_common */
252 =for apidoc_section $string
253 =for apidoc Amn|STRLEN|PL_na
255 A scratch pad variable in which to store a C<STRLEN> value. If would have been
256 better named something like C<PL_temp_strlen>.
258 It is is typically used with C<SvPV> when one is actually planning to discard
259 the returned length, (hence the length is "Not Applicable", which is how this
260 variable got its name).
262 B<BUT BEWARE>, if this is used in a situation where something that is using it
263 is in a call stack with something else that is using it, this variable would
264 get zapped, leading to hard-to-diagnose errors.
266 It is usually more efficient to either declare a local variable and use that
267 instead, or to use the C<SvPV_nolen> macro.
272 PERLVAR(I, na, STRLEN) /* for use in SvPV when length is
276 PERLVAR(I, statcache, Stat_t) /* _ */
277 PERLVAR(I, statgv, GV *)
278 PERLVARI(I, statname, SV *, NULL)
281 =for apidoc_section $io
282 =for apidoc mn|SV*|PL_rs
284 The input record separator - C<$/> in Perl space.
286 On threaded perls, each thread has an independent copy of this variable;
287 each initialized at creation time with the current value of the creating
290 =for apidoc_section $io
291 =for apidoc mn|GV*|PL_last_in_gv
293 The GV which was last used for a filehandle input operation. (C<< <FH> >>)
295 On threaded perls, each thread has an independent copy of this variable;
296 each initialized at creation time with the current value of the creating
299 =for apidoc_section $io
300 =for apidoc mn|GV*|PL_ofsgv
302 The glob containing the output field separator - C<*,> in Perl space.
304 On threaded perls, each thread has an independent copy of this variable;
305 each initialized at creation time with the current value of the creating
311 PERLVAR(I, rs, SV *) /* input record separator $/ */
312 PERLVAR(I, last_in_gv, GV *) /* GV used in last <FH> */
313 PERLVAR(I, ofsgv, GV *) /* GV of output field separator *, */
314 PERLVAR(I, defoutgv, GV *) /* default FH for output */
315 PERLVARI(I, chopset, const char *, " \n-") /* $: */
316 PERLVAR(I, formtarget, SV *)
317 PERLVAR(I, bodytarget, SV *)
318 PERLVAR(I, toptarget, SV *)
321 PERLVAR(I, restartop, OP *) /* propagating an error from croak? */
322 PERLVAR(I, restartjmpenv, JMPENV *) /* target frame for longjmp in die */
324 PERLVAR(I, top_env, JMPENV *) /* ptr to current sigjmp environment */
325 PERLVAR(I, start_env, JMPENV) /* empty startup sigjmp environment */
326 PERLVARI(I, errors, SV *, NULL) /* outstanding queued errors */
328 /* statics "owned" by various functions */
329 PERLVAR(I, hv_fetch_ent_mh, HE*) /* owned by hv_fetch_ent() */
331 PERLVAR(I, lastgotoprobe, OP*) /* from pp_ctl.c */
334 PERLVAR(I, sortcop, OP *) /* user defined sort routine */
335 PERLVAR(I, sortstash, HV *) /* which is in some package or other */
336 PERLVAR(I, firstgv, GV *) /* $a */
337 PERLVAR(I, secondgv, GV *) /* $b */
340 PERLVAR(I, efloatbuf, char *)
341 PERLVAR(I, efloatsize, STRLEN)
343 PERLVARI(I, dumpindent, U16, 4) /* number of blanks per dump
347 =for apidoc_section $embedding
348 =for apidoc Amn|U8|PL_exit_flags
350 Contains flags controlling perl's behaviour on exit():
354 =item * C<PERL_EXIT_DESTRUCT_END>
356 If set, END blocks are executed when the interpreter is destroyed.
357 This is normally set by perl itself after the interpreter is
360 =item * C<PERL_EXIT_ABORT>
362 Call C<abort()> on exit. This is used internally by perl itself to
363 abort if exit is called while processing exit.
365 =item * C<PERL_EXIT_WARN>
369 =item * C<PERL_EXIT_EXPECTED>
371 Set by the L<perlfunc/exit> operator.
375 =for apidoc Amnh||PERL_EXIT_EXPECTED
376 =for apidoc Amnh||PERL_EXIT_ABORT
377 =for apidoc Amnh||PERL_EXIT_DESTRUCT_END
378 =for apidoc Amnh||PERL_EXIT_WARN
380 On threaded perls, each thread has an independent copy of this variable;
381 each initialized at creation time with the current value of the creating
387 PERLVAR(I, exit_flags, U8) /* was exit() unexpected, etc. */
389 PERLVAR(I, utf8locale, bool) /* utf8 locale detected */
391 #if defined(USE_LOCALE) && defined(USE_LOCALE_THREADS)
392 PERLVARI(I, locale_mutex_depth, int, 0) /* Emulate general semaphore */
395 #ifdef USE_LOCALE_CTYPE
396 PERLVAR(I, warn_locale, SV *)
397 PERLVAR(I, in_utf8_CTYPE_locale, bool)
398 PERLVAR(I, in_utf8_turkic_locale, bool)
401 PERLVARA(I, colors,6, char *) /* values from PERL_RE_COLORS env var */
404 =for apidoc_section $optree_construction
405 =for apidoc Amn|peep_t|PL_peepp
407 Pointer to the per-subroutine peephole optimiser. This is a function
408 that gets called at the end of compilation of a Perl subroutine (or
409 equivalently independent piece of Perl code) to perform fixups of
410 some ops and to perform small-scale optimisations. The function is
411 called once for each subroutine that is compiled, and is passed, as sole
412 parameter, a pointer to the op that is the entry point to the subroutine.
413 It modifies the op tree in place.
415 The peephole optimiser should never be completely replaced. Rather,
416 add code to it by wrapping the existing optimiser. The basic way to do
417 this can be seen in L<perlguts/Compile pass 3: peephole optimization>.
418 If the new code wishes to operate on ops throughout the subroutine's
419 structure, rather than just at the top level, it is likely to be more
420 convenient to wrap the L</PL_rpeepp> hook.
422 On threaded perls, each thread has an independent copy of this variable;
423 each initialized at creation time with the current value of the creating
429 PERLVARI(I, peepp, peep_t, Perl_peep)
432 =for apidoc_section $optree_construction
433 =for apidoc Amn|peep_t|PL_rpeepp
435 Pointer to the recursive peephole optimiser. This is a function
436 that gets called at the end of compilation of a Perl subroutine (or
437 equivalently independent piece of Perl code) to perform fixups of some
438 ops and to perform small-scale optimisations. The function is called
439 once for each chain of ops linked through their C<op_next> fields;
440 it is recursively called to handle each side chain. It is passed, as
441 sole parameter, a pointer to the op that is at the head of the chain.
442 It modifies the op tree in place.
444 The peephole optimiser should never be completely replaced. Rather,
445 add code to it by wrapping the existing optimiser. The basic way to do
446 this can be seen in L<perlguts/Compile pass 3: peephole optimization>.
447 If the new code wishes to operate only on ops at a subroutine's top level,
448 rather than throughout the structure, it is likely to be more convenient
449 to wrap the L</PL_peepp> hook.
451 On threaded perls, each thread has an independent copy of this variable;
452 each initialized at creation time with the current value of the creating
458 PERLVARI(I, rpeepp, peep_t, Perl_rpeep)
461 =for apidoc_section $optrees
462 =for apidoc Amn|Perl_ophook_t|PL_opfreehook
464 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.
465 This allows extensions to free any extra attribute they have locally attached to an OP.
466 It is also assured to first fire for the parent OP and then for its kids.
468 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.
470 On threaded perls, each thread has an independent copy of this variable;
471 each initialized at creation time with the current value of the creating
477 PERLVARI(I, opfreehook, Perl_ophook_t, 0) /* op_free() hook */
479 PERLVARI(I, watchaddr, char **, 0)
480 PERLVAR(I, watchok, char *)
482 PERLVAR(I, perldb, U32)
484 PERLVAR(I, signals, U32) /* Using which pre-5.8 signals */
486 PERLVAR(I, reentrant_retint, int) /* Integer return value from reentrant functions */
488 /* pseudo environmental stuff */
489 PERLVAR(I, origargc, int)
490 PERLVAR(I, origargv, char **)
491 PERLVAR(I, envgv, GV *)
492 PERLVAR(I, incgv, GV *)
493 PERLVAR(I, hintgv, GV *)
494 PERLVAR(I, origfilename, char *)
495 PERLVARI(I, xsubfilename, const char *, NULL)
496 PERLVAR(I, diehook, SV *)
497 PERLVAR(I, warnhook, SV *)
500 PERLVAR(I, patchlevel, SV *)
501 PERLVAR(I, localpatches, const char * const *)
502 PERLVARI(I, splitstr, char *, NULL)
504 PERLVAR(I, minus_c, bool)
505 PERLVAR(I, minus_n, bool)
506 PERLVAR(I, minus_p, bool)
507 PERLVAR(I, minus_l, bool)
508 PERLVAR(I, minus_a, bool)
509 PERLVAR(I, minus_F, bool)
510 PERLVAR(I, doswitches, bool)
511 PERLVAR(I, minus_E, bool)
513 PERLVAR(I, inplace, char *)
514 PERLVAR(I, e_script, SV *)
516 PERLVAR(I, basetime, Time_t) /* $^T */
518 PERLVARI(I, maxsysfd, I32, MAXSYSFD)
519 /* top fd to pass to subprocesses */
520 PERLVAR(I, statusvalue, I32) /* $? */
522 PERLVAR(I, statusvalue_vms, U32)
524 PERLVAR(I, statusvalue_posix, I32)
527 PERLVARI(I, sig_pending, int, 0) /* Number if highest signal pending */
528 PERLVAR(I, psig_pend, int *) /* per-signal "count" of pending */
530 /* shortcuts to various I/O objects */
531 PERLVAR(I, stdingv, GV *) /* *STDIN */
532 PERLVAR(I, stderrgv, GV *) /* *STDERR */
533 PERLVAR(I, argvgv, GV *) /* *ARGV */
534 PERLVAR(I, argvoutgv, GV *) /* *ARGVOUT */
535 PERLVAR(I, argvout_stack, AV *)
537 /* shortcuts to regexp stuff */
538 PERLVAR(I, replgv, GV *) /* *^R */
540 /* shortcuts to misc objects */
541 PERLVAR(I, errgv, GV *) /* *@ */
543 /* shortcuts to debugging objects */
544 PERLVAR(I, DBgv, GV *) /* *DB::DB */
545 PERLVAR(I, DBline, GV *) /* *DB::line */
548 =for apidoc_section $debugging
549 =for apidoc mn|GV *|PL_DBsub
550 When Perl is run in debugging mode, with the B<-d> switch, this GV contains
551 the SV which holds the name of the sub being debugged. This is the C
552 variable which corresponds to Perl's $DB::sub variable. See
555 On threaded perls, each thread has an independent copy of this variable;
556 each initialized at creation time with the current value of the creating
559 =for apidoc mn|SV *|PL_DBsingle
560 When Perl is run in debugging mode, with the B<-d> switch, this SV is a
561 boolean which indicates whether subs are being single-stepped.
562 Single-stepping is automatically turned on after every step. This is the C
563 variable which corresponds to Perl's $DB::single variable. See
566 On threaded perls, each thread has an independent copy of this variable;
567 each initialized at creation time with the current value of the creating
570 =for apidoc mn|SV *|PL_DBtrace
571 Trace variable used when Perl is run in debugging mode, with the B<-d>
572 switch. This is the C variable which corresponds to Perl's $DB::trace
573 variable. See C<L</PL_DBsingle>>.
575 On threaded perls, each thread has an independent copy of this variable;
576 each initialized at creation time with the current value of the creating
582 PERLVAR(I, DBsub, GV *) /* *DB::sub */
583 PERLVAR(I, DBsingle, SV *) /* $DB::single */
584 PERLVAR(I, DBtrace, SV *) /* $DB::trace */
585 PERLVAR(I, DBsignal, SV *) /* $DB::signal */
586 PERLVAR(I, dbargs, AV *) /* args to call listed by caller function */
588 PERLVARA(I, DBcontrol, DBVARMG_COUNT, IV) /* IV versions of $DB::single, trace, signal */
591 PERLVAR(I, debstash, HV *) /* symbol table for perldb package */
592 PERLVAR(I, globalstash, HV *) /* global keyword overrides imported here */
593 PERLVAR(I, curstname, SV *) /* name of current package */
594 PERLVAR(I, beginav, AV *) /* names of BEGIN subroutines */
595 PERLVAR(I, endav, AV *) /* names of END subroutines */
596 PERLVAR(I, unitcheckav, AV *) /* names of UNITCHECK subroutines */
597 PERLVAR(I, checkav, AV *) /* names of CHECK subroutines */
598 PERLVAR(I, initav, AV *) /* names of INIT subroutines */
600 /* subprocess state */
601 PERLVAR(I, fdpid, AV *) /* keep fd-to-pid mappings for my_popen */
604 PERLVARI(I, op_mask, char *, NULL) /* masked operations for safe evals */
606 /* current interpreter roots */
607 PERLVAR(I, main_cv, CV *)
608 PERLVAR(I, main_root, OP *)
609 PERLVAR(I, main_start, OP *)
610 PERLVAR(I, eval_root, OP *)
611 PERLVAR(I, eval_start, OP *)
613 /* runtime control stuff */
614 PERLVARI(I, curcopdb, COP *, NULL)
616 PERLVAR(I, filemode, int) /* so nextargv() can preserve mode */
617 PERLVAR(I, lastfd, int) /* what to preserve mode on */
618 PERLVAR(I, oldname, char *) /* what to preserve mode on */
619 /* Elements in this array have ';' appended and are injected as a single line
620 into the tokeniser. You can't put any (literal) newlines into any program
621 you stuff in into this array, as the point where it's injected is expecting
622 a single physical line. */
623 PERLVAR(I, preambleav, AV *)
624 PERLVAR(I, mess_sv, SV *)
625 PERLVAR(I, ors_sv, SV *) /* output record separator $\ */
627 /* funky return mechanisms */
628 PERLVAR(I, forkprocess, int) /* so do_open |- can return proc# */
630 /* statics moved here for shared library purposes */
631 PERLVARI(I, gensym, I32, 0) /* next symbol for getsym() to define */
632 PERLVARI(I, cv_has_eval, bool, FALSE) /* PL_compcv includes an entereval or similar */
633 PERLVAR(I, taint_warn, bool) /* taint warns instead of dying */
634 PERLVARI(I, laststype, U16, OP_STAT)
636 PERLVARI(I, laststatval, int, -1)
638 PERLVAR(I, modcount, I32) /* how much op_lvalue()ification in
641 /* interpreter atexit processing */
642 PERLVARI(I, exitlistlen, I32, 0) /* length of same */
643 PERLVARI(I, exitlist, PerlExitListEntry *, NULL)
644 /* list of exit functions */
647 =for apidoc_section $HV
648 =for apidoc Amn|HV*|PL_modglobal
650 C<PL_modglobal> is a general purpose, interpreter global HV for use by
651 extensions that need to keep information on a per-interpreter basis.
652 In a pinch, it can also be used as a symbol table for extensions
653 to share data among each other. It is a good idea to use keys
654 prefixed by the package name of the extension that owns the data.
656 On threaded perls, each thread has an independent copy of this variable;
657 each initialized at creation time with the current value of the creating
663 PERLVAR(I, modglobal, HV *) /* per-interp module data */
665 /* these used to be in global before 5.004_68 */
666 PERLVARI(I, profiledata, U32 *, NULL) /* table of ops, counts */
668 PERLVAR(I, compiling, COP) /* compiling/done executing marker */
670 PERLVAR(I, compcv, CV *) /* currently compiling subroutine */
671 PERLVAR(I, comppad_name, PADNAMELIST *) /* variable names for "my" variables */
672 PERLVAR(I, comppad_name_fill, PADOFFSET)/* last "introduced" variable offset */
673 PERLVAR(I, comppad_name_floor, PADOFFSET)/* start of vars in innermost block */
675 #ifdef HAVE_INTERP_INTERN
676 PERLVAR(I, sys_intern, struct interp_intern)
677 /* platform internals */
680 /* more statics moved here */
681 PERLVAR(I, DBcv, CV *) /* from perl.c */
682 PERLVARI(I, generation, int, 100) /* scan sequence# for OP_AASSIGN
683 compile-time common elem detection */
685 PERLVAR(I, unicode, U32) /* Unicode features: $ENV{PERL_UNICODE} or -C */
687 PERLVARI(I, in_clean_objs,bool, FALSE) /* from sv.c */
688 PERLVARI(I, in_clean_all, bool, FALSE) /* ptrs to freed SVs now legal */
689 PERLVAR(I, nomemok, bool) /* let malloc context handle nomem */
690 PERLVARI(I, savebegin, bool, FALSE) /* save BEGINs for compiler */
693 PERLVAR(I, delaymagic_uid, Uid_t) /* current real user id, only for delaymagic */
694 PERLVAR(I, delaymagic_euid, Uid_t) /* current effective user id, only for delaymagic */
695 PERLVAR(I, delaymagic_gid, Gid_t) /* current real group id, only for delaymagic */
696 PERLVAR(I, delaymagic_egid, Gid_t) /* current effective group id, only for delaymagic */
697 PERLVARI(I, an, U32, 0) /* malloc sequence number */
699 /* Perl_Ibreakable_sub_generation_ptr was too long for VMS, hence "gen" */
700 PERLVARI(I, breakable_sub_gen, U32, 0)
703 /* exercise wrap-around */
704 #define PERL_COP_SEQMAX (U32_MAX-50)
706 #define PERL_COP_SEQMAX 0
708 PERLVARI(I, cop_seqmax, U32, PERL_COP_SEQMAX) /* statement sequence number */
709 #undef PERL_COP_SEQMAX
711 PERLVARI(I, evalseq, U32, 0) /* eval sequence number */
712 PERLVAR(I, origalen, U32)
713 #ifdef PERL_USES_PL_PIDSTATUS
714 PERLVAR(I, pidstatus, HV *) /* pid-to-status mappings for waitpid */
716 PERLVAR(I, osname, char *) /* operating system */
718 PERLVAR(I, sighandlerp, Sighandler_t)
719 /* these two are provided only to solve library linkage issues; they
720 * should not be hooked by user code */
721 PERLVAR(I, sighandler1p, Sighandler1_t)
722 PERLVAR(I, sighandler3p, Sighandler3_t)
724 PERLVARA(I, body_roots, PERL_ARENA_ROOTS_SIZE, void*) /* array of body roots */
726 PERLVAR(I, debug, volatile U32) /* flags given to -D switch */
728 PERLVARI(I, padlist_generation, U32, 1) /* id to identify padlist clones */
730 PERLVARI(I, runops, runops_proc_t, RUNOPS_DEFAULT)
732 PERLVAR(I, subname, SV *) /* name of current subroutine */
734 PERLVAR(I, subline, I32) /* line this subroutine began on */
735 PERLVAR(I, min_intro_pending, PADOFFSET)/* start of vars to introduce */
737 PERLVAR(I, max_intro_pending, PADOFFSET)/* end of vars to introduce */
738 PERLVAR(I, padix, PADOFFSET) /* lowest unused index - 1
739 in current "register" pad */
740 PERLVAR(I, constpadix, PADOFFSET) /* lowest unused for constants */
742 PERLVAR(I, padix_floor, PADOFFSET) /* how low may inner block reset padix */
744 #if defined(USE_POSIX_2008_LOCALE) && defined(MULTIPLICITY)
745 PERLVARI(I, cur_locale_obj, locale_t, NULL)
747 #ifdef USE_PL_CURLOCALES
749 /* This is the most number of categories we've encountered so far on any
750 * platform, doesn't include LC_ALL */
751 PERLVARA(I, curlocales, 12, const char *)
754 #ifdef USE_PL_CUR_LC_ALL
756 PERLVARI(I, cur_LC_ALL, const char *, NULL)
759 #ifdef USE_LOCALE_COLLATE
761 /* The emory needed to store the collxfrm transformation of a string with
762 * length 'x' is predicted by the linear equation mx+b; m=mult, b=base */
763 PERLVARI(I, collxfrm_mult,Size_t, 0) /* Expansion factor in *xfrm();
764 0 => unknown or bad, depending on
766 PERLVAR(I, collxfrm_base, Size_t) /* Basic overhead in *xfrm();
767 mult == 0, base == 0 => need to compute
768 mult == 0, base != 0 => ill-formed;
770 PERLVAR(I, collation_name, char *) /* Name of current collation */
771 PERLVARI(I, collation_ix, U32, 0) /* Collation generation index */
772 PERLVARI(I, strxfrm_NUL_replacement, U8, 0) /* Code point to replace NULs */
773 PERLVARI(I, strxfrm_is_behaved, bool, TRUE)
774 /* Assume until proven otherwise that it works */
775 PERLVARI(I, strxfrm_max_cp, U8, 0) /* Highest collating cp in locale */
776 PERLVARI(I, collation_standard, bool, TRUE)
777 /* Assume simple collation */
778 PERLVAR(I, in_utf8_COLLATE_locale, bool)
779 #endif /* USE_LOCALE_COLLATE */
781 PERLVARI(I, langinfo_buf, const char *, NULL)
782 PERLVARI(I, langinfo_bufsize, Size_t, 0)
783 PERLVARI(I, setlocale_buf, const char *, NULL)
784 PERLVARI(I, setlocale_bufsize, Size_t, 0)
785 PERLVARI(I, stdize_locale_buf, const char *, NULL)
786 PERLVARI(I, stdize_locale_bufsize, Size_t, 0)
788 #ifdef PERL_SAWAMPERSAND
789 PERLVAR(I, sawampersand, U8) /* must save all match strings */
792 /* current phase the interpreter is in
793 for ordering this structure to remove holes, we're assuming that this is 4
795 PERLVARI(I, phase, enum perl_phase, PERL_PHASE_CONSTRUCT)
797 PERLVARI(I, in_load_module, bool, FALSE) /* to prevent recursions in PerlIO_find_layer */
799 PERLVARI(I, eval_begin_nest_depth, U32, 0)
801 PERLVAR(I, unsafe, bool)
802 PERLVAR(I, colorset, bool) /* PERL_RE_COLORS env var is in use */
805 =for apidoc_section $embedding
806 =for apidoc Amn|signed char|PL_perl_destruct_level
808 This value may be set when embedding for full cleanup.
818 =item * 2 or greater - full with checks.
822 If C<$ENV{PERL_DESTRUCT_LEVEL}> is set to an integer greater than the
823 value of C<PL_perl_destruct_level> its value is used instead.
825 On threaded perls, each thread has an independent copy of this variable;
826 each initialized at creation time with the current value of the creating
831 /* mod_perl is special, and also assigns a meaning -1 */
832 PERLVARI(I, perl_destruct_level, signed char, 0)
834 PERLVAR(I, pad_reset_pending, bool) /* reset pad on next attempted alloc */
836 PERLVARI(I, srand_called, bool, false) /* has random_state been initialized yet? */
837 PERLVARI(I, srand_override, U32, 0) /* Should we use a deterministic sequence? */
838 PERLVARI(I, srand_override_next, U32, 0) /* Next item in the sequence */
840 PERLVARI(I, numeric_underlying, bool, TRUE)
841 /* Assume underlying locale numerics */
842 PERLVARI(I, numeric_underlying_is_standard, bool, TRUE)
844 PERLVARI(I, numeric_standard, int, TRUE) /* Assume C locale numerics */
845 PERLVAR(I, numeric_name, char *) /* Name of current numeric locale */
846 PERLVAR(I, numeric_radix_sv, SV *) /* The radix separator */
847 PERLVAR(I, underlying_radix_sv, SV *) /* The radix in the program's current underlying locale */
849 #if defined(USE_LOCALE_NUMERIC) && defined(USE_POSIX_2008_LOCALE)
851 PERLVARI(I, underlying_numeric_obj, locale_t, NULL)
854 #ifdef USE_POSIX_2008_LOCALE
855 PERLVARI(I, scratch_locale_obj, locale_t, 0)
858 #ifdef USE_LOCALE_CTYPE
860 PERLVARI(I, ctype_name, const char *, NULL) /* Name of current ctype locale */
864 /* Array of signal handlers, indexed by signal number, through which the C
865 signal handler dispatches. */
866 PERLVAR(I, psig_ptr, SV **)
867 /* Array of names of signals, indexed by signal number, for (re)use as the first
868 argument to a signal handler. Only one block of memory is allocated for
869 both psig_name and psig_ptr. */
870 PERLVAR(I, psig_name, SV **)
872 #if defined(PERL_IMPLICIT_SYS)
873 PERLVAR(I, Mem, struct IPerlMem *)
874 PERLVAR(I, MemShared, struct IPerlMem *)
875 PERLVAR(I, MemParse, struct IPerlMem *)
876 PERLVAR(I, Env, struct IPerlEnv *)
877 PERLVAR(I, StdIO, struct IPerlStdIO *)
878 PERLVAR(I, LIO, struct IPerlLIO *)
879 PERLVAR(I, Dir, struct IPerlDir *)
880 PERLVAR(I, Sock, struct IPerlSock *)
881 PERLVAR(I, Proc, struct IPerlProc *)
884 PERLVAR(I, ptr_table, PTR_TBL_t *)
885 PERLVARI(I, beginav_save, AV *, NULL) /* save BEGIN{}s when compiling */
887 PERLVAR(I, body_arenas, void *) /* pointer to list of body-arenas */
890 #if defined(USE_ITHREADS)
891 PERLVAR(I, regex_pad, SV **) /* Shortcut into the array of
893 PERLVAR(I, regex_padav, AV *) /* All regex objects, indexed via the
894 values in op_pmoffset of pmop.
895 Entry 0 is an SV whose PV is a
896 "packed" list of IVs listing
897 the now-free slots in the array */
898 PERLVAR(I, stashpad, HV **) /* for CopSTASH */
899 PERLVARI(I, stashpadmax, PADOFFSET, 64)
900 PERLVARI(I, stashpadix, PADOFFSET, 0)
903 #ifdef USE_REENTRANT_API
904 PERLVAR(I, reentrant_buffer, REENTR *) /* here we store the _r buffers */
907 PERLVAR(I, custom_op_names, HV *) /* Names of user defined ops */
908 PERLVAR(I, custom_op_descs, HV *) /* Descriptions of user defined ops */
911 PERLVARI(I, perlio, PerlIOl *, NULL)
912 PERLVARI(I, known_layers, PerlIO_list_t *, NULL)
913 PERLVARI(I, def_layerlist, PerlIO_list_t *, NULL)
916 PERLVARI(I, checkav_save, AV *, NULL) /* save CHECK{}s when compiling */
917 PERLVARI(I, unitcheckav_save, AV *, NULL)
918 /* save UNITCHECK{}s when compiling */
920 PERLVARI(I, clocktick, long, 0) /* this many times() ticks in a second */
922 /* Hooks to shared SVs and locks. */
923 PERLVARI(I, sharehook, share_proc_t, Perl_sv_nosharing)
924 PERLVARI(I, lockhook, share_proc_t, Perl_sv_nosharing)
926 GCC_DIAG_IGNORE(-Wdeprecated-declarations)
928 # define PERL_UNLOCK_HOOK Perl_sv_nosharing
930 /* This reference ensures that the mathoms are linked with perl */
931 # define PERL_UNLOCK_HOOK Perl_sv_nounlocking
933 PERLVARI(I, unlockhook, share_proc_t, PERL_UNLOCK_HOOK)
937 PERLVARI(I, threadhook, thrhook_proc_t, Perl_nothreadhook)
939 /* Can shared object be destroyed */
940 PERLVARI(I, destroyhook, destroyable_proc_t, Perl_sv_destroyable)
943 PERLVARI(I, signalhook, despatch_signals_proc_t, Perl_despatch_signals)
946 PERLVARI(I, isarev, HV *, NULL) /* Reverse map of @ISA dependencies */
948 /* Register of known Method Resolution Orders.
949 What this actually points to is an implementation detail (it may change to
950 a structure incorporating a reference count - use mro_get_from_name to
951 retrieve a C<struct mro_alg *> */
952 PERLVAR(I, registered_mros, HV *)
954 /* Compile-time block start/end hooks */
955 PERLVAR(I, blockhooks, AV *)
957 PERLVAR(I, custom_ops, HV *) /* custom op registrations */
959 PERLVAR(I, Xpv, XPV *) /* (unused) held temporary value */
961 /* name of the scopes we've ENTERed. Only used with -DDEBUGGING, but needs to be
962 present always, as -DDEBUGGING must be binary compatible with non. */
963 PERLVARI(I, scopestack_name, const char **, NULL)
965 PERLVAR(I, debug_pad, struct perl_debug_pad) /* always needed because of the re extension */
967 /* Hook for File::Glob */
968 PERLVARI(I, globhook, globhook_t, NULL)
970 #if defined(MULTIPLICITY)
971 /* The last unconditional member of the interpreter structure when 5.18.0 was
972 released. The offset of the end of this is baked into a global variable in
973 any shared perl library which will allow a sanity test in future perl
975 # define PERL_LAST_5_18_0_INTERP_MEMBER Iglobhook
979 PERLVARI(I, my_cxt_list, void **, NULL) /* per-module array of MY_CXT pointers */
980 PERLVARI(I, my_cxt_size, int, 0) /* size of PL_my_cxt_list */
983 #if defined(MULTIPLICITY) || defined(PERL_DEBUG_READONLY_COW)
984 /* For use with the memory debugging code in util.c. This is used only in
985 * DEBUGGING builds (as long as the relevant structure is defined), but
986 * defining it in non-debug builds too means that we retain binary
987 * compatibility between otherwise-compatible plain and debug builds. */
988 PERLVAR(I, memory_debug_header, struct perl_memory_debug_header)
991 #ifdef DEBUG_LEAKING_SCALARS_FORK_DUMP
992 /* File descriptor to talk to the child which dumps scalars. */
993 PERLVARI(I, dumper_fd, int, -1)
997 #ifdef DEBUG_LEAKING_SCALARS
998 PERLVARI(I, sv_serial, U32, 0) /* SV serial number, used in sv.c */
1001 PERLVARA(I, sv_consts, SV_CONSTS_COUNT, SV*) /* constant SVs with precomputed hash value */
1003 #ifdef PERL_TRACE_OPS
1004 PERLVARA(I, op_exec_cnt, OP_max+2, UV) /* Counts of executed OPs of the given type.
1005 If PERL_TRACE_OPS is enabled, we'll dump
1006 a summary count of all ops executed in the
1007 program at perl_destruct time. Used only
1008 for profiling in DEBUGGING mode. */
1011 PERLVAR(I, random_state, PL_RANDOM_STATE_TYPE)
1013 PERLVARI(I, dump_re_max_len, STRLEN, 60)
1015 /* For internal uses of randomness, this ensures the sequence of
1016 * random numbers returned by rand() isn't modified by perl's internal
1017 * use of randomness.
1018 * This is important if the user has called srand() with a seed.
1021 PERLVAR(I, internal_random_state, PL_RANDOM_STATE_TYPE)
1023 PERLVARA(I, TR_SPECIAL_HANDLING_UTF8, UTF8_MAXBYTES, char)
1025 PERLVAR(I, AboveLatin1, SV *)
1026 PERLVAR(I, Assigned_invlist, SV *)
1027 PERLVAR(I, GCB_invlist, SV *)
1028 PERLVAR(I, HasMultiCharFold, SV *)
1029 PERLVAR(I, InMultiCharFold, SV *)
1030 PERLVAR(I, Latin1, SV *)
1031 PERLVAR(I, LB_invlist, SV *)
1032 PERLVAR(I, SB_invlist, SV *)
1033 PERLVAR(I, SCX_invlist, SV *)
1034 PERLVAR(I, UpperLatin1, SV *) /* Code points 128 - 255 */
1036 PERLVARA(I, fold_locale, 256, U8)
1038 /* List of characters that participate in any fold defined by Unicode */
1039 PERLVAR(I, in_some_fold, SV *)
1041 /* Everything that folds to a given character, for case insensitivity regex
1043 PERLVAR(I, utf8_foldclosures, SV *)
1045 PERLVAR(I, utf8_idcont, SV *)
1046 PERLVAR(I, utf8_idstart, SV *)
1047 PERLVAR(I, utf8_perl_idcont, SV *)
1048 PERLVAR(I, utf8_perl_idstart, SV *)
1049 PERLVAR(I, utf8_xidcont, SV *)
1050 PERLVAR(I, utf8_xidstart, SV *)
1051 PERLVAR(I, WB_invlist, SV *)
1052 PERLVARA(I, XPosix_ptrs, POSIX_CC_COUNT, SV *)
1053 PERLVARA(I, Posix_ptrs, POSIX_CC_COUNT, SV *)
1054 PERLVAR(I, utf8_toupper, SV *)
1055 PERLVAR(I, utf8_totitle, SV *)
1056 PERLVAR(I, utf8_tolower, SV *)
1057 PERLVAR(I, utf8_tofold, SV *)
1058 PERLVAR(I, utf8_tosimplefold, SV *)
1059 PERLVAR(I, utf8_charname_begin, SV *)
1060 PERLVAR(I, utf8_charname_continue, SV *)
1061 PERLVAR(I, utf8_mark, SV *)
1062 PERLVARI(I, InBitmap, SV *, NULL)
1063 PERLVAR(I, CCC_non0_non230, SV *)
1064 PERLVAR(I, Private_Use, SV *)
1067 PERLVAR(I, mbrlen_ps, mbstate_t)
1070 PERLVAR(I, mbrtowc_ps, mbstate_t)
1073 PERLVAR(I, wcrtomb_ps, mbstate_t)
1076 /* Enough space for the reserved byte, 1 for a potential leading 0, then enough
1077 * for the longest representable integer plus an extra, the 3 flag characters,
1079 #define PERL_MEM_LOG_ARYLEN (1 + 1 + TYPE_DIGITS(UV) + 1 + 3 + 1)
1080 PERLVARA(I, mem_log, PERL_MEM_LOG_ARYLEN, char)
1083 /* The most recently seen `use VERSION` declaration, encoded in a single
1084 * U16 as (major << 8) | minor. We do this rather than store an entire SV
1085 * version object so we can fit the U16 into the uv of a SAVEHINTS and not
1086 * have to worry about SV refcounts during scope enter/exit. */
1087 PERLVAR(I, prevailing_version, U16)
1089 /* If you are adding a U8 or U16, check to see if there are 'Space' comments
1090 * above on where there are gaps which currently will be structure padding. */
1092 /* Within a stable branch, new variables must be added to the very end, before
1093 * this comment, for binary compatibility (the offsets of the old members must
1095 * (Don't forget to add your variable also to perl_clone()!)