intrpvar.h

   1 /***********************************************/
   2 /* Global only to current interpreter instance */
   3 /***********************************************/
   4
   5 /* Don't forget to re-run embed.pl to propagate changes! */
   6
   7 /* New variables must be added to the very end for binary compatibility.
   8  * XSUB.h provides wrapper functions via perlapi.h that make this
   9  * irrelevant, but not all code may be expected to #include XSUB.h. */
  10
  11 /* Don't forget to add your variable also to perl_clone()! */
  12
  13 /* The 'I' prefix is only needed for vars that need appropriate #defines
  14  * generated when built with or without MULTIPLICITY.  It is also used
  15  * to generate the appropriate export list for win32.
  16  *
  17  * When building without MULTIPLICITY, these variables will be truly global. */
  18
  19 /* pseudo environmental stuff */
  20 PERLVAR(Iorigargc,      int)
  21 PERLVAR(Iorigargv,      char **)
  22 PERLVAR(Ienvgv,         GV *)
  23 PERLVAR(Iincgv,         GV *)
  24 PERLVAR(Ihintgv,        GV *)
  25 PERLVAR(Iorigfilename,  char *)
  26 PERLVAR(Idiehook,       SV *)
  27 PERLVAR(Iwarnhook,      SV *)
  28
  29 /* switches */
  30 PERLVAR(Iminus_c,       bool)
  31 PERLVAR(Ipatchlevel,    SV *)
  32 PERLVAR(Ilocalpatches,  const char * const *)
  33 PERLVARI(Isplitstr,     const char *, " ")
  34 PERLVAR(Ipreprocess,    bool)
  35 PERLVAR(Iminus_n,       bool)
  36 PERLVAR(Iminus_p,       bool)
  37 PERLVAR(Iminus_l,       bool)
  38 PERLVAR(Iminus_a,       bool)
  39 PERLVAR(Iminus_F,       bool)
  40 PERLVAR(Idoswitches,    bool)
  41 PERLVAR(Iminus_E,       bool)
  42
  43 /*
  44 =head1 Global Variables
  45
  46 =for apidoc mn|bool|PL_dowarn
  47
  48 The C variable which corresponds to Perl's $^W warning variable.
  49
  50 =cut
  51 */
  52
  53 PERLVAR(Idowarn,        U8)
  54 PERLVAR(Iwidesyscalls,  bool)           /* unused since 5.8.1 */
  55 PERLVAR(Idoextract,     bool)
  56 PERLVAR(Isawampersand,  bool)           /* must save all match strings */
  57 PERLVAR(Iunsafe,        bool)
  58 PERLVAR(Iinplace,       char *)
  59 PERLVAR(Ie_script,      SV *)
  60 PERLVAR(Iperldb,        U32)
  61
  62 /* This value may be set when embedding for full cleanup  */
  63 /* 0=none, 1=full, 2=full with checks */
  64 PERLVARI(Iperl_destruct_level,  int,    0)
  65
  66 /* magical thingies */
  67 PERLVAR(Ibasetime,      Time_t)         /* $^T */
  68 PERLVAR(Iformfeed,      SV *)           /* $^L */
  69
  70
  71 PERLVARI(Imaxsysfd,     I32,    MAXSYSFD)
  72                                         /* top fd to pass to subprocesses */
  73 PERLVAR(Imultiline,     int)            /* $*--do strings hold >1 line? */
  74 PERLVAR(Istatusvalue,   I32)            /* $? */
  75 PERLVAR(Iexit_flags,    U8)             /* was exit() unexpected, etc. */
  76 #ifdef VMS
  77 PERLVAR(Istatusvalue_vms,U32)
  78 #else
  79 PERLVAR(Istatusvalue_posix,I32)
  80 #endif
  81
  82 /* shortcuts to various I/O objects */
  83 PERLVAR(Istdingv,       GV *)
  84 PERLVAR(Istderrgv,      GV *)
  85 PERLVAR(Idefgv,         GV *)
  86 PERLVAR(Iargvgv,        GV *)
  87 PERLVAR(Iargvoutgv,     GV *)
  88 PERLVAR(Iargvout_stack, AV *)
  89
  90 /* shortcuts to regexp stuff */
  91 /* this one needs to be moved to thrdvar.h and accessed via
  92  * find_threadsv() when USE_5005THREADS */
  93 PERLVAR(Ireplgv,        GV *)
  94
  95 /* shortcuts to misc objects */
  96 PERLVAR(Ierrgv,         GV *)
  97
  98 /* shortcuts to debugging objects */
  99 PERLVAR(IDBgv,          GV *)
 100 PERLVAR(IDBline,        GV *)
 101
 102 /*
 103 =for apidoc mn|GV *|PL_DBsub
 104 When Perl is run in debugging mode, with the B<-d> switch, this GV contains
 105 the SV which holds the name of the sub being debugged.  This is the C
 106 variable which corresponds to Perl's $DB::sub variable.  See
 107 C<PL_DBsingle>.
 108
 109 =for apidoc mn|SV *|PL_DBsingle
 110 When Perl is run in debugging mode, with the B<-d> switch, this SV is a
 111 boolean which indicates whether subs are being single-stepped.
 112 Single-stepping is automatically turned on after every step.  This is the C
 113 variable which corresponds to Perl's $DB::single variable.  See
 114 C<PL_DBsub>.
 115
 116 =for apidoc mn|SV *|PL_DBtrace
 117 Trace variable used when Perl is run in debugging mode, with the B<-d>
 118 switch.  This is the C variable which corresponds to Perl's $DB::trace
 119 variable.  See C<PL_DBsingle>.
 120
 121 =cut
 122 */
 123
 124 PERLVAR(IDBsub,         GV *)
 125 PERLVAR(IDBsingle,      SV *)
 126 PERLVAR(IDBtrace,       SV *)
 127 PERLVAR(IDBsignal,      SV *)
 128 PERLVAR(Ilineary,       AV *)           /* lines of script for debugger */
 129 PERLVAR(Idbargs,        AV *)           /* args to call listed by caller function */
 130
 131 /* symbol tables */
 132 PERLVAR(Idebstash,      HV *)           /* symbol table for perldb package */
 133 PERLVAR(Iglobalstash,   HV *)           /* global keyword overrides imported here */
 134 PERLVAR(Icurstname,     SV *)           /* name of current package */
 135 PERLVAR(Ibeginav,       AV *)           /* names of BEGIN subroutines */
 136 PERLVAR(Iendav,         AV *)           /* names of END subroutines */
 137 PERLVAR(Icheckav,       AV *)           /* names of CHECK subroutines */
 138 PERLVAR(Iinitav,        AV *)           /* names of INIT subroutines */
 139 PERLVAR(Istrtab,        HV *)           /* shared string table */
 140 PERLVARI(Isub_generation,U32,1)         /* incr to invalidate method cache */
 141
 142 /* memory management */
 143 PERLVAR(Isv_count,      I32)            /* how many SV* are currently allocated */
 144 PERLVAR(Isv_objcount,   I32)            /* how many objects are currently allocated */
 145 PERLVAR(Isv_root,       SV*)            /* storage for SVs belonging to interp */
 146 PERLVAR(Isv_arenaroot,  SV*)            /* list of areas for garbage collection */
 147
 148 /* funky return mechanisms */
 149 PERLVAR(Iforkprocess,   int)            /* so do_open |- can return proc# */
 150
 151 /* subprocess state */
 152 PERLVAR(Ifdpid,         AV *)           /* keep fd-to-pid mappings for my_popen */
 153
 154 /* internal state */
 155 PERLVAR(Itainting,      bool)           /* doing taint checks */
 156 PERLVARI(Iop_mask,      char *, NULL)   /* masked operations for safe evals */
 157
 158 /* current interpreter roots */
 159 PERLVAR(Imain_cv,       CV *)
 160 PERLVAR(Imain_root,     OP *)
 161 PERLVAR(Imain_start,    OP *)
 162 PERLVAR(Ieval_root,     OP *)
 163 PERLVAR(Ieval_start,    OP *)
 164
 165 /* runtime control stuff */
 166 PERLVARI(Icurcopdb,     COP *,  NULL)
 167 PERLVARI(Icopline,      line_t, NOLINE)
 168
 169 /* statics moved here for shared library purposes */
 170 PERLVAR(Ifilemode,      int)            /* so nextargv() can preserve mode */
 171 PERLVAR(Ilastfd,        int)            /* what to preserve mode on */
 172 PERLVAR(Ioldname,       char *)         /* what to preserve mode on */
 173 PERLVAR(IArgv,          char **)        /* stuff to free from do_aexec, vfork safe */
 174 PERLVAR(ICmd,           char *)         /* stuff to free from do_aexec, vfork safe */
 175 PERLVARI(Igensym,       I32,    0)      /* next symbol for getsym() to define */
 176 PERLVAR(Ipreambled,     bool)
 177 PERLVAR(Ipreambleav,    AV *)
 178 PERLVARI(Ilaststatval,  int,    -1)
 179 PERLVARI(Ilaststype,    I32,    OP_STAT)
 180 PERLVAR(Imess_sv,       SV *)
 181
 182 /* XXX shouldn't these be per-thread? --GSAR */
 183 PERLVAR(Iors_sv,        SV *)           /* output record separator $\ */
 184
 185 /* interpreter atexit processing */
 186 PERLVARI(Iexitlist,     PerlExitListEntry *, NULL)
 187                                         /* list of exit functions */
 188 PERLVARI(Iexitlistlen,  I32, 0)         /* length of same */
 189
 190 /*
 191 =for apidoc Amn|HV*|PL_modglobal
 192
 193 C<PL_modglobal> is a general purpose, interpreter global HV for use by
 194 extensions that need to keep information on a per-interpreter basis.
 195 In a pinch, it can also be used as a symbol table for extensions
 196 to share data among each other.  It is a good idea to use keys
 197 prefixed by the package name of the extension that owns the data.
 198
 199 =cut
 200 */
 201
 202 PERLVAR(Imodglobal,     HV *)           /* per-interp module data */
 203
 204 /* these used to be in global before 5.004_68 */
 205 PERLVARI(Iprofiledata,  U32 *,  NULL)   /* table of ops, counts */
 206 PERLVARI(Irsfp, PerlIO * VOL,   Nullfp) /* current source file pointer */
 207 PERLVARI(Irsfp_filters, AV *,   NULL)   /* keeps active source filters */
 208
 209 PERLVAR(Icompiling,     COP)            /* compiling/done executing marker */
 210
 211 PERLVAR(Icompcv,        CV *)           /* currently compiling subroutine */
 212 PERLVAR(Icomppad,       AV *)           /* storage for lexically scoped temporaries */
 213 PERLVAR(Icomppad_name,  AV *)           /* variable names for "my" variables */
 214 PERLVAR(Icomppad_name_fill,     I32)    /* last "introduced" variable offset */
 215 PERLVAR(Icomppad_name_floor,    I32)    /* start of vars in innermost block */
 216
 217 #ifdef HAVE_INTERP_INTERN
 218 PERLVAR(Isys_intern,    struct interp_intern)
 219                                         /* platform internals */
 220 #endif
 221
 222 /* more statics moved here */
 223 PERLVARI(Igeneration,   int,    100)    /* from op.c */
 224 PERLVAR(IDBcv,          CV *)           /* from perl.c */
 225
 226 PERLVARI(Iin_clean_objs,bool,    FALSE) /* from sv.c */
 227 PERLVARI(Iin_clean_all, bool,    FALSE) /* from sv.c */
 228
 229 PERLVAR(Ilinestart,     char *)         /* beg. of most recently read line */
 230 PERLVAR(Ipending_ident, char)           /* pending identifier lookup */
 231 PERLVAR(Isublex_info,   SUBLEXINFO)     /* from toke.c */
 232
 233 PERLVAR(Iuid,           Uid_t)          /* current real user id */
 234 PERLVAR(Ieuid,          Uid_t)          /* current effective user id */
 235 PERLVAR(Igid,           Gid_t)          /* current real group id */
 236 PERLVAR(Iegid,          Gid_t)          /* current effective group id */
 237 PERLVAR(Inomemok,       bool)           /* let malloc context handle nomem */
 238 PERLVARI(Ian,           U32,    0)      /* malloc sequence number */
 239 PERLVARI(Icop_seqmax,   U32,    0)      /* statement sequence number */
 240 PERLVARI(Ievalseq,      U32,    0)      /* eval sequence number */
 241 PERLVAR(Iorigenviron,   char **)
 242 PERLVAR(Iorigalen,      U32)
 243 #ifdef PERL_USES_PL_PIDSTATUS
 244 PERLVAR(Ipidstatus,     HV *)           /* pid-to-status mappings for waitpid */
 245 #endif
 246 PERLVARI(Imaxo, int,    MAXO)           /* maximum number of ops */
 247 PERLVAR(Iosname,        char *)         /* operating system */
 248
 249 PERLVAR(Isighandlerp,   Sighandler_t)
 250
 251 PERLVARA(Ibody_roots,   SVt_LAST, void*) /* array of body roots */
 252
 253 PERLVAR(Inice_chunk,    char *)         /* a nice chunk of memory to reuse */
 254 PERLVAR(Inice_chunk_size,       U32)    /* how nice the chunk of memory is */
 255
 256 PERLVARI(Irunops,       runops_proc_t,  MEMBER_TO_FPTR(RUNOPS_DEFAULT))
 257
 258 PERLVARA(Itokenbuf,256, char)
 259
 260 /*
 261 =for apidoc Amn|SV|PL_sv_undef
 262 This is the C<undef> SV.  Always refer to this as C<&PL_sv_undef>.
 263
 264 =for apidoc Amn|SV|PL_sv_no
 265 This is the C<false> SV.  See C<PL_sv_yes>.  Always refer to this as
 266 C<&PL_sv_no>.
 267
 268 =for apidoc Amn|SV|PL_sv_yes
 269 This is the C<true> SV.  See C<PL_sv_no>.  Always refer to this as
 270 C<&PL_sv_yes>.
 271
 272 =cut
 273 */
 274
 275 PERLVAR(Isv_undef,      SV)
 276 PERLVAR(Isv_no,         SV)
 277 PERLVAR(Isv_yes,        SV)
 278
 279 #ifdef CSH
 280 PERLVARI(Icshname,      const char *,   CSH)
 281 PERLVARI(Icshlen,       I32,    0)
 282 #endif
 283
 284 PERLVAR(Ilex_state,     U32)            /* next token is determined */
 285 PERLVAR(Ilex_defer,     U32)            /* state after determined token */
 286 PERLVAR(Ilex_expect,    int)            /* expect after determined token */
 287 PERLVAR(Ilex_brackets,  I32)            /* bracket count */
 288 PERLVAR(Ilex_formbrack, I32)            /* bracket count at outer format level */
 289 PERLVAR(Ilex_casemods,  I32)            /* casemod count */
 290 PERLVAR(Ilex_dojoin,    I32)            /* doing an array interpolation */
 291 PERLVAR(Ilex_starts,    I32)            /* how many interps done on level */
 292 PERLVAR(Ilex_stuff,     SV *)           /* runtime pattern from m// or s/// */
 293 PERLVAR(Ilex_repl,      SV *)           /* runtime replacement from s/// */
 294 PERLVAR(Ilex_op,        OP *)           /* extra info to pass back on op */
 295 PERLVAR(Ilex_inpat,     OP *)           /* in pattern $) and $| are special */
 296 PERLVAR(Ilex_inwhat,    I32)            /* what kind of quoting are we in */
 297 PERLVAR(Ilex_brackstack,char *)         /* what kind of brackets to pop */
 298 PERLVAR(Ilex_casestack, char *)         /* what kind of case mods in effect */
 299
 300 /* What we know when we're in LEX_KNOWNEXT state. */
 301 PERLVARA(Inextval,5,    YYSTYPE)        /* value of next token, if any */
 302 PERLVARA(Inexttype,5,   I32)            /* type of next token */
 303 PERLVAR(Inexttoke,      I32)
 304
 305 PERLVAR(Ilinestr,       SV *)
 306 PERLVAR(Ibufptr,        char *)
 307 PERLVAR(Ioldbufptr,     char *)
 308 PERLVAR(Ioldoldbufptr,  char *)
 309 PERLVAR(Ibufend,        char *)
 310 PERLVARI(Iexpect,int,   XSTATE)         /* how to interpret ambiguous tokens */
 311
 312 PERLVAR(Imulti_start,   I32)            /* 1st line of multi-line string */
 313 PERLVAR(Imulti_end,     I32)            /* last line of multi-line string */
 314 PERLVAR(Imulti_open,    I32)            /* delimiter of said string */
 315 PERLVAR(Imulti_close,   I32)            /* delimiter of said string */
 316
 317 PERLVAR(Ierror_count,   I32)            /* how many errors so far, max 10 */
 318 PERLVAR(Isubline,       I32)            /* line this subroutine began on */
 319 PERLVAR(Isubname,       SV *)           /* name of current subroutine */
 320
 321 PERLVAR(Imin_intro_pending,     I32)    /* start of vars to introduce */
 322 PERLVAR(Imax_intro_pending,     I32)    /* end of vars to introduce */
 323 PERLVAR(Ipadix,         I32)            /* max used index in current "register" pad */
 324 PERLVAR(Ipadix_floor,   I32)            /* how low may inner block reset padix */
 325 PERLVAR(Ipad_reset_pending,     I32)    /* reset pad on next attempted alloc */
 326
 327 PERLVAR(Ilast_uni,      char *)         /* position of last named-unary op */
 328 PERLVAR(Ilast_lop,      char *)         /* position of last list operator */
 329 PERLVAR(Ilast_lop_op,   OPCODE)         /* last list operator */
 330 PERLVAR(Iin_my,         I32)            /* we're compiling a "my" (or "our") declaration */
 331 PERLVAR(Iin_my_stash,   HV *)           /* declared class of this "my" declaration */
 332 #ifdef FCRYPT
 333 PERLVARI(Icryptseen,    bool,   FALSE)  /* has fast crypt() been initialized? */
 334 #endif
 335
 336 PERLVAR(Ihints,         U32)            /* pragma-tic compile-time flags */
 337
 338 PERLVAR(Idebug,         VOL U32)        /* flags given to -D switch */
 339
 340 PERLVARI(Iamagic_generation,    long,   0)
 341
 342 #ifdef USE_LOCALE_COLLATE
 343 PERLVARI(Icollation_ix, U32,    0)      /* Collation generation index */
 344 PERLVAR(Icollation_name,char *)         /* Name of current collation */
 345 PERLVARI(Icollation_standard, bool,     TRUE)
 346                                         /* Assume simple collation */
 347 PERLVAR(Icollxfrm_base, Size_t)         /* Basic overhead in *xfrm() */
 348 PERLVARI(Icollxfrm_mult,Size_t, 2)      /* Expansion factor in *xfrm() */
 349 #endif /* USE_LOCALE_COLLATE */
 350
 351 #ifdef USE_LOCALE_NUMERIC
 352
 353 PERLVAR(Inumeric_name,  char *)         /* Name of current numeric locale */
 354 PERLVARI(Inumeric_standard,     bool,   TRUE)
 355                                         /* Assume simple numerics */
 356 PERLVARI(Inumeric_local,        bool,   TRUE)
 357                                         /* Assume local numerics */
 358
 359 PERLVAR(Inumeric_compat1,               char)
 360                                         /* Used to be numeric_radix */
 361 #endif /* !USE_LOCALE_NUMERIC */
 362
 363 /* utf8 character classes */
 364 PERLVAR(Iutf8_alnum,    SV *)
 365 PERLVAR(Iutf8_alnumc,   SV *)
 366 PERLVAR(Iutf8_ascii,    SV *)
 367 PERLVAR(Iutf8_alpha,    SV *)
 368 PERLVAR(Iutf8_space,    SV *)
 369 PERLVAR(Iutf8_cntrl,    SV *)
 370 PERLVAR(Iutf8_graph,    SV *)
 371 PERLVAR(Iutf8_digit,    SV *)
 372 PERLVAR(Iutf8_upper,    SV *)
 373 PERLVAR(Iutf8_lower,    SV *)
 374 PERLVAR(Iutf8_print,    SV *)
 375 PERLVAR(Iutf8_punct,    SV *)
 376 PERLVAR(Iutf8_xdigit,   SV *)
 377 PERLVAR(Iutf8_mark,     SV *)
 378 PERLVAR(Iutf8_toupper,  SV *)
 379 PERLVAR(Iutf8_totitle,  SV *)
 380 PERLVAR(Iutf8_tolower,  SV *)
 381 PERLVAR(Iutf8_tofold,   SV *)
 382 PERLVAR(Ilast_swash_hv, HV *)
 383 PERLVAR(Ilast_swash_klen,       U32)
 384 PERLVARA(Ilast_swash_key,10,    U8)
 385 PERLVAR(Ilast_swash_tmps,       U8 *)
 386 PERLVAR(Ilast_swash_slen,       STRLEN)
 387
 388 /* perly.c globals */
 389 PERLVAR(Iyycharp,       int *)
 390 PERLVAR(Iyylvalp,       YYSTYPE *)
 391
 392 PERLVARI(Iglob_index,   int,    0)
 393 PERLVAR(Isrand_called,  bool)
 394 PERLVARA(Iuudmap,256,   char)
 395 PERLVAR(Ibitcount,      char *)
 396
 397 PERLVAR(Ipsig_ptr, SV**)
 398 PERLVAR(Ipsig_name, SV**)
 399
 400 #if defined(PERL_IMPLICIT_SYS)
 401 PERLVAR(IMem,           struct IPerlMem*)
 402 PERLVAR(IMemShared,     struct IPerlMem*)
 403 PERLVAR(IMemParse,      struct IPerlMem*)
 404 PERLVAR(IEnv,           struct IPerlEnv*)
 405 PERLVAR(IStdIO,         struct IPerlStdIO*)
 406 PERLVAR(ILIO,           struct IPerlLIO*)
 407 PERLVAR(IDir,           struct IPerlDir*)
 408 PERLVAR(ISock,          struct IPerlSock*)
 409 PERLVAR(IProc,          struct IPerlProc*)
 410 #endif
 411
 412 #if defined(USE_ITHREADS)
 413 PERLVAR(Iptr_table,     PTR_TBL_t*)
 414 #endif
 415 PERLVARI(Ibeginav_save, AV*, NULL)      /* save BEGIN{}s when compiling */
 416
 417 PERLVARA(Ibody_arenaroots, SVt_LAST, void*) /* consolidated body-arena pointers */
 418
 419      /* 5.6.0 stopped here */
 420
 421 PERLVAR(Ipsig_pend, int *)              /* per-signal "count" of pending */
 422 PERLVARI(Isig_pending, int,0)           /* Number if highest signal pending */
 423
 424 #ifdef USE_LOCALE_NUMERIC
 425
 426 PERLVAR(Inumeric_radix_sv,      SV *)   /* The radix separator if not '.' */
 427
 428 #endif
 429
 430 #if defined(USE_ITHREADS)
 431 PERLVAR(Iregex_pad,     SV**)           /* All regex objects */
 432 PERLVAR(Iregex_padav,   AV*)            /* All regex objects */
 433
 434 #endif
 435
 436 #ifdef USE_REENTRANT_API
 437 PERLVAR(Ireentrant_buffer, REENTR*)     /* here we store the _r buffers */
 438 #endif
 439
 440 PERLVARI(Isavebegin,     bool,  FALSE)  /* save BEGINs for compiler     */
 441
 442 PERLVAR(Icustom_op_names, HV*)  /* Names of user defined ops */
 443 PERLVAR(Icustom_op_descs, HV*)  /* Descriptions of user defined ops */
 444
 445 #ifdef PERLIO_LAYERS
 446 PERLVARI(Iperlio, PerlIO *,NULL)
 447 PERLVARI(Iknown_layers, PerlIO_list_t *,NULL)
 448 PERLVARI(Idef_layerlist, PerlIO_list_t *,NULL)
 449 #endif
 450
 451 PERLVARI(Iencoding,     SV*, Nullsv)            /* character encoding */
 452
 453 PERLVAR(Idebug_pad,     struct perl_debug_pad)  /* always needed because of the re extension */
 454
 455 PERLVAR(Itaint_warn, bool)      /* taint warns instead of dying */
 456
 457 #ifdef PL_OP_SLAB_ALLOC
 458 PERLVAR(IOpPtr,I32 **)
 459 PERLVARI(IOpSpace,I32,0)
 460 PERLVAR(IOpSlab,I32 *)
 461 #endif
 462
 463 PERLVAR(Iutf8locale,    bool)           /* utf8 locale detected */
 464
 465 PERLVAR(Iutf8_idstart,  SV *)
 466 PERLVAR(Iutf8_idcont,   SV *)
 467
 468 PERLVAR(Isort_RealCmp,  SVCOMPARE_t)
 469
 470 PERLVARI(Icheckav_save, AV*, NULL)      /* save CHECK{}s when compiling */
 471
 472 PERLVARI(Iclocktick, long, 0)   /* this many times() ticks in a second */
 473
 474 PERLVARI(Iin_load_module, int, 0)       /* to prevent recursions in PerlIO_find_layer */
 475
 476 PERLVAR(Iunicode, U32)  /* Unicode features: $ENV{PERL_UNICODE} or -C */
 477
 478 PERLVAR(Isignals, U32)  /* Using which pre-5.8 signals */
 479
 480 PERLVAR(Istashcache,    HV *)           /* Cache to speed up S_method_common */
 481
 482 PERLVAR(Ireentrant_retint, int) /* Integer return value from reentrant functions */
 483
 484 /* Hooks to shared SVs and locks. */
 485 PERLVARI(Isharehook,    share_proc_t,   MEMBER_TO_FPTR(Perl_sv_nosharing))
 486 PERLVARI(Ilockhook,     share_proc_t,   MEMBER_TO_FPTR(Perl_sv_nosharing))
 487 PERLVARI(Iunlockhook,   share_proc_t,   MEMBER_TO_FPTR(Perl_sv_nosharing))
 488 PERLVARI(Ithreadhook,   thrhook_proc_t, MEMBER_TO_FPTR(Perl_nothreadhook))
 489
 490 /* Force inclusion of both runops options */
 491 PERLVARI(Irunops_std,   runops_proc_t,  MEMBER_TO_FPTR(Perl_runops_standard))
 492 PERLVARI(Irunops_dbg,   runops_proc_t,  MEMBER_TO_FPTR(Perl_runops_debug))
 493
 494 /* Stores the PPID */
 495 #ifdef THREADS_HAVE_PIDS
 496 PERLVARI(Ippid,         IV,             0)
 497 #endif
 498
 499 PERLVARI(Ihash_seed, UV, 0)             /* Hash initializer */
 500
 501 PERLVARI(Ihash_seed_set, bool, FALSE)           /* Hash initialized? */
 502
 503 PERLVAR(IDBassertion,   SV *)
 504
 505 PERLVARI(Icv_has_eval, I32, 0) /* PL_compcv includes an entereval or similar */
 506
 507 PERLVARI(Irehash_seed, UV, 0)           /* 582 hash initializer */
 508
 509 PERLVARI(Irehash_seed_set, bool, FALSE) /* 582 hash initialized? */
 510
 511 /* These two variables are needed to preserve 5.8.x bincompat because we can't
 512    change function prototypes of two exported functions.  Probably should be
 513    taken out of blead soon, and relevant prototypes changed.  */
 514 PERLVARI(Ifdscript, int, -1)    /* fd for script */
 515 PERLVARI(Isuidscript, int, -1)  /* fd for suid script */
 516 #ifdef DEBUG_LEAKING_SCALARS_FORK_DUMP
 517 /* File descriptor to talk to the child which dumps scalars.  */
 518 PERLVARI(Idumper_fd, int, -1)
 519 #endif
 520 /* New variables must be added to the very end, before this comment,
 521  * for binary compatibility (the offsets of the old members must not change).
 522  * (Don't forget to add your variable also to perl_clone()!)
 523  * XSUB.h provides wrapper functions via perlapi.h that make this
 524  * irrelevant, but not all code may be expected to #include XSUB.h.
 525  */