regexec.c: Nits coding standards-type changing
[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 #ifdef PERL_SAWAMPERSAND
295 PERLVAR(I, sawampersand, U8)            /* must save all match strings */
296 #endif
297 PERLVAR(I, unsafe,      bool)
298 PERLVAR(I, exit_flags,  U8)             /* was exit() unexpected, etc. */
299
300 PERLVAR(I, inplace,     char *)
301 PERLVAR(I, e_script,    SV *)
302
303 PERLVAR(I, basetime,    Time_t)         /* $^T */
304
305 PERLVARI(I, maxsysfd,   I32,    MAXSYSFD)
306                                         /* top fd to pass to subprocesses */
307 PERLVAR(I, statusvalue, I32)            /* $? */
308 #ifdef VMS
309 PERLVAR(I, statusvalue_vms, U32)
310 #else
311 PERLVAR(I, statusvalue_posix, I32)
312 #endif
313
314 PERLVARI(I, sig_pending, int, 0)        /* Number if highest signal pending */
315 PERLVAR(I, psig_pend, int *)            /* per-signal "count" of pending */
316
317 /* shortcuts to various I/O objects */
318 PERLVAR(I, stdingv,     GV *)           /*  *STDIN      */
319 PERLVAR(I, stderrgv,    GV *)           /*  *STDERR     */
320 PERLVAR(I, defgv,       GV *)
321 PERLVAR(I, argvgv,      GV *)           /*  *ARGV       */
322 PERLVAR(I, argvoutgv,   GV *)           /*  *ARGVOUT    */
323 PERLVAR(I, argvout_stack, AV *)
324
325 /* shortcuts to regexp stuff */
326 PERLVAR(I, replgv,      GV *)           /*  *^R         */
327
328 /* shortcuts to misc objects */
329 PERLVAR(I, errgv,       GV *)           /*  *@          */
330
331 /* shortcuts to debugging objects */
332 PERLVAR(I, DBgv,        GV *)           /*  *DB::DB     */
333 PERLVAR(I, DBline,      GV *)           /*  *DB::line   */
334
335 /*
336 =for apidoc mn|GV *|PL_DBsub
337 When Perl is run in debugging mode, with the B<-d> switch, this GV contains
338 the SV which holds the name of the sub being debugged.  This is the C
339 variable which corresponds to Perl's $DB::sub variable.  See
340 C<PL_DBsingle>.
341
342 =for apidoc mn|SV *|PL_DBsingle
343 When Perl is run in debugging mode, with the B<-d> switch, this SV is a
344 boolean which indicates whether subs are being single-stepped.
345 Single-stepping is automatically turned on after every step.  This is the C
346 variable which corresponds to Perl's $DB::single variable.  See
347 C<PL_DBsub>.
348
349 =for apidoc mn|SV *|PL_DBtrace
350 Trace variable used when Perl is run in debugging mode, with the B<-d>
351 switch.  This is the C variable which corresponds to Perl's $DB::trace
352 variable.  See C<PL_DBsingle>.
353
354 =cut
355 */
356
357 PERLVAR(I, DBsub,       GV *)           /*  *DB::sub    */
358 PERLVAR(I, DBsingle,    SV *)           /*  $DB::single */
359 PERLVAR(I, DBtrace,     SV *)           /*  $DB::trace  */
360 PERLVAR(I, DBsignal,    SV *)           /*  $DB::signal */
361 PERLVAR(I, dbargs,      AV *)           /* args to call listed by caller function */
362
363 /* symbol tables */
364 PERLVAR(I, debstash,    HV *)           /* symbol table for perldb package */
365 PERLVAR(I, globalstash, HV *)           /* global keyword overrides imported here */
366 PERLVAR(I, curstname,   SV *)           /* name of current package */
367 PERLVAR(I, beginav,     AV *)           /* names of BEGIN subroutines */
368 PERLVAR(I, endav,       AV *)           /* names of END subroutines */
369 PERLVAR(I, unitcheckav, AV *)           /* names of UNITCHECK subroutines */
370 PERLVAR(I, checkav,     AV *)           /* names of CHECK subroutines */
371 PERLVAR(I, initav,      AV *)           /* names of INIT subroutines */
372 PERLVAR(I, strtab,      HV *)           /* shared string table */
373 PERLVARI(I, sub_generation, U32, 1)     /* incr to invalidate method cache */
374
375 /* funky return mechanisms */
376 PERLVAR(I, forkprocess, int)            /* so do_open |- can return proc# */
377
378 /* memory management */
379 PERLVAR(I, sv_count,    I32)            /* how many SV* are currently allocated */
380 PERLVAR(I, sv_objcount, I32)            /* how many objects are currently allocated */
381 PERLVAR(I, sv_root,     SV *)           /* storage for SVs belonging to interp */
382 PERLVAR(I, sv_arenaroot, SV *)          /* list of areas for garbage collection */
383
384 /* subprocess state */
385 PERLVAR(I, fdpid,       AV *)           /* keep fd-to-pid mappings for my_popen */
386
387 /* internal state */
388 PERLVARI(I, op_mask,    char *, NULL)   /* masked operations for safe evals */
389
390 /* current interpreter roots */
391 PERLVAR(I, main_cv,     CV *)
392 PERLVAR(I, main_root,   OP *)
393 PERLVAR(I, main_start,  OP *)
394 PERLVAR(I, eval_root,   OP *)
395 PERLVAR(I, eval_start,  OP *)
396
397 /* runtime control stuff */
398 PERLVARI(I, curcopdb,   COP *,  NULL)
399
400 PERLVAR(I, filemode,    int)            /* so nextargv() can preserve mode */
401 PERLVAR(I, lastfd,      int)            /* what to preserve mode on */
402 PERLVAR(I, oldname,     char *)         /* what to preserve mode on */
403 PERLVAR(I, Argv,        const char **)  /* stuff to free from do_aexec, vfork safe */
404 PERLVAR(I, Cmd,         char *)         /* stuff to free from do_aexec, vfork safe */
405 /* Elements in this array have ';' appended and are injected as a single line
406    into the tokeniser. You can't put any (literal) newlines into any program
407    you stuff in into this array, as the point where it's injected is expecting
408    a single physical line. */
409 PERLVAR(I, preambleav,  AV *)
410 PERLVAR(I, mess_sv,     SV *)
411 PERLVAR(I, ors_sv,      SV *)           /* output record separator $\ */
412 /* statics moved here for shared library purposes */
413 PERLVARI(I, gensym,     I32,    0)      /* next symbol for getsym() to define */
414 PERLVARI(I, cv_has_eval, bool, FALSE)   /* PL_compcv includes an entereval or similar */
415 PERLVAR(I, taint_warn,  bool)           /* taint warns instead of dying */
416 PERLVARI(I, laststype,  U16,    OP_STAT)
417 PERLVARI(I, laststatval, int,   -1)
418
419 /* interpreter atexit processing */
420 PERLVARI(I, exitlistlen, I32, 0)        /* length of same */
421 PERLVARI(I, exitlist,   PerlExitListEntry *, NULL)
422                                         /* list of exit functions */
423
424 /*
425 =for apidoc Amn|HV*|PL_modglobal
426
427 C<PL_modglobal> is a general purpose, interpreter global HV for use by
428 extensions that need to keep information on a per-interpreter basis.
429 In a pinch, it can also be used as a symbol table for extensions
430 to share data among each other.  It is a good idea to use keys
431 prefixed by the package name of the extension that owns the data.
432
433 =cut
434 */
435
436 PERLVAR(I, modglobal,   HV *)           /* per-interp module data */
437
438 /* these used to be in global before 5.004_68 */
439 PERLVARI(I, profiledata, U32 *, NULL)   /* table of ops, counts */
440
441 PERLVAR(I, compiling,   COP)            /* compiling/done executing marker */
442
443 PERLVAR(I, compcv,      CV *)           /* currently compiling subroutine */
444 PERLVAR(I, comppad,     PAD *)          /* storage for lexically scoped temporaries */
445 PERLVAR(I, comppad_name, PADNAMELIST *) /* variable names for "my" variables */
446 PERLVAR(I, comppad_name_fill,   I32)    /* last "introduced" variable offset */
447 PERLVAR(I, comppad_name_floor,  I32)    /* start of vars in innermost block */
448
449 #ifdef HAVE_INTERP_INTERN
450 PERLVAR(I, sys_intern,  struct interp_intern)
451                                         /* platform internals */
452 #endif
453
454 /* more statics moved here */
455 PERLVAR(I, DBcv,        CV *)           /* from perl.c */
456 PERLVARI(I, generation, int,    100)    /* from op.c */
457
458 PERLVARI(I, in_clean_objs,bool,    FALSE)       /* from sv.c */
459 PERLVARI(I, in_clean_all, bool,    FALSE)       /* ptrs to freed SVs now legal */
460 PERLVAR(I, nomemok,     bool)           /* let malloc context handle nomem */
461 PERLVARI(I, savebegin,  bool,   FALSE)  /* save BEGINs for compiler     */
462
463 PERLVAR(I, delaymagic_uid,      Uid_t)  /* current real user id, only for delaymagic */
464 PERLVAR(I, delaymagic_euid,     Uid_t)  /* current effective user id, only for delaymagic */
465 PERLVAR(I, delaymagic_gid,      Gid_t)  /* current real group id, only for delaymagic */
466 PERLVAR(I, delaymagic_egid,     Gid_t)  /* current effective group id, only for delaymagic */
467 PERLVARI(I, an,         U32,    0)      /* malloc sequence number */
468
469 #ifdef DEBUGGING
470     /* exercise wrap-around */
471     #define PERL_COP_SEQMAX (U32_MAX-50)
472 #else
473     #define PERL_COP_SEQMAX 0
474 #endif
475 PERLVARI(I, cop_seqmax, U32,    PERL_COP_SEQMAX) /* statement sequence number */
476 #undef PERL_COP_SEQMAX
477
478 PERLVARI(I, evalseq,    U32,    0)      /* eval sequence number */
479 PERLVAR(I, origalen,    U32)
480 PERLVAR(I, origenviron, char **)
481 #ifdef PERL_USES_PL_PIDSTATUS
482 PERLVAR(I, pidstatus,   HV *)           /* pid-to-status mappings for waitpid */
483 #endif
484 PERLVAR(I, osname,      char *)         /* operating system */
485
486 PERLVAR(I, sighandlerp, Sighandler_t)
487
488 PERLVARA(I, body_roots, PERL_ARENA_ROOTS_SIZE, void*) /* array of body roots */
489
490 PERLVAR(I, unicode, U32)        /* Unicode features: $ENV{PERL_UNICODE} or -C */
491
492 PERLVARI(I, maxo,       int,    MAXO)   /* maximum number of ops */
493
494 PERLVARI(I, runops,     runops_proc_t, RUNOPS_DEFAULT)
495
496 /*
497 =for apidoc Amn|SV|PL_sv_undef
498 This is the C<undef> SV.  Always refer to this as C<&PL_sv_undef>.
499
500 =for apidoc Amn|SV|PL_sv_no
501 This is the C<false> SV.  See C<PL_sv_yes>.  Always refer to this as
502 C<&PL_sv_no>.
503
504 =for apidoc Amn|SV|PL_sv_yes
505 This is the C<true> SV.  See C<PL_sv_no>.  Always refer to this as
506 C<&PL_sv_yes>.
507
508 =cut
509 */
510
511 PERLVAR(I, sv_undef,    SV)
512 PERLVAR(I, sv_no,       SV)
513 PERLVAR(I, sv_yes,      SV)
514
515 PERLVAR(I, subname,     SV *)           /* name of current subroutine */
516
517 PERLVAR(I, subline,     I32)            /* line this subroutine began on */
518 PERLVAR(I, min_intro_pending, I32)      /* start of vars to introduce */
519
520 PERLVAR(I, max_intro_pending, I32)      /* end of vars to introduce */
521 PERLVAR(I, padix,       I32)            /* max used index in current "register" pad */
522
523 PERLVAR(I, padix_floor, I32)            /* how low may inner block reset padix */
524
525 PERLVAR(I, hints,       U32)            /* pragma-tic compile-time flags */
526
527 PERLVAR(I, debug,       VOL U32)        /* flags given to -D switch */
528
529 /* Perl_Ibreakable_sub_generation_ptr was too long for VMS, hence "gen"  */
530 PERLVARI(I, breakable_sub_gen, U32, 0)
531
532 #ifdef USE_LOCALE_COLLATE
533 PERLVAR(I, collation_name, char *)      /* Name of current collation */
534 PERLVAR(I, collxfrm_base, Size_t)       /* Basic overhead in *xfrm() */
535 PERLVARI(I, collxfrm_mult,Size_t, 2)    /* Expansion factor in *xfrm() */
536 PERLVARI(I, collation_ix, U32,  0)      /* Collation generation index */
537 PERLVARI(I, collation_standard, bool, TRUE)
538                                         /* Assume simple collation */
539 #endif /* USE_LOCALE_COLLATE */
540
541
542 #if defined (PERL_UTF8_CACHE_ASSERT) || defined (DEBUGGING)
543 #  define PERL___I -1
544 #else
545 #  define PERL___I 1
546 #endif
547 PERLVARI(I, utf8cache, I8, PERL___I)    /* Is the utf8 caching code enabled? */
548 #undef PERL___I
549
550
551 #ifdef USE_LOCALE_NUMERIC
552
553 PERLVARI(I, numeric_standard, bool, TRUE)
554                                         /* Assume simple numerics */
555 PERLVARI(I, numeric_local, bool, TRUE)
556                                         /* Assume local numerics */
557 PERLVAR(I, numeric_name, char *)        /* Name of current numeric locale */
558 PERLVAR(I, numeric_radix_sv, SV *)      /* The radix separator if not '.' */
559
560 #endif /* !USE_LOCALE_NUMERIC */
561
562 /* Unicode inversion lists */
563 PERLVAR(I, ASCII,       SV *)
564 PERLVAR(I, Latin1,      SV *)
565 PERLVAR(I, AboveLatin1, SV *)
566
567 PERLVAR(I, PerlSpace,   SV *)
568 PERLVAR(I, XPerlSpace,  SV *)
569
570 PERLVAR(I, L1PosixAlnum,SV *)
571 PERLVAR(I, PosixAlnum,  SV *)
572
573 PERLVAR(I, L1PosixAlpha,SV *)
574 PERLVAR(I, PosixAlpha,  SV *)
575
576 PERLVAR(I, PosixBlank,  SV *)
577 PERLVAR(I, XPosixBlank, SV *)
578
579 PERLVAR(I, L1Cased,     SV *)
580
581 PERLVAR(I, PosixCntrl,  SV *)
582 PERLVAR(I, XPosixCntrl, SV *)
583
584 PERLVAR(I, PosixDigit,  SV *)
585
586 PERLVAR(I, L1PosixGraph,SV *)
587 PERLVAR(I, PosixGraph,  SV *)
588
589 PERLVAR(I, L1PosixLower,SV *)
590 PERLVAR(I, PosixLower,  SV *)
591
592 PERLVAR(I, L1PosixPrint,SV *)
593 PERLVAR(I, PosixPrint,  SV *)
594
595 PERLVAR(I, L1PosixPunct,SV *)
596 PERLVAR(I, PosixPunct,  SV *)
597
598 PERLVAR(I, PosixSpace,  SV *)
599 PERLVAR(I, XPosixSpace, SV *)
600
601 PERLVAR(I, L1PosixUpper,SV *)
602 PERLVAR(I, PosixUpper,  SV *)
603
604 PERLVAR(I, L1PosixWord, SV *)
605 PERLVAR(I, PosixWord,   SV *)
606
607 PERLVAR(I, PosixXDigit, SV *)
608 PERLVAR(I, XPosixXDigit, SV *)
609
610 PERLVAR(I, VertSpace,   SV *)
611
612 PERLVAR(I, NonL1NonFinalFold,   SV *)
613 PERLVAR(I, HasMultiCharFold,   SV *)
614
615 /* utf8 character class swashes */
616 PERLVAR(I, utf8_alnum,  SV *)   /* Should really be named "utf8_wordchar" */
617 PERLVAR(I, utf8_alpha,  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_mark,   SV *)
625 PERLVAR(I, utf8_X_regular_begin, SV *)
626 PERLVAR(I, utf8_X_extend, SV *)
627 PERLVAR(I, utf8_X_LVT,  SV *)
628 PERLVAR(I, utf8_toupper, SV *)
629 PERLVAR(I, utf8_totitle, SV *)
630 PERLVAR(I, utf8_tolower, SV *)
631 PERLVAR(I, utf8_tofold, SV *)
632 PERLVAR(I, utf8_charname_begin, SV *)
633 PERLVAR(I, utf8_charname_continue, SV *)
634 PERLVAR(I, last_swash_hv, HV *)
635 PERLVAR(I, last_swash_tmps, U8 *)
636 PERLVAR(I, last_swash_slen, STRLEN)
637 PERLVARA(I, last_swash_key,UTF8_MAXBYTES-1, U8)
638 PERLVAR(I, last_swash_klen, U8)         /* Only needs to store 0-12  */
639
640 #ifdef FCRYPT
641 PERLVARI(I, cryptseen,  bool,   FALSE)  /* has fast crypt() been initialized? */
642 #endif
643
644 PERLVAR(I, pad_reset_pending, bool)     /* reset pad on next attempted alloc */
645 PERLVAR(I, srand_called, bool)
646 PERLVARI(I, in_load_module, bool, FALSE)        /* to prevent recursions in PerlIO_find_layer */
647
648 PERLVAR(I, parser,      yy_parser *)    /* current parser state */
649
650 /* Array of signal handlers, indexed by signal number, through which the C
651    signal handler dispatches.  */
652 PERLVAR(I, psig_ptr,    SV **)
653 /* Array of names of signals, indexed by signal number, for (re)use as the first
654    argument to a signal handler.   Only one block of memory is allocated for
655    both psig_name and psig_ptr.  */
656 PERLVAR(I, psig_name,   SV **)
657
658 #if defined(PERL_IMPLICIT_SYS)
659 PERLVAR(I, Mem,         struct IPerlMem *)
660 PERLVAR(I, MemShared,   struct IPerlMem *)
661 PERLVAR(I, MemParse,    struct IPerlMem *)
662 PERLVAR(I, Env,         struct IPerlEnv *)
663 PERLVAR(I, StdIO,       struct IPerlStdIO *)
664 PERLVAR(I, LIO,         struct IPerlLIO *)
665 PERLVAR(I, Dir,         struct IPerlDir *)
666 PERLVAR(I, Sock,        struct IPerlSock *)
667 PERLVAR(I, Proc,        struct IPerlProc *)
668 #endif
669
670 PERLVAR(I, ptr_table,   PTR_TBL_t *)
671 PERLVARI(I, beginav_save, AV *, NULL)   /* save BEGIN{}s when compiling */
672
673 PERLVAR(I, body_arenas, void *)         /* pointer to list of body-arenas */
674
675
676 #if defined(USE_ITHREADS)
677 PERLVAR(I, regex_pad,     SV **)        /* Shortcut into the array of
678                                            regex_padav */
679 PERLVAR(I, regex_padav,   AV *)         /* All regex objects, indexed via the
680                                            values in op_pmoffset of pmop.
681                                            Entry 0 is an SV whose PV is a
682                                            "packed" list of IVs listing
683                                            the now-free slots in the array */
684 PERLVAR(I, stashpad,    HV **)          /* for CopSTASH */
685 PERLVARI(I, stashpadmax, PADOFFSET, 64)
686 PERLVARI(I, stashpadix, PADOFFSET, 0)
687 #endif
688
689 #ifdef USE_REENTRANT_API
690 PERLVAR(I, reentrant_buffer, REENTR *)  /* here we store the _r buffers */
691 #endif
692
693 PERLVAR(I, custom_op_names, HV *)       /* Names of user defined ops */
694 PERLVAR(I, custom_op_descs, HV *)       /* Descriptions of user defined ops */
695
696 #ifdef PERLIO_LAYERS
697 PERLVARI(I, perlio,     PerlIOl *, NULL)
698 PERLVARI(I, known_layers, PerlIO_list_t *, NULL)
699 PERLVARI(I, def_layerlist, PerlIO_list_t *, NULL)
700 #endif
701
702 PERLVARI(I, encoding,   SV *,   NULL)   /* character encoding */
703
704 PERLVAR(I, debug_pad,   struct perl_debug_pad)  /* always needed because of the re extension */
705
706 PERLVAR(I, utf8_idstart, SV *)
707 PERLVAR(I, utf8_idcont, SV *)
708 PERLVAR(I, utf8_xidstart, SV *)
709 PERLVAR(I, utf8_perl_idstart, SV *)
710 PERLVAR(I, utf8_xidcont, SV *)
711
712 PERLVAR(I, sort_RealCmp, SVCOMPARE_t)
713
714 PERLVARI(I, checkav_save, AV *, NULL)   /* save CHECK{}s when compiling */
715 PERLVARI(I, unitcheckav_save, AV *, NULL)
716                                         /* save UNITCHECK{}s when compiling */
717
718 PERLVARI(I, clocktick,  long,   0)      /* this many times() ticks in a second */
719
720 PERLVAR(I, stashcache,  HV *)           /* Cache to speed up S_method_common */
721
722 /* Hooks to shared SVs and locks. */
723 PERLVARI(I, sharehook,  share_proc_t, Perl_sv_nosharing)
724 PERLVARI(I, lockhook,   share_proc_t, Perl_sv_nosharing)
725 #ifdef NO_MATHOMS
726 #  define PERL_UNLOCK_HOOK Perl_sv_nosharing
727 #else
728 /* This reference ensures that the mathoms are linked with perl */
729 #  define PERL_UNLOCK_HOOK Perl_sv_nounlocking
730 #endif
731 PERLVARI(I, unlockhook, share_proc_t, PERL_UNLOCK_HOOK)
732
733 PERLVARI(I, threadhook, thrhook_proc_t, Perl_nothreadhook)
734
735 /* Can shared object be destroyed */
736 PERLVARI(I, destroyhook, destroyable_proc_t, Perl_sv_destroyable)
737
738 #ifndef PERL_MICRO
739 PERLVARI(I, signalhook, despatch_signals_proc_t, Perl_despatch_signals)
740 #endif
741
742 PERLVARI(I, isarev, HV *, NULL)         /* Reverse map of @ISA dependencies */
743
744 /* Register of known Method Resolution Orders.
745    What this actually points to is an implementation detail (it may change to
746    a structure incorporating a reference count - use mro_get_from_name to
747    retrieve a C<struct mro_alg *>  */
748 PERLVAR(I, registered_mros, HV *)
749
750 /* Compile-time block start/end hooks */
751 PERLVAR(I, blockhooks,  AV *)
752
753 /* Everything that folds to a given character, for case insensitivity regex
754  * matching */
755 PERLVARI(I, utf8_foldclosures, HV *, NULL)
756
757 /* List of characters that participate in folds (except marks, etc in
758  * multi-char folds) */
759 PERLVARI(I, utf8_foldable, SV *, NULL)
760
761 PERLVAR(I, custom_ops,  HV *)           /* custom op registrations */
762
763 /* Hook for File::Glob */
764 PERLVARI(I, globhook,   globhook_t, NULL)
765
766 PERLVARI(I, glob_index, int,    0)
767
768 PERLVAR(I, reentrant_retint, int)       /* Integer return value from reentrant functions */
769
770 /* The last unconditional member of the interpreter structure when 5.10.0 was
771    released. The offset of the end of this is baked into a global variable in 
772    any shared perl library which will allow a sanity test in future perl
773    releases.  */
774 #define PERL_LAST_5_16_0_INTERP_MEMBER  Ireentrant_retint
775
776 #ifdef PERL_IMPLICIT_CONTEXT
777 PERLVARI(I, my_cxt_list, void **, NULL) /* per-module array of MY_CXT pointers */
778 PERLVARI(I, my_cxt_size, int,   0)      /* size of PL_my_cxt_list */
779 #  ifdef PERL_GLOBAL_STRUCT_PRIVATE
780 PERLVARI(I, my_cxt_keys, const char **, NULL) /* per-module array of pointers to MY_CXT_KEY constants */
781 #  endif
782 #endif
783
784 #ifdef PERL_TRACK_MEMPOOL
785 /* For use with the memory debugging code in util.c  */
786 PERLVAR(I, memory_debug_header, struct perl_memory_debug_header)
787 #endif
788
789 #ifdef DEBUG_LEAKING_SCALARS_FORK_DUMP
790 /* File descriptor to talk to the child which dumps scalars.  */
791 PERLVARI(I, dumper_fd,  int,    -1)
792 #endif
793
794 #ifdef PERL_MAD
795 PERLVARI(I, madskills,  bool,   FALSE)  /* preserve all syntactic info */
796                                         /* (MAD = Misc Attribute Decoration) */
797 PERLVARI(I, xmlfp,      PerlIO *, NULL)
798 #endif
799
800 #ifdef DEBUG_LEAKING_SCALARS
801 PERLVARI(I, sv_serial,  U32,    0)      /* SV serial number, used in sv.c */
802 #endif
803
804 /* If you are adding a U8 or U16, check to see if there are 'Space' comments
805  * above on where there are gaps which currently will be structure padding.  */
806
807 /* Within a stable branch, new variables must be added to the very end, before
808  * this comment, for binary compatibility (the offsets of the old members must
809  *  not change).
810  * (Don't forget to add your variable also to perl_clone()!)
811  * XSUB.h provides wrapper functions via perlapi.h that make this
812  * irrelevant, but not all code may be expected to #include XSUB.h.
813  */