1 /* perlvars.h 2 * 3 * Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 4 * by Larry Wall and others 5 * 6 * You may distribute under the terms of either the GNU General Public 7 * License or the Artistic License, as specified in the README file. 8 * 9 */ 10 11 /* 12 =head1 Global Variables 13 14 These variables are global to an entire process. They are shared between 15 all interpreters and all threads in a process. 16 17 =cut 18 */ 19 20 /* Don't forget to re-run regen/embed.pl to propagate changes! */ 21 22 /* This file describes the "global" variables used by perl 23 * This used to be in perl.h directly but we want to abstract out into 24 * distinct files which are per-thread, per-interpreter or really global, 25 * and how they're initialized. 26 * 27 * The 'G' prefix is only needed for vars that need appropriate #defines 28 * generated in embed*.h. Such symbols are also used to generate 29 * the appropriate export list for win32. */ 30 31 /* global state */ 32 #if defined(USE_ITHREADS) 33 PERLVAR(G, op_mutex, perl_mutex) /* Mutex for op refcounting */ 34 #endif 35 PERLVARI(G, curinterp, PerlInterpreter *, NULL) 36 /* currently running interpreter 37 * (initial parent interpreter under 38 * useithreads) */ 39 #if defined(USE_ITHREADS) 40 PERLVAR(G, thr_key, perl_key) /* key to retrieve per-thread struct */ 41 #endif 42 43 /* XXX does anyone even use this? */ 44 PERLVARI(G, do_undump, bool, FALSE) /* -u or dump seen? */ 45 46 #ifndef PERL_USE_SAFE_PUTENV 47 PERLVARI(G, use_safe_putenv, bool, TRUE) 48 #endif 49 50 #if defined(FAKE_PERSISTENT_SIGNAL_HANDLERS)||defined(FAKE_DEFAULT_SIGNAL_HANDLERS) 51 PERLVARI(G, sig_handlers_initted, int, 0) 52 #endif 53 #ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS 54 PERLVARA(G, sig_ignoring, SIG_SIZE, int) 55 /* which signals we are ignoring */ 56 #endif 57 #ifdef FAKE_DEFAULT_SIGNAL_HANDLERS 58 PERLVARA(G, sig_defaulting, SIG_SIZE, int) 59 #endif 60 61 /* XXX signals are process-wide anyway, so we 62 * ignore the implications of this for threading */ 63 #ifndef HAS_SIGACTION 64 PERLVARI(G, sig_trapped, int, 0) 65 #endif 66 67 #ifndef PERL_MICRO 68 /* If Perl has to ignore SIGPFE, this is its saved state. 69 * See perl.h macros PERL_FPU_INIT and PERL_FPU_{PRE,POST}_EXEC. */ 70 PERLVAR(G, sigfpe_saved, Sighandler_t) 71 PERLVARI(G, csighandlerp, Sighandler_t, Perl_csighandler) 72 /* Pointer to C-level sighandler */ 73 #endif 74 75 /* This is constant on most architectures, a global on OS/2 */ 76 #ifdef OS2 77 PERLVARI(G, sh_path, char *, SH_PATH) /* full path of shell */ 78 #endif 79 80 #ifdef USE_PERLIO 81 82 # if defined(USE_ITHREADS) 83 PERLVAR(G, perlio_mutex, perl_mutex) /* Mutex for perlio fd refcounts */ 84 # endif 85 86 PERLVARI(G, perlio_fd_refcnt, int *, 0) /* Pointer to array of fd refcounts. */ 87 PERLVARI(G, perlio_fd_refcnt_size, int, 0) /* Size of the array */ 88 PERLVARI(G, perlio_debug_fd, int, 0) /* the fd to write perlio debug into, 0 means not set yet */ 89 #endif 90 91 #ifdef HAS_MMAP 92 PERLVARI(G, mmap_page_size, IV, 0) 93 #endif 94 95 #if defined(USE_ITHREADS) 96 PERLVAR(G, hints_mutex, perl_mutex) /* Mutex for refcounted he refcounting */ 97 #endif 98 99 #ifdef DEBUGGING 100 PERLVARI(G, watch_pvx, char *, NULL) 101 #endif 102 103 /* 104 =for apidoc AmU|Perl_check_t *|PL_check 105 106 Array, indexed by opcode, of functions that will be called for the "check" 107 phase of optree building during compilation of Perl code. For most (but 108 not all) types of op, once the op has been initially built and populated 109 with child ops it will be filtered through the check function referenced 110 by the appropriate element of this array. The new op is passed in as the 111 sole argument to the check function, and the check function returns the 112 completed op. The check function may (as the name suggests) check the op 113 for validity and signal errors. It may also initialise or modify parts of 114 the ops, or perform more radical surgery such as adding or removing child 115 ops, or even throw the op away and return a different op in its place. 116 117 This array of function pointers is a convenient place to hook into the 118 compilation process. An XS module can put its own custom check function 119 in place of any of the standard ones, to influence the compilation of a 120 particular type of op. However, a custom check function must never fully 121 replace a standard check function (or even a custom check function from 122 another module). A module modifying checking must instead B<wrap> the 123 preexisting check function. A custom check function must be selective 124 about when to apply its custom behaviour. In the usual case where 125 it decides not to do anything special with an op, it must chain the 126 preexisting op function. Check functions are thus linked in a chain, 127 with the core's base checker at the end. 128 129 For thread safety, modules should not write directly to this array. 130 Instead, use the function L</wrap_op_checker>. 131 132 =cut 133 */ 134 135 #if defined(USE_ITHREADS) 136 PERLVAR(G, check_mutex, perl_mutex) /* Mutex for PL_check */ 137 #endif 138 #ifdef PERL_GLOBAL_STRUCT 139 PERLVAR(G, ppaddr, Perl_ppaddr_t *) /* or opcode.h */ 140 PERLVAR(G, check, Perl_check_t *) /* or opcode.h */ 141 PERLVARA(G, fold_locale, 256, unsigned char) /* or perl.h */ 142 #endif 143 144 #ifdef PERL_NEED_APPCTX 145 PERLVAR(G, appctx, void*) /* the application context */ 146 #endif 147 148 #if defined(HAS_TIMES) && defined(PERL_NEED_TIMESBASE) 149 PERLVAR(G, timesbase, struct tms) 150 #endif 151 152 /* allocate a unique index to every module that calls MY_CXT_INIT */ 153 154 #ifdef PERL_IMPLICIT_CONTEXT 155 # ifdef USE_ITHREADS 156 PERLVAR(G, my_ctx_mutex, perl_mutex) 157 # endif 158 PERLVARI(G, my_cxt_index, int, 0) 159 #endif 160 161 /* this is currently set without MUTEX protection, so keep it a type which 162 * can be set atomically (ie not a bit field) */ 163 PERLVARI(G, veto_cleanup, int, FALSE) /* exit without cleanup */ 164 165 /* 166 =for apidoc AmUx|Perl_keyword_plugin_t|PL_keyword_plugin 167 168 Function pointer, pointing at a function used to handle extended keywords. 169 The function should be declared as 170 171 int keyword_plugin_function(pTHX_ 172 char *keyword_ptr, STRLEN keyword_len, 173 OP **op_ptr) 174 175 The function is called from the tokeniser, whenever a possible keyword 176 is seen. C<keyword_ptr> points at the word in the parser's input 177 buffer, and C<keyword_len> gives its length; it is not null-terminated. 178 The function is expected to examine the word, and possibly other state 179 such as L<%^H|perlvar/%^H>, to decide whether it wants to handle it 180 as an extended keyword. If it does not, the function should return 181 C<KEYWORD_PLUGIN_DECLINE>, and the normal parser process will continue. 182 183 If the function wants to handle the keyword, it first must 184 parse anything following the keyword that is part of the syntax 185 introduced by the keyword. See L</Lexer interface> for details. 186 187 When a keyword is being handled, the plugin function must build 188 a tree of C<OP> structures, representing the code that was parsed. 189 The root of the tree must be stored in C<*op_ptr>. The function then 190 returns a constant indicating the syntactic role of the construct that 191 it has parsed: C<KEYWORD_PLUGIN_STMT> if it is a complete statement, or 192 C<KEYWORD_PLUGIN_EXPR> if it is an expression. Note that a statement 193 construct cannot be used inside an expression (except via C<do BLOCK> 194 and similar), and an expression is not a complete statement (it requires 195 at least a terminating semicolon). 196 197 When a keyword is handled, the plugin function may also have 198 (compile-time) side effects. It may modify C<%^H>, define functions, and 199 so on. Typically, if side effects are the main purpose of a handler, 200 it does not wish to generate any ops to be included in the normal 201 compilation. In this case it is still required to supply an op tree, 202 but it suffices to generate a single null op. 203 204 That's how the C<*PL_keyword_plugin> function needs to behave overall. 205 Conventionally, however, one does not completely replace the existing 206 handler function. Instead, take a copy of C<PL_keyword_plugin> before 207 assigning your own function pointer to it. Your handler function should 208 look for keywords that it is interested in and handle those. Where it 209 is not interested, it should call the saved plugin function, passing on 210 the arguments it received. Thus C<PL_keyword_plugin> actually points 211 at a chain of handler functions, all of which have an opportunity to 212 handle keywords, and only the last function in the chain (built into 213 the Perl core) will normally return C<KEYWORD_PLUGIN_DECLINE>. 214 215 =cut 216 */ 217 218 PERLVARI(G, keyword_plugin, Perl_keyword_plugin_t, Perl_keyword_plugin_standard) 219 220 PERLVARI(G, op_sequence, HV *, NULL) /* dump.c */ 221 PERLVARI(G, op_seq, UV, 0) /* dump.c */ 222 223 #ifdef USE_ITHREADS 224 PERLVAR(G, dollarzero_mutex, perl_mutex) /* Modifying $0 */ 225 #endif 226 227 /* Restricted hashes placeholder value. 228 In theory, the contents are never used, only the address. 229 In practice, &PL_sv_placeholder is returned by some APIs, and the calling 230 code is checking SvOK(). */ 231 232 PERLVAR(G, sv_placeholder, SV) 233 234 #if defined(MYMALLOC) && defined(USE_ITHREADS) 235 PERLVAR(G, malloc_mutex, perl_mutex) /* Mutex for malloc */ 236 #endif 237 238 PERLVARI(G, hash_seed_set, bool, FALSE) /* perl.c */ 239 PERLVARA(G, hash_seed, PERL_HASH_SEED_BYTES, unsigned char) /* perl.c and hv.h */ 240