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.
12 =head1 Per-Interpreter Variables
15 /* These variables are per-interpreter in threaded/multiplicity builds,
18 * Don't forget to re-run regen/embed.pl to propagate changes! */
20 /* New variables must be added to the very end for binary compatibility. */
22 /* Don't forget to add your variable also to perl_clone()! (in sv.c) */
24 /* The 'I' prefix is only needed for vars that need appropriate #defines
25 * generated when built with or without MULTIPLICITY. It is also used
26 * to generate the appropriate export list for win32. If the variable
27 * needs to be initialized, use PERLVARI.
29 * When building without MULTIPLICITY, these variables will be truly global.
31 * Important ones in the first cache line (if alignment is done right) */
33 PERLVAR(I, stack_sp, SV **) /* top of the stack */
35 PERLVAR(I, opsave, OP *)
37 PERLVAR(I, op, OP *) /* currently executing op */
39 PERLVAR(I, curpad, SV **) /* active pad (lexicals+tmps) */
41 PERLVAR(I, stack_base, SV **)
42 PERLVAR(I, stack_max, SV **)
44 PERLVAR(I, scopestack, I32 *) /* scopes we've ENTERed */
45 /* name of the scopes we've ENTERed. Only used with -DDEBUGGING, but needs to be
46 present always, as -DDEUBGGING must be binary compatible with non. */
47 PERLVARI(I, scopestack_name, const char * *, NULL)
48 PERLVAR(I, scopestack_ix, I32)
49 PERLVAR(I, scopestack_max, I32)
51 PERLVAR(I, savestack, ANY *) /* items that need to be restored when
52 LEAVEing scopes we've ENTERed */
53 PERLVAR(I, savestack_ix, I32)
54 PERLVAR(I, savestack_max, I32)
56 PERLVAR(I, tmps_stack, SV **) /* mortals we've made */
57 PERLVARI(I, tmps_ix, I32, -1)
58 PERLVARI(I, tmps_floor, I32, -1)
59 PERLVAR(I, tmps_max, I32)
60 PERLVAR(I, modcount, I32) /* how much op_lvalue()ification in
63 PERLVAR(I, markstack, I32 *) /* stack_sp locations we're
65 PERLVAR(I, markstack_ptr, I32 *)
66 PERLVAR(I, markstack_max, I32 *)
68 PERLVAR(I, Sv, SV *) /* used to hold temporary values */
69 PERLVAR(I, Xpv, XPV *) /* used to hold temporary values */
72 =for apidoc Amn|STRLEN|PL_na
74 A convenience variable which is typically used with C<SvPV> when one
75 doesn't care about the length of the string. It is usually more efficient
76 to either declare a local variable and use that instead or to use the
82 PERLVAR(I, na, STRLEN) /* for use in SvPV when length is
86 PERLVAR(I, statbuf, Stat_t)
87 PERLVAR(I, statcache, Stat_t) /* _ */
88 PERLVAR(I, statgv, GV *)
89 PERLVARI(I, statname, SV *, NULL)
92 PERLVAR(I, timesbuf, struct tms)
95 /* Fields used by magic variables such as $@, $/ and so on */
96 PERLVAR(I, curpm, PMOP *) /* what to do \ interps in REs from */
99 =for apidoc mn|SV*|PL_rs
101 The input record separator - C<$/> in Perl space.
103 =for apidoc mn|GV*|PL_last_in_gv
105 The GV which was last used for a filehandle input operation. (C<< <FH> >>)
107 =for apidoc mn|GV*|PL_ofsgv
109 The glob containing the output field separator - C<*,> in Perl space.
114 PERLVAR(I, rs, SV *) /* input record separator $/ */
115 PERLVAR(I, last_in_gv, GV *) /* GV used in last <FH> */
116 PERLVAR(I, ofsgv, GV *) /* GV of output field separator *, */
117 PERLVAR(I, defoutgv, GV *) /* default FH for output */
118 PERLVARI(I, chopset, const char *, " \n-") /* $: */
119 PERLVAR(I, formtarget, SV *)
120 PERLVAR(I, bodytarget, SV *)
121 PERLVAR(I, toptarget, SV *)
124 PERLVAR(I, defstash, HV *) /* main symbol table */
125 PERLVAR(I, curstash, HV *) /* symbol table for current package */
127 PERLVAR(I, restartop, OP *) /* propagating an error from croak? */
128 PERLVAR(I, restartjmpenv, JMPENV *) /* target frame for longjmp in die */
129 PERLVAR(I, curcop, COP *)
130 PERLVAR(I, curstack, AV *) /* THE STACK */
131 PERLVAR(I, curstackinfo, PERL_SI *) /* current stack + context */
132 PERLVAR(I, mainstack, AV *) /* the stack when nothing funny is
135 PERLVAR(I, top_env, JMPENV *) /* ptr to current sigjmp environment */
136 PERLVAR(I, start_env, JMPENV) /* empty startup sigjmp environment */
137 PERLVARI(I, errors, SV *, NULL) /* outstanding queued errors */
139 /* statics "owned" by various functions */
140 PERLVAR(I, hv_fetch_ent_mh, HE*) /* owned by hv_fetch_ent() */
142 PERLVAR(I, lastgotoprobe, OP*) /* from pp_ctl.c */
145 PERLVAR(I, sortcop, OP *) /* user defined sort routine */
146 PERLVAR(I, sortstash, HV *) /* which is in some package or other */
147 PERLVAR(I, firstgv, GV *) /* $a */
148 PERLVAR(I, secondgv, GV *) /* $b */
151 PERLVAR(I, efloatbuf, char *)
152 PERLVAR(I, efloatsize, STRLEN)
156 PERLVAR(I, reg_state, struct re_save_state)
158 PERLVAR(I, regdummy, regnode) /* from regcomp.c */
160 PERLVARI(I, dumpindent, U16, 4) /* number of blanks per dump
164 PERLVAR(I, utf8locale, bool) /* utf8 locale detected */
166 PERLVARA(I, colors,6, char *) /* from regcomp.c */
169 =for apidoc Amn|peep_t|PL_peepp
171 Pointer to the per-subroutine peephole optimiser. This is a function
172 that gets called at the end of compilation of a Perl subroutine (or
173 equivalently independent piece of Perl code) to perform fixups of
174 some ops and to perform small-scale optimisations. The function is
175 called once for each subroutine that is compiled, and is passed, as sole
176 parameter, a pointer to the op that is the entry point to the subroutine.
177 It modifies the op tree in place.
179 The peephole optimiser should never be completely replaced. Rather,
180 add code to it by wrapping the existing optimiser. The basic way to do
181 this can be seen in L<perlguts/Compile pass 3: peephole optimization>.
182 If the new code wishes to operate on ops throughout the subroutine's
183 structure, rather than just at the top level, it is likely to be more
184 convenient to wrap the L</PL_rpeepp> hook.
189 PERLVARI(I, peepp, peep_t, Perl_peep)
192 =for apidoc Amn|peep_t|PL_rpeepp
194 Pointer to the recursive peephole optimiser. This is a function
195 that gets called at the end of compilation of a Perl subroutine (or
196 equivalently independent piece of Perl code) to perform fixups of some
197 ops and to perform small-scale optimisations. The function is called
198 once for each chain of ops linked through their C<op_next> fields;
199 it is recursively called to handle each side chain. It is passed, as
200 sole parameter, a pointer to the op that is at the head of the chain.
201 It modifies the op tree in place.
203 The peephole optimiser should never be completely replaced. Rather,
204 add code to it by wrapping the existing optimiser. The basic way to do
205 this can be seen in L<perlguts/Compile pass 3: peephole optimization>.
206 If the new code wishes to operate only on ops at a subroutine's top level,
207 rather than throughout the structure, it is likely to be more convenient
208 to wrap the L</PL_peepp> hook.
213 PERLVARI(I, rpeepp, peep_t, Perl_rpeep)
216 =for apidoc Amn|Perl_ophook_t|PL_opfreehook
218 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.
219 This allows extensions to free any extra attribute they have locally attached to an OP.
220 It is also assured to first fire for the parent OP and then for its kids.
222 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.
227 PERLVARI(I, opfreehook, Perl_ophook_t, 0) /* op_free() hook */
229 PERLVARI(I, watchaddr, char **, 0)
230 PERLVAR(I, watchok, char *)
232 /* the currently active slab in a chain of slabs of regmatch states,
233 * and the currently active state within that slab */
235 PERLVARI(I, regmatch_slab, regmatch_slab *, NULL)
236 PERLVAR(I, regmatch_state, regmatch_state *)
238 /* Put anything new that is pointer aligned here. */
240 PERLVAR(I, delaymagic, U16) /* ($<,$>) = ... */
241 PERLVAR(I, localizing, U8) /* are we processing a local() list? */
242 PERLVAR(I, colorset, bool) /* from regcomp.c */
243 PERLVAR(I, in_eval, U8) /* trap "fatal" errors? */
244 PERLVAR(I, tainted, bool) /* using variables controlled by $< */
245 PERLVAR(I, tainting, bool) /* doing taint checks */
247 /* This value may be set when embedding for full cleanup */
248 /* 0=none, 1=full, 2=full with checks */
249 /* mod_perl is special, and also assigns a meaning -1 */
250 PERLVARI(I, perl_destruct_level, signed char, 0)
252 /* current phase the interpreter is in */
253 PERLVARI(I, phase, enum perl_phase, PERL_PHASE_CONSTRUCT)
255 PERLVAR(I, perldb, U32)
257 PERLVAR(I, signals, U32) /* Using which pre-5.8 signals */
259 /* pseudo environmental stuff */
260 PERLVAR(I, origargc, int)
261 PERLVAR(I, origargv, char **)
262 PERLVAR(I, envgv, GV *)
263 PERLVAR(I, incgv, GV *)
264 PERLVAR(I, hintgv, GV *)
265 PERLVAR(I, origfilename, char *)
266 PERLVAR(I, diehook, SV *)
267 PERLVAR(I, warnhook, SV *)
270 PERLVAR(I, patchlevel, SV *)
271 PERLVAR(I, apiversion, SV *)
272 PERLVAR(I, localpatches, const char * const *)
273 PERLVARI(I, splitstr, const char *, " ")
275 PERLVAR(I, minus_c, bool)
276 PERLVAR(I, minus_n, bool)
277 PERLVAR(I, minus_p, bool)
278 PERLVAR(I, minus_l, bool)
279 PERLVAR(I, minus_a, bool)
280 PERLVAR(I, minus_F, bool)
281 PERLVAR(I, doswitches, bool)
282 PERLVAR(I, minus_E, bool)
286 =for apidoc mn|bool|PL_dowarn
288 The C variable which corresponds to Perl's $^W warning variable.
293 PERLVAR(I, dowarn, U8)
294 PERLVAR(I, sawampersand, U8) /* must save all match strings */
295 PERLVAR(I, unsafe, bool)
296 PERLVAR(I, exit_flags, U8) /* was exit() unexpected, etc. */
298 PERLVAR(I, inplace, char *)
299 PERLVAR(I, e_script, SV *)
301 PERLVAR(I, basetime, Time_t) /* $^T */
303 PERLVARI(I, maxsysfd, I32, MAXSYSFD)
304 /* top fd to pass to subprocesses */
305 PERLVAR(I, statusvalue, I32) /* $? */
307 PERLVAR(I, statusvalue_vms, U32)
309 PERLVAR(I, statusvalue_posix, I32)
312 PERLVARI(I, sig_pending, int, 0) /* Number if highest signal pending */
313 PERLVAR(I, psig_pend, int *) /* per-signal "count" of pending */
315 /* shortcuts to various I/O objects */
316 PERLVAR(I, stdingv, GV *) /* *STDIN */
317 PERLVAR(I, stderrgv, GV *) /* *STDERR */
318 PERLVAR(I, defgv, GV *)
319 PERLVAR(I, argvgv, GV *) /* *ARGV */
320 PERLVAR(I, argvoutgv, GV *) /* *ARGVOUT */
321 PERLVAR(I, argvout_stack, AV *)
323 /* shortcuts to regexp stuff */
324 PERLVAR(I, replgv, GV *) /* *^R */
326 /* shortcuts to misc objects */
327 PERLVAR(I, errgv, GV *) /* *@ */
329 /* shortcuts to debugging objects */
330 PERLVAR(I, DBgv, GV *) /* *DB::DB */
331 PERLVAR(I, DBline, GV *) /* *DB::line */
334 =for apidoc mn|GV *|PL_DBsub
335 When Perl is run in debugging mode, with the B<-d> switch, this GV contains
336 the SV which holds the name of the sub being debugged. This is the C
337 variable which corresponds to Perl's $DB::sub variable. See
340 =for apidoc mn|SV *|PL_DBsingle
341 When Perl is run in debugging mode, with the B<-d> switch, this SV is a
342 boolean which indicates whether subs are being single-stepped.
343 Single-stepping is automatically turned on after every step. This is the C
344 variable which corresponds to Perl's $DB::single variable. See
347 =for apidoc mn|SV *|PL_DBtrace
348 Trace variable used when Perl is run in debugging mode, with the B<-d>
349 switch. This is the C variable which corresponds to Perl's $DB::trace
350 variable. See C<PL_DBsingle>.
355 PERLVAR(I, DBsub, GV *) /* *DB::sub */
356 PERLVAR(I, DBsingle, SV *) /* $DB::single */
357 PERLVAR(I, DBtrace, SV *) /* $DB::trace */
358 PERLVAR(I, DBsignal, SV *) /* $DB::signal */
359 PERLVAR(I, dbargs, AV *) /* args to call listed by caller function */
362 PERLVAR(I, debstash, HV *) /* symbol table for perldb package */
363 PERLVAR(I, globalstash, HV *) /* global keyword overrides imported here */
364 PERLVAR(I, curstname, SV *) /* name of current package */
365 PERLVAR(I, beginav, AV *) /* names of BEGIN subroutines */
366 PERLVAR(I, endav, AV *) /* names of END subroutines */
367 PERLVAR(I, unitcheckav, AV *) /* names of UNITCHECK subroutines */
368 PERLVAR(I, checkav, AV *) /* names of CHECK subroutines */
369 PERLVAR(I, initav, AV *) /* names of INIT subroutines */
370 PERLVAR(I, strtab, HV *) /* shared string table */
371 PERLVARI(I, sub_generation, U32, 1) /* incr to invalidate method cache */
373 /* funky return mechanisms */
374 PERLVAR(I, forkprocess, int) /* so do_open |- can return proc# */
376 /* memory management */
377 PERLVAR(I, sv_count, I32) /* how many SV* are currently allocated */
378 PERLVAR(I, sv_objcount, I32) /* how many objects are currently allocated */
379 PERLVAR(I, sv_root, SV *) /* storage for SVs belonging to interp */
380 PERLVAR(I, sv_arenaroot, SV *) /* list of areas for garbage collection */
382 /* subprocess state */
383 PERLVAR(I, fdpid, AV *) /* keep fd-to-pid mappings for my_popen */
386 PERLVARI(I, op_mask, char *, NULL) /* masked operations for safe evals */
388 /* current interpreter roots */
389 PERLVAR(I, main_cv, CV *)
390 PERLVAR(I, main_root, OP *)
391 PERLVAR(I, main_start, OP *)
392 PERLVAR(I, eval_root, OP *)
393 PERLVAR(I, eval_start, OP *)
395 /* runtime control stuff */
396 PERLVARI(I, curcopdb, COP *, NULL)
398 PERLVAR(I, filemode, int) /* so nextargv() can preserve mode */
399 PERLVAR(I, lastfd, int) /* what to preserve mode on */
400 PERLVAR(I, oldname, char *) /* what to preserve mode on */
401 PERLVAR(I, Argv, const char **) /* stuff to free from do_aexec, vfork safe */
402 PERLVAR(I, Cmd, char *) /* stuff to free from do_aexec, vfork safe */
403 /* Elements in this array have ';' appended and are injected as a single line
404 into the tokeniser. You can't put any (literal) newlines into any program
405 you stuff in into this array, as the point where it's injected is expecting
406 a single physical line. */
407 PERLVAR(I, preambleav, AV *)
408 PERLVAR(I, mess_sv, SV *)
409 PERLVAR(I, ors_sv, SV *) /* output record separator $\ */
410 /* statics moved here for shared library purposes */
411 PERLVARI(I, gensym, I32, 0) /* next symbol for getsym() to define */
412 PERLVARI(I, cv_has_eval, bool, FALSE) /* PL_compcv includes an entereval or similar */
413 PERLVAR(I, taint_warn, bool) /* taint warns instead of dying */
414 PERLVARI(I, laststype, U16, OP_STAT)
415 PERLVARI(I, laststatval, int, -1)
417 /* interpreter atexit processing */
418 PERLVARI(I, exitlistlen, I32, 0) /* length of same */
419 PERLVARI(I, exitlist, PerlExitListEntry *, NULL)
420 /* list of exit functions */
423 =for apidoc Amn|HV*|PL_modglobal
425 C<PL_modglobal> is a general purpose, interpreter global HV for use by
426 extensions that need to keep information on a per-interpreter basis.
427 In a pinch, it can also be used as a symbol table for extensions
428 to share data among each other. It is a good idea to use keys
429 prefixed by the package name of the extension that owns the data.
434 PERLVAR(I, modglobal, HV *) /* per-interp module data */
436 /* these used to be in global before 5.004_68 */
437 PERLVARI(I, profiledata, U32 *, NULL) /* table of ops, counts */
439 PERLVAR(I, compiling, COP) /* compiling/done executing marker */
441 PERLVAR(I, compcv, CV *) /* currently compiling subroutine */
442 PERLVAR(I, comppad, PAD *) /* storage for lexically scoped temporaries */
443 PERLVAR(I, comppad_name, PADNAMELIST *) /* variable names for "my" variables */
444 PERLVAR(I, comppad_name_fill, I32) /* last "introduced" variable offset */
445 PERLVAR(I, comppad_name_floor, I32) /* start of vars in innermost block */
447 #ifdef HAVE_INTERP_INTERN
448 PERLVAR(I, sys_intern, struct interp_intern)
449 /* platform internals */
452 /* more statics moved here */
453 PERLVAR(I, DBcv, CV *) /* from perl.c */
454 PERLVARI(I, generation, int, 100) /* from op.c */
456 PERLVARI(I, in_clean_objs,bool, FALSE) /* from sv.c */
457 PERLVARI(I, in_clean_all, bool, FALSE) /* ptrs to freed SVs now legal */
458 PERLVAR(I, nomemok, bool) /* let malloc context handle nomem */
459 PERLVARI(I, savebegin, bool, FALSE) /* save BEGINs for compiler */
461 PERLVAR(I, delaymagic_uid, Uid_t) /* current real user id, only for delaymagic */
462 PERLVAR(I, delaymagic_euid, Uid_t) /* current effective user id, only for delaymagic */
463 PERLVAR(I, delaymagic_gid, Gid_t) /* current real group id, only for delaymagic */
464 PERLVAR(I, delaymagic_egid, Gid_t) /* current effective group id, only for delaymagic */
465 PERLVARI(I, an, U32, 0) /* malloc sequence number */
468 /* exercise wrap-around */
469 #define PERL_COP_SEQMAX (U32_MAX-50)
471 #define PERL_COP_SEQMAX 0
473 PERLVARI(I, cop_seqmax, U32, PERL_COP_SEQMAX) /* statement sequence number */
474 #undef PERL_COP_SEQMAX
476 PERLVARI(I, evalseq, U32, 0) /* eval sequence number */
477 PERLVAR(I, origalen, U32)
478 PERLVAR(I, origenviron, char **)
479 #ifdef PERL_USES_PL_PIDSTATUS
480 PERLVAR(I, pidstatus, HV *) /* pid-to-status mappings for waitpid */
482 PERLVAR(I, osname, char *) /* operating system */
484 PERLVAR(I, sighandlerp, Sighandler_t)
486 PERLVARA(I, body_roots, PERL_ARENA_ROOTS_SIZE, void*) /* array of body roots */
488 PERLVAR(I, unicode, U32) /* Unicode features: $ENV{PERL_UNICODE} or -C */
490 PERLVARI(I, maxo, int, MAXO) /* maximum number of ops */
492 PERLVARI(I, runops, runops_proc_t, RUNOPS_DEFAULT)
495 =for apidoc Amn|SV|PL_sv_undef
496 This is the C<undef> SV. Always refer to this as C<&PL_sv_undef>.
498 =for apidoc Amn|SV|PL_sv_no
499 This is the C<false> SV. See C<PL_sv_yes>. Always refer to this as
502 =for apidoc Amn|SV|PL_sv_yes
503 This is the C<true> SV. See C<PL_sv_no>. Always refer to this as
509 PERLVAR(I, sv_undef, SV)
510 PERLVAR(I, sv_no, SV)
511 PERLVAR(I, sv_yes, SV)
513 PERLVAR(I, subname, SV *) /* name of current subroutine */
515 PERLVAR(I, subline, I32) /* line this subroutine began on */
516 PERLVAR(I, min_intro_pending, I32) /* start of vars to introduce */
518 PERLVAR(I, max_intro_pending, I32) /* end of vars to introduce */
519 PERLVAR(I, padix, I32) /* max used index in current "register" pad */
521 PERLVAR(I, padix_floor, I32) /* how low may inner block reset padix */
523 PERLVAR(I, hints, U32) /* pragma-tic compile-time flags */
525 PERLVAR(I, debug, VOL U32) /* flags given to -D switch */
527 /* Perl_Ibreakable_sub_generation_ptr was too long for VMS, hence "gen" */
528 PERLVARI(I, breakable_sub_gen, U32, 0)
530 #ifdef USE_LOCALE_COLLATE
531 PERLVAR(I, collation_name, char *) /* Name of current collation */
532 PERLVAR(I, collxfrm_base, Size_t) /* Basic overhead in *xfrm() */
533 PERLVARI(I, collxfrm_mult,Size_t, 2) /* Expansion factor in *xfrm() */
534 PERLVARI(I, collation_ix, U32, 0) /* Collation generation index */
535 PERLVARI(I, collation_standard, bool, TRUE)
536 /* Assume simple collation */
537 #endif /* USE_LOCALE_COLLATE */
540 #if defined (PERL_UTF8_CACHE_ASSERT) || defined (DEBUGGING)
545 PERLVARI(I, utf8cache, I8, PERL___I) /* Is the utf8 caching code enabled? */
549 #ifdef USE_LOCALE_NUMERIC
551 PERLVARI(I, numeric_standard, bool, TRUE)
552 /* Assume simple numerics */
553 PERLVARI(I, numeric_local, bool, TRUE)
554 /* Assume local numerics */
555 PERLVAR(I, numeric_name, char *) /* Name of current numeric locale */
556 PERLVAR(I, numeric_radix_sv, SV *) /* The radix separator if not '.' */
558 #endif /* !USE_LOCALE_NUMERIC */
560 /* Unicode inversion lists */
561 PERLVAR(I, ASCII, SV *)
562 PERLVAR(I, Latin1, SV *)
563 PERLVAR(I, AboveLatin1, SV *)
565 PERLVAR(I, PerlSpace, SV *)
566 PERLVAR(I, XPerlSpace, SV *)
568 PERLVAR(I, L1PosixAlnum,SV *)
569 PERLVAR(I, PosixAlnum, SV *)
571 PERLVAR(I, L1PosixAlpha,SV *)
572 PERLVAR(I, PosixAlpha, SV *)
574 PERLVAR(I, PosixBlank, SV *)
575 PERLVAR(I, XPosixBlank, SV *)
577 PERLVAR(I, L1Cased, SV *)
579 PERLVAR(I, PosixCntrl, SV *)
580 PERLVAR(I, XPosixCntrl, SV *)
582 PERLVAR(I, PosixDigit, SV *)
584 PERLVAR(I, L1PosixGraph,SV *)
585 PERLVAR(I, PosixGraph, SV *)
587 PERLVAR(I, L1PosixLower,SV *)
588 PERLVAR(I, PosixLower, SV *)
590 PERLVAR(I, L1PosixPrint,SV *)
591 PERLVAR(I, PosixPrint, SV *)
593 PERLVAR(I, L1PosixPunct,SV *)
594 PERLVAR(I, PosixPunct, SV *)
596 PERLVAR(I, PosixSpace, SV *)
597 PERLVAR(I, XPosixSpace, SV *)
599 PERLVAR(I, L1PosixUpper,SV *)
600 PERLVAR(I, PosixUpper, SV *)
602 PERLVAR(I, L1PosixWord, SV *)
603 PERLVAR(I, PosixWord, SV *)
605 PERLVAR(I, PosixXDigit, SV *)
606 PERLVAR(I, XPosixXDigit, SV *)
608 PERLVAR(I, VertSpace, SV *)
610 PERLVAR(I, NonL1NonFinalFold, SV *)
611 PERLVAR(I, HasMultiCharFold, SV *)
613 /* utf8 character class swashes */
614 PERLVAR(I, utf8_alnum, SV *)
615 PERLVAR(I, utf8_alpha, SV *)
616 PERLVAR(I, utf8_blank, SV *)
617 PERLVAR(I, utf8_space, SV *)
618 PERLVAR(I, utf8_graph, SV *)
619 PERLVAR(I, utf8_digit, SV *)
620 PERLVAR(I, utf8_upper, SV *)
621 PERLVAR(I, utf8_lower, SV *)
622 PERLVAR(I, utf8_print, SV *)
623 PERLVAR(I, utf8_punct, SV *)
624 PERLVAR(I, utf8_xdigit, SV *)
625 PERLVAR(I, utf8_mark, SV *)
626 PERLVAR(I, utf8_X_regular_begin, SV *)
627 PERLVAR(I, utf8_X_extend, SV *)
628 PERLVAR(I, utf8_X_LVT, SV *)
629 PERLVAR(I, utf8_toupper, SV *)
630 PERLVAR(I, utf8_totitle, SV *)
631 PERLVAR(I, utf8_tolower, SV *)
632 PERLVAR(I, utf8_tofold, SV *)
633 PERLVAR(I, utf8_charname_begin, SV *)
634 PERLVAR(I, utf8_charname_continue, SV *)
635 PERLVAR(I, last_swash_hv, HV *)
636 PERLVAR(I, last_swash_tmps, U8 *)
637 PERLVAR(I, last_swash_slen, STRLEN)
638 PERLVARA(I, last_swash_key,12, U8)
639 PERLVAR(I, last_swash_klen, U8) /* Only needs to store 0-12 */
642 PERLVARI(I, cryptseen, bool, FALSE) /* has fast crypt() been initialized? */
645 PERLVAR(I, pad_reset_pending, bool) /* reset pad on next attempted alloc */
646 PERLVAR(I, srand_called, bool)
647 PERLVARI(I, in_load_module, bool, FALSE) /* to prevent recursions in PerlIO_find_layer */
649 PERLVAR(I, parser, yy_parser *) /* current parser state */
651 /* Array of signal handlers, indexed by signal number, through which the C
652 signal handler dispatches. */
653 PERLVAR(I, psig_ptr, SV **)
654 /* Array of names of signals, indexed by signal number, for (re)use as the first
655 argument to a signal handler. Only one block of memory is allocated for
656 both psig_name and psig_ptr. */
657 PERLVAR(I, psig_name, SV **)
659 #if defined(PERL_IMPLICIT_SYS)
660 PERLVAR(I, Mem, struct IPerlMem *)
661 PERLVAR(I, MemShared, struct IPerlMem *)
662 PERLVAR(I, MemParse, struct IPerlMem *)
663 PERLVAR(I, Env, struct IPerlEnv *)
664 PERLVAR(I, StdIO, struct IPerlStdIO *)
665 PERLVAR(I, LIO, struct IPerlLIO *)
666 PERLVAR(I, Dir, struct IPerlDir *)
667 PERLVAR(I, Sock, struct IPerlSock *)
668 PERLVAR(I, Proc, struct IPerlProc *)
671 PERLVAR(I, ptr_table, PTR_TBL_t *)
672 PERLVARI(I, beginav_save, AV *, NULL) /* save BEGIN{}s when compiling */
674 PERLVAR(I, body_arenas, void *) /* pointer to list of body-arenas */
677 #if defined(USE_ITHREADS)
678 PERLVAR(I, regex_pad, SV **) /* Shortcut into the array of
680 PERLVAR(I, regex_padav, AV *) /* All regex objects, indexed via the
681 values in op_pmoffset of pmop.
682 Entry 0 is an SV whose PV is a
683 "packed" list of IVs listing
684 the now-free slots in the array */
685 PERLVAR(I, stashpad, HV **) /* for CopSTASH */
686 PERLVARI(I, stashpadmax, PADOFFSET, 64)
687 PERLVARI(I, stashpadix, PADOFFSET, 0)
690 #ifdef USE_REENTRANT_API
691 PERLVAR(I, reentrant_buffer, REENTR *) /* here we store the _r buffers */
694 PERLVAR(I, custom_op_names, HV *) /* Names of user defined ops */
695 PERLVAR(I, custom_op_descs, HV *) /* Descriptions of user defined ops */
698 PERLVARI(I, perlio, PerlIOl *, NULL)
699 PERLVARI(I, known_layers, PerlIO_list_t *, NULL)
700 PERLVARI(I, def_layerlist, PerlIO_list_t *, NULL)
703 PERLVARI(I, encoding, SV *, NULL) /* character encoding */
705 PERLVAR(I, debug_pad, struct perl_debug_pad) /* always needed because of the re extension */
707 PERLVAR(I, utf8_idstart, SV *)
708 PERLVAR(I, utf8_idcont, SV *)
709 PERLVAR(I, utf8_xidstart, SV *)
710 PERLVAR(I, utf8_perl_idstart, SV *)
711 PERLVAR(I, utf8_xidcont, SV *)
713 PERLVAR(I, sort_RealCmp, SVCOMPARE_t)
715 PERLVARI(I, checkav_save, AV *, NULL) /* save CHECK{}s when compiling */
716 PERLVARI(I, unitcheckav_save, AV *, NULL)
717 /* save UNITCHECK{}s when compiling */
719 PERLVARI(I, clocktick, long, 0) /* this many times() ticks in a second */
721 PERLVAR(I, stashcache, HV *) /* Cache to speed up S_method_common */
723 /* Hooks to shared SVs and locks. */
724 PERLVARI(I, sharehook, share_proc_t, Perl_sv_nosharing)
725 PERLVARI(I, lockhook, share_proc_t, Perl_sv_nosharing)
727 # define PERL_UNLOCK_HOOK Perl_sv_nosharing
729 /* This reference ensures that the mathoms are linked with perl */
730 # define PERL_UNLOCK_HOOK Perl_sv_nounlocking
732 PERLVARI(I, unlockhook, share_proc_t, PERL_UNLOCK_HOOK)
734 PERLVARI(I, threadhook, thrhook_proc_t, Perl_nothreadhook)
736 /* Can shared object be destroyed */
737 PERLVARI(I, destroyhook, destroyable_proc_t, Perl_sv_destroyable)
740 PERLVARI(I, signalhook, despatch_signals_proc_t, Perl_despatch_signals)
743 PERLVARI(I, isarev, HV *, NULL) /* Reverse map of @ISA dependencies */
745 /* Register of known Method Resolution Orders.
746 What this actually points to is an implementation detail (it may change to
747 a structure incorporating a reference count - use mro_get_from_name to
748 retrieve a C<struct mro_alg *> */
749 PERLVAR(I, registered_mros, HV *)
751 /* Compile-time block start/end hooks */
752 PERLVAR(I, blockhooks, AV *)
754 /* Everything that folds to a given character, for case insensitivity regex
756 PERLVARI(I, utf8_foldclosures, HV *, NULL)
758 /* List of characters that participate in folds (except marks, etc in
759 * multi-char folds) */
760 PERLVARI(I, utf8_foldable, SV *, NULL)
762 PERLVAR(I, custom_ops, HV *) /* custom op registrations */
764 /* Hook for File::Glob */
765 PERLVARI(I, globhook, globhook_t, NULL)
767 PERLVARI(I, glob_index, int, 0)
769 PERLVAR(I, reentrant_retint, int) /* Integer return value from reentrant functions */
771 /* The last unconditional member of the interpreter structure when 5.10.0 was
772 released. The offset of the end of this is baked into a global variable in
773 any shared perl library which will allow a sanity test in future perl
775 #define PERL_LAST_5_16_0_INTERP_MEMBER Ireentrant_retint
777 #ifdef PERL_IMPLICIT_CONTEXT
778 PERLVARI(I, my_cxt_list, void **, NULL) /* per-module array of MY_CXT pointers */
779 PERLVARI(I, my_cxt_size, int, 0) /* size of PL_my_cxt_list */
780 # ifdef PERL_GLOBAL_STRUCT_PRIVATE
781 PERLVARI(I, my_cxt_keys, const char **, NULL) /* per-module array of pointers to MY_CXT_KEY constants */
785 #ifdef PERL_TRACK_MEMPOOL
786 /* For use with the memory debugging code in util.c */
787 PERLVAR(I, memory_debug_header, struct perl_memory_debug_header)
790 #ifdef DEBUG_LEAKING_SCALARS_FORK_DUMP
791 /* File descriptor to talk to the child which dumps scalars. */
792 PERLVARI(I, dumper_fd, int, -1)
796 PERLVARI(I, madskills, bool, FALSE) /* preserve all syntactic info */
797 /* (MAD = Misc Attribute Decoration) */
798 PERLVARI(I, xmlfp, PerlIO *, NULL)
801 #ifdef DEBUG_LEAKING_SCALARS
802 PERLVARI(I, sv_serial, U32, 0) /* SV serial number, used in sv.c */
805 /* If you are adding a U8 or U16, check to see if there are 'Space' comments
806 * above on where there are gaps which currently will be structure padding. */
808 /* Within a stable branch, new variables must be added to the very end, before
809 * this comment, for binary compatibility (the offsets of the old members must
811 * (Don't forget to add your variable also to perl_clone()!)
812 * XSUB.h provides wrapper functions via perlapi.h that make this
813 * irrelevant, but not all code may be expected to #include XSUB.h.