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_alnumc, SV *)
 618 PERLVAR(I, utf8_alpha,  SV *)
 619 PERLVAR(I, utf8_graph,  SV *)
 620 PERLVAR(I, utf8_digit,  SV *)
 621 PERLVAR(I, utf8_upper,  SV *)
 622 PERLVAR(I, utf8_lower,  SV *)
 623 PERLVAR(I, utf8_print,  SV *)
 624 PERLVAR(I, utf8_punct,  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_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 PERLVAR(I, reentrant_retint, int)       /* Integer return value from reentrant functions */
 767
 768 /* The last unconditional member of the interpreter structure when 5.10.0 was
 769    released. The offset of the end of this is baked into a global variable in
 770    any shared perl library which will allow a sanity test in future perl
 771    releases.  */
 772 #define PERL_LAST_5_16_0_INTERP_MEMBER  Ireentrant_retint
 773
 774 #ifdef PERL_IMPLICIT_CONTEXT
 775 PERLVARI(I, my_cxt_list, void **, NULL) /* per-module array of MY_CXT pointers */
 776 PERLVARI(I, my_cxt_size, int,   0)      /* size of PL_my_cxt_list */
 777 #  ifdef PERL_GLOBAL_STRUCT_PRIVATE
 778 PERLVARI(I, my_cxt_keys, const char **, NULL) /* per-module array of pointers to MY_CXT_KEY constants */
 779 #  endif
 780 #endif
 781
 782 #ifdef PERL_TRACK_MEMPOOL
 783 /* For use with the memory debugging code in util.c  */
 784 PERLVAR(I, memory_debug_header, struct perl_memory_debug_header)
 785 #endif
 786
 787 #ifdef DEBUG_LEAKING_SCALARS_FORK_DUMP
 788 /* File descriptor to talk to the child which dumps scalars.  */
 789 PERLVARI(I, dumper_fd,  int,    -1)
 790 #endif
 791
 792 #ifdef PERL_MAD
 793 PERLVARI(I, madskills,  bool,   FALSE)  /* preserve all syntactic info */
 794                                         /* (MAD = Misc Attribute Decoration) */
 795 PERLVARI(I, xmlfp,      PerlIO *, NULL)
 796 #endif
 797
 798 #ifdef DEBUG_LEAKING_SCALARS
 799 PERLVARI(I, sv_serial,  U32,    0)      /* SV serial number, used in sv.c */
 800 #endif
 801
 802 /* If you are adding a U8 or U16, check to see if there are 'Space' comments
 803  * above on where there are gaps which currently will be structure padding.  */
 804
 805 /* Within a stable branch, new variables must be added to the very end, before
 806  * this comment, for binary compatibility (the offsets of the old members must
 807  *  not change).
 808  * (Don't forget to add your variable also to perl_clone()!)
 809  * XSUB.h provides wrapper functions via perlapi.h that make this
 810  * irrelevant, but not all code may be expected to #include XSUB.h.
 811  */