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