/*
=head1 Global Variables
+These variables are global to an entire process. They are shared between
+all interpreters and all threads in a process. Any variables not documented
+here may be changed or removed without notice, so don't use them!
+If you feel you really do need to use an unlisted variable, first send email to
+L<perl5-porters@perl.org|mailto:perl5-porters@perl.org>. It may be that
+someone there will point out a way to accomplish what you need without using an
+internal variable. But if not, you should get a go-ahead to document and then
+use the variable.
+
+=cut
*/
-/* Don't forget to re-run embed.pl to propagate changes! */
+/* Don't forget to re-run regen/embed.pl to propagate changes! */
/* This file describes the "global" variables used by perl
* This used to be in perl.h directly but we want to abstract out into
* the appropriate export list for win32. */
/* global state */
-PERLVAR(Gcurinterp, PerlInterpreter *)
+#if defined(USE_ITHREADS)
+PERLVAR(G, op_mutex, perl_mutex) /* Mutex for op refcounting */
+#endif
+PERLVARI(G, curinterp, PerlInterpreter *, NULL)
/* currently running interpreter
* (initial parent interpreter under
* useithreads) */
#if defined(USE_ITHREADS)
-PERLVAR(Gthr_key, perl_key) /* key to retrieve per-thread struct */
+PERLVAR(G, thr_key, perl_key) /* key to retrieve per-thread struct */
#endif
-/* constants (these are not literals to facilitate pointer comparisons)
- * (PERLVARISC really does create variables, despite its looks) */
-PERLVARISC(GYes, "1")
-PERLVARISC(GNo, "")
-PERLVARISC(Ghexdigit, "0123456789abcdef0123456789ABCDEF")
-PERLVARISC(Gpatleave, "\\.^$@dDwWsSbB+*?|()-nrtfeaxc0123456789[{]}")
-
/* XXX does anyone even use this? */
-PERLVARI(Gdo_undump, bool, FALSE) /* -u or dump seen? */
+PERLVARI(G, do_undump, bool, FALSE) /* -u or dump seen? */
-#if defined(MYMALLOC) && defined(USE_ITHREADS)
-PERLVAR(Gmalloc_mutex, perl_mutex) /* Mutex for malloc */
+#ifndef PERL_USE_SAFE_PUTENV
+PERLVARI(G, use_safe_putenv, bool, TRUE)
#endif
-#if defined(USE_ITHREADS)
-PERLVAR(Gop_mutex, perl_mutex) /* Mutex for op refcounting */
+#if defined(FAKE_PERSISTENT_SIGNAL_HANDLERS)||defined(FAKE_DEFAULT_SIGNAL_HANDLERS)
+PERLVARI(G, sig_handlers_initted, int, 0)
#endif
-
-#ifdef USE_ITHREADS
-PERLVAR(Gdollarzero_mutex, perl_mutex) /* Modifying $0 */
+#ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
+PERLVARA(G, sig_ignoring, SIG_SIZE, int)
+ /* which signals we are ignoring */
+#endif
+#ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
+PERLVARA(G, sig_defaulting, SIG_SIZE, int)
#endif
-
-/* This is constant on most architectures, a global on OS/2 */
-#ifdef OS2
-# define PERL___C
-#else
-# define PERL___C const
+/* XXX signals are process-wide anyway, so we
+ * ignore the implications of this for threading */
+#ifndef HAS_SIGACTION
+PERLVARI(G, sig_trapped, int, 0)
#endif
-PERLVARI(Gsh_path, PERL___C char *, SH_PATH) /* full path of shell */
-#undef PERL___C
#ifndef PERL_MICRO
/* If Perl has to ignore SIGPFE, this is its saved state.
* See perl.h macros PERL_FPU_INIT and PERL_FPU_{PRE,POST}_EXEC. */
-PERLVAR(Gsigfpe_saved, Sighandler_t)
-#endif
+PERLVAR(G, sigfpe_saved, Sighandler_t)
-/* Restricted hashes placeholder value.
- * The contents are never used, only the address. */
-PERLVAR(Gsv_placeholder, SV)
-
-#ifndef PERL_MICRO
-PERLVARI(Gcsighandlerp, Sighandler_t, Perl_csighandler) /* Pointer to C-level sighandler */
+/* these ptrs to functions are to avoid linkage problems; see
+ * perl-5.8.0-2193-g5c1546dc48
+ */
+PERLVARI(G, csighandlerp, Sighandler_t, Perl_csighandler)
+PERLVARI(G, csighandler1p, Sighandler1_t, Perl_csighandler1)
+PERLVARI(G, csighandler3p, Sighandler3_t, Perl_csighandler3)
#endif
-#ifndef PERL_USE_SAFE_PUTENV
-PERLVARI(Guse_safe_putenv, int, 1)
+/* This is constant on most architectures, a global on OS/2 */
+#ifdef OS2
+PERLVARI(G, sh_path, char *, SH_PATH) /* full path of shell */
#endif
#ifdef USE_PERLIO
-PERLVARI(Gperlio_fd_refcnt, int*, 0) /* Pointer to array of fd refcounts. */
-PERLVARI(Gperlio_fd_refcnt_size, int, 0) /* Size of the array */
-PERLVARI(Gperlio_debug_fd, int, 0) /* the fd to write perlio debug into, 0 means not set yet */
+
+# if defined(USE_ITHREADS)
+PERLVAR(G, perlio_mutex, perl_mutex) /* Mutex for perlio fd refcounts */
+# endif
+
+PERLVARI(G, perlio_fd_refcnt, int *, 0) /* Pointer to array of fd refcounts. */
+PERLVARI(G, perlio_fd_refcnt_size, int, 0) /* Size of the array */
+PERLVARI(G, perlio_debug_fd, int, 0) /* the fd to write perlio debug into, 0 means not set yet */
#endif
#ifdef HAS_MMAP
-PERLVARI(Gmmap_page_size, IV, 0)
+PERLVARI(G, mmap_page_size, IV, 0)
#endif
-#if defined(FAKE_PERSISTENT_SIGNAL_HANDLERS)||defined(FAKE_DEFAULT_SIGNAL_HANDLERS)
-PERLVARI(Gsig_handlers_initted, int, 0)
-#endif
-#ifdef FAKE_PERSISTENT_SIGNAL_HANDLERS
-PERLVARA(Gsig_ignoring, SIG_SIZE, int) /* which signals we are ignoring */
-#endif
-#ifdef FAKE_DEFAULT_SIGNAL_HANDLERS
-PERLVARA(Gsig_defaulting, SIG_SIZE, int)
+#if defined(USE_ITHREADS)
+PERLVAR(G, hints_mutex, perl_mutex) /* Mutex for refcounted he refcounting */
+# if ! defined(USE_THREAD_SAFE_LOCALE) || defined(TS_W32_BROKEN_LOCALECONV)
+PERLVAR(G, locale_mutex, perl_mutex) /* Mutex for setlocale() changing */
+# endif
+# ifndef USE_THREAD_SAFE_LOCALE
+PERLVAR(G, lc_numeric_mutex, perl_mutex) /* Mutex for switching LC_NUMERIC */
+# endif
#endif
-#ifndef PERL_IMPLICIT_CONTEXT
-PERLVAR(Gsig_sv, SV*)
+#ifdef USE_POSIX_2008_LOCALE
+PERLVAR(G, C_locale_obj, locale_t)
#endif
-/* XXX signals are process-wide anyway, so we
- * ignore the implications of this for threading */
-#ifndef HAS_SIGACTION
-PERLVARI(Gsig_trapped, int, 0)
-#endif
+PERLVARI(G, watch_pvx, char *, NULL)
-#ifdef DEBUGGING
-PERLVAR(Gwatch_pvx, char*)
-#endif
+/*
+=for apidoc AmnU|Perl_check_t *|PL_check
+
+Array, indexed by opcode, of functions that will be called for the "check"
+phase of optree building during compilation of Perl code. For most (but
+not all) types of op, once the op has been initially built and populated
+with child ops it will be filtered through the check function referenced
+by the appropriate element of this array. The new op is passed in as the
+sole argument to the check function, and the check function returns the
+completed op. The check function may (as the name suggests) check the op
+for validity and signal errors. It may also initialise or modify parts of
+the ops, or perform more radical surgery such as adding or removing child
+ops, or even throw the op away and return a different op in its place.
+
+This array of function pointers is a convenient place to hook into the
+compilation process. An XS module can put its own custom check function
+in place of any of the standard ones, to influence the compilation of a
+particular type of op. However, a custom check function must never fully
+replace a standard check function (or even a custom check function from
+another module). A module modifying checking must instead B<wrap> the
+preexisting check function. A custom check function must be selective
+about when to apply its custom behaviour. In the usual case where
+it decides not to do anything special with an op, it must chain the
+preexisting op function. Check functions are thus linked in a chain,
+with the core's base checker at the end.
+
+For thread safety, modules should not write directly to this array.
+Instead, use the function L</wrap_op_checker>.
+=cut
+*/
+
+#if defined(USE_ITHREADS)
+PERLVAR(G, check_mutex, perl_mutex) /* Mutex for PL_check */
+#endif
#ifdef PERL_GLOBAL_STRUCT
-PERLVAR(Gppaddr, Perl_ppaddr_t*) /* or opcode.h */
-PERLVAR(Gcheck, Perl_check_t *) /* or opcode.h */
-PERLVARA(Gfold_locale, 256, unsigned char) /* or perl.h */
+PERLVAR(G, ppaddr, Perl_ppaddr_t *) /* or opcode.h */
+PERLVAR(G, check, Perl_check_t *) /* or opcode.h */
+PERLVARA(G, fold_locale, 256, unsigned char) /* or perl.h */
#endif
#ifdef PERL_NEED_APPCTX
-PERLVAR(Gappctx, void*) /* the application context */
+PERLVAR(G, appctx, void*) /* the application context */
#endif
-PERLVAR(Gop_sequence, HV*) /* dump.c */
-PERLVARI(Gop_seq, UV, 0) /* dump.c */
-
#if defined(HAS_TIMES) && defined(PERL_NEED_TIMESBASE)
-PERLVAR(Gtimesbase, struct tms)
+PERLVAR(G, timesbase, struct tms)
#endif
/* allocate a unique index to every module that calls MY_CXT_INIT */
#ifdef PERL_IMPLICIT_CONTEXT
# ifdef USE_ITHREADS
-PERLVAR(Gmy_ctx_mutex, perl_mutex)
+PERLVAR(G, my_ctx_mutex, perl_mutex)
# endif
-PERLVARI(Gmy_cxt_index, int, 0)
-#endif
-
-#if defined(USE_ITHREADS)
-PERLVAR(Ghints_mutex, perl_mutex) /* Mutex for refcounted he refcounting */
-#endif
-
-#if defined(USE_ITHREADS)
-PERLVAR(Gperlio_mutex, perl_mutex) /* Mutex for perlio fd refcounts */
+PERLVARI(G, my_cxt_index, int, 0)
#endif
/* this is currently set without MUTEX protection, so keep it a type which
* can be set atomically (ie not a bit field) */
-PERLVARI(Gveto_cleanup, int, FALSE) /* exit without cleanup */
-
-/* dummy variables that hold pointers to both runops functions, thus forcing
- * them *both* to get linked in (useful for Peek.xs, debugging etc) */
-
-PERLVARI(Grunops_std, runops_proc_t, MEMBER_TO_FPTR(Perl_runops_standard))
-PERLVARI(Grunops_dbg, runops_proc_t, MEMBER_TO_FPTR(Perl_runops_debug))
-
-
-/* These are baked at compile time into any shared perl library.
- In future 5.10.x releases this will allow us in main() to sanity test the
- library we're linking against. */
-
-PERLVARI(Grevision, U8, PERL_REVISION)
-PERLVARI(Gversion, U8, PERL_VERSION)
-PERLVARI(Gsubversion, U8, PERL_SUBVERSION)
-
-#if defined(MULTIPLICITY)
-# define PERL_INTERPRETER_SIZE_UPTO_MEMBER(member) \
- STRUCT_OFFSET(struct interpreter, member) + \
- sizeof(((struct interpreter*)0)->member)
-
-/* These might be useful. */
-PERLVARI(Ginterp_size, U16, sizeof(struct interpreter))
-#if defined(PERL_GLOBAL_STRUCT)
-PERLVARI(Gglobal_struct_size, U16, sizeof(struct perl_vars))
-#endif
-
-/* This will be useful for subsequent releases, because this has to be the
- same in your libperl as in main(), else you have a mismatch and must abort.
-*/
-PERLVARI(Ginterp_size_5_10_0, U16,
- PERL_INTERPRETER_SIZE_UPTO_MEMBER(PERL_LAST_5_10_0_INTERP_MEMBER))
-#endif
+PERLVARI(G, veto_cleanup, int, FALSE) /* exit without cleanup */
/*
-=for apidoc AmUx|Perl_keyword_plugin_t|PL_keyword_plugin
+=for apidoc AmnUx|Perl_keyword_plugin_t|PL_keyword_plugin
Function pointer, pointing at a function used to handle extended keywords.
The function should be declared as
If the function wants to handle the keyword, it first must
parse anything following the keyword that is part of the syntax
-introduced by the keyword. The lexer interface is poorly documented.
-Broadly speaking, parsing needs to look at the buffer that extends
-from C<PL_parser-E<gt>bufptr> to C<PL_parser-E<gt>bufend>, and
-C<PL_parser-E<gt>bufptr> must be advanced across whatever text is
-consumed by the parsing process. The buffer end is not necessarily the
-real end of the input text, but refilling the buffer is too complicated
-to discuss here. See L<Devel::Declare> for some parsing experience,
-and hope for more core support in a future version of Perl.
+introduced by the keyword. See L</Lexer interface> for details.
When a keyword is being handled, the plugin function must build
a tree of C<OP> structures, representing the code that was parsed.
The root of the tree must be stored in C<*op_ptr>. The function then
-returns a contant indicating the syntactic role of the construct that
+returns a constant indicating the syntactic role of the construct that
it has parsed: C<KEYWORD_PLUGIN_STMT> if it is a complete statement, or
C<KEYWORD_PLUGIN_EXPR> if it is an expression. Note that a statement
construct cannot be used inside an expression (except via C<do BLOCK>
handle keywords, and only the last function in the chain (built into
the Perl core) will normally return C<KEYWORD_PLUGIN_DECLINE>.
+For thread safety, modules should not set this variable directly.
+Instead, use the function L</wrap_keyword_plugin>.
+
=cut
*/
-PERLVARI(Gkeyword_plugin, Perl_keyword_plugin_t, MEMBER_TO_FPTR(Perl_keyword_plugin_standard))
+#if defined(USE_ITHREADS)
+PERLVAR(G, keyword_plugin_mutex, perl_mutex) /* Mutex for PL_keyword_plugin */
+#endif
+PERLVARI(G, keyword_plugin, Perl_keyword_plugin_t, Perl_keyword_plugin_standard)
+
+PERLVARI(G, op_sequence, HV *, NULL) /* dump.c */
+PERLVARI(G, op_seq, UV, 0) /* dump.c */
+
+#ifdef USE_ITHREADS
+PERLVAR(G, dollarzero_mutex, perl_mutex) /* Modifying $0 */
+#endif
+
+/* Restricted hashes placeholder value.
+ In theory, the contents are never used, only the address.
+ In practice, &PL_sv_placeholder is returned by some APIs, and the calling
+ code is checking SvOK(). */
+
+PERLVAR(G, sv_placeholder, SV)
+
+#if defined(MYMALLOC) && defined(USE_ITHREADS)
+PERLVAR(G, malloc_mutex, perl_mutex) /* Mutex for malloc */
+#endif
+
+PERLVARI(G, hash_seed_set, bool, FALSE) /* perl.c */
+PERLVARA(G, hash_seed, PERL_HASH_SEED_BYTES, unsigned char) /* perl.c and hv.h */
+#if defined(PERL_HASH_STATE_BYTES)
+PERLVARA(G, hash_state, PERL_HASH_STATE_BYTES, unsigned char) /* perl.c and hv.h */
+#endif
+#if defined(PERL_USE_SINGLE_CHAR_HASH_CACHE)
+PERLVARA(G, hash_chars, (1+256) * sizeof(U32), unsigned char) /* perl.c and hv.h */
+#endif
+
+/* The path separator can vary depending on whether we're running under DCL or
+ * a Unix shell.
+ */
+#ifdef __VMS
+PERLVAR(G, perllib_sep, char)
+#endif
+
+PERLVAR(G, AboveLatin1, SV *)
+PERLVAR(G, Assigned_invlist, SV *)
+PERLVAR(G, GCB_invlist, SV *)
+PERLVAR(G, HasMultiCharFold, SV *)
+PERLVAR(G, InMultiCharFold, SV *)
+PERLVAR(G, Latin1, SV *)
+PERLVAR(G, LB_invlist, SV *)
+PERLVAR(G, SB_invlist, SV *)
+PERLVAR(G, SCX_invlist, SV *)
+PERLVAR(G, UpperLatin1, SV *) /* Code points 128 - 255 */
+
+/* List of characters that participate in any fold defined by Unicode */
+PERLVAR(G, in_some_fold, SV *)
+
+PERLVAR(G, utf8_idcont, SV *)
+PERLVAR(G, utf8_idstart, SV *)
+PERLVAR(G, utf8_perl_idcont, SV *)
+PERLVAR(G, utf8_perl_idstart, SV *)
+PERLVAR(G, utf8_xidcont, SV *)
+PERLVAR(G, utf8_xidstart, SV *)
+PERLVAR(G, WB_invlist, SV *)
+PERLVARA(G, XPosix_ptrs, POSIX_CC_COUNT, SV *)
+PERLVARA(G, Posix_ptrs, POSIX_CC_COUNT, SV *)
+PERLVAR(G, utf8_toupper, SV *)
+PERLVAR(G, utf8_totitle, SV *)
+PERLVAR(G, utf8_tolower, SV *)
+PERLVAR(G, utf8_tofold, SV *)
+PERLVAR(G, utf8_tosimplefold, SV *)
+PERLVAR(G, utf8_charname_begin, SV *)
+PERLVAR(G, utf8_charname_continue, SV *)
+PERLVAR(G, utf8_mark, SV *)
+PERLVARI(G, InBitmap, SV *, NULL)
+PERLVAR(G, CCC_non0_non230, SV *)
+PERLVAR(G, Private_Use, SV *)
+
+/* Definitions of user-defined \p{} properties, as the subs that define them
+ * are only called once */
+PERLVARI(G, user_def_props, HV *, NULL)
+
+#if defined(USE_ITHREADS)
+PERLVAR(G, user_def_props_aTHX, PerlInterpreter *) /* aTHX that user_def_props
+ was defined in */
+PERLVAR(G, user_prop_mutex, perl_mutex) /* Mutex for manipulating
+ PL_user_defined_properties */
+#endif
+
+/* Everything that folds to a given character, for case insensitivity regex
+ * matching */
+PERLVAR(G, utf8_foldclosures, SV *)
+
+/* these record the best way to to perform certain IO operations while
+ * atomically setting FD_CLOEXEC. On the first call, a probe is done
+ * and the result recorded for use by subsequent calls.
+ * In theory these variables aren't thread-safe, but the worst that can
+ * happen is that two treads will both do an initial probe
+ */
+PERLVARI(G, strategy_dup, int, 0) /* doio.c */
+PERLVARI(G, strategy_dup2, int, 0) /* doio.c */
+PERLVARI(G, strategy_open, int, 0) /* doio.c */
+PERLVARI(G, strategy_open3, int, 0) /* doio.c */
+PERLVARI(G, strategy_mkstemp, int, 0) /* doio.c */
+PERLVARI(G, strategy_socket, int, 0) /* doio.c */
+PERLVARI(G, strategy_accept, int, 0) /* doio.c */
+PERLVARI(G, strategy_pipe, int, 0) /* doio.c */
+PERLVARI(G, strategy_socketpair, int, 0) /* doio.c */
+
+#ifdef PERL_IMPLICIT_CONTEXT
+# ifdef PERL_GLOBAL_STRUCT_PRIVATE
+/* per-module array of pointers to MY_CXT_KEY constants.
+ * It simulates each module having a static my_cxt_index var on builds
+ * which don't allow static vars */
+PERLVARI(G, my_cxt_keys, const char **, NULL)
+PERLVARI(G, my_cxt_keys_size, int, 0) /* size of PL_my_cxt_keys */
+# endif
+#endif