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 #include "handy.h" 12 13 /* These variables are per-interpreter in threaded/multiplicity builds, 14 * global otherwise. 15 16 * Don't forget to re-run regen/embed.pl to propagate changes! */ 17 18 /* New variables must be added to the very end for binary compatibility. */ 19 20 /* DON'T FORGET to add your variable also to perl_clone()! (in sv.c) */ 21 22 /* The 'I' prefix is only needed for vars that need appropriate #defines 23 * generated when built with or without MULTIPLICITY. It is also used 24 * to generate the appropriate export list for win32. If the variable 25 * needs to be initialized, use PERLVARI. 26 * 27 * When building without MULTIPLICITY, these variables will be truly global. 28 * 29 * Important ones in the first cache line (if alignment is done right) */ 30 31 PERLVAR(I, stack_sp, SV **) /* top of the stack */ 32 PERLVAR(I, op, OP *) /* currently executing op */ 33 PERLVAR(I, curpad, SV **) /* active pad (lexicals+tmps) */ 34 35 PERLVAR(I, stack_base, SV **) 36 PERLVAR(I, stack_max, SV **) 37 38 PERLVAR(I, savestack, ANY *) /* items that need to be restored when 39 LEAVEing scopes we've ENTERed */ 40 PERLVAR(I, savestack_ix, I32) 41 PERLVAR(I, savestack_max, I32) 42 43 PERLVAR(I, scopestack, I32 *) /* scopes we've ENTERed */ 44 PERLVAR(I, scopestack_ix, I32) 45 PERLVAR(I, scopestack_max, I32) 46 47 PERLVAR(I, tmps_stack, SV **) /* mortals we've made */ 48 PERLVARI(I, tmps_ix, SSize_t, -1) 49 PERLVARI(I, tmps_floor, SSize_t, -1) 50 PERLVAR(I, tmps_max, SSize_t) /* first unalloced slot in tmps stack */ 51 52 PERLVAR(I, markstack, Stack_off_t *) /* stack_sp locations we're 53 remembering */ 54 PERLVAR(I, markstack_ptr, Stack_off_t *) 55 PERLVAR(I, markstack_max, Stack_off_t *) 56 57 PERLVARI(I, sub_generation, U32, 1) /* incr to invalidate method cache */ 58 59 #ifdef PERL_HASH_RANDOMIZE_KEYS 60 #ifdef USE_PERL_PERTURB_KEYS 61 PERLVARI(I, hash_rand_bits_enabled, U8, 1) /* used to randomize hash stuff 62 0. no-random 63 1. random 64 2. deterministic */ 65 #endif 66 PERLVARI(I, hash_rand_bits, UV, 0) /* used to randomize hash stuff */ 67 #endif 68 PERLVAR(I, strtab, HV *) /* shared string table */ 69 /* prog counter for the currently executing OP_MULTIDEREF Used to signal 70 * to S_find_uninit_var() where we are */ 71 PERLVAR(I, multideref_pc, UNOP_AUX_item *) 72 73 /* Fields used by magic variables such as $@, $/ and so on */ 74 PERLVAR(I, curpm, PMOP *) /* what to do \ interps in REs from */ 75 PERLVAR(I, curpm_under, PMOP *) /* what to do \ interps in REs from */ 76 77 PERLVAR(I, tainting, bool) /* ? doing taint checks */ 78 PERLVARI(I, tainted, bool, FALSE) /* using variables controlled by $< */ 79 80 /* PL_delaymagic is currently used for two purposes: to assure simultaneous 81 * updates in ($<,$>) = ..., and to assure atomic update in push/unshift 82 * @ISA, It works like this: a few places such as pp_push set the DM_DELAY 83 * flag; then various places such as av_store() skip mg_set(ary) if this 84 * flag is set, and various magic vtable methods set flags like 85 * DM_ARRAY_ISA if they've seen something of that ilk. Finally when 86 * control returns to pp_push or whatever, it sees if any of those flags 87 * have been set, and if so finally calls mg_set(). 88 * 89 * NB: PL_delaymagic is automatically saved and restored by JMPENV_PUSH 90 * / POP. This removes the need to do ENTER/SAVEI16(PL_delaymagic)/LEAVE 91 * in hot code like pp_push. 92 */ 93 PERLVAR(I, delaymagic, U16) /* ($<,$>) = ... */ 94 95 /* 96 =for apidoc_section $warning 97 =for apidoc mn|U8|PL_dowarn 98 99 The C variable that roughly corresponds to Perl's C<$^W> warning variable. 100 However, C<$^W> is treated as a boolean, whereas C<PL_dowarn> is a 101 collection of flag bits. 102 103 On threaded perls, each thread has an independent copy of this variable; 104 each initialized at creation time with the current value of the creating 105 thread's copy. 106 107 =cut 108 */ 109 110 PERLVAR(I, dowarn, U8) 111 112 #if defined (PERL_UTF8_CACHE_ASSERT) || defined (DEBUGGING) 113 # define PERL___I -1 114 #else 115 # define PERL___I 1 116 #endif 117 PERLVARI(I, utf8cache, I8, PERL___I) /* Is the utf8 caching code enabled? */ 118 #undef PERL___I 119 120 /* 121 =for apidoc_section $GV 122 =for apidoc Amn|GV *|PL_defgv 123 124 The GV representing C<*_>. Useful for access to C<$_>. 125 126 On threaded perls, each thread has an independent copy of this variable; 127 each initialized at creation time with the current value of the creating 128 thread's copy. 129 130 =cut 131 */ 132 133 PERLVAR(I, localizing, U8) /* are we processing a local() list? 134 0 = no, 1 = localizing, 2 = delocalizing */ 135 PERLVAR(I, in_eval, U8) /* trap "fatal" errors? */ 136 PERLVAR(I, defgv, GV *) /* the *_ glob */ 137 138 /* 139 =for apidoc_section $GV 140 =for apidoc Amn|HV*|PL_curstash 141 142 The stash for the package code will be compiled into. 143 144 On threaded perls, each thread has an independent copy of this variable; 145 each initialized at creation time with the current value of the creating 146 thread's copy. 147 148 =cut 149 */ 150 151 /* Stashes */ 152 PERLVAR(I, defstash, HV *) /* main symbol table */ 153 PERLVAR(I, curstash, HV *) /* symbol table for current package */ 154 155 /* 156 =for apidoc_section $COP 157 =for apidoc Amn|COP*|PL_curcop 158 159 The currently active COP (control op) roughly representing the current 160 statement in the source. 161 162 On threaded perls, each thread has an independent copy of this variable; 163 each initialized at creation time with the current value of the creating 164 thread's copy. 165 166 =cut 167 */ 168 169 PERLVAR(I, curcop, COP *) 170 PERLVAR(I, curstack, AV *) /* THE STACK */ 171 PERLVAR(I, curstackinfo, PERL_SI *) /* current stack + context */ 172 PERLVAR(I, mainstack, AV *) /* the stack when nothing funny is 173 happening */ 174 175 /* memory management */ 176 PERLVAR(I, sv_count, IV) /* how many SV* are currently allocated */ 177 178 PERLVAR(I, sv_root, SV *) /* storage for SVs belonging to interp */ 179 PERLVAR(I, sv_arenaroot, SV *) /* list of areas for garbage collection */ 180 181 /* fake PMOP that PL_curpm points to while in (?{}) so $1 et al are visible */ 182 PERLVARI(I, reg_curpm, PMOP*, NULL) 183 184 /* the currently active slab in a chain of slabs of regmatch states, 185 * and the currently active state within that slab. This stack of states 186 * is shared amongst re-entrant calls to the regex engine */ 187 188 PERLVARI(I, regmatch_slab, regmatch_slab *, NULL) 189 PERLVAR(I, regmatch_state, regmatch_state *) 190 191 PERLVAR(I, comppad, PAD *) /* storage for lexically scoped temporaries */ 192 193 /* 194 =for apidoc_section $SV 195 =for apidoc Amn|SV|PL_sv_undef 196 This is the C<undef> SV. It is readonly. Always refer to this as 197 C<&PL_sv_undef>. 198 199 =for apidoc Amn|SV|PL_sv_no 200 This is the C<false> SV. It is readonly. See C<L</PL_sv_yes>>. Always refer 201 to this as C<&PL_sv_no>. 202 203 =for apidoc Amn|SV|PL_sv_yes 204 This is the C<true> SV. It is readonly. See C<L</PL_sv_no>>. Always refer to 205 this as C<&PL_sv_yes>. 206 207 =for apidoc Amn|SV|PL_sv_zero 208 This readonly SV has a zero numeric value and a C<"0"> string value. It's 209 similar to C<L</PL_sv_no>> except for its string value. Can be used as a 210 cheap alternative to C<mXPUSHi(0)> for example. Always refer to this as 211 C<&PL_sv_zero>. Introduced in 5.28. 212 213 =cut 214 */ 215 216 #ifdef MULTIPLICITY 217 PERLVAR(I, sv_yes, SV) 218 PERLVAR(I, sv_undef, SV) 219 PERLVAR(I, sv_no, SV) 220 PERLVAR(I, sv_zero, SV) 221 #else 222 /* store the immortals as an array to ensure they are contiguous in 223 * memory: makes SvIMMORTAL_INTERP(sv) possible */ 224 PERLVARA(I, sv_immortals, 4, SV) 225 #endif 226 227 PERLVAR(I, padname_undef, PADNAME) 228 PERLVAR(I, padname_const, PADNAME) 229 230 /* 231 =for apidoc_section $SV 232 =for apidoc Cmn||PL_Sv 233 234 A scratch pad SV for whatever temporary use you need. Chiefly used as a 235 fallback by macros on platforms where L<perlapi/PERL_USE_GCC_BRACE_GROUPS>> is 236 unavailable, and which would otherwise evaluate their SV parameter more than 237 once. 238 239 B<BUT BEWARE>, if this is used in a situation where something that is using it 240 is in a call stack with something else that is using it, this variable would 241 get zapped, leading to hard-to-diagnose errors. 242 243 =cut 244 */ 245 PERLVAR(I, Sv, SV *) 246 247 PERLVAR(I, parser, yy_parser *) /* current parser state */ 248 249 PERLVAR(I, stashcache, HV *) /* Cache to speed up S_method_common */ 250 251 252 /* 253 =for apidoc_section $string 254 =for apidoc Amn|STRLEN|PL_na 255 256 A scratch pad variable in which to store a C<STRLEN> value. If would have been 257 better named something like C<PL_temp_strlen>. 258 259 It is is typically used with C<SvPV> when one is actually planning to discard 260 the returned length, (hence the length is "Not Applicable", which is how this 261 variable got its name). 262 263 B<BUT BEWARE>, if this is used in a situation where something that is using it 264 is in a call stack with something else that is using it, this variable would 265 get zapped, leading to hard-to-diagnose errors. 266 267 It is usually more efficient to either declare a local variable and use that 268 instead, or to use the C<SvPV_nolen> macro. 269 270 =cut 271 */ 272 273 PERLVAR(I, na, STRLEN) /* for use in SvPV when length is 274 Not Applicable */ 275 276 /* stat stuff */ 277 PERLVAR(I, statcache, Stat_t) /* _ */ 278 PERLVAR(I, statgv, GV *) 279 PERLVARI(I, statname, SV *, NULL) 280 281 /* 282 =for apidoc_section $io 283 =for apidoc mn|SV*|PL_rs 284 285 The input record separator - C<$/> in Perl space. 286 287 On threaded perls, each thread has an independent copy of this variable; 288 each initialized at creation time with the current value of the creating 289 thread's copy. 290 291 =for apidoc_section $io 292 =for apidoc mn|GV*|PL_last_in_gv 293 294 The GV which was last used for a filehandle input operation. (C<< <FH> >>) 295 296 On threaded perls, each thread has an independent copy of this variable; 297 each initialized at creation time with the current value of the creating 298 thread's copy. 299 300 =for apidoc_section $io 301 =for apidoc mn|GV*|PL_ofsgv 302 303 The glob containing the output field separator - C<*,> in Perl space. 304 305 On threaded perls, each thread has an independent copy of this variable; 306 each initialized at creation time with the current value of the creating 307 thread's copy. 308 309 =cut 310 */ 311 312 PERLVAR(I, rs, SV *) /* input record separator $/ */ 313 PERLVAR(I, last_in_gv, GV *) /* GV used in last <FH> */ 314 PERLVAR(I, ofsgv, GV *) /* GV of output field separator *, */ 315 PERLVAR(I, defoutgv, GV *) /* default FH for output */ 316 PERLVARI(I, chopset, const char *, " \n-") /* $: */ 317 PERLVAR(I, formtarget, SV *) 318 PERLVAR(I, bodytarget, SV *) 319 PERLVAR(I, toptarget, SV *) 320 321 322 PERLVAR(I, restartop, OP *) /* propagating an error from croak? */ 323 PERLVAR(I, restartjmpenv, JMPENV *) /* target frame for longjmp in die */ 324 325 PERLVAR(I, top_env, JMPENV *) /* ptr to current sigjmp environment */ 326 PERLVAR(I, start_env, JMPENV) /* empty startup sigjmp environment */ 327 PERLVARI(I, errors, SV *, NULL) /* outstanding queued errors */ 328 329 /* statics "owned" by various functions */ 330 PERLVAR(I, hv_fetch_ent_mh, HE*) /* owned by hv_fetch_ent() */ 331 332 PERLVAR(I, lastgotoprobe, OP*) /* from pp_ctl.c */ 333 334 /* sort stuff */ 335 PERLVAR(I, sortcop, OP *) /* user defined sort routine */ 336 PERLVAR(I, sortstash, HV *) /* which is in some package or other */ 337 PERLVAR(I, firstgv, GV *) /* $a */ 338 PERLVAR(I, secondgv, GV *) /* $b */ 339 340 /* float buffer */ 341 PERLVAR(I, efloatbuf, char *) 342 PERLVAR(I, efloatsize, STRLEN) 343 344 PERLVARI(I, dumpindent, U16, 4) /* number of blanks per dump 345 indentation level */ 346 347 /* 348 =for apidoc_section $embedding 349 =for apidoc Amn|U8|PL_exit_flags 350 351 Contains flags controlling perl's behaviour on exit(): 352 353 =over 354 355 =item * C<PERL_EXIT_DESTRUCT_END> 356 357 If set, END blocks are executed when the interpreter is destroyed. 358 This is normally set by perl itself after the interpreter is 359 constructed. 360 361 =item * C<PERL_EXIT_ABORT> 362 363 Call C<abort()> on exit. This is used internally by perl itself to 364 abort if exit is called while processing exit. 365 366 =item * C<PERL_EXIT_WARN> 367 368 Warn on exit. 369 370 =item * C<PERL_EXIT_EXPECTED> 371 372 Set by the L<perlfunc/exit> operator. 373 374 =back 375 376 =for apidoc Amnh||PERL_EXIT_EXPECTED 377 =for apidoc Amnh||PERL_EXIT_ABORT 378 =for apidoc Amnh||PERL_EXIT_DESTRUCT_END 379 =for apidoc Amnh||PERL_EXIT_WARN 380 381 On threaded perls, each thread has an independent copy of this variable; 382 each initialized at creation time with the current value of the creating 383 thread's copy. 384 385 =cut 386 */ 387 388 PERLVAR(I, exit_flags, U8) /* was exit() unexpected, etc. */ 389 390 PERLVAR(I, utf8locale, bool) /* utf8 locale detected */ 391 392 #if defined(USE_LOCALE) && defined(USE_LOCALE_THREADS) 393 PERLVARI(I, locale_mutex_depth, int, 0) /* Emulate general semaphore */ 394 #endif 395 396 #ifdef USE_LOCALE_CTYPE 397 PERLVAR(I, warn_locale, SV *) 398 PERLVARI(I, in_utf8_CTYPE_locale, bool, false) 399 PERLVARI(I, in_utf8_turkic_locale, bool, false) 400 #endif 401 402 PERLVARA(I, colors,6, char *) /* values from PERL_RE_COLORS env var */ 403 404 /* 405 =for apidoc_section $optree_construction 406 =for apidoc Amn|peep_t|PL_peepp 407 408 Pointer to the per-subroutine peephole optimiser. This is a function 409 that gets called at the end of compilation of a Perl subroutine (or 410 equivalently independent piece of Perl code) to perform fixups of 411 some ops and to perform small-scale optimisations. The function is 412 called once for each subroutine that is compiled, and is passed, as sole 413 parameter, a pointer to the op that is the entry point to the subroutine. 414 It modifies the op tree in place. 415 416 The peephole optimiser should never be completely replaced. Rather, 417 add code to it by wrapping the existing optimiser. The basic way to do 418 this can be seen in L<perlguts/Compile pass 3: peephole optimization>. 419 If the new code wishes to operate on ops throughout the subroutine's 420 structure, rather than just at the top level, it is likely to be more 421 convenient to wrap the L</PL_rpeepp> hook. 422 423 On threaded perls, each thread has an independent copy of this variable; 424 each initialized at creation time with the current value of the creating 425 thread's copy. 426 427 =cut 428 */ 429 430 PERLVARI(I, peepp, peep_t, Perl_peep) 431 432 /* 433 =for apidoc_section $optree_construction 434 =for apidoc Amn|peep_t|PL_rpeepp 435 436 Pointer to the recursive peephole optimiser. This is a function 437 that gets called at the end of compilation of a Perl subroutine (or 438 equivalently independent piece of Perl code) to perform fixups of some 439 ops and to perform small-scale optimisations. The function is called 440 once for each chain of ops linked through their C<op_next> fields; 441 it is recursively called to handle each side chain. It is passed, as 442 sole parameter, a pointer to the op that is at the head of the chain. 443 It modifies the op tree in place. 444 445 The peephole optimiser should never be completely replaced. Rather, 446 add code to it by wrapping the existing optimiser. The basic way to do 447 this can be seen in L<perlguts/Compile pass 3: peephole optimization>. 448 If the new code wishes to operate only on ops at a subroutine's top level, 449 rather than throughout the structure, it is likely to be more convenient 450 to wrap the L</PL_peepp> hook. 451 452 On threaded perls, each thread has an independent copy of this variable; 453 each initialized at creation time with the current value of the creating 454 thread's copy. 455 456 =cut 457 */ 458 459 PERLVARI(I, rpeepp, peep_t, Perl_rpeep) 460 461 /* 462 =for apidoc_section $optrees 463 =for apidoc Amn|Perl_ophook_t|PL_opfreehook 464 465 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. 466 This allows extensions to free any extra attribute they have locally attached to an OP. 467 It is also assured to first fire for the parent OP and then for its kids. 468 469 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. 470 471 On threaded perls, each thread has an independent copy of this variable; 472 each initialized at creation time with the current value of the creating 473 thread's copy. 474 475 =cut 476 */ 477 478 PERLVARI(I, opfreehook, Perl_ophook_t, 0) /* op_free() hook */ 479 480 PERLVARI(I, watchaddr, char **, 0) 481 PERLVAR(I, watchok, char *) 482 483 PERLVAR(I, perldb, U32) 484 485 PERLVAR(I, signals, U32) /* Using which pre-5.8 signals */ 486 487 PERLVAR(I, reentrant_retint, int) /* Integer return value from reentrant functions */ 488 489 /* pseudo environmental stuff */ 490 PERLVAR(I, origargc, int) 491 PERLVAR(I, origargv, char **) 492 PERLVAR(I, envgv, GV *) 493 PERLVAR(I, incgv, GV *) 494 PERLVAR(I, hintgv, GV *) 495 PERLVAR(I, origfilename, char *) 496 PERLVARI(I, xsubfilename, const char *, NULL) 497 PERLVAR(I, diehook, SV *) 498 PERLVAR(I, warnhook, SV *) 499 /* keyword hooks*/ 500 PERLVARI(I, hook__require__before, SV *,NULL) 501 PERLVARI(I, hook__require__after, SV *,NULL) 502 503 /* switches */ 504 PERLVAR(I, patchlevel, SV *) 505 PERLVAR(I, localpatches, const char * const *) 506 PERLVARI(I, splitstr, char *, NULL) 507 508 PERLVAR(I, minus_c, bool) 509 PERLVAR(I, minus_n, bool) 510 PERLVAR(I, minus_p, bool) 511 PERLVAR(I, minus_l, bool) 512 PERLVAR(I, minus_a, bool) 513 PERLVAR(I, minus_F, bool) 514 PERLVAR(I, doswitches, bool) 515 PERLVAR(I, minus_E, bool) 516 517 PERLVAR(I, inplace, char *) 518 PERLVAR(I, e_script, SV *) 519 520 PERLVAR(I, basetime, Time_t) /* $^T */ 521 522 PERLVARI(I, maxsysfd, I32, MAXSYSFD) 523 /* top fd to pass to subprocesses */ 524 PERLVAR(I, statusvalue, I32) /* $? */ 525 #ifdef VMS 526 PERLVAR(I, statusvalue_vms, U32) 527 #else 528 PERLVAR(I, statusvalue_posix, I32) 529 #endif 530 531 PERLVARI(I, sig_pending, int, 0) /* Number if highest signal pending */ 532 PERLVAR(I, psig_pend, int *) /* per-signal "count" of pending */ 533 534 /* shortcuts to various I/O objects */ 535 PERLVAR(I, stdingv, GV *) /* *STDIN */ 536 PERLVAR(I, stderrgv, GV *) /* *STDERR */ 537 PERLVAR(I, argvgv, GV *) /* *ARGV */ 538 PERLVAR(I, argvoutgv, GV *) /* *ARGVOUT */ 539 PERLVAR(I, argvout_stack, AV *) 540 541 /* shortcuts to regexp stuff */ 542 PERLVAR(I, replgv, GV *) /* *^R */ 543 544 /* shortcuts to misc objects */ 545 PERLVAR(I, errgv, GV *) /* *@ */ 546 547 /* shortcuts to debugging objects */ 548 PERLVAR(I, DBgv, GV *) /* *DB::DB */ 549 PERLVAR(I, DBline, GV *) /* *DB::line */ 550 551 /* 552 =for apidoc_section $debugging 553 =for apidoc mn|GV *|PL_DBsub 554 When Perl is run in debugging mode, with the B<-d> switch, this GV contains 555 the SV which holds the name of the sub being debugged. This is the C 556 variable which corresponds to Perl's $DB::sub variable. See 557 C<L</PL_DBsingle>>. 558 559 On threaded perls, each thread has an independent copy of this variable; 560 each initialized at creation time with the current value of the creating 561 thread's copy. 562 563 =for apidoc mn|SV *|PL_DBsingle 564 When Perl is run in debugging mode, with the B<-d> switch, this SV is a 565 boolean which indicates whether subs are being single-stepped. 566 Single-stepping is automatically turned on after every step. This is the C 567 variable which corresponds to Perl's $DB::single variable. See 568 C<L</PL_DBsub>>. 569 570 On threaded perls, each thread has an independent copy of this variable; 571 each initialized at creation time with the current value of the creating 572 thread's copy. 573 574 =for apidoc mn|SV *|PL_DBtrace 575 Trace variable used when Perl is run in debugging mode, with the B<-d> 576 switch. This is the C variable which corresponds to Perl's $DB::trace 577 variable. See C<L</PL_DBsingle>>. 578 579 On threaded perls, each thread has an independent copy of this variable; 580 each initialized at creation time with the current value of the creating 581 thread's copy. 582 583 =cut 584 */ 585 586 PERLVAR(I, DBsub, GV *) /* *DB::sub */ 587 PERLVAR(I, DBsingle, SV *) /* $DB::single */ 588 PERLVAR(I, DBtrace, SV *) /* $DB::trace */ 589 PERLVAR(I, DBsignal, SV *) /* $DB::signal */ 590 PERLVAR(I, dbargs, AV *) /* args to call listed by caller function */ 591 592 PERLVARA(I, DBcontrol, DBVARMG_COUNT, IV) /* IV versions of $DB::single, trace, signal */ 593 594 /* symbol tables */ 595 PERLVAR(I, debstash, HV *) /* symbol table for perldb package */ 596 PERLVAR(I, globalstash, HV *) /* global keyword overrides imported here */ 597 PERLVAR(I, curstname, SV *) /* name of current package */ 598 PERLVAR(I, beginav, AV *) /* names of BEGIN subroutines */ 599 PERLVAR(I, endav, AV *) /* names of END subroutines */ 600 PERLVAR(I, unitcheckav, AV *) /* names of UNITCHECK subroutines */ 601 PERLVAR(I, checkav, AV *) /* names of CHECK subroutines */ 602 PERLVAR(I, initav, AV *) /* names of INIT subroutines */ 603 604 /* subprocess state */ 605 PERLVAR(I, fdpid, AV *) /* keep fd-to-pid mappings for my_popen */ 606 607 /* internal state */ 608 PERLVARI(I, op_mask, char *, NULL) /* masked operations for safe evals */ 609 610 /* current interpreter roots */ 611 PERLVAR(I, main_cv, CV *) 612 PERLVAR(I, main_root, OP *) 613 PERLVAR(I, main_start, OP *) 614 PERLVAR(I, eval_root, OP *) 615 PERLVAR(I, eval_start, OP *) 616 617 /* runtime control stuff */ 618 PERLVARI(I, curcopdb, COP *, NULL) 619 620 PERLVAR(I, filemode, int) /* so nextargv() can preserve mode */ 621 PERLVAR(I, lastfd, int) /* what to preserve mode on */ 622 PERLVAR(I, oldname, char *) /* what to preserve mode on */ 623 /* Elements in this array have ';' appended and are injected as a single line 624 into the tokeniser. You can't put any (literal) newlines into any program 625 you stuff in into this array, as the point where it's injected is expecting 626 a single physical line. */ 627 PERLVAR(I, preambleav, AV *) 628 PERLVAR(I, mess_sv, SV *) 629 PERLVAR(I, ors_sv, SV *) /* output record separator $\ */ 630 631 /* funky return mechanisms */ 632 PERLVAR(I, forkprocess, int) /* so do_open |- can return proc# */ 633 634 /* statics moved here for shared library purposes */ 635 PERLVARI(I, gensym, I32, 0) /* next symbol for getsym() to define */ 636 PERLVARI(I, cv_has_eval, bool, FALSE) /* PL_compcv includes an entereval or similar */ 637 PERLVAR(I, taint_warn, bool) /* taint warns instead of dying */ 638 PERLVARI(I, laststype, U16, OP_STAT) 639 640 PERLVARI(I, laststatval, int, -1) 641 642 PERLVAR(I, modcount, I32) /* how much op_lvalue()ification in 643 assignment? */ 644 645 /* interpreter atexit processing */ 646 PERLVARI(I, exitlistlen, I32, 0) /* length of same */ 647 PERLVARI(I, exitlist, PerlExitListEntry *, NULL) 648 /* list of exit functions */ 649 650 /* 651 =for apidoc_section $HV 652 =for apidoc Amn|HV*|PL_modglobal 653 654 C<PL_modglobal> is a general purpose, interpreter global HV for use by 655 extensions that need to keep information on a per-interpreter basis. 656 In a pinch, it can also be used as a symbol table for extensions 657 to share data among each other. It is a good idea to use keys 658 prefixed by the package name of the extension that owns the data. 659 660 On threaded perls, each thread has an independent copy of this variable; 661 each initialized at creation time with the current value of the creating 662 thread's copy. 663 664 =cut 665 */ 666 667 PERLVAR(I, modglobal, HV *) /* per-interp module data */ 668 669 /* these used to be in global before 5.004_68 */ 670 PERLVARI(I, profiledata, U32 *, NULL) /* table of ops, counts */ 671 672 PERLVAR(I, compiling, COP) /* compiling/done executing marker */ 673 674 PERLVAR(I, compcv, CV *) /* currently compiling subroutine */ 675 PERLVAR(I, comppad_name, PADNAMELIST *) /* variable names for "my" variables */ 676 PERLVAR(I, comppad_name_fill, PADOFFSET)/* last "introduced" variable offset */ 677 PERLVAR(I, comppad_name_floor, PADOFFSET)/* start of vars in innermost block */ 678 679 #ifdef HAVE_INTERP_INTERN 680 PERLVAR(I, sys_intern, struct interp_intern) 681 /* platform internals */ 682 #endif 683 684 /* more statics moved here */ 685 PERLVAR(I, DBcv, CV *) /* from perl.c */ 686 PERLVARI(I, generation, int, 100) /* scan sequence# for OP_AASSIGN 687 compile-time common elem detection */ 688 689 PERLVAR(I, unicode, U32) /* Unicode features: $ENV{PERL_UNICODE} or -C */ 690 691 PERLVARI(I, in_clean_objs,bool, FALSE) /* from sv.c */ 692 PERLVARI(I, in_clean_all, bool, FALSE) /* ptrs to freed SVs now legal */ 693 PERLVAR(I, nomemok, bool) /* let malloc context handle nomem */ 694 PERLVARI(I, savebegin, bool, FALSE) /* save BEGINs for compiler */ 695 696 697 PERLVAR(I, delaymagic_uid, Uid_t) /* current real user id, only for delaymagic */ 698 PERLVAR(I, delaymagic_euid, Uid_t) /* current effective user id, only for delaymagic */ 699 PERLVAR(I, delaymagic_gid, Gid_t) /* current real group id, only for delaymagic */ 700 PERLVAR(I, delaymagic_egid, Gid_t) /* current effective group id, only for delaymagic */ 701 PERLVARI(I, an, U32, 0) /* malloc sequence number */ 702 703 /* Perl_Ibreakable_sub_generation_ptr was too long for VMS, hence "gen" */ 704 PERLVARI(I, breakable_sub_gen, U32, 0) 705 706 #ifdef DEBUGGING 707 /* exercise wrap-around */ 708 #define PERL_COP_SEQMAX (U32_MAX-50) 709 #else 710 #define PERL_COP_SEQMAX 0 711 #endif 712 PERLVARI(I, cop_seqmax, U32, PERL_COP_SEQMAX) /* statement sequence number */ 713 #undef PERL_COP_SEQMAX 714 715 PERLVARI(I, evalseq, U32, 0) /* eval sequence number */ 716 PERLVAR(I, origalen, U32) 717 #ifdef PERL_USES_PL_PIDSTATUS 718 PERLVAR(I, pidstatus, HV *) /* pid-to-status mappings for waitpid */ 719 #endif 720 PERLVAR(I, osname, char *) /* operating system */ 721 722 PERLVAR(I, sighandlerp, Sighandler_t) 723 /* these two are provided only to solve library linkage issues; they 724 * should not be hooked by user code */ 725 PERLVAR(I, sighandler1p, Sighandler1_t) 726 PERLVAR(I, sighandler3p, Sighandler3_t) 727 728 PERLVARA(I, body_roots, PERL_ARENA_ROOTS_SIZE, void*) /* array of body roots */ 729 730 PERLVAR(I, debug, volatile U32) /* flags given to -D switch */ 731 732 PERLVARI(I, padlist_generation, U32, 1) /* id to identify padlist clones */ 733 734 PERLVARI(I, runops, runops_proc_t, RUNOPS_DEFAULT) 735 736 PERLVAR(I, subname, SV *) /* name of current subroutine */ 737 738 PERLVAR(I, subline, I32) /* line this subroutine began on */ 739 PERLVAR(I, min_intro_pending, PADOFFSET)/* start of vars to introduce */ 740 741 PERLVAR(I, max_intro_pending, PADOFFSET)/* end of vars to introduce */ 742 PERLVAR(I, padix, PADOFFSET) /* lowest unused index - 1 743 in current "register" pad */ 744 PERLVAR(I, constpadix, PADOFFSET) /* lowest unused for constants */ 745 746 PERLVAR(I, padix_floor, PADOFFSET) /* how low may inner block reset padix */ 747 748 #if defined(USE_POSIX_2008_LOCALE) && defined(MULTIPLICITY) 749 PERLVARI(I, cur_locale_obj, locale_t, LC_GLOBAL_LOCALE) 750 #endif 751 #ifdef USE_PL_CURLOCALES 752 753 /* Some configurations do not allow perl to query libc to find out what the 754 * locale for a given category is. On such platforms this array contains that 755 * information, indexed by the perl-defined category index. 756 * Note that this array keeps the actual locale for each category. LC_NUMERIC 757 * is almost always toggled into the C locale, and the locale it nominally is 758 * is stored as PL_numeric_name. */ 759 PERLVARA(I, curlocales, LOCALE_CATEGORIES_COUNT_ + 1, const char *) 760 761 #endif 762 #ifdef USE_PL_CUR_LC_ALL 763 PERLVARI(I, cur_LC_ALL, const char *, NULL) 764 #endif 765 #ifdef USE_LOCALE_COLLATE 766 767 /* The memory needed to store the collxfrm transformation of a string with 768 * length 'x' is predicted by the linear equation mx+b; m=mult, b=base */ 769 PERLVARI(I, collxfrm_mult,Size_t, 0) /* Expansion factor in *xfrm(); 770 0 => unknown or bad, depending on 771 base */ 772 PERLVAR(I, collxfrm_base, Size_t) /* Basic overhead in *xfrm(); 773 mult == 0, base == 0 => need to compute 774 mult == 0, base != 0 => ill-formed; 775 */ 776 PERLVAR(I, collation_name, char *) /* Name of current collation */ 777 PERLVARI(I, collation_ix, PERL_UINTMAX_T, 0) /* Collation generation index */ 778 PERLVARI(I, strxfrm_NUL_replacement, U8, 0) /* Code point to replace NULs */ 779 PERLVARI(I, strxfrm_is_behaved, bool, TRUE) 780 /* Assume until proven otherwise that it works */ 781 PERLVARI(I, strxfrm_max_cp, U8, 0) /* Highest collating cp in locale */ 782 PERLVARI(I, collation_standard, bool, TRUE) 783 /* Assume simple collation */ 784 PERLVAR(I, in_utf8_COLLATE_locale, bool) 785 #endif /* USE_LOCALE_COLLATE */ 786 787 PERLVARI(I, langinfo_sv, SV *, NULL) /* For Perl_langinfo8? */ 788 PERLVARI(I, scratch_langinfo, SV *, NULL) /* For internal use */ 789 PERLVARI(I, setlocale_buf, char *, NULL) 790 PERLVARI(I, setlocale_bufsize, Size_t, 0) 791 792 #if defined(USE_LOCALE_THREADS) && ! defined(USE_THREAD_SAFE_LOCALE) 793 PERLVARI(I, less_dicey_locale_buf, char *, NULL) 794 PERLVARI(I, less_dicey_locale_bufsize, Size_t, 0) 795 #endif 796 797 #ifdef PERL_SAWAMPERSAND 798 PERLVAR(I, sawampersand, U8) /* must save all match strings */ 799 #endif 800 801 /* current phase the interpreter is in 802 for ordering this structure to remove holes, we're assuming that this is 4 803 bytes. */ 804 PERLVARI(I, phase, enum perl_phase, PERL_PHASE_CONSTRUCT) 805 806 PERLVARI(I, in_load_module, bool, FALSE) /* to prevent recursions in PerlIO_find_layer */ 807 808 PERLVARI(I, eval_begin_nest_depth, U32, 0) 809 810 PERLVAR(I, unsafe, bool) 811 PERLVAR(I, colorset, bool) /* PERL_RE_COLORS env var is in use */ 812 813 /* 814 =for apidoc_section $embedding 815 =for apidoc Amn|signed char|PL_perl_destruct_level 816 817 This value may be set when embedding for full cleanup. 818 819 Possible values: 820 821 =over 822 823 =item * 0 - none 824 825 =item * 1 - full 826 827 =item * 2 or greater - full with checks. 828 829 =back 830 831 If C<$ENV{PERL_DESTRUCT_LEVEL}> is set to an integer greater than the 832 value of C<PL_perl_destruct_level> its value is used instead. 833 834 On threaded perls, each thread has an independent copy of this variable; 835 each initialized at creation time with the current value of the creating 836 thread's copy. 837 838 =cut 839 */ 840 /* mod_perl is special, and also assigns a meaning -1 */ 841 PERLVARI(I, perl_destruct_level, signed char, 0) 842 843 PERLVAR(I, pad_reset_pending, bool) /* reset pad on next attempted alloc */ 844 845 PERLVARI(I, srand_called, bool, false) /* has random_state been initialized yet? */ 846 PERLVARI(I, srand_override, U32, 0) /* Should we use a deterministic sequence? */ 847 PERLVARI(I, srand_override_next, U32, 0) /* Next item in the sequence */ 848 849 PERLVARI(I, numeric_underlying, bool, TRUE) 850 /* Assume underlying locale numerics */ 851 PERLVARI(I, numeric_underlying_is_standard, bool, TRUE) 852 853 PERLVARI(I, numeric_standard, int, TRUE) /* Assume C locale numerics */ 854 PERLVAR(I, numeric_name, char *) /* Name of current numeric locale */ 855 PERLVAR(I, numeric_radix_sv, SV *) /* The radix separator */ 856 PERLVAR(I, underlying_radix_sv, SV *) /* The radix in the program's current underlying locale */ 857 858 #ifdef USE_POSIX_2008_LOCALE 859 PERLVARI(I, scratch_locale_obj, locale_t, 0) 860 #endif 861 862 #ifdef USE_LOCALE_CTYPE 863 864 PERLVARI(I, ctype_name, const char *, NULL) /* Name of current ctype locale */ 865 866 # endif 867 868 /* Array of signal handlers, indexed by signal number, through which the C 869 signal handler dispatches. */ 870 PERLVAR(I, psig_ptr, SV **) 871 /* Array of names of signals, indexed by signal number, for (re)use as the first 872 argument to a signal handler. Only one block of memory is allocated for 873 both psig_name and psig_ptr. */ 874 PERLVAR(I, psig_name, SV **) 875 876 #if defined(PERL_IMPLICIT_SYS) 877 PERLVAR(I, Mem, struct IPerlMem *) 878 PERLVAR(I, MemShared, struct IPerlMem *) 879 PERLVAR(I, MemParse, struct IPerlMem *) 880 PERLVAR(I, Env, struct IPerlEnv *) 881 PERLVAR(I, StdIO, struct IPerlStdIO *) 882 PERLVAR(I, LIO, struct IPerlLIO *) 883 PERLVAR(I, Dir, struct IPerlDir *) 884 PERLVAR(I, Sock, struct IPerlSock *) 885 PERLVAR(I, Proc, struct IPerlProc *) 886 #endif 887 888 PERLVAR(I, ptr_table, PTR_TBL_t *) 889 PERLVARI(I, beginav_save, AV *, NULL) /* save BEGIN{}s when compiling */ 890 891 PERLVAR(I, body_arenas, void *) /* pointer to list of body-arenas */ 892 893 894 #if defined(USE_ITHREADS) 895 PERLVAR(I, regex_pad, SV **) /* Shortcut into the array of 896 regex_padav */ 897 PERLVAR(I, regex_padav, AV *) /* All regex objects, indexed via the 898 values in op_pmoffset of pmop. 899 Entry 0 is an SV whose PV is a 900 "packed" list of IVs listing 901 the now-free slots in the array */ 902 PERLVAR(I, stashpad, HV **) /* for CopSTASH */ 903 PERLVARI(I, stashpadmax, PADOFFSET, 64) 904 PERLVARI(I, stashpadix, PADOFFSET, 0) 905 #endif 906 907 #ifdef USE_REENTRANT_API 908 PERLVAR(I, reentrant_buffer, REENTR *) /* here we store the _r buffers */ 909 #endif 910 911 PERLVAR(I, custom_op_names, HV *) /* Names of user defined ops */ 912 PERLVAR(I, custom_op_descs, HV *) /* Descriptions of user defined ops */ 913 914 #ifdef PERLIO_LAYERS 915 PERLVARI(I, perlio, PerlIOl *, NULL) 916 PERLVARI(I, known_layers, PerlIO_list_t *, NULL) 917 PERLVARI(I, def_layerlist, PerlIO_list_t *, NULL) 918 #endif 919 920 PERLVARI(I, checkav_save, AV *, NULL) /* save CHECK{}s when compiling */ 921 PERLVARI(I, unitcheckav_save, AV *, NULL) 922 /* save UNITCHECK{}s when compiling */ 923 924 PERLVARI(I, clocktick, long, 0) /* this many times() ticks in a second */ 925 926 /* Hooks to shared SVs and locks. */ 927 PERLVARI(I, sharehook, share_proc_t, Perl_sv_nosharing) 928 PERLVARI(I, lockhook, share_proc_t, Perl_sv_nosharing) 929 930 #if defined(__HP_cc) || defined(__HP_aCC) 931 #pragma diag_suppress 3215 932 #endif 933 GCC_DIAG_IGNORE(-Wdeprecated-declarations) 934 MSVC_DIAG_IGNORE(4996) 935 936 #ifdef NO_MATHOMS 937 # define PERL_UNLOCK_HOOK Perl_sv_nosharing 938 #else 939 /* This reference ensures that the mathoms are linked with perl */ 940 # define PERL_UNLOCK_HOOK Perl_sv_nounlocking 941 #endif 942 PERLVARI(I, unlockhook, share_proc_t, PERL_UNLOCK_HOOK) 943 944 MSVC_DIAG_RESTORE 945 GCC_DIAG_RESTORE 946 #if defined(__HP_cc) || defined(__HP_aCC) 947 #pragma diag_default 3215 948 #endif 949 950 PERLVARI(I, threadhook, thrhook_proc_t, Perl_nothreadhook) 951 952 /* Can shared object be destroyed */ 953 PERLVARI(I, destroyhook, destroyable_proc_t, Perl_sv_destroyable) 954 955 PERLVARI(I, signalhook, despatch_signals_proc_t, Perl_despatch_signals) 956 957 PERLVARI(I, isarev, HV *, NULL) /* Reverse map of @ISA dependencies */ 958 959 /* Register of known Method Resolution Orders. 960 What this actually points to is an implementation detail (it may change to 961 a structure incorporating a reference count - use mro_get_from_name to 962 retrieve a C<struct mro_alg *> */ 963 PERLVAR(I, registered_mros, HV *) 964 965 /* Compile-time block start/end hooks */ 966 PERLVAR(I, blockhooks, AV *) 967 968 PERLVAR(I, custom_ops, HV *) /* custom op registrations */ 969 970 PERLVAR(I, Xpv, XPV *) /* (unused) held temporary value */ 971 972 /* name of the scopes we've ENTERed. Only used with -DDEBUGGING, but needs to be 973 present always, as -DDEBUGGING must be binary compatible with non. */ 974 PERLVARI(I, scopestack_name, const char **, NULL) 975 976 PERLVAR(I, debug_pad, struct perl_debug_pad) /* always needed because of the re extension */ 977 978 /* Hook for File::Glob */ 979 PERLVARI(I, globhook, globhook_t, NULL) 980 981 #if defined(MULTIPLICITY) 982 /* The last unconditional member of the interpreter structure when 5.18.0 was 983 released. The offset of the end of this is baked into a global variable in 984 any shared perl library which will allow a sanity test in future perl 985 releases. */ 986 # define PERL_LAST_5_18_0_INTERP_MEMBER Iglobhook 987 #endif 988 989 #ifdef MULTIPLICITY 990 PERLVARI(I, my_cxt_list, void **, NULL) /* per-module array of MY_CXT pointers */ 991 PERLVARI(I, my_cxt_size, int, 0) /* size of PL_my_cxt_list */ 992 #endif 993 994 #if defined(MULTIPLICITY) || defined(PERL_DEBUG_READONLY_COW) 995 /* For use with the memory debugging code in util.c. This is used only in 996 * DEBUGGING builds (as long as the relevant structure is defined), but 997 * defining it in non-debug builds too means that we retain binary 998 * compatibility between otherwise-compatible plain and debug builds. */ 999 PERLVAR(I, memory_debug_header, struct perl_memory_debug_header) 1000 #endif 1001 1002 #ifdef DEBUG_LEAKING_SCALARS_FORK_DUMP 1003 /* File descriptor to talk to the child which dumps scalars. */ 1004 PERLVARI(I, dumper_fd, int, -1) 1005 #endif 1006 1007 1008 #ifdef DEBUG_LEAKING_SCALARS 1009 PERLVARI(I, sv_serial, U32, 0) /* SV serial number, used in sv.c */ 1010 #endif 1011 1012 PERLVARA(I, sv_consts, SV_CONSTS_COUNT, SV*) /* constant SVs with precomputed hash value */ 1013 1014 #ifdef PERL_TRACE_OPS 1015 PERLVARA(I, op_exec_cnt, OP_max+2, UV) /* Counts of executed OPs of the given type. 1016 If PERL_TRACE_OPS is enabled, we'll dump 1017 a summary count of all ops executed in the 1018 program at perl_destruct time. Used only 1019 for profiling in DEBUGGING mode. */ 1020 #endif 1021 1022 PERLVAR(I, random_state, PL_RANDOM_STATE_TYPE) 1023 1024 PERLVARI(I, dump_re_max_len, STRLEN, 60) 1025 1026 /* For internal uses of randomness, this ensures the sequence of 1027 * random numbers returned by rand() isn't modified by perl's internal 1028 * use of randomness. 1029 * This is important if the user has called srand() with a seed. 1030 */ 1031 1032 PERLVAR(I, internal_random_state, PL_RANDOM_STATE_TYPE) 1033 1034 PERLVARA(I, TR_SPECIAL_HANDLING_UTF8, UTF8_MAXBYTES, char) 1035 1036 PERLVAR(I, AboveLatin1, SV *) 1037 PERLVAR(I, Assigned_invlist, SV *) 1038 PERLVAR(I, GCB_invlist, SV *) 1039 PERLVAR(I, HasMultiCharFold, SV *) 1040 PERLVAR(I, InMultiCharFold, SV *) 1041 PERLVAR(I, Latin1, SV *) 1042 PERLVAR(I, LB_invlist, SV *) 1043 PERLVAR(I, SB_invlist, SV *) 1044 PERLVAR(I, SCX_invlist, SV *) 1045 PERLVAR(I, UpperLatin1, SV *) /* Code points 128 - 255 */ 1046 1047 PERLVARA(I, fold_locale, 256, U8) 1048 1049 /* List of characters that participate in any fold defined by Unicode */ 1050 PERLVAR(I, in_some_fold, SV *) 1051 1052 /* Everything that folds to a given character, for case insensitivity regex 1053 * matching */ 1054 PERLVAR(I, utf8_foldclosures, SV *) 1055 1056 PERLVAR(I, utf8_idcont, SV *) 1057 PERLVAR(I, utf8_idstart, SV *) 1058 PERLVAR(I, utf8_perl_idcont, SV *) 1059 PERLVAR(I, utf8_perl_idstart, SV *) 1060 PERLVAR(I, utf8_xidcont, SV *) 1061 PERLVAR(I, utf8_xidstart, SV *) 1062 PERLVAR(I, WB_invlist, SV *) 1063 PERLVARA(I, XPosix_ptrs, POSIX_CC_COUNT, SV *) 1064 PERLVARA(I, Posix_ptrs, POSIX_CC_COUNT, SV *) 1065 PERLVAR(I, utf8_toupper, SV *) 1066 PERLVAR(I, utf8_totitle, SV *) 1067 PERLVAR(I, utf8_tolower, SV *) 1068 PERLVAR(I, utf8_tofold, SV *) 1069 PERLVAR(I, utf8_tosimplefold, SV *) 1070 PERLVAR(I, utf8_charname_begin, SV *) 1071 PERLVAR(I, utf8_charname_continue, SV *) 1072 PERLVAR(I, utf8_mark, SV *) 1073 PERLVARI(I, InBitmap, SV *, NULL) 1074 PERLVAR(I, CCC_non0_non230, SV *) 1075 PERLVAR(I, Private_Use, SV *) 1076 1077 #ifdef HAS_MBRLEN 1078 PERLVAR(I, mbrlen_ps, mbstate_t) 1079 #endif 1080 #ifdef HAS_MBRTOWC 1081 PERLVAR(I, mbrtowc_ps, mbstate_t) 1082 #endif 1083 #ifdef HAS_WCRTOMB 1084 PERLVAR(I, wcrtomb_ps, mbstate_t) 1085 #endif 1086 #ifdef PERL_MEM_LOG 1087 /* Enough space for the reserved byte, 1 for a potential leading 0, then enough 1088 * for the longest representable integer plus an extra, the 3 flag characters, 1089 * and NUL */ 1090 #define PERL_MEM_LOG_ARYLEN (1 + 1 + TYPE_DIGITS(UV) + 1 + 3 + 1) 1091 PERLVARA(I, mem_log, PERL_MEM_LOG_ARYLEN, char) 1092 #endif 1093 1094 /* The most recently seen `use VERSION` declaration, encoded in a single 1095 * U16 as (major << 8) | minor. We do this rather than store an entire SV 1096 * version object so we can fit the U16 into the uv of a SAVEHINTS and not 1097 * have to worry about SV refcounts during scope enter/exit. */ 1098 PERLVAR(I, prevailing_version, U16) 1099 1100 /* If you are adding a U8 or U16, check to see if there are 'Space' comments 1101 * above on where there are gaps which currently will be structure padding. */ 1102 1103 /* Within a stable branch, new variables must be added to the very end, before 1104 * this comment, for binary compatibility (the offsets of the old members must 1105 * not change). 1106 * (Don't forget to add your variable also to perl_clone()!) 1107 */ 1108