Hash Function Change - Murmur hash and true per process hash seed
[perl.git] / intrpvar.h
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 /*
12 =head1 Per-Interpreter Variables
13 */
14
15 /* These variables are per-interpreter in threaded/multiplicity builds,
16  * global otherwise.
17
18  * Don't forget to re-run regen/embed.pl to propagate changes! */
19
20 /* New variables must be added to the very end for binary compatibility. */
21
22 /* Don't forget to add your variable also to perl_clone()! (in sv.c) */
23
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.
28  *
29  * When building without MULTIPLICITY, these variables will be truly global.
30  *
31  * Important ones in the first cache line (if alignment is done right) */
32
33 PERLVAR(I, stack_sp,    SV **)          /* top of the stack */
34 #ifdef OP_IN_REGISTER
35 PERLVAR(I, opsave,      OP *)
36 #else
37 PERLVAR(I, op,          OP *)           /* currently executing op */
38 #endif
39 PERLVAR(I, curpad,      SV **)          /* active pad (lexicals+tmps) */
40
41 PERLVAR(I, stack_base,  SV **)
42 PERLVAR(I, stack_max,   SV **)
43
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)
50
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)
55
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
61                                            assignment? */
62
63 PERLVAR(I, markstack,   I32 *)          /* stack_sp locations we're
64                                            remembering */
65 PERLVAR(I, markstack_ptr, I32 *)
66 PERLVAR(I, markstack_max, I32 *)
67
68 PERLVAR(I, Sv,          SV *)           /* used to hold temporary values */
69 PERLVAR(I, Xpv,         XPV *)          /* used to hold temporary values */
70
71 /*
72 =for apidoc Amn|STRLEN|PL_na
73
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
77 C<SvPV_nolen> macro.
78
79 =cut
80 */
81
82 PERLVAR(I, na,          STRLEN)         /* for use in SvPV when length is
83                                            Not Applicable */
84
85 /* stat stuff */
86 PERLVAR(I, statbuf,     Stat_t)
87 PERLVAR(I, statcache,   Stat_t)         /* _ */
88 PERLVAR(I, statgv,      GV *)
89 PERLVARI(I, statname,   SV *,   NULL)
90
91 #ifdef HAS_TIMES
92 PERLVAR(I, timesbuf,    struct tms)
93 #endif
94
95 /* Fields used by magic variables such as $@, $/ and so on */
96 PERLVAR(I, curpm,       PMOP *)         /* what to do \ interps in REs from */
97
98 /*
99 =for apidoc mn|SV*|PL_rs
100
101 The input record separator - C<$/> in Perl space.
102
103 =for apidoc mn|GV*|PL_last_in_gv
104
105 The GV which was last used for a filehandle input operation. (C<< <FH> >>)
106
107 =for apidoc mn|GV*|PL_ofsgv
108
109 The glob containing the output field separator - C<*,> in Perl space.
110
111 =cut
112 */
113
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 *)
122
123 /* Stashes */
124 PERLVAR(I, defstash,    HV *)           /* main symbol table */
125 PERLVAR(I, curstash,    HV *)           /* symbol table for current package */
126
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
133                                            happening */
134
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 */
138
139 /* statics "owned" by various functions */
140 PERLVAR(I, hv_fetch_ent_mh, HE*)        /* owned by hv_fetch_ent() */
141
142 PERLVAR(I, lastgotoprobe, OP*)          /* from pp_ctl.c */
143
144 /* sort stuff */
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 */
149
150 /* float buffer */
151 PERLVAR(I, efloatbuf,   char *)
152 PERLVAR(I, efloatsize,  STRLEN)
153
154 /* regex stuff */
155
156 PERLVAR(I, reg_state,   struct re_save_state)
157
158 PERLVAR(I, regdummy,    regnode)        /* from regcomp.c */
159
160 PERLVARI(I, dumpindent, U16,    4)      /* number of blanks per dump
161                                            indentation level */
162
163
164 PERLVAR(I, utf8locale,  bool)           /* utf8 locale detected */
165
166 PERLVARA(I, colors,6,   char *)         /* from regcomp.c */
167
168 /*
169 =for apidoc Amn|peep_t|PL_peepp
170
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.
178
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.
185
186 =cut
187 */
188
189 PERLVARI(I, peepp,      peep_t, Perl_peep)
190
191 /*
192 =for apidoc Amn|peep_t|PL_rpeepp
193
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.
202
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.
209
210 =cut
211 */
212
213 PERLVARI(I, rpeepp,     peep_t, Perl_rpeep)
214
215 /*
216 =for apidoc Amn|Perl_ophook_t|PL_opfreehook
217
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.
221
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.
223
224 =cut
225 */
226
227 PERLVARI(I, opfreehook, Perl_ophook_t, 0) /* op_free() hook */
228
229 PERLVARI(I, watchaddr,  char **, 0)
230 PERLVAR(I, watchok,     char *)
231
232 /* the currently active slab in a chain of slabs of regmatch states,
233  * and the currently active state within that slab */
234
235 PERLVARI(I, regmatch_slab, regmatch_slab *,     NULL)
236 PERLVAR(I, regmatch_state, regmatch_state *)
237
238 /* Put anything new that is pointer aligned here. */
239
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 */
246
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)
251
252 /* current phase the interpreter is in */
253 PERLVARI(I, phase,      enum perl_phase, PERL_PHASE_CONSTRUCT)
254
255 PERLVAR(I, perldb,      U32)
256
257 PERLVAR(I, signals,     U32)    /* Using which pre-5.8 signals */
258
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 *)
268
269 /* switches */
270 PERLVAR(I, patchlevel,  SV *)
271 PERLVAR(I, apiversion,  SV *)
272 PERLVAR(I, localpatches, const char * const *)
273 PERLVARI(I, splitstr,   const char *, " ")
274
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)
283
284 /*
285
286 =for apidoc mn|bool|PL_dowarn
287
288 The C variable which corresponds to Perl's $^W warning variable.
289
290 =cut
291 */
292
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. */
297
298 PERLVAR(I, inplace,     char *)
299 PERLVAR(I, e_script,    SV *)
300
301 PERLVAR(I, basetime,    Time_t)         /* $^T */
302
303 PERLVARI(I, maxsysfd,   I32,    MAXSYSFD)
304                                         /* top fd to pass to subprocesses */
305 PERLVAR(I, statusvalue, I32)            /* $? */
306 #ifdef VMS
307 PERLVAR(I, statusvalue_vms, U32)
308 #else
309 PERLVAR(I, statusvalue_posix, I32)
310 #endif
311
312 PERLVARI(I, sig_pending, int, 0)        /* Number if highest signal pending */
313 PERLVAR(I, psig_pend, int *)            /* per-signal "count" of pending */
314
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 *)
322
323 /* shortcuts to regexp stuff */
324 PERLVAR(I, replgv,      GV *)           /*  *^R         */
325
326 /* shortcuts to misc objects */
327 PERLVAR(I, errgv,       GV *)           /*  *@          */
328
329 /* shortcuts to debugging objects */
330 PERLVAR(I, DBgv,        GV *)           /*  *DB::DB     */
331 PERLVAR(I, DBline,      GV *)           /*  *DB::line   */
332
333 /*
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
338 C<PL_DBsingle>.
339
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
345 C<PL_DBsub>.
346
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>.
351
352 =cut
353 */
354
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 */
360
361 /* symbol tables */
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 */
372
373 /* funky return mechanisms */
374 PERLVAR(I, forkprocess, int)            /* so do_open |- can return proc# */
375
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 */
381
382 /* subprocess state */
383 PERLVAR(I, fdpid,       AV *)           /* keep fd-to-pid mappings for my_popen */
384
385 /* internal state */
386 PERLVARI(I, op_mask,    char *, NULL)   /* masked operations for safe evals */
387
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 *)
394
395 /* runtime control stuff */
396 PERLVARI(I, curcopdb,   COP *,  NULL)
397
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)
416
417 /* interpreter atexit processing */
418 PERLVARI(I, exitlistlen, I32, 0)        /* length of same */
419 PERLVARI(I, exitlist,   PerlExitListEntry *, NULL)
420                                         /* list of exit functions */
421
422 /*
423 =for apidoc Amn|HV*|PL_modglobal
424
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.
430
431 =cut
432 */
433
434 PERLVAR(I, modglobal,   HV *)           /* per-interp module data */
435
436 /* these used to be in global before 5.004_68 */
437 PERLVARI(I, profiledata, U32 *, NULL)   /* table of ops, counts */
438
439 PERLVAR(I, compiling,   COP)            /* compiling/done executing marker */
440
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 */
446
447 #ifdef HAVE_INTERP_INTERN
448 PERLVAR(I, sys_intern,  struct interp_intern)
449                                         /* platform internals */
450 #endif
451
452 /* more statics moved here */
453 PERLVAR(I, DBcv,        CV *)           /* from perl.c */
454 PERLVARI(I, generation, int,    100)    /* from op.c */
455
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     */
460
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 */
466
467 #ifdef DEBUGGING
468     /* exercise wrap-around */
469     #define PERL_COP_SEQMAX (U32_MAX-50)
470 #else
471     #define PERL_COP_SEQMAX 0
472 #endif
473 PERLVARI(I, cop_seqmax, U32,    PERL_COP_SEQMAX) /* statement sequence number */
474 #undef PERL_COP_SEQMAX
475
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 */
481 #endif
482 PERLVAR(I, osname,      char *)         /* operating system */
483
484 PERLVAR(I, sighandlerp, Sighandler_t)
485
486 PERLVARA(I, body_roots, PERL_ARENA_ROOTS_SIZE, void*) /* array of body roots */
487
488 PERLVAR(I, unicode, U32)        /* Unicode features: $ENV{PERL_UNICODE} or -C */
489
490 PERLVARI(I, maxo,       int,    MAXO)   /* maximum number of ops */
491
492 PERLVARI(I, runops,     runops_proc_t, RUNOPS_DEFAULT)
493
494 /*
495 =for apidoc Amn|SV|PL_sv_undef
496 This is the C<undef> SV.  Always refer to this as C<&PL_sv_undef>.
497
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
500 C<&PL_sv_no>.
501
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
504 C<&PL_sv_yes>.
505
506 =cut
507 */
508
509 PERLVAR(I, sv_undef,    SV)
510 PERLVAR(I, sv_no,       SV)
511 PERLVAR(I, sv_yes,      SV)
512
513 PERLVAR(I, subname,     SV *)           /* name of current subroutine */
514
515 PERLVAR(I, subline,     I32)            /* line this subroutine began on */
516 PERLVAR(I, min_intro_pending, I32)      /* start of vars to introduce */
517
518 PERLVAR(I, max_intro_pending, I32)      /* end of vars to introduce */
519 PERLVAR(I, padix,       I32)            /* max used index in current "register" pad */
520
521 PERLVAR(I, padix_floor, I32)            /* how low may inner block reset padix */
522
523 PERLVAR(I, hints,       U32)            /* pragma-tic compile-time flags */
524
525 PERLVAR(I, debug,       VOL U32)        /* flags given to -D switch */
526
527 /* Perl_Ibreakable_sub_generation_ptr was too long for VMS, hence "gen"  */
528 PERLVARI(I, breakable_sub_gen, U32, 0)
529
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 */
538
539
540 #if defined (PERL_UTF8_CACHE_ASSERT) || defined (DEBUGGING)
541 #  define PERL___I -1
542 #else
543 #  define PERL___I 1
544 #endif
545 PERLVARI(I, utf8cache, I8, PERL___I)    /* Is the utf8 caching code enabled? */
546 #undef PERL___I
547
548
549 #ifdef USE_LOCALE_NUMERIC
550
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 '.' */
557
558 #endif /* !USE_LOCALE_NUMERIC */
559
560 /* Unicode inversion lists */
561 PERLVAR(I, ASCII,       SV *)
562 PERLVAR(I, Latin1,      SV *)
563 PERLVAR(I, AboveLatin1, SV *)
564
565 PERLVAR(I, PerlSpace,   SV *)
566 PERLVAR(I, XPerlSpace,  SV *)
567
568 PERLVAR(I, L1PosixAlnum,SV *)
569 PERLVAR(I, PosixAlnum,  SV *)
570
571 PERLVAR(I, L1PosixAlpha,SV *)
572 PERLVAR(I, PosixAlpha,  SV *)
573
574 PERLVAR(I, PosixBlank,  SV *)
575 PERLVAR(I, XPosixBlank, SV *)
576
577 PERLVAR(I, L1Cased,     SV *)
578
579 PERLVAR(I, PosixCntrl,  SV *)
580 PERLVAR(I, XPosixCntrl, SV *)
581
582 PERLVAR(I, PosixDigit,  SV *)
583
584 PERLVAR(I, L1PosixGraph,SV *)
585 PERLVAR(I, PosixGraph,  SV *)
586
587 PERLVAR(I, L1PosixLower,SV *)
588 PERLVAR(I, PosixLower,  SV *)
589
590 PERLVAR(I, L1PosixPrint,SV *)
591 PERLVAR(I, PosixPrint,  SV *)
592
593 PERLVAR(I, L1PosixPunct,SV *)
594 PERLVAR(I, PosixPunct,  SV *)
595
596 PERLVAR(I, PosixSpace,  SV *)
597 PERLVAR(I, XPosixSpace, SV *)
598
599 PERLVAR(I, L1PosixUpper,SV *)
600 PERLVAR(I, PosixUpper,  SV *)
601
602 PERLVAR(I, L1PosixWord, SV *)
603 PERLVAR(I, PosixWord,   SV *)
604
605 PERLVAR(I, PosixXDigit, SV *)
606 PERLVAR(I, XPosixXDigit, SV *)
607
608 PERLVAR(I, VertSpace,   SV *)
609
610 PERLVAR(I, NonL1NonFinalFold,   SV *)
611 PERLVAR(I, HasMultiCharFold,   SV *)
612
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  */
640
641 #ifdef FCRYPT
642 PERLVARI(I, cryptseen,  bool,   FALSE)  /* has fast crypt() been initialized? */
643 #endif
644
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 */
648
649 PERLVAR(I, parser,      yy_parser *)    /* current parser state */
650
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 **)
658
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 *)
669 #endif
670
671 PERLVAR(I, ptr_table,   PTR_TBL_t *)
672 PERLVARI(I, beginav_save, AV *, NULL)   /* save BEGIN{}s when compiling */
673
674 PERLVAR(I, body_arenas, void *)         /* pointer to list of body-arenas */
675
676
677 #if defined(USE_ITHREADS)
678 PERLVAR(I, regex_pad,     SV **)        /* Shortcut into the array of
679                                            regex_padav */
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)
688 #endif
689
690 #ifdef USE_REENTRANT_API
691 PERLVAR(I, reentrant_buffer, REENTR *)  /* here we store the _r buffers */
692 #endif
693
694 PERLVAR(I, custom_op_names, HV *)       /* Names of user defined ops */
695 PERLVAR(I, custom_op_descs, HV *)       /* Descriptions of user defined ops */
696
697 #ifdef PERLIO_LAYERS
698 PERLVARI(I, perlio,     PerlIOl *, NULL)
699 PERLVARI(I, known_layers, PerlIO_list_t *, NULL)
700 PERLVARI(I, def_layerlist, PerlIO_list_t *, NULL)
701 #endif
702
703 PERLVARI(I, encoding,   SV *,   NULL)   /* character encoding */
704
705 PERLVAR(I, debug_pad,   struct perl_debug_pad)  /* always needed because of the re extension */
706
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 *)
712
713 PERLVAR(I, sort_RealCmp, SVCOMPARE_t)
714
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 */
718
719 PERLVARI(I, clocktick,  long,   0)      /* this many times() ticks in a second */
720
721 PERLVAR(I, stashcache,  HV *)           /* Cache to speed up S_method_common */
722
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)
726 #ifdef NO_MATHOMS
727 #  define PERL_UNLOCK_HOOK Perl_sv_nosharing
728 #else
729 /* This reference ensures that the mathoms are linked with perl */
730 #  define PERL_UNLOCK_HOOK Perl_sv_nounlocking
731 #endif
732 PERLVARI(I, unlockhook, share_proc_t, PERL_UNLOCK_HOOK)
733
734 PERLVARI(I, threadhook, thrhook_proc_t, Perl_nothreadhook)
735
736 /* Can shared object be destroyed */
737 PERLVARI(I, destroyhook, destroyable_proc_t, Perl_sv_destroyable)
738
739 #ifndef PERL_MICRO
740 PERLVARI(I, signalhook, despatch_signals_proc_t, Perl_despatch_signals)
741 #endif
742
743 PERLVARI(I, isarev, HV *, NULL)         /* Reverse map of @ISA dependencies */
744
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 *)
750
751 /* Compile-time block start/end hooks */
752 PERLVAR(I, blockhooks,  AV *)
753
754 /* Everything that folds to a given character, for case insensitivity regex
755  * matching */
756 PERLVARI(I, utf8_foldclosures, HV *, NULL)
757
758 /* List of characters that participate in folds (except marks, etc in
759  * multi-char folds) */
760 PERLVARI(I, utf8_foldable, SV *, NULL)
761
762 PERLVAR(I, custom_ops,  HV *)           /* custom op registrations */
763
764 /* Hook for File::Glob */
765 PERLVARI(I, globhook,   globhook_t, NULL)
766
767 PERLVARI(I, glob_index, int,    0)
768
769 PERLVAR(I, reentrant_retint, int)       /* Integer return value from reentrant functions */
770
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
774    releases.  */
775 #define PERL_LAST_5_16_0_INTERP_MEMBER  Ireentrant_retint
776
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 */
782 #  endif
783 #endif
784
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)
788 #endif
789
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)
793 #endif
794
795 #ifdef PERL_MAD
796 PERLVARI(I, madskills,  bool,   FALSE)  /* preserve all syntactic info */
797                                         /* (MAD = Misc Attribute Decoration) */
798 PERLVARI(I, xmlfp,      PerlIO *, NULL)
799 #endif
800
801 #ifdef DEBUG_LEAKING_SCALARS
802 PERLVARI(I, sv_serial,  U32,    0)      /* SV serial number, used in sv.c */
803 #endif
804
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.  */
807
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
810  *  not change).
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.
814  */