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