From 20dec6c374a08af34a0d233c462c1cddcd90103d Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Sat, 4 Oct 2025 15:49:56 -0600 Subject: [PATCH 01/12] mathoms.c: Add a few coments --- mathoms.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/mathoms.c b/mathoms.c index 7bc47bf8dea5..cfce11e6e33f 100644 --- a/mathoms.c +++ b/mathoms.c @@ -27,6 +27,9 @@ * 1) A function has been replaced by a macro within a minor release, * so XS modules compiled against an older release will expect to * still be able to link against the function + * 2) A function is deprecated, and so placing it here will cause a compiler + * warning to be generated (for participating compilers). + * 3) A few other reasons, documented with the functions below * * It used to be that this was the way to handle the case were a function * Perl_foo(...) had been replaced by a macro. But see the 'm' flag discussion From c1aeb614090ac02bbcb99ae29dc0c544e6111366 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Sat, 4 Oct 2025 15:35:29 -0600 Subject: [PATCH 02/12] regen/embed.pl: Don't create prototype for private macros Prior to this commit, a commented-out prototype was created for all macros that we have argument and return type information for. This might be useful information for a reader of proto.h. This commits stops doing this for private macros. It makes a future commit slightly easier, and I'm unsure of the usefulness of this anyway. But I could be persuaded otherwise. --- proto.h | 21 --------------------- regen/embed.pl | 4 ++++ 2 files changed, 4 insertions(+), 21 deletions(-) diff --git a/proto.h b/proto.h index acd96ff396ad..7f3fef32484e 100644 --- a/proto.h +++ b/proto.h @@ -791,9 +791,6 @@ Perl_die_unwind(pTHX_ SV *msv) #define PERL_ARGS_ASSERT_DIE_UNWIND \ assert(msv) -/* PERL_CALLCONV bool -Perl_do_aexec(pTHX_ SV *really, SV **mark, SV **sp); */ - PERL_CALLCONV bool Perl_do_aexec5(pTHX_ SV *really, SV **mark, SV **sp, int fd, int do_report) __attribute__visibility__("hidden"); @@ -2648,9 +2645,6 @@ PERL_CALLCONV Pid_t Perl_my_fork(void); #define PERL_ARGS_ASSERT_MY_FORK -/* PERL_CALLCONV I32 -Perl_my_lstat(pTHX); */ - PERL_CALLCONV I32 Perl_my_lstat_flags(pTHX_ const U32 flags); #define PERL_ARGS_ASSERT_MY_LSTAT_FLAGS @@ -2688,9 +2682,6 @@ PERL_CALLCONV int Perl_my_socketpair(int family, int type, int protocol, int fd[2]); #define PERL_ARGS_ASSERT_MY_SOCKETPAIR -/* PERL_CALLCONV I32 -Perl_my_stat(pTHX); */ - PERL_CALLCONV I32 Perl_my_stat_flags(pTHX_ const U32 flags); #define PERL_ARGS_ASSERT_MY_STAT_FLAGS @@ -6884,21 +6875,12 @@ S_do_trans_simple(pTHX_ SV * const sv, const OPtrans_map * const tbl) defined(PERL_IN_REGCOMP_ANY) || defined(PERL_IN_UTF8_C) # define PERL_ARGS_ASSERT_ADD_RANGE_TO_INVLIST_ -/* PERL_CALLCONV void -invlist_intersection_(pTHX_ SV * const a, SV * const b, SV **i); */ - # define PERL_ARGS_ASSERT_INVLIST_INTERSECTION_MAYBE_COMPLEMENT_2ND_ \ assert(b); assert(i) # define PERL_ARGS_ASSERT_INVLIST_INVERT_ \ assert(invlist) -/* PERL_CALLCONV void -invlist_subtract_(pTHX_ SV * const a, SV * const b, SV **result); */ - -/* PERL_CALLCONV void -invlist_union_(pTHX_ SV * const a, SV * const b, SV **output); */ - # define PERL_ARGS_ASSERT_INVLIST_UNION_MAYBE_COMPLEMENT_2ND_ \ assert(b); assert(output) @@ -10750,9 +10732,6 @@ Perl_dump_c_backtrace(pTHX_ PerlIO *fp, int max_depth, int skip); # define PERL_ARGS_ASSERT_DUMP_C_BACKTRACE \ assert(fp) -/* PERL_CALLCONV void -free_c_backtrace(pTHX_ Perl_c_backtrace *bt); */ - PERL_CALLCONV Perl_c_backtrace * Perl_get_c_backtrace(pTHX_ int max_depth, int skip) __attribute__visibility__("hidden"); diff --git a/regen/embed.pl b/regen/embed.pl index 98090467fba2..3e613e18522b 100755 --- a/regen/embed.pl +++ b/regen/embed.pl @@ -191,6 +191,10 @@ sub generate_proto_h { die_at_end "$plain_func: m and S flags are mutually exclusive"; } + + # Don't generate a prototype for a macro that is not usable by the + # outside world. + next unless $flags =~ /[ACE]/; } else { die_at_end "$plain_func: u flag only usable with m" From 1c90bc0ed56ac5a5361f0c1371c0bc3a712b617c Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Sat, 4 Oct 2025 15:38:35 -0600 Subject: [PATCH 03/12] regen/embed.pl: Don't create prototype for weird macros Where 'weird' is defined as meaning something where the normal rules don't apply, so something we generate is unlikely to be correct. This only affects one element, and it uses aTHX in a way that is incompatible with it being automated. --- proto.h | 3 --- regen/embed.pl | 3 +++ 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/proto.h b/proto.h index 7f3fef32484e..9ef3faaf0e24 100644 --- a/proto.h +++ b/proto.h @@ -55,9 +55,6 @@ Perl_PerlLIO_open_cloexec(pTHX_ const char *file, int flag) #define PERL_ARGS_ASSERT_PERLLIO_OPEN_CLOEXEC \ assert(file) -/* PERL_CALLCONV const XOP * -Perl_custom_op_xop(pTHX_ const OP *o); */ - PERL_CALLCONV const char * Perl_langinfo(const nl_item item); #define PERL_ARGS_ASSERT_PERL_LANGINFO diff --git a/regen/embed.pl b/regen/embed.pl index 3e613e18522b..3fd68610e58b 100755 --- a/regen/embed.pl +++ b/regen/embed.pl @@ -195,6 +195,9 @@ sub generate_proto_h { # Don't generate a prototype for a macro that is not usable by the # outside world. next unless $flags =~ /[ACE]/; + + # Nor one that is weird, which would likely be a syntax error. + next if $flags =~ /u/; } else { die_at_end "$plain_func: u flag only usable with m" From 71e96dc40a6faa0d10be9c8145d6f08d2cc9c947 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Tue, 14 Oct 2025 10:32:35 -0600 Subject: [PATCH 04/12] embed.pl: enum and union are like struct in parameters These keywords all need another word to indicate the parameter type. Previously only 'struct' was considered to have. This changed showed an error in one entry embed.fnc, which is also corrected in this commit. --- embed.fnc | 2 +- proto.h | 2 +- regen/embed.pl | 3 ++- 3 files changed, 4 insertions(+), 3 deletions(-) diff --git a/embed.fnc b/embed.fnc index 7e6ea1afe56d..af137e24b847 100644 --- a/embed.fnc +++ b/embed.fnc @@ -2693,7 +2693,7 @@ CTp |Signal_t|perly_sighandler \ |bool safe Admp |const char * const|phase_name \ - |enum perl_phase + |enum perl_phase phase Adp |void |pmop_dump |NULLOK PMOP *pm : Used in perly.y p |OP * |pmruntime |NN OP *o \ diff --git a/proto.h b/proto.h index 9ef3faaf0e24..07f7819dff3a 100644 --- a/proto.h +++ b/proto.h @@ -3563,7 +3563,7 @@ Perl_perly_sighandler(int sig, Siginfo_t *info, void *uap, bool safe); #define PERL_ARGS_ASSERT_PERLY_SIGHANDLER /* PERL_CALLCONV const char * const -Perl_phase_name(pTHX_ enum perl_phase); */ +Perl_phase_name(pTHX_ enum perl_phase phase); */ PERL_CALLCONV void Perl_pmop_dump(pTHX_ PMOP *pm); diff --git a/regen/embed.pl b/regen/embed.pl index 3fd68610e58b..4b15f69332d5 100755 --- a/regen/embed.pl +++ b/regen/embed.pl @@ -374,7 +374,8 @@ sub generate_proto_h { my $temp_arg = $arg; $temp_arg =~ s/\*//g; - $temp_arg =~ s/\s*\bstruct\b\s*/ /g; + $temp_arg =~ + s/ \s* \b ( struct | enum | union ) \b \s*/ /xg; if ( ($temp_arg ne "...") && ($temp_arg !~ /\w+\s+(\w+)(?:\[\d+\])?\s*$/) ) { die_at_end "$func: $arg ($n) doesn't have a name\n"; From d3cbebf2b72a9a26cafe76593baa1c0a900dc8d4 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Tue, 14 Oct 2025 11:06:53 -0600 Subject: [PATCH 05/12] embed.fnc: Drop Perl_ on do_aexec my_stat my_lstat These macros are not for external use, so don't need a Perl_ prefix --- embed.fnc | 6 +++--- embed.h | 9 --------- 2 files changed, 3 insertions(+), 12 deletions(-) diff --git a/embed.fnc b/embed.fnc index af137e24b847..4f82d225f477 100644 --- a/embed.fnc +++ b/embed.fnc @@ -1117,7 +1117,7 @@ Adpr |OP * |die_sv |NN SV *baseex : Used in util.c pr |void |die_unwind |NN SV *msv : FIXME -mp |bool |do_aexec |NULLOK SV *really \ +m |bool |do_aexec |NULLOK SV *really \ |NN SV **mark \ |NN SV **sp : Used in pp_sys.c @@ -2210,7 +2210,7 @@ Adpr |void |my_exit |U32 status Adpr |void |my_failure_exit Cdp |I32 |my_fflush_all CTdp |Pid_t |my_fork -mp |I32 |my_lstat +m |I32 |my_lstat Xp |I32 |my_lstat_flags |NULLOK const U32 flags RTop |int |my_mkostemp_cloexec \ |NN char *templte \ @@ -2231,7 +2231,7 @@ CTdp |int |my_socketpair |int family \ |int type \ |int protocol \ |int fd[2] -mp |I32 |my_stat +m |I32 |my_stat Xp |I32 |my_stat_flags |NULLOK const U32 flags p |const char *|my_strerror \ |const int errnum \ diff --git a/embed.h b/embed.h index 42a12ea3dc79..81c491adb5c9 100644 --- a/embed.h +++ b/embed.h @@ -1829,15 +1829,6 @@ # define quadmath_format_needed Perl_quadmath_format_needed # define quadmath_format_valid Perl_quadmath_format_valid # endif -# if defined(USE_THREADS) -# define Perl_do_aexec(mTHX,a,b,c) do_aexec(a,b,c) -# define Perl_my_lstat(mTHX) my_lstat() -# define Perl_my_stat(mTHX) my_stat() -# else -# define Perl_do_aexec do_aexec -# define Perl_my_lstat my_lstat -# define Perl_my_stat my_stat -# endif # if defined(WIN32) # define get_win32_message_utf8ness(a) Perl_get_win32_message_utf8ness(aTHX_ a) # else From 6fbd26bcc11dceaafb3dafaff9d2c38b33e94ee7 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Tue, 14 Oct 2025 11:16:48 -0600 Subject: [PATCH 06/12] Move hv_stores() declaration from embed.fnc to hv.h This is required for the next few commits that start automatically creating long Perl_name functions for the elements in embed.fnc that are macros and don't already have them in the source. Only macros can take a parameter that has to be a literal string, so don't fit with the next few commits. This is the only case in embed.fnc like that, so I'm deferring dealing with it for now. --- embed.fnc | 3 --- embed.h | 2 -- hv.h | 1 + proto.h | 3 --- 4 files changed, 1 insertion(+), 8 deletions(-) diff --git a/embed.fnc b/embed.fnc index 4f82d225f477..878dbd8bf2fc 100644 --- a/embed.fnc +++ b/embed.fnc @@ -1699,9 +1699,6 @@ Ampx |SV ** |hv_store_flags |NULLOK HV *hv \ |NULLOK SV *val \ |U32 hash \ |int flags -Admp |SV ** |hv_stores |NULLOK HV *hv \ - |"key" \ - |NULLOK SV *val Admp |void |hv_undef |NULLOK HV *hv Xop |void |hv_undef_flags |NULLOK HV *hv \ |U32 flags diff --git a/embed.h b/embed.h index 81c491adb5c9..98297e3ad627 100644 --- a/embed.h +++ b/embed.h @@ -2289,7 +2289,6 @@ # define Perl_hv_store(mTHX,a,b,c,d,e) hv_store(a,b,c,d,e) # define Perl_hv_store_ent(mTHX,a,b,c,d) hv_store_ent(a,b,c,d) # define Perl_hv_store_flags(mTHX,a,b,c,d,e,f) hv_store_flags(a,b,c,d,e,f) -# define Perl_hv_stores(mTHX,a,b,c) hv_stores(a,b,c) # define Perl_hv_undef(mTHX,a) hv_undef(a) # define Perl_ibcmp(mTHX,a,b,c) ibcmp(a,b,c) # define Perl_ibcmp_locale(mTHX,a,b,c) ibcmp_locale(a,b,c) @@ -2390,7 +2389,6 @@ # define Perl_hv_store hv_store # define Perl_hv_store_ent hv_store_ent # define Perl_hv_store_flags hv_store_flags -# define Perl_hv_stores hv_stores # define Perl_hv_undef hv_undef # define Perl_ibcmp ibcmp # define Perl_ibcmp_locale ibcmp_locale diff --git a/hv.h b/hv.h index f83dcc1b5ccf..ca055c9342e1 100644 --- a/hv.h +++ b/hv.h @@ -584,6 +584,7 @@ whether it is valid to call C. =for apidoc_defn Am|SV**|hv_fetchs|HV* hv|"key"|I32 lval =for apidoc_defn Am|SV *|hv_deletes|HV *hv|"key"|U32 flags =for apidoc_defn Am|void|hv_name_sets|HV *hv|"name"|U32 flags +=for apidoc_defn Am|SV**|hv_stores|HV *hv|"name"|U32 flags =cut */ #define hv_fetchs(hv, key, lval) \ diff --git a/proto.h b/proto.h index 07f7819dff3a..cf40b9ef6c60 100644 --- a/proto.h +++ b/proto.h @@ -1705,9 +1705,6 @@ Perl_hv_store_ent(pTHX_ HV *hv, SV *key, SV *val, U32 hash); */ /* PERL_CALLCONV SV ** Perl_hv_store_flags(pTHX_ HV *hv, const char *key, I32 klen, SV *val, U32 hash, int flags); */ -/* PERL_CALLCONV SV ** -Perl_hv_stores(pTHX_ HV *hv, const char * const key, SV *val); */ - /* PERL_CALLCONV void Perl_hv_undef(pTHX_ HV *hv); */ From 6cf98858630d912c8ffb42fc477dfd5e082bc4a6 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Tue, 25 Nov 2025 08:34:26 -0700 Subject: [PATCH 07/12] embed.fnc: free_c_backtrace is only Perl_free_c_backtrace --- embed.fnc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/embed.fnc b/embed.fnc index 878dbd8bf2fc..c884063a0d58 100644 --- a/embed.fnc +++ b/embed.fnc @@ -6452,7 +6452,7 @@ Adp |bool |dump_c_backtrace \ |NN PerlIO *fp \ |int max_depth \ |int skip -dm |void |free_c_backtrace \ +dmo |void |free_c_backtrace \ |NN Perl_c_backtrace *bt dp |Perl_c_backtrace *|get_c_backtrace \ |int max_depth \ From edd43ab40dbaf6625fdbf9ebe41ecaf07b0d95dd Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Tue, 14 Oct 2025 11:19:47 -0600 Subject: [PATCH 08/12] Remove const char * const return value A function can't return something of that type, but this has always been a macro, so this hasn't been caught. --- embed.fnc | 3 +-- proto.h | 2 +- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/embed.fnc b/embed.fnc index c884063a0d58..610d8378aff8 100644 --- a/embed.fnc +++ b/embed.fnc @@ -2689,8 +2689,7 @@ CTp |Signal_t|perly_sighandler \ |NULLOK void *uap \ |bool safe -Admp |const char * const|phase_name \ - |enum perl_phase phase +Admp |const char *|phase_name|enum perl_phase phase Adp |void |pmop_dump |NULLOK PMOP *pm : Used in perly.y p |OP * |pmruntime |NN OP *o \ diff --git a/proto.h b/proto.h index cf40b9ef6c60..92aedba2a58b 100644 --- a/proto.h +++ b/proto.h @@ -3559,7 +3559,7 @@ PERL_CALLCONV Signal_t Perl_perly_sighandler(int sig, Siginfo_t *info, void *uap, bool safe); #define PERL_ARGS_ASSERT_PERLY_SIGHANDLER -/* PERL_CALLCONV const char * const +/* PERL_CALLCONV const char * Perl_phase_name(pTHX_ enum perl_phase phase); */ PERL_CALLCONV void From 2e6696edff406c992d4593c4cb27f745c1fcc69c Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 30 Oct 2025 11:18:34 -0600 Subject: [PATCH 09/12] Three macros are used in perl extensions They were marked as core-only. --- embed.fnc | 6 +++--- handy.h | 2 +- proto.h | 6 ++++++ 3 files changed, 10 insertions(+), 4 deletions(-) diff --git a/embed.fnc b/embed.fnc index 610d8378aff8..a6580f9e56f2 100644 --- a/embed.fnc +++ b/embed.fnc @@ -4490,7 +4490,7 @@ ERXp |SV * |add_range_to_invlist_ \ |NULLOK SV *invlist \ |UV start \ |UV end -m |void |invlist_intersection_ \ +Em |void |invlist_intersection_ \ |NN SV * const a \ |NN SV * const b \ |NN SV **i @@ -4500,11 +4500,11 @@ EXp |void |invlist_intersection_maybe_complement_2nd_ \ |const bool complement_b \ |NN SV **i EXp |void |invlist_invert_|NN SV * const invlist -m |void |invlist_subtract_ \ +Em |void |invlist_subtract_ \ |NN SV * const a \ |NN SV * const b \ |NN SV **result -m |void |invlist_union_ |NULLOK SV * const a \ +Em |void |invlist_union_ |NULLOK SV * const a \ |NN SV * const b \ |NN SV **output EXp |void |invlist_union_maybe_complement_2nd_ \ diff --git a/handy.h b/handy.h index 0ada57f2d2e3..9224c87584da 100644 --- a/handy.h +++ b/handy.h @@ -450,7 +450,7 @@ a string/length pair. /* -=for apidoc_defn mx|void|lex_stuff_pvs|"pv"|U32 flags +=for apidoc_defn Emx|void|lex_stuff_pvs|"pv"|U32 flags =cut */ diff --git a/proto.h b/proto.h index 92aedba2a58b..dcdbdf86a431 100644 --- a/proto.h +++ b/proto.h @@ -6162,10 +6162,16 @@ Perl_invlist_search_(SV * const invlist, const UV cp) PERL_CALLCONV SV * Perl_add_range_to_invlist_(pTHX_ SV *invlist, UV start, UV end) __attribute__warn_unused_result__; +/* PERL_CALLCONV void +invlist_intersection_(pTHX_ SV * const a, SV * const b, SV **i); */ PERL_CALLCONV void Perl_invlist_intersection_maybe_complement_2nd_(pTHX_ SV * const a, SV * const b, const bool complement_b, SV **i); PERL_CALLCONV void Perl_invlist_invert_(pTHX_ SV * const invlist); +/* PERL_CALLCONV void +invlist_subtract_(pTHX_ SV * const a, SV * const b, SV **result); */ +/* PERL_CALLCONV void +invlist_union_(pTHX_ SV * const a, SV * const b, SV **output); */ PERL_CALLCONV void Perl_invlist_union_maybe_complement_2nd_(pTHX_ SV * const a, SV * const b, const bool complement_b, SV **output); PERL_CALLCONV SV * From 9b25da7ad79395201fbdda141a7138145feeb1fe Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 30 Oct 2025 12:59:30 -0600 Subject: [PATCH 10/12] regen/embed.pl: Move declaration Future commits make the new location a better choice --- regen/embed.pl | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/regen/embed.pl b/regen/embed.pl index 4b15f69332d5..a2e927a850bf 100755 --- a/regen/embed.pl +++ b/regen/embed.pl @@ -28,6 +28,8 @@ BEGIN require './regen/embed_lib.pl'; } +my @az = ('a'..'z'); + # This program has historically generated compatibility macros for a few # functions of the form Perl_FOO(pTHX_ ...). Those macros would be named # FOO(...), and would expand outside the core to Perl_FOO_nocontext(...) @@ -58,7 +60,6 @@ BEGIN my %perl_compats; # Have 'perl_' prefix my $unflagged_pointers; -my @az = ('a'..'z'); # # See database of global and static function prototypes in embed.fnc From 6a092317cfefaddff25933ba99e1672d9df03946 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 30 Oct 2025 13:01:51 -0600 Subject: [PATCH 11/12] regen/embed.pl: Move declaration to first use --- regen/embed.pl | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/regen/embed.pl b/regen/embed.pl index a2e927a850bf..130c4f248261 100755 --- a/regen/embed.pl +++ b/regen/embed.pl @@ -59,8 +59,6 @@ BEGIN $has_compat_macro{$_} = 1 for @have_compatibility_macros; my %perl_compats; # Have 'perl_' prefix -my $unflagged_pointers; - # # See database of global and static function prototypes in embed.fnc # This is used to generate prototype headers under various configurations, @@ -132,6 +130,10 @@ sub open_buf_out { # take non-initialised GV pointers ); +# Pointer arguments that erroneously don't indicate whether they can be NULL, +# etc. +my $unflagged_pointers; + # generate proto.h sub generate_proto_h { my ($all)= @_; From 7b66af147104307399fcb5e0525d57eaae834712 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 30 Oct 2025 13:06:22 -0600 Subject: [PATCH 12/12] Gain control of macro namespace visibility This commit adds the capability to undefine macros that are visible to XS code but shouldn't be. This can be used to stop macro namespace pollution by perl. It works by changing embed.h to have two modes, controlled by a #ifdef that is set by perl.h. perl.h now #includes embed.h twice. The first time works as it always has. The second sets the #ifdef, and causes embed.h to #undef the macros that shouldn't be visible. This call is just before perl.h returns to its includer, so that these macros have come and gone before the file that #included perl.h is affected by them. It comes after the inline headers get included, so they have access to all the symbols that are defined. The list of macros is determined by the visibility given by the apidoc lines documenting them, plus several exception lists that allow a symbol to be visible even though it is not documented as such. In this commit, the main exception list contains everything that is currently visible outside the Perl core, so this should not break any code. But it means that the visibility control is established for future changes to our code base. New macros will not be visible except when documented as needing to be such. We can no longer inadvertently add new names to pollute the user's. I expect that over time, the exception list will become smaller, as we go through it and remove the items that really shouldn't be visible. We can then see via smoking if someone is actually using them, and either decide that these should be visible, or work with the module author for another way to accomplish their needs. (I would hope this would lead to proper documentation of the ones that need to be visible.) There are currently four lists of symbols. One list is for symbols that are used by libc functions, and that Perl may redefine (usually so that code doesn't have to know if it is running on a platform that is lacking the given feature.) The algorithm added here catches most of these and keeps them visible, but there are a few items that currently must be manually listed. A second list is of symbols that the re extension to Perl requires, but no one else needs to. This list is currently empty, as everything initially is in the main exception list. A third list is for items that other Perl extensions require, but no one else needs to. This list is currently empty, as everything initially is in the main exception list. The final list is for items that currently are visible to the whole world. It contains thousands of items. This list should be examined for: 1) Names that shouldn't be so visible; and 2) Names that need to remain visible but should be changed so they are less likely to clash with anything the user might come up with. I have wanted this ability to happen for a long time; and now things have come together to enable it. This allows us to have a clear-cut boundary with CPAN. It means you can add macros that have internal-only use without having to worry about making them likely not to clash with user names. It shows precisely in one place what our names are that are visible to CPAN. --- embed.h | 138 +- perl.h | 6 + regen/embed.pl | 5696 +++++++++++++++++++++++++++++++++++++++++++++++- 3 files changed, 5754 insertions(+), 86 deletions(-) diff --git a/embed.h b/embed.h index 98297e3ad627..c0c701376022 100644 --- a/embed.h +++ b/embed.h @@ -21,77 +21,11 @@ /* (Doing namespace management portably in C is really gross.) */ -/* By defining PERL_NO_SHORT_NAMES (not done by default) the short forms - * (like warn instead of Perl_warn) for the API are not defined. - * Not defining the short forms is a good thing for cleaner embedding. - * BEWARE that a bunch of macros don't have long names, so either must be - * added or don't use them if you define this symbol */ +/* When this symbol is defined, we undef various symbols we have defined + * earlier when this file was #included with this symbol undefined */ +#if !defined(PERL_DO_UNDEFS) -#if !defined(MULTIPLICITY) -/* undefined symbols, point them back at the usual ones */ -# define Perl_deb_nocontext Perl_deb -# define Perl_form_nocontext Perl_form -# define Perl_load_module_nocontext Perl_load_module -# define Perl_mess_nocontext Perl_mess -# define Perl_newSVpvf_nocontext Perl_newSVpvf -# define Perl_sv_catpvf_nocontext Perl_sv_catpvf -# define Perl_sv_catpvf_mg_nocontext Perl_sv_catpvf_mg -# define Perl_sv_setpvf_nocontext Perl_sv_setpvf -# define Perl_sv_setpvf_mg_nocontext Perl_sv_setpvf_mg -# define Perl_warn_nocontext Perl_warn -# define Perl_warner_nocontext Perl_warner -#endif /* !defined(MULTIPLICITY) */ -#if !defined(PERL_CORE) -/* Compatibility stubs. Compile extensions with -DPERL_NOCOMPAT to - * disable them. - */ -# define sv_setptrobj(rv,ptr,name) sv_setref_iv(rv,name,PTR2IV(ptr)) -# define sv_setptrref(rv,ptr) sv_setref_iv(rv,NULL,PTR2IV(ptr)) -# if !defined(PERL_NOCOMPAT) - -/* Compatibility for this renamed function. */ -# define perl_atexit(a,b) Perl_call_atexit(aTHX_ a,b) - -/* Compatibility for these functions that had a 'perl_' prefix before - * 'Perl_' became the standard */ -# define perl_call_argv(a,b,c) Perl_call_argv(aTHX_ a,b,c) -# define perl_call_method(a,b) Perl_call_method(aTHX_ a,b) -# define perl_call_pv(a,b) Perl_call_pv(aTHX_ a,b) -# define perl_call_sv(a,b) Perl_call_sv(aTHX_ a,b) -# define perl_eval_pv(a,b) Perl_eval_pv(aTHX_ a,b) -# define perl_eval_sv(a,b) Perl_eval_sv(aTHX_ a,b) -# define perl_get_av(a,b) Perl_get_av(aTHX_ a,b) -# define perl_get_cv(a,b) Perl_get_cv(aTHX_ a,b) -# define perl_get_hv(a,b) Perl_get_hv(aTHX_ a,b) -# define perl_get_sv(a,b) Perl_get_sv(aTHX_ a,b) -# define perl_init_i18nl10n(a) Perl_init_i18nl10n(aTHX_ a) -# define perl_require_pv(a) Perl_require_pv(aTHX_ a) - -/* Before C99, macros could not wrap varargs functions. This - provides a set of compatibility functions that don't take an - extra argument but grab the context pointer using the macro dTHX. - */ - -# if defined(MULTIPLICITY) && !defined(PERL_NO_SHORT_NAMES) && \ - !defined(PERL_WANT_VARARGS) -# define deb Perl_deb_nocontext -# define form Perl_form_nocontext -# define load_module Perl_load_module_nocontext -# define mess Perl_mess_nocontext -# define newSVpvf Perl_newSVpvf_nocontext -# define sv_catpvf Perl_sv_catpvf_nocontext -# define sv_catpvf_mg Perl_sv_catpvf_mg_nocontext -# define sv_setpvf Perl_sv_setpvf_nocontext -# define sv_setpvf_mg Perl_sv_setpvf_mg_nocontext -# define warn Perl_warn_nocontext -# define warner Perl_warner_nocontext -# endif /* defined(MULTIPLICITY) && !defined(PERL_NO_SHORT_NAMES) && - !defined(PERL_WANT_VARARGS) */ -# endif /* !defined(PERL_NOCOMPAT) */ -#endif /* !defined(PERL_CORE) */ -#if !defined(PERL_NO_SHORT_NAMES) - -/* Hide global symbols */ +/* Create short name macros that hide any need for thread context */ # define AvFILL_(a) Perl_AvFILL_(aTHX_ a) # define Gv_AMupdate(a,b) Perl_Gv_AMupdate(aTHX_ a,b) @@ -908,7 +842,20 @@ # define sv_setpvf_nocontext Perl_sv_setpvf_nocontext # define warn_nocontext Perl_warn_nocontext # define warner_nocontext Perl_warner_nocontext -# endif /* defined(MULTIPLICITY) */ +# else /* if !defined(MULTIPLICITY) */ +/* undefined symbols, point them back at the usual ones */ +# define Perl_deb_nocontext Perl_deb +# define Perl_form_nocontext Perl_form +# define Perl_load_module_nocontext Perl_load_module +# define Perl_mess_nocontext Perl_mess +# define Perl_newSVpvf_nocontext Perl_newSVpvf +# define Perl_sv_catpvf_nocontext Perl_sv_catpvf +# define Perl_sv_catpvf_mg_nocontext Perl_sv_catpvf_mg +# define Perl_sv_setpvf_nocontext Perl_sv_setpvf +# define Perl_sv_setpvf_mg_nocontext Perl_sv_setpvf_mg +# define Perl_warn_nocontext Perl_warn +# define Perl_warner_nocontext Perl_warner +# endif /* !defined(MULTIPLICITY) */ # if !defined(MULTIPLICITY) || defined(PERL_CORE) || \ defined(PERL_WANT_VARARGS) # define deb(...) Perl_deb(aTHX_ __VA_ARGS__) @@ -1834,7 +1781,52 @@ # else # define do_exec3(a,b,c) Perl_do_exec3(aTHX_ a,b,c) # endif -# endif /* defined(PERL_CORE) */ +# else /* if !defined(PERL_CORE) */ +/* Compatibility stubs. Compile extensions with -DPERL_NOCOMPAT to + * disable them. + */ +# define sv_setptrobj(rv,ptr,name) sv_setref_iv(rv,name,PTR2IV(ptr)) +# define sv_setptrref(rv,ptr) sv_setref_iv(rv,NULL,PTR2IV(ptr)) +# if !defined(PERL_NOCOMPAT) + +/* Compatibility for this renamed function. */ +# define perl_atexit(a,b) Perl_call_atexit(aTHX_ a,b) + +/* Compatibility for these functions that had a 'perl_' prefix before + * 'Perl_' became the standard */ +# define perl_call_argv(a,b,c) Perl_call_argv(aTHX_ a,b,c) +# define perl_call_method(a,b) Perl_call_method(aTHX_ a,b) +# define perl_call_pv(a,b) Perl_call_pv(aTHX_ a,b) +# define perl_call_sv(a,b) Perl_call_sv(aTHX_ a,b) +# define perl_eval_pv(a,b) Perl_eval_pv(aTHX_ a,b) +# define perl_eval_sv(a,b) Perl_eval_sv(aTHX_ a,b) +# define perl_get_av(a,b) Perl_get_av(aTHX_ a,b) +# define perl_get_cv(a,b) Perl_get_cv(aTHX_ a,b) +# define perl_get_hv(a,b) Perl_get_hv(aTHX_ a,b) +# define perl_get_sv(a,b) Perl_get_sv(aTHX_ a,b) +# define perl_init_i18nl10n(a) Perl_init_i18nl10n(aTHX_ a) +# define perl_require_pv(a) Perl_require_pv(aTHX_ a) + +/* Before C99, macros could not wrap varargs functions. This + provides a set of compatibility functions that don't take an + extra argument but grab the context pointer using the macro dTHX. + */ + +# if defined(MULTIPLICITY) && !defined(PERL_WANT_VARARGS) +# define deb Perl_deb_nocontext +# define form Perl_form_nocontext +# define load_module Perl_load_module_nocontext +# define mess Perl_mess_nocontext +# define newSVpvf Perl_newSVpvf_nocontext +# define sv_catpvf Perl_sv_catpvf_nocontext +# define sv_catpvf_mg Perl_sv_catpvf_mg_nocontext +# define sv_setpvf Perl_sv_setpvf_nocontext +# define sv_setpvf_mg Perl_sv_setpvf_mg_nocontext +# define warn Perl_warn_nocontext +# define warner Perl_warner_nocontext +# endif /* defined(MULTIPLICITY) && !defined(PERL_WANT_VARARGS) */ +# endif /* !defined(PERL_NOCOMPAT) */ +# endif /* !defined(PERL_CORE) */ # if defined(PERL_CORE) || defined(PERL_EXT) # define append_utf8_from_native_byte Perl_append_utf8_from_native_byte # define av_reify(a) Perl_av_reify(aTHX_ a) @@ -2474,6 +2466,6 @@ # else # define get_context Perl_get_context # endif -#endif /* !defined(PERL_NO_SHORT_NAMES) */ +#endif /* !defined(PERL_DO_UNDEFS) */ /* ex: set ro ft=c: */ diff --git a/perl.h b/perl.h index 8707b00ad288..e31337a45130 100644 --- a/perl.h +++ b/perl.h @@ -9354,6 +9354,12 @@ END_EXTERN_C */ +/* #including a second time causes it to #undef any unwanted symbols to avoid + * polluting the user name space */ +# define PERL_DO_UNDEFS +# include "embed.h" +# undef PERL_DO_UNDEFS + #endif /* Include guard */ /* diff --git a/regen/embed.pl b/regen/embed.pl index 130c4f248261..e5d619a97948 100755 --- a/regen/embed.pl +++ b/regen/embed.pl @@ -16,6 +16,16 @@ # Accepts the standard regen_lib -q and -v args. # # This script is normally invoked from regen.pl. +# +# We strive to not pollute the namespace of XS modules. To that end, embed.h +# (in cooperation with perl.h) keeps all macro names out of that namespace +# that this program thinks shouldn't be in it. The way that works is that +# perl.h #includes embed.h twice. The first time is to #define everything +# needed. And the second time, to #undef those elements that aren't needed +# for the #including file. For the perl core, everything is retained; for +# perl extensions, much is retained; for the rest, only expected things are +# retained. The #undef'ing is done after any inline functions are processed, +# so they always have access to everything. require 5.004; # keep this compatible, an old perl is all we may have before # we build the new one @@ -59,7 +69,5440 @@ BEGIN $has_compat_macro{$_} = 1 for @have_compatibility_macros; my %perl_compats; # Have 'perl_' prefix +# This program inspects various top-level header files, except those on this +# list. +my %skip_files; +$skip_files{$_} = 1 for qw( + charclass_invlists.inc + config.h + embed.h + fakesdio.h + nostdio.h + perl_langinfo.h + perlio.h + proto.h + XSUB.h + ); + +# Items that are marked as being in the API are, by definition, not namespace +# pollutants. To find those, this program looks for API declarations. These +# are in embed.fnc, any top-level dot c file, and certain pod files. In order +# to save a bit of run time, this static list comprises the pod files known to +# have such defintions. It is not expected this will change often. +my @pod_list = qw( + INSTALL + pod/perlguts.pod + pod/perlinterp.pod + pod/perlapio.pod + pod/perlhacktips.pod + pod/perlcall.pod + pod/perlreguts.pod + pod/perlmroapi.pod + pod/perlembed.pod + dist/ExtUtils-ParseXS/lib/perlxs.pod + pod/perliol.pod + pod/perlreapi.pod + ); + +# This is a list of symbols that are not documented to be available for +# modules to use, but are nevertheless currently not kept by embed.h from +# being visible to the world. +# +# Strive to make this list empty. +# +# The list does not include symbols that we have documented as being reserved +# for perl's use, namely those that begin with 'PL_' or contain qr/perl/i. +# There are two parts of the list; the second part contains the symbols which +# have a trailing underscore; the first part those without. # +# For all modules that aren't deliberating using particular names, all the +# other symbols on it are namespace pollutants. + +my @unresolved_visibility_overrides = qw( + _ + ABORT + ABS_IV_MIN + ACCEPT + ACCEPT_t8 + ACCEPT_t8_p8 + ACCEPT_t8_pb + ACCEPT_tb + ACCEPT_tb_p8 + ACCEPT_tb_pb + AHOCORASICK + AHOCORASICKC + AHOCORASICKC_t8 + AHOCORASICKC_t8_p8 + AHOCORASICKC_t8_pb + AHOCORASICKC_tb + AHOCORASICKC_tb_p8 + AHOCORASICKC_tb_pb + AHOCORASICK_t8 + AHOCORASICK_t8_p8 + AHOCORASICK_t8_pb + AHOCORASICK_tb + AHOCORASICK_tb_p8 + AHOCORASICK_tb_pb + ALIGNED_TYPE + ALIGNED_TYPE_NAME + ALL_PARENS_COUNTED + ALWAYS_WARN_SUPER + AMG_CALLun + AMG_CALLunary + AMGfallNEVER + AMGfallNO + AMGfallYES + AMGf_assign + AMGf_noleft + AMGf_noright + AMGf_numarg + AMGf_numeric + AMGf_unary + AMGf_want_list + AMG_id2name + AMG_id2namelen + AMT_AMAGIC + AMT_AMAGIC_off + AMT_AMAGIC_on + AMTf_AMAGIC + anchored_end_shift + anchored_offset + anchored_substr + anchored_utf8 + ANGSTROM_SIGN + ANY_FEATURE_BITS_SET + ANYOF + ANYOF_ALNUM + ANYOF_ALNUML + ANYOF_ALPHA + ANYOF_ALPHANUMERIC + ANYOF_ASCII + ANYOF_BIT + ANYOF_BITMAP + ANYOF_BITMAP_BYTE + ANYOF_BITMAP_CLEAR + ANYOF_BITMAP_CLEARALL + ANYOF_BITMAP_SET + ANYOF_BITMAP_SETALL + ANYOF_BITMAP_SIZE + ANYOF_BITMAP_TEST + ANYOF_BITMAP_ZERO + ANYOF_BLANK + ANYOF_CASED + ANYOF_CLASS_OR + ANYOF_CLASS_SETALL + ANYOF_CLASS_TEST_ANY_SET + ANYOF_CNTRL + ANYOF_COMMON_FLAGS + ANYOFD + ANYOF_DIGIT + ANYOFD_NON_UTF8_MATCHES_ALL_NON_ASCII__shared + ANYOFD_t8 + ANYOFD_t8_p8 + ANYOFD_t8_pb + ANYOFD_tb + ANYOFD_tb_p8 + ANYOFD_tb_pb + ANYOF_FLAGS + ANYOF_FLAGS_ALL + ANYOF_GRAPH + ANYOFH + ANYOF_HAS_AUX + ANYOF_HAS_EXTRA_RUNTIME_MATCHES + ANYOFHb + ANYOFHbbm + ANYOFHbbm_t8 + ANYOFHbbm_t8_p8 + ANYOFHbbm_t8_pb + ANYOFHbbm_tb + ANYOFHbbm_tb_p8 + ANYOFHbbm_tb_pb + ANYOFHb_t8 + ANYOFHb_t8_p8 + ANYOFHb_t8_pb + ANYOFHb_tb + ANYOFHb_tb_p8 + ANYOFHb_tb_pb + ANYOF_HORIZWS + ANYOFHr + ANYOFHr_t8 + ANYOFHr_t8_p8 + ANYOFHr_t8_pb + ANYOFHr_tb + ANYOFHr_tb_p8 + ANYOFHr_tb_pb + ANYOFHs + ANYOFHs_t8 + ANYOFHs_t8_p8 + ANYOFHs_t8_pb + ANYOFHs_tb + ANYOFHs_tb_p8 + ANYOFHs_tb_pb + ANYOFH_t8 + ANYOFH_t8_p8 + ANYOFH_t8_pb + ANYOFH_tb + ANYOFH_tb_p8 + ANYOFH_tb_pb + ANYOF_INVERT + ANYOFL + ANYOFL_FOLD + ANYOF_LOCALE_FLAGS + ANYOF_LOWER + ANYOFL_t8 + ANYOFL_t8_p8 + ANYOFL_t8_pb + ANYOFL_tb + ANYOFL_tb_p8 + ANYOFL_tb_pb + ANYOFL_UTF8_LOCALE_REQD + ANYOFM + ANYOF_MATCHES_ALL_OUTSIDE_BITMAP + ANYOF_MATCHES_ALL_OUTSIDE_BITMAP_VALUE + ANYOF_MATCHES_NONE_OUTSIDE_BITMAP + ANYOF_MATCHES_NONE_OUTSIDE_BITMAP_VALUE + ANYOF_MATCHES_POSIXL + ANYOF_MAX + ANYOFM_t8 + ANYOFM_t8_p8 + ANYOFM_t8_pb + ANYOFM_tb + ANYOFM_tb_p8 + ANYOFM_tb_pb + ANYOF_NALNUM + ANYOF_NALNUML + ANYOF_NALPHA + ANYOF_NALPHANUMERIC + ANYOF_NASCII + ANYOF_NBLANK + ANYOF_NCASED + ANYOF_NCNTRL + ANYOF_NDIGIT + ANYOF_NGRAPH + ANYOF_NHORIZWS + ANYOF_NLOWER + ANYOF_NPRINT + ANYOF_NPUNCT + ANYOF_NSPACE + ANYOF_NSPACEL + ANYOF_NUPPER + ANYOF_NVERTWS + ANYOF_NWORDCHAR + ANYOF_NXDIGIT + ANYOF_ONLY_HAS_BITMAP + ANYOF_ONLY_HAS_BITMAP_MASK + ANYOFPOSIXL + ANYOF_POSIXL_AND + ANYOF_POSIXL_BITMAP + ANYOF_POSIXL_CLEAR + ANYOF_POSIXL_MAX + ANYOF_POSIXL_OR + ANYOF_POSIXL_SET + ANYOF_POSIXL_SETALL + ANYOF_POSIXL_SET_TO_BITMAP + ANYOF_POSIXL_SSC_TEST_ALL_SET + ANYOF_POSIXL_SSC_TEST_ANY_SET + ANYOFPOSIXL_t8 + ANYOFPOSIXL_t8_p8 + ANYOFPOSIXL_t8_pb + ANYOFPOSIXL_tb + ANYOFPOSIXL_tb_p8 + ANYOFPOSIXL_tb_pb + ANYOF_POSIXL_TEST + ANYOF_POSIXL_TEST_ALL_SET + ANYOF_POSIXL_TEST_ANY_SET + ANYOF_POSIXL_ZERO + ANYOF_PRINT + ANYOF_PUNCT + ANYOFR + ANYOFRb + ANYOFRbase + ANYOFR_BASE_BITS + ANYOFRb_t8 + ANYOFRb_t8_p8 + ANYOFRb_t8_pb + ANYOFRb_tb + ANYOFRb_tb_p8 + ANYOFRb_tb_pb + ANYOFRdelta + ANYOFR_t8 + ANYOFR_t8_p8 + ANYOFR_t8_pb + ANYOFR_tb + ANYOFR_tb_p8 + ANYOFR_tb_pb + ANYOF_SPACE + ANYOF_SPACEL + ANYOF_t8 + ANYOF_t8_p8 + ANYOF_t8_pb + ANYOF_tb + ANYOF_tb_p8 + ANYOF_tb_pb + ANYOF_UNIPROP + ANYOF_UPPER + ANYOF_VERTWS + ANYOF_WARN_SUPER__shared + ANYOF_WORDCHAR + ANYOF_XDIGIT + ARABIC_DECIMAL_SEPARATOR_UTF8 + ARABIC_DECIMAL_SEPARATOR_UTF8_FIRST_BYTE + ARABIC_DECIMAL_SEPARATOR_UTF8_FIRST_BYTE_s + ARABIC_DECIMAL_SEPARATOR_UTF8_TAIL + ARG1a + ARG1a_LOC + ARG1a_SET + ARG1b + ARG1b_LOC + ARG1b_SET + ARG1i + ARG1i_LOC + ARG1i_SET + ARG1u + ARG1u_LOC + ARG1u_SET + ARG2a + ARG2a_LOC + ARG2a_SET + ARG2b + ARG2b_LOC + ARG2b_SET + ARG2i + ARG2i_LOC + ARG2i_SET + ARG2u + ARG2u_LOC + ARG2u_SET + ARG3a + ARG3a_LOC + ARG3a_SET + ARG3b + ARG3b_LOC + ARG3b_SET + ARG3i + ARG3i_LOC + ARG3i_SET + ARG3u + ARG3u_LOC + ARG3u_SET + ARGp + ARGp_BYTES_LOC + ARGp_SET + ARG__SET + ARGTARG + ARG_VALUE + ASCII_FOLD_RESTRICTED + ASCII_MORE_RESTRICT_PAT_MODS + ASCII_PLATFORM_UTF8_MAXBYTES + ASCII_RESTRICTED + ASCII_RESTRICT_PAT_MOD + ASCII_RESTRICT_PAT_MODS + ASCII_TO_NATIVE + ASCTIME_LOCK + ASCTIME_UNLOCK + ASSERT_CURPAD_ACTIVE + ASSERT_CURPAD_LEGAL + ASSERT_IS_LITERAL + ASSERT_IS_PTR + assert_not_glob + ASSERT_NOT_PTR + assert_not_ROK + aTHXa + aTHXo + aTHXx + AT_LEAST_ASCII_RESTRICTED + AT_LEAST_UNI_SEMANTICS + AvARYLEN + av_dup + av_dup_inc + AvMAX + AvREAL + AvREALISH + AvREAL_off + AvREAL_on + AvREAL_only + AvREIFY + AvREIFY_off + AvREIFY_on + AvREIFY_only + av_tindex_skip_len_mg + av_top_index_skip_len_mg + BADVERSION + BASEOP + BhkENTRY + BHKf_bhk_eval + BHKf_bhk_post_end + BHKf_bhk_pre_end + BHKf_bhk_start + BhkFLAGS + BIT_BUCKET + BIT_DIGITS + BITMAP_BIT + BITMAP_BYTE + BITMAP_TEST + blk_eval + blk_format + blk_gimme + blk_givwhen + blk_loop + blk_oldcop + blk_oldmarksp + blk_oldpm + blk_oldsaveix + blk_oldscopesp + blk_oldsp + blk_old_tmpsfloor + blk_sub + blk_u16 + BmFLAGS + BmPREVIOUS + BmRARE + BmUSEFUL + BOL + BOL_t8 + BOL_t8_p8 + BOL_t8_pb + BOL_tb + BOL_tb_p8 + BOL_tb_pb + BOM_UTF8_FIRST_BYTE + BOM_UTF8_TAIL + BOUND + BOUNDA + BOUNDA_t8 + BOUNDA_t8_p8 + BOUNDA_t8_pb + BOUNDA_tb + BOUNDA_tb_p8 + BOUNDA_tb_pb + BOUNDL + BOUNDL_t8 + BOUNDL_t8_p8 + BOUNDL_t8_pb + BOUNDL_tb + BOUNDL_tb_p8 + BOUNDL_tb_pb + BOUND_t8 + BOUND_t8_p8 + BOUND_t8_pb + BOUND_tb + BOUND_tb_p8 + BOUND_tb_pb + BOUNDU + BOUNDU_t8 + BOUNDU_t8_p8 + BOUNDU_t8_pb + BOUNDU_tb + BOUNDU_tb_p8 + BOUNDU_tb_pb + BRANCH + BRANCHJ + BRANCHJ_t8 + BRANCHJ_t8_p8 + BRANCHJ_t8_pb + BRANCHJ_tb + BRANCHJ_tb_p8 + BRANCHJ_tb_pb + BRANCH_next + BRANCH_next_fail + BRANCH_next_fail_t8 + BRANCH_next_fail_t8_p8 + BRANCH_next_fail_t8_pb + BRANCH_next_fail_tb + BRANCH_next_fail_tb_p8 + BRANCH_next_fail_tb_pb + BRANCH_next_t8 + BRANCH_next_t8_p8 + BRANCH_next_t8_pb + BRANCH_next_tb + BRANCH_next_tb_p8 + BRANCH_next_tb_pb + BRANCH_t8 + BRANCH_t8_p8 + BRANCH_t8_pb + BRANCH_tb + BRANCH_tb_p8 + BRANCH_tb_pb + BSD_GETPGRP + BSD_SETPGRP + BYTES_REMAINING_IN_WORD + CALL_BLOCK_HOOKS + CALL_FPTR + CALLREGCOMP + CALLREGCOMP_ENG + CALLREGDUPE + CALLREGDUPE_PVT + CALLREGEXEC + CALLREGFREE + CALLREGFREE_PVT + CALLREG_INTUIT_START + CALLREG_INTUIT_STRING + CALLREG_NAMED_BUFF_ALL + CALLREG_NAMED_BUFF_CLEAR + CALLREG_NAMED_BUFF_COUNT + CALLREG_NAMED_BUFF_DELETE + CALLREG_NAMED_BUFF_EXISTS + CALLREG_NAMED_BUFF_FETCH + CALLREG_NAMED_BUFF_FIRSTKEY + CALLREG_NAMED_BUFF_NEXTKEY + CALLREG_NAMED_BUFF_SCALAR + CALLREG_NAMED_BUFF_STORE + CALLREG_NUMBUF_FETCH + CALLREG_NUMBUF_LENGTH + CALLREG_NUMBUF_STORE + CALLREG_PACKAGE + CALLRUNOPS + CAN64BITHASH + CAN_COW_FLAGS + CAN_COW_MASK + CAN_PROTOTYPE + case_100_SBOX32 + case_101_SBOX32 + case_102_SBOX32 + case_103_SBOX32 + case_104_SBOX32 + case_105_SBOX32 + case_106_SBOX32 + case_107_SBOX32 + case_108_SBOX32 + case_109_SBOX32 + case_10_SBOX32 + case_110_SBOX32 + case_111_SBOX32 + case_112_SBOX32 + case_113_SBOX32 + case_114_SBOX32 + case_115_SBOX32 + case_116_SBOX32 + case_117_SBOX32 + case_118_SBOX32 + case_119_SBOX32 + case_11_SBOX32 + case_120_SBOX32 + case_121_SBOX32 + case_122_SBOX32 + case_123_SBOX32 + case_124_SBOX32 + case_125_SBOX32 + case_126_SBOX32 + case_127_SBOX32 + case_128_SBOX32 + case_129_SBOX32 + case_12_SBOX32 + case_130_SBOX32 + case_131_SBOX32 + case_132_SBOX32 + case_133_SBOX32 + case_134_SBOX32 + case_135_SBOX32 + case_136_SBOX32 + case_137_SBOX32 + case_138_SBOX32 + case_139_SBOX32 + case_13_SBOX32 + case_140_SBOX32 + case_141_SBOX32 + case_142_SBOX32 + case_143_SBOX32 + case_144_SBOX32 + case_145_SBOX32 + case_146_SBOX32 + case_147_SBOX32 + case_148_SBOX32 + case_149_SBOX32 + case_14_SBOX32 + case_150_SBOX32 + case_151_SBOX32 + case_152_SBOX32 + case_153_SBOX32 + case_154_SBOX32 + case_155_SBOX32 + case_156_SBOX32 + case_157_SBOX32 + case_158_SBOX32 + case_159_SBOX32 + case_15_SBOX32 + case_160_SBOX32 + case_161_SBOX32 + case_162_SBOX32 + case_163_SBOX32 + case_164_SBOX32 + case_165_SBOX32 + case_166_SBOX32 + case_167_SBOX32 + case_168_SBOX32 + case_169_SBOX32 + case_16_SBOX32 + case_170_SBOX32 + case_171_SBOX32 + case_172_SBOX32 + case_173_SBOX32 + case_174_SBOX32 + case_175_SBOX32 + case_176_SBOX32 + case_177_SBOX32 + case_178_SBOX32 + case_179_SBOX32 + case_17_SBOX32 + case_180_SBOX32 + case_181_SBOX32 + case_182_SBOX32 + case_183_SBOX32 + case_184_SBOX32 + case_185_SBOX32 + case_186_SBOX32 + case_187_SBOX32 + case_188_SBOX32 + case_189_SBOX32 + case_18_SBOX32 + case_190_SBOX32 + case_191_SBOX32 + case_192_SBOX32 + case_193_SBOX32 + case_194_SBOX32 + case_195_SBOX32 + case_196_SBOX32 + case_197_SBOX32 + case_198_SBOX32 + case_199_SBOX32 + case_19_SBOX32 + case_1_SBOX32 + case_200_SBOX32 + case_201_SBOX32 + case_202_SBOX32 + case_203_SBOX32 + case_204_SBOX32 + case_205_SBOX32 + case_206_SBOX32 + case_207_SBOX32 + case_208_SBOX32 + case_209_SBOX32 + case_20_SBOX32 + case_210_SBOX32 + case_211_SBOX32 + case_212_SBOX32 + case_213_SBOX32 + case_214_SBOX32 + case_215_SBOX32 + case_216_SBOX32 + case_217_SBOX32 + case_218_SBOX32 + case_219_SBOX32 + case_21_SBOX32 + case_220_SBOX32 + case_221_SBOX32 + case_222_SBOX32 + case_223_SBOX32 + case_224_SBOX32 + case_225_SBOX32 + case_226_SBOX32 + case_227_SBOX32 + case_228_SBOX32 + case_229_SBOX32 + case_22_SBOX32 + case_230_SBOX32 + case_231_SBOX32 + case_232_SBOX32 + case_233_SBOX32 + case_234_SBOX32 + case_235_SBOX32 + case_236_SBOX32 + case_237_SBOX32 + case_238_SBOX32 + case_239_SBOX32 + case_23_SBOX32 + case_240_SBOX32 + case_241_SBOX32 + case_242_SBOX32 + case_243_SBOX32 + case_244_SBOX32 + case_245_SBOX32 + case_246_SBOX32 + case_247_SBOX32 + case_248_SBOX32 + case_249_SBOX32 + case_24_SBOX32 + case_250_SBOX32 + case_251_SBOX32 + case_252_SBOX32 + case_253_SBOX32 + case_254_SBOX32 + case_255_SBOX32 + case_256_SBOX32 + case_25_SBOX32 + case_26_SBOX32 + case_27_SBOX32 + case_28_SBOX32 + case_29_SBOX32 + case_2_SBOX32 + case_30_SBOX32 + case_31_SBOX32 + case_32_SBOX32 + case_33_SBOX32 + case_34_SBOX32 + case_35_SBOX32 + case_36_SBOX32 + case_37_SBOX32 + case_38_SBOX32 + case_39_SBOX32 + case_3_SBOX32 + case_40_SBOX32 + case_41_SBOX32 + case_42_SBOX32 + case_43_SBOX32 + case_44_SBOX32 + case_45_SBOX32 + case_46_SBOX32 + case_47_SBOX32 + case_48_SBOX32 + case_49_SBOX32 + case_4_SBOX32 + case_50_SBOX32 + case_51_SBOX32 + case_52_SBOX32 + case_53_SBOX32 + case_54_SBOX32 + case_55_SBOX32 + case_56_SBOX32 + case_57_SBOX32 + case_58_SBOX32 + case_59_SBOX32 + case_5_SBOX32 + case_60_SBOX32 + case_61_SBOX32 + case_62_SBOX32 + case_63_SBOX32 + case_64_SBOX32 + case_65_SBOX32 + case_66_SBOX32 + case_67_SBOX32 + case_68_SBOX32 + case_69_SBOX32 + case_6_SBOX32 + case_70_SBOX32 + case_71_SBOX32 + case_72_SBOX32 + case_73_SBOX32 + case_74_SBOX32 + case_75_SBOX32 + case_76_SBOX32 + case_77_SBOX32 + case_78_SBOX32 + case_79_SBOX32 + case_7_SBOX32 + case_80_SBOX32 + case_81_SBOX32 + case_82_SBOX32 + case_83_SBOX32 + case_84_SBOX32 + case_85_SBOX32 + case_86_SBOX32 + case_87_SBOX32 + case_88_SBOX32 + case_89_SBOX32 + case_8_SBOX32 + case_90_SBOX32 + case_91_SBOX32 + case_92_SBOX32 + case_93_SBOX32 + case_94_SBOX32 + case_95_SBOX32 + case_96_SBOX32 + case_97_SBOX32 + case_98_SBOX32 + case_99_SBOX32 + case_9_SBOX32 + CASE_STD_PMMOD_FLAGS_PARSE_SET + CATCH_GET + CATCH_SET + cBINOP + cBINOPo + cBINOPx + cCOP + cCOPo + cCOPx + cGVOP_gv + cGVOPo_gv + cGVOPx_gv + CHANGE_MULTICALL_FLAGS + CHARSET_PAT_MODS + check_end_shift + CHECK_MALLOC_TAINT + CHECK_MALLOC_TOO_LATE_FOR + check_offset_max + check_offset_min + check_substr + check_utf8 + child_offset_bits + CHR_SVLEN + ckDEAD + ckWARN2_non_literal_string + ckWARN2reg + ckWARN2reg_d + ckWARN3reg + ckWARN4reg + ckWARNdep + ckWARNexperimental + ckWARNexperimental_with_arg + ckWARNreg + ckWARNregdep + CLANG_DIAG_IGNORE + CLANG_DIAG_IGNORE_DECL + CLANG_DIAG_IGNORE_STMT + CLANG_DIAG_PRAGMA + CLANG_DIAG_RESTORE + CLANG_DIAG_RESTORE_DECL + CLANG_DIAG_RESTORE_STMT + classnum_to_namedclass + CLEAR_ARGARRAY + CLEARFEATUREBITS + CLEAR_OPTSTART + cLISTOP + cLISTOPo + cLISTOPx + cLOGOP + cLOGOPo + cLOGOPx + CLONEf_CLONE_HOST + CLONEf_COPY_STACKS + CLONEf_JOIN_IN + CLONEf_KEEP_PTR_TABLE + cLOOP + cLOOPo + cLOOPx + CLOSE + CLOSE_t8 + CLOSE_t8_p8 + CLOSE_t8_pb + CLOSE_tb + CLOSE_tb_p8 + CLOSE_tb_pb + CLUMP + CLUMP_2IV + CLUMP_2UV + CLUMP_t8 + CLUMP_t8_p8 + CLUMP_t8_pb + CLUMP_tb + CLUMP_tb_p8 + CLUMP_tb_pb + cMETHOP + cMETHOP_meth + cMETHOPo + cMETHOPo_meth + cMETHOPo_rclass + cMETHOP_rclass + cMETHOPx + cMETHOPx_meth + cMETHOPx_rclass + COMBINING_DOT_ABOVE_UTF8 + COMBINING_GRAVE_ACCENT_UTF8 + COMBINING_GREEK_YPOGEGRAMMENI_UTF8 + COMMIT + COMMIT_next + COMMIT_next_fail + COMMIT_next_fail_t8 + COMMIT_next_fail_t8_p8 + COMMIT_next_fail_t8_pb + COMMIT_next_fail_tb + COMMIT_next_fail_tb_p8 + COMMIT_next_fail_tb_pb + COMMIT_next_t8 + COMMIT_next_t8_p8 + COMMIT_next_t8_pb + COMMIT_next_tb + COMMIT_next_tb_p8 + COMMIT_next_tb_pb + COMMIT_t8 + COMMIT_t8_p8 + COMMIT_t8_pb + COMMIT_tb + COMMIT_tb_p8 + COMMIT_tb_pb + CONTINUE_PAT_MOD + COP_FEATURE_SIZE + CopFEATURES_setfrom + CopFILEAVx + CopFILE_copy_x + CopFILE_debug + CopFILE_free_x + CopFILE_setn_x + CopFILE_set_x + COPHH_EXISTS + cophh_exists_pv + cophh_exists_pvs + cophh_exists_sv + CopHINTHASH_get + CopHINTHASH_set + CopHINTS_get + CopHINTS_set + CopLABEL_alloc + CopLINE_dec + CopLINE_inc + CopLINE_set + COP_SEQMAX_INC + COP_SEQ_RANGE_HIGH + COP_SEQ_RANGE_LOW + CopSTASH_ne + copy_length + CowREFCNT + cPADOP + cPADOPo + cPADOPx + cPMOP + cPMOPo + cPMOPx + cPVOP + cPVOPo + cPVOPx + CR_NATIVE + cSVOP + cSVOPo + cSVOPo_sv + cSVOP_sv + cSVOPx + cSVOPx_sv + cSVOPx_svp + CTIME_LOCK + CTIME_UNLOCK + Ctl + cUNOP + cUNOP_AUX + cUNOP_AUXo + cUNOP_AUXx + cUNOPo + cUNOPx + CURLY + CURLY_B_max + CURLY_B_max_fail + CURLY_B_max_fail_t8 + CURLY_B_max_fail_t8_p8 + CURLY_B_max_fail_t8_pb + CURLY_B_max_fail_tb + CURLY_B_max_fail_tb_p8 + CURLY_B_max_fail_tb_pb + CURLY_B_max_t8 + CURLY_B_max_t8_p8 + CURLY_B_max_t8_pb + CURLY_B_max_tb + CURLY_B_max_tb_p8 + CURLY_B_max_tb_pb + CURLY_B_min + CURLY_B_min_fail + CURLY_B_min_fail_t8 + CURLY_B_min_fail_t8_p8 + CURLY_B_min_fail_t8_pb + CURLY_B_min_fail_tb + CURLY_B_min_fail_tb_p8 + CURLY_B_min_fail_tb_pb + CURLY_B_min_t8 + CURLY_B_min_t8_p8 + CURLY_B_min_t8_pb + CURLY_B_min_tb + CURLY_B_min_tb_p8 + CURLY_B_min_tb_pb + CURLYM + CURLYM_A + CURLYM_A_fail + CURLYM_A_fail_t8 + CURLYM_A_fail_t8_p8 + CURLYM_A_fail_t8_pb + CURLYM_A_fail_tb + CURLYM_A_fail_tb_p8 + CURLYM_A_fail_tb_pb + CURLYM_A_t8 + CURLYM_A_t8_p8 + CURLYM_A_t8_pb + CURLYM_A_tb + CURLYM_A_tb_p8 + CURLYM_A_tb_pb + CURLYM_B + CURLYM_B_fail + CURLYM_B_fail_t8 + CURLYM_B_fail_t8_p8 + CURLYM_B_fail_t8_pb + CURLYM_B_fail_tb + CURLYM_B_fail_tb_p8 + CURLYM_B_fail_tb_pb + CURLYM_B_t8 + CURLYM_B_t8_p8 + CURLYM_B_t8_pb + CURLYM_B_tb + CURLYM_B_tb_p8 + CURLYM_B_tb_pb + CURLYM_t8 + CURLYM_t8_p8 + CURLYM_t8_pb + CURLYM_tb + CURLYM_tb_p8 + CURLYM_tb_pb + CURLYN + CURLYN_t8 + CURLYN_t8_p8 + CURLYN_t8_pb + CURLYN_tb + CURLYN_tb_p8 + CURLYN_tb_pb + CURLY_t8 + CURLY_t8_p8 + CURLY_t8_pb + CURLY_tb + CURLY_tb_p8 + CURLY_tb_pb + CURLYX + CURLYX_end + CURLYX_end_fail + CURLYX_end_fail_t8 + CURLYX_end_fail_t8_p8 + CURLYX_end_fail_t8_pb + CURLYX_end_fail_tb + CURLYX_end_fail_tb_p8 + CURLYX_end_fail_tb_pb + CURLYX_end_t8 + CURLYX_end_t8_p8 + CURLYX_end_t8_pb + CURLYX_end_tb + CURLYX_end_tb_p8 + CURLYX_end_tb_pb + CURLYX_t8 + CURLYX_t8_p8 + CURLYX_t8_pb + CURLYX_tb + CURLYX_tb_p8 + CURLYX_tb_pb + CURRENT_FEATURE_BUNDLE + CURRENT_HINTS + CUTGROUP + CUTGROUP_next + CUTGROUP_next_fail + CUTGROUP_next_fail_t8 + CUTGROUP_next_fail_t8_p8 + CUTGROUP_next_fail_t8_pb + CUTGROUP_next_fail_tb + CUTGROUP_next_fail_tb_p8 + CUTGROUP_next_fail_tb_pb + CUTGROUP_next_t8 + CUTGROUP_next_t8_p8 + CUTGROUP_next_t8_pb + CUTGROUP_next_tb + CUTGROUP_next_tb_p8 + CUTGROUP_next_tb_pb + CUTGROUP_t8 + CUTGROUP_t8_p8 + CUTGROUP_t8_pb + CUTGROUP_tb + CUTGROUP_tb_p8 + CUTGROUP_tb_pb + CvANON + CvANONCONST + CvANONCONST_off + CvANONCONST_on + CvANON_off + CvANON_on + CvAUTOLOAD + CvAUTOLOAD_off + CvAUTOLOAD_on + cv_ckproto + CvCLONE + CvCLONED + CvCLONED_off + CvCLONED_on + CvCLONE_off + CvCLONE_on + CvCONST + CvCONST_off + CvCONST_on + CvCVGV_RC + CvCVGV_RC_off + CvCVGV_RC_on + CvDEPTHunsafe + cv_dup + cv_dup_inc + CvDYNFILE + CvDYNFILE_off + CvDYNFILE_on + CvEVAL + CvEVAL_COMPILED + CvEVAL_COMPILED_off + CvEVAL_COMPILED_on + CvEVAL_off + CvEVAL_on + CVf_ANON + CVf_ANONCONST + CVf_AUTOLOAD + CVf_BUILTIN_ATTRS + CVf_CLONE + CVf_CLONED + CVf_CONST + CVf_CVGV_RC + CVf_DYNFILE + CVf_EVAL_COMPILED + CVf_HASEVAL + CvFILE + CvFILEGV + CvFILE_set_from_cop + CVf_IsMETHOD + CVf_ISXSUB + CvFLAGS + CVf_LEXICAL + CVf_LVALUE + CVf_METHOD + CVf_NAMED + CVf_NODEBUG + CVf_NOWARN_AMBIGUOUS + CVf_REFCOUNTED_ANYSV + CVf_SIGNATURE + CVf_UNIQUE + CVf_WEAKOUTSIDE + CVf_XS_RCSTACK + CvGvNAME_HEK + CvGV_set + CvHASEVAL + CvHASEVAL_off + CvHASEVAL_on + CvHASGV + CvHSCXT + CvIsMETHOD + CvIsMETHOD_off + CvIsMETHOD_on + CvISXSUB + CvISXSUB_off + CvISXSUB_on + CvLEXICAL + CvLEXICAL_off + CvLEXICAL_on + CvLVALUE + CvLVALUE_off + CvLVALUE_on + CvMETHOD + CvMETHOD_off + CvMETHOD_on + CvNAMED + CvNAMED_off + CvNAMED_on + CvNAME_HEK_set + CvNODEBUG + CvNODEBUG_off + CvNODEBUG_on + CvNOWARN_AMBIGUOUS + CvNOWARN_AMBIGUOUS_off + CvNOWARN_AMBIGUOUS_on + CvOUTSIDE + CvOUTSIDE_SEQ + CvPADLIST_set + CvPROTO + CvPROTOLEN + CvREFCOUNTED_ANYSV + CvREFCOUNTED_ANYSV_off + CvREFCOUNTED_ANYSV_on + CvSIGNATURE + CvSIGNATURE_off + CvSIGNATURE_on + CvSLABBED + CvSLABBED_off + CvSLABBED_on + CvSPECIAL + CvSPECIAL_off + CvSPECIAL_on + CvSTASH_set + CV_UNDEF_KEEP_NAME + CvUNIQUE + CvUNIQUE_off + CvUNIQUE_on + CvWEAKOUTSIDE + CvWEAKOUTSIDE_off + CvWEAKOUTSIDE_on + CvXS_RCSTACK + CvXS_RCSTACK_off + CvXS_RCSTACK_on + CvXSUB + CvXSUBANY + CX_CURPAD_SAVE + CX_CURPAD_SV + CX_DEBUG + CxEVALBLOCK + CxEVAL_TXT_REFCNTED + CxFOREACH + CxHASARGS + CxITERVAR + CxLABEL + CxLABEL_len + CxLABEL_len_flags + CxLVAL + CxMULTICALL + CxOLD_IN_EVAL + CxOLD_OP_TYPE + CxONCE + CxPADLOOP + CXp_EVALBLOCK + CXp_FINALLY + CXp_FOR_DEF + CXp_FOR_GV + CXp_FOR_LVREF + CXp_FOR_PAD + CXp_HASARGS + CXp_MULTICALL + CXp_ONCE + CX_POP_SAVEARRAY + CX_POPSUBST + CXp_REAL + CXp_SUB_RE + CXp_SUB_RE_FAKE + CXp_TRY + CXp_TRYBLOCK + CX_PUSHSUB_GET_LVALUE_MASK + CX_PUSHSUBST + CxREALEVAL + cxstack_max + CXt_DEFER + CxTRY + CxTRYBLOCK + CxTYPE + CxTYPE_is_LOOP + CXTYPEMASK + dATARGET + DBVARMG_COUNT + DBVARMG_SIGNAL + DBVARMG_SINGLE + DBVARMG_TRACE + DEBUG_A + DEBUG_A_FLAG + DEBUG_A_TEST + DEBUG_B + DEBUG_B_FLAG + DEBUG_B_TEST + DEBUG_BUFFERS_r + DEBUG_c + DEBUG_C + DEBUG_c_FLAG + DEBUG_C_FLAG + DEBUG_COMPILE_r + DEBUG_c_TEST + DEBUG_C_TEST + DEBUG_D + DEBUG_DB_RECURSE_FLAG + DEBUG_D_FLAG + DEBUG_D_TEST + DEBUG_DUMP_PRE_OPTIMIZE_r + DEBUG_DUMP_r + DEBUG_EXECUTE_r + DEBUG_EXTRA_r + DEBUG_f + DEBUG_f_FLAG + DEBUG_FLAGS_r + DEBUG_f_TEST + DEBUG_GPOS_r + DEBUG_h_FLAG + DEBUG_h_TEST + DEBUG_i + DEBUG_i_FLAG + DEBUG_INTUIT_r + DEBUG_i_TEST + DEBUG_J_FLAG + DEBUG_J_TEST + DEBUG_l + DEBUG_L + DEBUG_l_FLAG + DEBUG_L_FLAG + DEBUG_l_TEST + DEBUG_L_TEST + DEBUG_Lv + DEBUG_Lv_TEST + DEBUG_m + DEBUG_M + DEBUG_MASK + DEBUG_MATCH_r + DEBUG_m_FLAG + DEBUG_M_FLAG + DEBUG_m_TEST + DEBUG_M_TEST + DEBUG_o + DEBUG_o_FLAG + DEBUG_OPTIMISE_MORE_r + DEBUG_OPTIMISE_r + DEBUG_o_TEST + DEBUG_p + DEBUG_P + DEBUG_PARSE_r + DEBUG_PEEP + DEBUG_p_FLAG + DEBUG_P_FLAG + DEBUG_p_TEST + DEBUG_P_TEST + DEBUG_Pv + DEBUG_Pv_TEST + DEBUG_q + DEBUG_q_FLAG + DEBUG_q_TEST + DEBUG_r + DEBUG_R + DEBUG_RExC_seen + DEBUG_r_FLAG + DEBUG_R_FLAG + DEBUG_r_TEST + DEBUG_R_TEST + DEBUG_s + DEBUG_S + DEBUG_SCOPE + DEBUG_s_FLAG + DEBUG_S_FLAG + DEBUG_SHOW_STUDY_FLAG + DEBUG_STACK_r + DEBUG_STATE_r + DEBUG_s_TEST + DEBUG_S_TEST + DEBUG_STUDYDATA + DEBUG_t + DEBUG_T + DEBUG_TEST_r + DEBUG_t_FLAG + DEBUG_T_FLAG + DEBUG_TOP_FLAG + DEBUG_TRIE_COMPILE_MORE_r + DEBUG_TRIE_COMPILE_r + DEBUG_TRIE_EXECUTE_MORE_r + DEBUG_TRIE_EXECUTE_r + DEBUG_TRIE_r + DEBUG_t_TEST + DEBUG_T_TEST + DEBUG_u + DEBUG_U + DEBUG_u_FLAG + DEBUG_U_FLAG + DEBUG_u_TEST + DEBUG_U_TEST + DEBUG_Uv + DEBUG_Uv_TEST + DEBUG_v + DEBUG_v_FLAG + DEBUG_v_TEST + DEBUG_x + DEBUG_X + DEBUG_x_FLAG + DEBUG_X_FLAG + DEBUG_x_TEST + DEBUG_X_TEST + DEBUG_Xv + DEBUG_Xv_TEST + DEBUG_y + DEBUG_y_FLAG + DEBUG_y_TEST + DEBUG_yv + DEBUG_yv_TEST + DECLARE_AND_GET_RE_DEBUG_FLAGS + DECLARE_AND_GET_RE_DEBUG_FLAGS_NON_REGEX + DEFAULT_PAT_MOD + DEFERRED_COULD_BE_OFFICIAL_MARKERc + DEFERRED_COULD_BE_OFFICIAL_MARKERs + DEFERRED_USER_DEFINED_INDEX + DEFINEP + DEFINEP_t8 + DEFINEP_t8_p8 + DEFINEP_t8_pb + DEFINEP_tb + DEFINEP_tb_p8 + DEFINEP_tb_pb + del_body_by_type + DEL_NATIVE + DEPENDS_PAT_MOD + DEPENDS_PAT_MODS + DEPENDS_SEMANTICS + deprecate + deprecate_disappears_in + DEPRECATED_OPENING_NON_UTF8_BRACKETS + DEPRECATED_OPENING_UTF8_BRACKETS + deprecate_fatal_in + DIE + DISABLE_LC_NUMERIC_CHANGES + dJMPENV + djSP + DM_ARRAY_ISA + DM_DELAY + DM_EGID + DM_EUID + DM_GID + DM_RGID + DM_RUID + DM_UID + dMY_CXT_INTERP + do_aexec + do_exec + DOSISH + DOUBLE_BIG_ENDIAN + DOUBLE_HAS_INF + DOUBLE_HAS_NAN + DOUBLE_IS_IEEE_FORMAT + DOUBLE_IS_VAX_FLOAT + DOUBLE_LITTLE_ENDIAN + DOUBLE_MIX_ENDIAN + DOUBLE_VAX_ENDIAN + dPOPiv + dPOPnv + dPOPnv_nomg + dPOPPOPiirl + dPOPPOPnnrl + dPOPPOPssrl + dPOPss + dPOPTOPiirl + dPOPTOPiirl_nomg + dPOPTOPiirl_ul_nomg + dPOPTOPnnrl + dPOPTOPnnrl_nomg + dPOPTOPssrl + dPOPuv + dPOPXiirl + dPOPXiirl_ul_nomg + dPOPXnnrl + dPOPXssrl + DPTR2FPTR + dSAVE_ERRNO + dSS_ADD + dTARG + dTARGETSTACKED + dTHX_DEBUGGING + dTHXo + dTHXs + dTHXx + dTOPiv + dTOPnv + dTOPss + dTOPuv + DUMP_FEATURE_BITS + DUMPUNTIL + DUP_WARNINGS + dXSUB_SYS + eC + eI + EIGHT_BIT_UTF8_TO_NATIVE + ELEMENT_RANGE_MATCHES_INVLIST + EMBEDMYMALLOC + EMULATE_THREAD_SAFE_LOCALES + END + ENDGRENT_R_HAS_FPTR + ENDLIKE + ENDLIKE_t8 + ENDLIKE_t8_p8 + ENDLIKE_t8_pb + ENDLIKE_tb + ENDLIKE_tb_p8 + ENDLIKE_tb_pb + ENDPWENT_R_HAS_FPTR + END_t8 + END_t8_p8 + END_t8_pb + END_tb + END_tb_p8 + END_tb_pb + ENV_INIT + environ + ENV_LOCK + ENV_READ_LOCK + ENV_READ_UNLOCK + ENVr_LOCALEr_LOCK + ENVr_LOCALEr_UNLOCK + ENV_TERM + ENV_UNLOCK + EOL + EOL_t8 + EOL_t8_p8 + EOL_t8_pb + EOL_tb + EOL_tb_p8 + EOL_tb_pb + EOS + EOS_t8 + EOS_t8_p8 + EOS_t8_pb + EOS_tb + EOS_tb_p8 + EOS_tb_pb + ESC_NATIVE + EVAL + EVAL_B + EVAL_B_fail + EVAL_B_fail_t8 + EVAL_B_fail_t8_p8 + EVAL_B_fail_t8_pb + EVAL_B_fail_tb + EVAL_B_fail_tb_p8 + EVAL_B_fail_tb_pb + EVAL_B_t8 + EVAL_B_t8_p8 + EVAL_B_t8_pb + EVAL_B_tb + EVAL_B_tb_p8 + EVAL_B_tb_pb + EVAL_FLAGS_MASK + EVAL_INEVAL + EVAL_INREQUIRE + EVAL_KEEPERR + EVAL_NULL + EVAL_OPTIMISTIC_FLAG + EVAL_postponed_AB + EVAL_postponed_AB_fail + EVAL_postponed_AB_fail_t8 + EVAL_postponed_AB_fail_t8_p8 + EVAL_postponed_AB_fail_t8_pb + EVAL_postponed_AB_fail_tb + EVAL_postponed_AB_fail_tb_p8 + EVAL_postponed_AB_fail_tb_pb + EVAL_postponed_AB_t8 + EVAL_postponed_AB_t8_p8 + EVAL_postponed_AB_t8_pb + EVAL_postponed_AB_tb + EVAL_postponed_AB_tb_p8 + EVAL_postponed_AB_tb_pb + EVAL_RE_REPARSING + EVAL_t8 + EVAL_t8_p8 + EVAL_t8_pb + EVAL_tb + EVAL_tb_p8 + EVAL_tb_pb + EVAL_WARNONLY + EXACT + EXACTF + EXACTFAA + EXACTFAA_NO_TRIE + EXACTFAA_NO_TRIE_t8 + EXACTFAA_NO_TRIE_t8_p8 + EXACTFAA_NO_TRIE_t8_pb + EXACTFAA_NO_TRIE_tb + EXACTFAA_NO_TRIE_tb_p8 + EXACTFAA_NO_TRIE_tb_pb + EXACTFAA_t8 + EXACTFAA_t8_p8 + EXACTFAA_t8_pb + EXACTFAA_tb + EXACTFAA_tb_p8 + EXACTFAA_tb_pb + EXACTFL + EXACTFL_t8 + EXACTFL_t8_p8 + EXACTFL_t8_pb + EXACTFL_tb + EXACTFL_tb_p8 + EXACTFL_tb_pb + EXACTFLU8 + EXACTFLU8_t8 + EXACTFLU8_t8_p8 + EXACTFLU8_t8_pb + EXACTFLU8_tb + EXACTFLU8_tb_p8 + EXACTFLU8_tb_pb + EXACTF_t8 + EXACTF_t8_p8 + EXACTF_t8_pb + EXACTF_tb + EXACTF_tb_p8 + EXACTF_tb_pb + EXACTFU + EXACTFUP + EXACTFUP_t8 + EXACTFUP_t8_p8 + EXACTFUP_t8_pb + EXACTFUP_tb + EXACTFUP_tb_p8 + EXACTFUP_tb_pb + EXACTFU_REQ8 + EXACTFU_REQ8_t8 + EXACTFU_REQ8_t8_p8 + EXACTFU_REQ8_t8_pb + EXACTFU_REQ8_tb + EXACTFU_REQ8_tb_p8 + EXACTFU_REQ8_tb_pb + EXACTFU_S_EDGE + EXACTFU_S_EDGE_t8 + EXACTFU_S_EDGE_t8_p8 + EXACTFU_S_EDGE_t8_pb + EXACTFU_S_EDGE_tb + EXACTFU_S_EDGE_tb_p8 + EXACTFU_S_EDGE_tb_pb + EXACTFU_t8 + EXACTFU_t8_p8 + EXACTFU_t8_pb + EXACTFU_tb + EXACTFU_tb_p8 + EXACTFU_tb_pb + EXACTL + EXACTL_t8 + EXACTL_t8_p8 + EXACTL_t8_pb + EXACTL_tb + EXACTL_tb_p8 + EXACTL_tb_pb + EXACT_REQ8 + EXACT_REQ8_t8 + EXACT_REQ8_t8_p8 + EXACT_REQ8_t8_pb + EXACT_REQ8_tb + EXACT_REQ8_tb_p8 + EXACT_REQ8_tb_pb + EXACT_t8 + EXACT_t8_p8 + EXACT_t8_pb + EXACT_tb + EXACT_tb_p8 + EXACT_tb_pb + EXEC_PAT_MOD + EXEC_PAT_MODS + EXPECT + EXPERIMENTAL_INPLACESCAN + EXTEND_HWM_SET + EXTEND_MORTAL + EXTEND_SKIP + EXT_MGVTBL + EXT_PAT_MODS + EXTRA_CLOSING_NON_UTF8_BRACKETS + EXTRA_CLOSING_UTF8_BRACKETS + EXTRA_OPENING_NON_UTF8_BRACKETS + EXTRA_OPENING_UTF8_BRACKETS + EXTRA_SIZE + FAIL + FAIL2 + FAIL3 + FAKE_BIT_BUCKET + FAKE_DEFAULT_SIGNAL_HANDLERS + FAKE_PERSISTENT_SIGNAL_HANDLERS + FALSE + FATAL_ABOVE_FF_MSG + F_atan2_amg + FBMcf_TAIL + FBMcf_TAIL_DOLLAR + FBMcf_TAIL_DOLLARM + FBMcf_TAIL_z + FBMcf_TAIL_Z + FBMrf_MULTILINE + F_cos_amg + FEATURE_APOS_AS_NAME_SEP_BIT + FEATURE_APOS_AS_NAME_SEP_INDEX + FEATURE_APOS_AS_NAME_SEP_IS_ENABLED + FEATURE_BAREWORD_FILEHANDLES_BIT + FEATURE_BAREWORD_FILEHANDLES_INDEX + FEATURE_BAREWORD_FILEHANDLES_IS_ENABLED + FEATURE_BITWISE_BIT + FEATURE_BITWISE_INDEX + FEATURE_BITWISE_IS_ENABLED + FEATURE_BUNDLE_510 + FEATURE_BUNDLE_511 + FEATURE_BUNDLE_515 + FEATURE_BUNDLE_523 + FEATURE_BUNDLE_527 + FEATURE_BUNDLE_535 + FEATURE_BUNDLE_537 + FEATURE_BUNDLE_539 + FEATURE_BUNDLE_541 + FEATURE_BUNDLE_CUSTOM + FEATURE_BUNDLE_DEFAULT + FEATURE_CLASS_BIT + FEATURE_CLASS_INDEX + FEATURE_CLASS_IS_ENABLED + FEATURE_DEFER_BIT + FEATURE_DEFER_INDEX + FEATURE_DEFER_IS_ENABLED + FEATURE_EVALBYTES_BIT + FEATURE_EVALBYTES_INDEX + FEATURE_EVALBYTES_IS_ENABLED + FEATURE_FC_BIT + FEATURE_FC_INDEX + FEATURE_FC_IS_ENABLED + FEATURE_INDIRECT_BIT + FEATURE_INDIRECT_INDEX + FEATURE_INDIRECT_IS_ENABLED + FEATURE_ISA_BIT + FEATURE_ISA_INDEX + FEATURE_ISA_IS_ENABLED + FEATURE_IS_ENABLED_MASK + FEATURE_KEYWORD_ALL_BIT + FEATURE_KEYWORD_ALL_INDEX + FEATURE_KEYWORD_ALL_IS_ENABLED + FEATURE_KEYWORD_ANY_BIT + FEATURE_KEYWORD_ANY_INDEX + FEATURE_KEYWORD_ANY_IS_ENABLED + FEATURE_MODULE_TRUE_BIT + FEATURE_MODULE_TRUE_INDEX + FEATURE_MODULE_TRUE_IS_ENABLED + FEATURE_MORE_DELIMS_BIT + FEATURE_MORE_DELIMS_INDEX + FEATURE_MORE_DELIMS_IS_ENABLED + FEATURE_MULTIDIMENSIONAL_BIT + FEATURE_MULTIDIMENSIONAL_INDEX + FEATURE_MULTIDIMENSIONAL_IS_ENABLED + FEATURE_MYREF_BIT + FEATURE_MYREF_INDEX + FEATURE_MYREF_IS_ENABLED + FEATURE_POSTDEREF_QQ_BIT + FEATURE_POSTDEREF_QQ_INDEX + FEATURE_POSTDEREF_QQ_IS_ENABLED + FEATURE_REFALIASING_BIT + FEATURE_REFALIASING_INDEX + FEATURE_REFALIASING_IS_ENABLED + FEATURE_SAY_BIT + FEATURE_SAY_INDEX + FEATURE_SAY_IS_ENABLED + FEATURE_SIGNATURES_BIT + FEATURE_SIGNATURES_INDEX + FEATURE_SIGNATURES_IS_ENABLED + FEATURE_SMARTMATCH_BIT + FEATURE_SMARTMATCH_INDEX + FEATURE_SMARTMATCH_IS_ENABLED + FEATURE_STATE_BIT + FEATURE_STATE_INDEX + FEATURE_STATE_IS_ENABLED + FEATURE___SUB___BIT + FEATURE___SUB___INDEX + FEATURE___SUB___IS_ENABLED + FEATURE_SWITCH_BIT + FEATURE_SWITCH_INDEX + FEATURE_SWITCH_IS_ENABLED + FEATURE_TRY_BIT + FEATURE_TRY_INDEX + FEATURE_TRY_IS_ENABLED + FEATURE_UNICODE_BIT + FEATURE_UNICODE_INDEX + FEATURE_UNICODE_IS_ENABLED + FEATURE_UNIEVAL_BIT + FEATURE_UNIEVAL_INDEX + FEATURE_UNIEVAL_IS_ENABLED + FETCHFEATUREBITSHH + F_exp_amg + FF_0DECIMAL + FF_BLANK + FF_CHECKCHOP + FF_CHECKNL + FF_CHOP + FF_DECIMAL + FF_END + FF_FETCH + FF_HALFSPACE + FF_ITEM + FF_LINEGLOB + FF_LINEMARK + FF_LINESNGL + FF_LITERAL + Fflush + FF_MORE + FF_NEWLINE + FF_SKIP + FF_SPACE + FILL_ADVANCE_NODE + FILL_ADVANCE_NODE_2ui_ARG + FILL_ADVANCE_NODE_ARG1u + FILL_ADVANCE_NODE_ARGp + FILL_NODE + FILTER_DATA + FILTER_ISREADER + FILTER_READ + FIND_RUNCV_level_eq + FIND_RUNCV_padid_eq + FIRST_BYTE + FIRST_NON_ASCII_DECIMAL_DIGIT + first_upper_bit_set_byte_number + FIT_ARENA + FIT_ARENA0 + FIT_ARENAn + FITS_IN_8_BITS + FLAGS + float_end_shift + float_max_offset + float_min_offset + float_substr + float_utf8 + F_log_amg + FmLINES + FOLD + FOLD_FLAGS_FULL + FOLD_FLAGS_LOCALE + FOLD_FLAGS_NOMIX_ASCII + F_pow_amg + FP_PINF + FP_QNAN + FPTR2DPTR + free_and_set_cop_warnings + free_c_backtrace + FreeOp + FROM_INTERNAL_SIZE + F_sin_amg + F_sqrt_amg + FULL_TRIE_STUDY + fwrite1 + G_ARRAY + GCC_DIAG_IGNORE + GCC_DIAG_IGNORE_DECL + GCC_DIAG_IGNORE_STMT + GCC_DIAG_PRAGMA + GCC_DIAG_RESTORE + GCC_DIAG_RESTORE_DECL + GCC_DIAG_RESTORE_STMT + GETATARGET + GETENV_LOCK + GETENV_UNLOCK + get_extended_os_errno + GETGRENT_R_HAS_BUFFER + GETGRENT_R_HAS_FPTR + GETGRENT_R_HAS_PTR + GETGRGID_R_HAS_BUFFER + GETGRGID_R_HAS_PTR + GETGRNAM_R_HAS_BUFFER + GETGRNAM_R_HAS_PTR + GETHOSTBYADDR_LOCK + GETHOSTBYADDR_R_HAS_BUFFER + GETHOSTBYADDR_R_HAS_ERRNO + GETHOSTBYADDR_R_HAS_PTR + GETHOSTBYADDR_UNLOCK + GETHOSTBYNAME_LOCK + GETHOSTBYNAME_R_HAS_BUFFER + GETHOSTBYNAME_R_HAS_ERRNO + GETHOSTBYNAME_R_HAS_PTR + GETHOSTBYNAME_UNLOCK + GETHOSTENT_R_HAS_BUFFER + GETHOSTENT_R_HAS_ERRNO + GETHOSTENT_R_HAS_PTR + GETNETBYADDR_LOCK + GETNETBYADDR_R_HAS_BUFFER + GETNETBYADDR_R_HAS_ERRNO + GETNETBYADDR_R_HAS_PTR + GETNETBYADDR_UNLOCK + GETNETBYNAME_LOCK + GETNETBYNAME_R_HAS_BUFFER + GETNETBYNAME_R_HAS_ERRNO + GETNETBYNAME_R_HAS_PTR + GETNETBYNAME_UNLOCK + GETNETENT_R_HAS_BUFFER + GETNETENT_R_HAS_ERRNO + GETNETENT_R_HAS_PTR + GETPROTOBYNAME_LOCK + GETPROTOBYNAME_R_HAS_BUFFER + GETPROTOBYNAME_R_HAS_PTR + GETPROTOBYNAME_UNLOCK + GETPROTOBYNUMBER_LOCK + GETPROTOBYNUMBER_R_HAS_BUFFER + GETPROTOBYNUMBER_R_HAS_PTR + GETPROTOBYNUMBER_UNLOCK + GETPROTOENT_LOCK + GETPROTOENT_R_HAS_BUFFER + GETPROTOENT_R_HAS_PTR + GETPROTOENT_UNLOCK + GETPWENT_R_HAS_BUFFER + GETPWENT_R_HAS_FPTR + GETPWENT_R_HAS_PTR + GETPWNAM_LOCK + GETPWNAM_R_HAS_BUFFER + GETPWNAM_R_HAS_PTR + GETPWNAM_UNLOCK + GETPWUID_LOCK + GETPWUID_R_HAS_PTR + GETPWUID_UNLOCK + GET_REGCLASS_AUX_DATA + GETSERVBYNAME_LOCK + GETSERVBYNAME_R_HAS_BUFFER + GETSERVBYNAME_R_HAS_PTR + GETSERVBYNAME_UNLOCK + GETSERVBYPORT_LOCK + GETSERVBYPORT_R_HAS_BUFFER + GETSERVBYPORT_R_HAS_PTR + GETSERVBYPORT_UNLOCK + GETSERVENT_LOCK + GETSERVENT_R_HAS_BUFFER + GETSERVENT_R_HAS_PTR + GETSERVENT_UNLOCK + GETSPNAM_LOCK + GETSPNAM_R_HAS_BUFFER + GETSPNAM_R_HAS_PTR + GETSPNAM_UNLOCK + GETTARGET + GETTARGETSTACKED + G_FAKINGEVAL + GLOBAL_PAT_MOD + GMTIME_LOCK + GMTIME_UNLOCK + G_NODEBUG + GOSUB + GOSUB_t8 + GOSUB_t8_p8 + GOSUB_t8_pb + GOSUB_tb + GOSUB_tb_p8 + GOSUB_tb_pb + GPOS + GPOS_t8 + GPOS_t8_p8 + GPOS_t8_pb + GPOS_tb + GPOS_tb_p8 + GPOS_tb_pb + GREEK_CAPITAL_LETTER_MU + GREEK_SMALL_LETTER_MU + G_RE_REPARSING + GROUPP + GROUPPN + GROUPPN_t8 + GROUPPN_t8_p8 + GROUPPN_t8_pb + GROUPPN_tb + GROUPPN_tb_p8 + GROUPPN_tb_pb + GROUPP_t8 + GROUPP_t8_p8 + GROUPP_t8_pb + GROUPP_tb + GROUPP_tb_p8 + GROUPP_tb_pb + G_UNDEF_FILL + Gv_AMG + GvASSUMECV + GvASSUMECV_off + GvASSUMECV_on + GV_AUTOLOAD + GvAVn + GV_CROAK + GvCVGEN + GvCV_set + GvCVu + gv_dup + gv_dup_inc + GvEGV + GvEGVx + GvENAME + GvENAME_HEK + GvENAMELEN + GvENAMEUTF8 + GvESTASH + GVf_ASSUMECV + gv_fetchmethod_flags + GvFILE + GvFILEGV + GvFILE_HEK + GvFILEx + GVf_IMPORTED + GVf_IMPORTED_AV + GVf_IMPORTED_CV + GVf_IMPORTED_HV + GVf_IMPORTED_SV + GVf_INTRO + GvFLAGS + GVf_MULTI + GVF_NOADD + GVf_ONCE_FATAL + GvFORM + GVf_RESERVED + GvGP + GvGPFLAGS + GvGP_set + GvHVn + GvIMPORTED + GvIMPORTED_AV + GvIMPORTED_AV_off + GvIMPORTED_AV_on + GvIMPORTED_CV + GvIMPORTED_CV_off + GvIMPORTED_CV_on + GvIMPORTED_HV + GvIMPORTED_HV_off + GvIMPORTED_HV_on + GvIMPORTED_off + GvIMPORTED_on + GvIMPORTED_SV + GvIMPORTED_SV_off + GvIMPORTED_SV_on + GvIN_PAD + GvIN_PAD_off + GvIN_PAD_on + GvINTRO + GvINTRO_off + GvINTRO_on + GvIO + GvIOn + GvIOp + GvLINE + gv_method_changed + GvMULTI + GvMULTI_off + GvMULTI_on + GvNAME + GvNAME_get + GvNAME_HEK + GvNAMELEN + GvNAMELEN_get + GvNAMEUTF8 + GV_NOADD_MASK + GvONCE_FATAL + GvONCE_FATAL_off + GvONCE_FATAL_on + GvREFCNT + GvSTASH + GvXPVGV + G_WANT + G_WARN_ALL_MASK + G_WARN_ALL_OFF + G_WARN_ALL_ON + G_WARN_OFF + G_WARN_ON + G_WARN_ONCE + gwENVr_LOCALEr_LOCK + gwENVr_LOCALEr_UNLOCK + gwLOCALE_LOCK + gwLOCALEr_LOCK + gwLOCALEr_UNLOCK + gwLOCALE_UNLOCK + G_WRITING_TO_STDERR + HADNV + HASARENA + HASATTRIBUTE_ALWAYS_INLINE + HASATTRIBUTE_DEPRECATED + HASATTRIBUTE_FORMAT + HASATTRIBUTE_MALLOC + HASATTRIBUTE_NONNULL + HASATTRIBUTE_NORETURN + HASATTRIBUTE_PURE + HASATTRIBUTE_UNUSED + HASATTRIBUTE_VISIBILITY + HASATTRIBUTE_WARN_UNUSED_RESULT + HAS_BUILTIN_UNREACHABLE + HAS_C99 + HAS_CHOWN + HAS_EXTENDED_OS_ERRNO + HAS_EXTRA_LONG_UTF8 + HAS_GROUP + HAS_IOCTL + HAS_KILL + HAS_NONLATIN1_FOLD_CLOSURE + HAS_NONLATIN1_SIMPLE_FOLD_CLOSURE + HAS_PASSWD + HAS_POSIX_2008_LOCALE + HAS_PTHREAD_UNCHECKED_GETSPECIFIC_NP + HAS_UTIME + HAS_WAIT + hasWARNBIT + HASWIDTH + HE_ARENA_ROOT_IX + HEK_BASESIZE + HeKEY_hek + HeKEY_sv + HEKfARG + HeKFLAGS + HEK_FLAGS + HEK_HASH + HEK_KEY + HEK_LEN + HeKLEN_UTF8 + HeKUTF8 + HEK_UTF8 + HEK_UTF8_off + HEK_UTF8_on + HeKWASUTF8 + HEK_WASUTF8 + HEK_WASUTF8_off + HEK_WASUTF8_on + HeNEXT + HIGHEST_ANYOF_HRx_BYTE + HIGHEST_CASE_CHANGING_CP + HINT_ALL_STRICT + HINT_ASCII_ENCODING + HINT_BLOCK_SCOPE + HINT_BYTES + HINT_EXPLICIT_STRICT_REFS + HINT_EXPLICIT_STRICT_SUBS + HINT_EXPLICIT_STRICT_VARS + HINT_FEATURE_MASK + HINT_FEATURE_SHIFT + HINT_FILETEST_ACCESS + HINT_INTEGER + HINT_LEXICAL_IO_IN + HINT_LEXICAL_IO_OUT + HINT_LOCALE + HINT_LOCALIZE_HH + HINT_NEW_BINARY + HINT_NEW_FLOAT + HINT_NEW_INTEGER + HINT_NEW_RE + HINT_NEW_STRING + HINT_NO_AMAGIC + HINT_RE_EVAL + HINT_RE_FLAGS + HINT_RE_TAINT + HINTS_DEFAULT + HINTS_REFCNT_INIT + HINTS_REFCNT_LOCK + HINTS_REFCNT_TERM + HINTS_REFCNT_UNLOCK + HINT_STRICT_REFS + HINT_STRICT_SUBS + HINT_STRICT_VARS + HINT_UNI_8_BIT + HINT_UTF8 + HS_APIVERLEN_MAX + HS_CXT + HSf_IMP_CXT + HSf_NOCHK + HSf_POPMARK + HSf_SETXSUBFN + HS_GETAPIVERLEN + HS_GETINTERPSIZE + HS_GETXSVERLEN + HS_KEY + HS_KEYp + HSm_APIVERLEN + HSm_INTRPSIZE + HSm_KEY_MATCH + HSm_XSVERLEN + HS_XSVERLEN_MAX + htoni + htonl + htons + htovl + htovs + HvAMAGIC + HvAMAGIC_off + HvAMAGIC_on + HvARRAY + HvAUX + HVAUX_ARENA_ROOT_IX + HvAUXf_IS_CLASS + HvAUXf_NO_DEREF + HvAUXf_SCAN_STASH + HV_DELETE + hv_deletehek + HV_DISABLE_UVAR_XKEY + hv_dup + hv_dup_inc + HvEITER + HvEITER_get + HvEITER_set + HvENAME_get + HvENAME_HEK + HvENAME_HEK_NN + HvENAMELEN_get + hv_existshek + HV_FETCH_EMPTY_HE + hv_fetchhek + HV_FETCH_ISEXISTS + HV_FETCH_ISSTORE + HV_FETCH_JUST_SV + HV_FETCH_LVALUE + HvHasENAME + HvHasENAME_HEK + HvHASKFLAGS + HvHASKFLAGS_off + HvHASKFLAGS_on + HvHasNAME + HVhek_ENABLEHVKFLAGS + HVhek_FREEKEY + HVhek_KEYCANONICAL + HVhek_NOTSHARED + HVhek_PLACEHOLD + HVhek_UTF8 + HVhek_WASUTF8 + HvKEYS + HvLASTRAND_get + HvLAZYDEL + HvLAZYDEL_off + HvLAZYDEL_on + HvMAX + HvNAME_HEK_NN + HvPLACEHOLDERS + HvPLACEHOLDERS_get + HvPLACEHOLDERS_set + HvRAND_get + HVrhek_delete + HVrhek_IV + HVrhek_PV + HVrhek_PV_UTF8 + HVrhek_typemask + HVrhek_undef + HVrhek_UV + HvRITER + HvRITER_get + HvRITER_set + HvSHAREKEYS + HvSHAREKEYS_off + HvSHAREKEYS_on + HvSTASH_IS_CLASS + hv_storehek + HvTOTALKEYS + HvUSEDKEYS + HYPHEN_UTF8 + I16_MAX + I16_MIN + I32_MAX + I32_MAX_P1 + I32_MIN + I8_TO_NATIVE + I8_TO_NATIVE_UTF8 + IFMATCH + IFMATCH_A + IFMATCH_A_fail + IFMATCH_A_fail_t8 + IFMATCH_A_fail_t8_p8 + IFMATCH_A_fail_t8_pb + IFMATCH_A_fail_tb + IFMATCH_A_fail_tb_p8 + IFMATCH_A_fail_tb_pb + IFMATCH_A_t8 + IFMATCH_A_t8_p8 + IFMATCH_A_t8_pb + IFMATCH_A_tb + IFMATCH_A_tb_p8 + IFMATCH_A_tb_pb + IFMATCH_t8 + IFMATCH_t8_p8 + IFMATCH_t8_pb + IFMATCH_tb + IFMATCH_tb_p8 + IFMATCH_tb_pb + IFTHEN + IFTHEN_t8 + IFTHEN_t8_p8 + IFTHEN_t8_pb + IFTHEN_tb + IFTHEN_tb_p8 + IFTHEN_tb_pb + IGNORE_PAT_MOD + I_LIMITS + ILLEGAL_UTF8_BYTE + IN_BYTES + INCMARK + INFNAN_NV_U8_DECL + INFNAN_U8_NV_DECL + init_os_extras + INIT_TRACK_MEMPOOL + IN_LC + IN_LC_ALL_COMPILETIME + IN_LC_ALL_RUNTIME + IN_LC_COMPILETIME + IN_LC_PARTIAL_COMPILETIME + IN_LC_PARTIAL_RUNTIME + IN_LC_RUNTIME + IN_PARENS_PASS + inRANGE + IN_SOME_LOCALE_FORM + IN_SOME_LOCALE_FORM_COMPILETIME + IN_SOME_LOCALE_FORM_RUNTIME + INSUBP + INSUBP_t8 + INSUBP_t8_p8 + INSUBP_t8_pb + INSUBP_tb + INSUBP_tb_p8 + INSUBP_tb_pb + INT32_MIN + INT_64_T + INT_PAT_MODS + IN_UNI_8_BIT + IN_UTF8_CTYPE_LOCALE + IN_UTF8_TURKIC_LOCALE + INVLIST_INDEX + IoANY + io_dup + io_dup_inc + IOf_ARGV + IOf_DIDTOP + IOf_FAKE_DIRP + IOf_NOLINE + IOf_START + IoTYPE_APPEND + IoTYPE_CLOSED + IoTYPE_IMPLICIT + IoTYPE_NUMERIC + IoTYPE_PIPE + IoTYPE_RDONLY + IoTYPE_RDWR + IoTYPE_SOCKET + IoTYPE_STD + IoTYPE_WRONLY + isALNUMC_LC_utf8_safe + isALNUMC_uni + isALNUMC_utf8 + isALNUMC_utf8_safe + isALNUM_lazy_if_safe + isALNUM_LC_utf8 + isALNUM_LC_utf8_safe + isALNUMU + isALNUM_uni + isALNUM_utf8 + isALNUM_utf8_safe + isALPHA_FOLD_EQ + isALPHA_FOLD_NE + isALPHA_LC_utf8 + isALPHANUMERIC_LC_utf8 + isALPHANUMERIC_uni + isALPHAU + isALPHA_uni + is_ANYOF_SYNTHETIC + IS_ANYOF_TRIE + isASCII_LC_utf8 + isASCII_uni + ISA_VERSION_OBJ + isBACKSLASHED_PUNCT + isBLANK_LC_uni + isBLANK_LC_utf8 + isBLANK_uni + isCASED_LC + isCHARNAME_CONT + isCNTRL_LC_utf8 + isCNTRL_uni + isDEBUG_WILDCARD + isDIGIT_LC_utf8 + isDIGIT_uni + isEXACTFish + isEXACT_REQ8 + is_FOLDS_TO_MULTI_utf8 + isGRAPH_LC_utf8 + isGRAPH_uni + isGV + isGV_or_RVCV + isGV_with_GP_off + isGV_with_GP_on + is_HANGUL_ED_utf8_safe + is_HORIZWS_cp_high + is_HORIZWS_high + isIDCONT_lazy_if_safe + isIDCONT_LC_utf8 + isIDCONT_uni + isIDFIRST_lazy_if_safe + isIDFIRST_LC_utf8 + isIDFIRST_uni + IS_IN_SOME_FOLD_L1 + is_LARGER_NON_CHARS_utf8 + isLEXWARN_off + isLEXWARN_on + is_LNBREAK_latin1_safe + is_LNBREAK_safe + is_LNBREAK_utf8_safe + isLOWER_LC_utf8 + isLOWER_uni + isMNEMONIC_CNTRL + is_MULTI_CHAR_FOLD_latin1_safe + is_MULTI_CHAR_FOLD_utf8_safe + isNON_BRACE_QUANTIFIER + is_NONCHAR_utf8_safe + IS_NON_FINAL_FOLD + isnormal + IS_NUMERIC_RADIX + IS_PADCONST + IS_PADGV + is_PATWS_safe + is_posix_ALPHA + is_posix_ALPHANUMERIC + is_posix_ASCII + is_posix_BLANK + is_posix_CASED + is_posix_CNTRL + is_posix_DIGIT + is_posix_GRAPH + is_posix_IDFIRST + is_posix_LOWER + is_posix_PRINT + is_posix_PUNCT + is_posix_SPACE + is_posix_UPPER + is_posix_WORDCHAR + is_posix_XDIGIT + isPOWER_OF_2 + isPRINT_LC_utf8 + isPRINT_uni + is_PROBLEMATIC_LOCALE_FOLD_cp + is_PROBLEMATIC_LOCALE_FOLDEDS_START_cp + is_PROBLEMATIC_LOCALE_FOLDEDS_START_utf8 + is_PROBLEMATIC_LOCALE_FOLD_utf8 + isPSXSPC_LC_utf8 + isPSXSPC_uni + isPUNCT_LC_utf8 + isPUNCT_uni + isQUANTIFIER + isQUOTEMETA + is_QUOTEMETA_high + isREGEXP + IS_SAFE_PATHNAME + IS_SAFE_SYSCALL + is_SHORTER_NON_CHARS_utf8 + isSPACE_LC_utf8 + isSPACE_uni + is_SPACE_utf8_safe_backwards + is_SURROGATE_utf8 + is_SURROGATE_utf8_safe + I_STDARG + is_THREE_CHAR_FOLD_HEAD_latin1_safe + is_THREE_CHAR_FOLD_HEAD_utf8_safe + is_THREE_CHAR_FOLD_latin1_safe + is_THREE_CHAR_FOLD_utf8_safe + IS_TRIE_AC + isU8_ALPHA_LC + isU8_ALPHANUMERIC_LC + isU8_ASCII_LC + isU8_BLANK_LC + isU8_CASED_LC + isU8_CNTRL_LC + isU8_DIGIT_LC + isU8_GRAPH_LC + isU8_IDFIRST_LC + isU8_LOWER_LC + isU8_PRINT_LC + isU8_PUNCT_LC + isU8_SPACE_LC + isU8_UPPER_LC + isU8_WORDCHAR_LC + isU8_XDIGIT_LC + isUNICODE_POSSIBLY_PROBLEMATIC + isUPPER_LC_utf8 + isUPPER_uni + IS_UTF8_CHAR + isUTF8_POSSIBLY_PROBLEMATIC + is_VERTWS_cp_high + is_VERTWS_high + isVERTWS_uni + isVERTWS_utf8 + isVERTWS_utf8_safe + isVERTWS_uvchr + isWARNf_on + isWARN_on + isWARN_ONCE + isWORDCHAR_lazy_if_safe + isWORDCHAR_LC_utf8 + isWORDCHAR_uni + is_XDIGIT_cp_high + is_XDIGIT_high + isXDIGIT_LC_utf8 + isXDIGIT_uni + IV_DIG + IV_MAX_P1 + JE_OLD_STACK_HWM_restore + JE_OLD_STACK_HWM_save + JE_OLD_STACK_HWM_zero + JMPENV_BOOTSTRAP + JMPENV_POP + kBINOP + kCOP + KEEPCOPY_PAT_MOD + KEEPCOPY_PAT_MODS + KEEPS + KEEPS_next + KEEPS_next_fail + KEEPS_next_fail_t8 + KEEPS_next_fail_t8_p8 + KEEPS_next_fail_t8_pb + KEEPS_next_fail_tb + KEEPS_next_fail_tb_p8 + KEEPS_next_fail_tb_pb + KEEPS_next_t8 + KEEPS_next_t8_p8 + KEEPS_next_t8_pb + KEEPS_next_tb + KEEPS_next_tb_p8 + KEEPS_next_tb_pb + KEEPS_t8 + KEEPS_t8_p8 + KEEPS_t8_pb + KEEPS_tb + KEEPS_tb_p8 + KEEPS_tb_pb + KELVIN_SIGN + KERNEL + KEY_abs + KEY_accept + KEY_ADJUST + KEY_alarm + KEY_all + KEY_and + KEY_any + KEY_atan2 + KEY_AUTOLOAD + KEY_BEGIN + KEY_bind + KEY_binmode + KEY_bless + KEY_break + KEY_caller + KEY_catch + KEY_chdir + KEY_CHECK + KEY_chmod + KEY_chomp + KEY_chop + KEY_chown + KEY_chr + KEY_chroot + KEY_class + KEY_close + KEY_closedir + KEY_cmp + KEY_connect + KEY_continue + KEY_cos + KEY_crypt + KEY_dbmclose + KEY_dbmopen + KEY_default + KEY_defer + KEY_defined + KEY_delete + KEY_DESTROY + KEY_die + KEY_do + KEY_dump + KEY_each + KEY_else + KEY_elsif + KEY_END + KEY_endgrent + KEY_endhostent + KEY_endnetent + KEY_endprotoent + KEY_endpwent + KEY_endservent + KEY_eof + KEY_eq + KEY_eval + KEY_evalbytes + KEY_exec + KEY_exists + KEY_exit + KEY_exp + KEY_fc + KEY_fcntl + KEY_field + KEY_fileno + KEY_finally + KEY_flock + KEY_for + KEY_foreach + KEY_fork + KEY_format + KEY_formline + KEY_ge + KEY_getc + KEY_getgrent + KEY_getgrgid + KEY_getgrnam + KEY_gethostbyaddr + KEY_gethostbyname + KEY_gethostent + KEY_getlogin + KEY_getnetbyaddr + KEY_getnetbyname + KEY_getnetent + KEY_getpeername + KEY_getpgrp + KEY_getppid + KEY_getpriority + KEY_getprotobyname + KEY_getprotobynumber + KEY_getprotoent + KEY_getpwent + KEY_getpwnam + KEY_getpwuid + KEY_getservbyname + KEY_getservbyport + KEY_getservent + KEY_getsockname + KEY_getsockopt + KEY_getspnam + KEY_given + KEY_glob + KEY_gmtime + KEY_goto + KEY_grep + KEY_gt + KEY_hex + KEY_if + KEY_index + KEY_INIT + KEY_int + KEY_ioctl + KEY_isa + KEY_join + KEY_keys + KEY_kill + KEY_last + KEY_lc + KEY_lcfirst + KEY_le + KEY_length + KEY_link + KEY_listen + KEY_local + KEY_localtime + KEY_lock + KEY_log + KEY_lstat + KEY_lt + KEY_m + KEY_map + KEY_method + KEY_mkdir + KEY_msgctl + KEY_msgget + KEY_msgrcv + KEY_msgsnd + KEY_my + KEY_ne + KEY_next + KEY_no + KEY_not + KEY_NULL + KEY_oct + KEY_open + KEY_opendir + KEY_or + KEY_ord + KEY_our + KEY_pack + KEY_package + KEY_pipe + KEY_pop + KEY_pos + KEY_print + KEY_printf + KEY_prototype + KEY_push + KEY_q + KEY_qq + KEY_qr + KEY_quotemeta + KEY_qw + KEY_qx + KEY_rand + KEY_read + KEY_readdir + KEY_readline + KEY_readlink + KEY_readpipe + KEY_recv + KEY_redo + KEY_ref + KEY_rename + KEY_require + KEY_reset + KEY_return + KEY_reverse + KEY_rewinddir + KEY_rindex + KEY_rmdir + KEY_s + KEY_say + KEY_scalar + KEY_seek + KEY_seekdir + KEY_select + KEY_semctl + KEY_semget + KEY_semop + KEY_send + KEY_setgrent + KEY_sethostent + KEY_setnetent + KEY_setpgrp + KEY_setpriority + KEY_setprotoent + KEY_setpwent + KEY_setservent + KEY_setsockopt + KEY_shift + KEY_shmctl + KEY_shmget + KEY_shmread + KEY_shmwrite + KEY_shutdown + KEY_sigvar + KEY_sin + KEY_sleep + KEY_socket + KEY_socketpair + KEY_sort + KEY_splice + KEY_split + KEY_sprintf + KEY_sqrt + KEY_srand + KEY_stat + KEY_state + KEY_study + KEY_sub + KEY_substr + KEY_symlink + KEY_syscall + KEY_sysopen + KEY_sysread + KEY_sysseek + KEY_system + KEY_syswrite + KEY_tell + KEY_telldir + KEY_tie + KEY_tied + KEY_time + KEY_times + KEY_tr + KEY_truncate + KEY_try + KEY_uc + KEY_ucfirst + KEY_umask + KEY_undef + KEY_UNITCHECK + KEY_unless + KEY_unlink + KEY_unpack + KEY_unshift + KEY_untie + KEY_until + KEY_use + KEY_utime + KEY_values + KEY_vec + KEY_wait + KEY_waitpid + KEY_wantarray + KEY_warn + KEY_when + KEY_while + KEYWORD_PLUGIN_DECLINE + KEYWORD_PLUGIN_EXPR + KEYWORD_PLUGIN_MUTEX_INIT + KEYWORD_PLUGIN_MUTEX_LOCK + KEYWORD_PLUGIN_MUTEX_TERM + KEYWORD_PLUGIN_MUTEX_UNLOCK + KEYWORD_PLUGIN_STMT + KEY_write + KEY_x + KEY_xor + KEY_y + kGVOP_gv + kLISTOP + kLOGOP + kLOOP + kMETHOP + kPADOP + kPMOP + kPVOP + kSVOP + kSVOP_sv + kUNOP + kUNOP_AUX + LARGE_HASH_HEURISTIC + LATIN_CAPITAL_LETTER_A_WITH_RING_ABOVE + LATIN_CAPITAL_LETTER_A_WITH_RING_ABOVE_NATIVE + LATIN_CAPITAL_LETTER_I_WITH_DOT_ABOVE + LATIN_CAPITAL_LETTER_I_WITH_DOT_ABOVE_UTF8 + LATIN_CAPITAL_LETTER_SHARP_S + LATIN_CAPITAL_LETTER_SHARP_S_UTF8 + LATIN_CAPITAL_LETTER_Y_WITH_DIAERESIS + LATIN_SMALL_LETTER_A_WITH_RING_ABOVE + LATIN_SMALL_LETTER_A_WITH_RING_ABOVE_NATIVE + LATIN_SMALL_LETTER_DOTLESS_I + LATIN_SMALL_LETTER_DOTLESS_I_UTF8 + LATIN_SMALL_LETTER_LONG_S + LATIN_SMALL_LETTER_LONG_S_UTF8 + LATIN_SMALL_LETTER_SHARP_S + LATIN_SMALL_LETTER_SHARP_S_NATIVE + LATIN_SMALL_LETTER_SHARP_S_UTF8 + LATIN_SMALL_LETTER_Y_WITH_DIAERESIS + LATIN_SMALL_LETTER_Y_WITH_DIAERESIS_NATIVE + LATIN_SMALL_LIGATURE_LONG_S_T + LATIN_SMALL_LIGATURE_LONG_S_T_UTF8 + LATIN_SMALL_LIGATURE_ST + LATIN_SMALL_LIGATURE_ST_UTF8 + LC_COLLATE_LOCK + LC_COLLATE_UNLOCK + LC_NUMERIC_UNLOCK + LDBL_DIG + LEAVE_SCOPE + LEXACT + LEXACT_REQ8 + LEXACT_REQ8_t8 + LEXACT_REQ8_t8_p8 + LEXACT_REQ8_t8_pb + LEXACT_REQ8_tb + LEXACT_REQ8_tb_p8 + LEXACT_REQ8_tb_pb + LEXACT_t8 + LEXACT_t8_p8 + LEXACT_t8_pb + LEXACT_tb + LEXACT_tb_p8 + LEXACT_tb_pb + LEX_DONT_CLOSE_RSFP + LEX_EVALBYTES + LEX_IGNORE_UTF8_HINTS + LEX_NOTPARSING + LEX_START_COPIED + LEX_START_FLAGS + LEX_START_SAME_FILTER + LF_NATIVE + LIB_INVARG + LINE_Tf + LNBREAK + LNBREAK_t8 + LNBREAK_t8_p8 + LNBREAK_t8_pb + LNBREAK_tb + LNBREAK_tb_p8 + LNBREAK_tb_pb + LOC + LOCALE_INIT + LOCALE_LOCK + LOCALE_PAT_MOD + LOCALE_PAT_MODS + LOCALE_READ_LOCK + LOCALE_READ_UNLOCK + LOCALE_TERM + LOCALE_UNLOCK + LOCALTIME_LOCK + LOCALTIME_UNLOCK + LOCK_LC_NUMERIC_STANDARD + LOGICAL + LOGICAL_t8 + LOGICAL_t8_p8 + LOGICAL_t8_pb + LOGICAL_tb + LOGICAL_tb_p8 + LOGICAL_tb_pb + LONGDOUBLE_BIG_ENDIAN + LONGDOUBLE_DOUBLEDOUBLE + LONG_DOUBLE_EQUALS_DOUBLE + LONGDOUBLE_LITTLE_ENDIAN + LONGDOUBLE_MIX_ENDIAN + LONGDOUBLE_VAX_ENDIAN + LONGDOUBLE_X86_80_BIT + LONGJMP + LONGJMP_t8 + LONGJMP_t8_p8 + LONGJMP_t8_pb + LONGJMP_tb + LONGJMP_tb_p8 + LONGJMP_tb_pb + LOOKBEHIND_END + LOOKBEHIND_END_t8 + LOOKBEHIND_END_t8_p8 + LOOKBEHIND_END_t8_pb + LOOKBEHIND_END_tb + LOOKBEHIND_END_tb_p8 + LOOKBEHIND_END_tb_pb + LOOP_PAT_MODS + LOWEST_ANYOF_HRx_BYTE + lsbit_pos + LvFLAGS + LVf_NEG_LEN + LVf_NEG_OFF + LVf_OUT_OF_RANGE + LVRET + LvSTARGOFF + LvTARG + LvTARGLEN + LvTARGOFF + LvTYPE + MADE_EXACT_TRIE + MADE_JUMP_TRIE + MADE_TRIE + magic_sethint_feature + MALFORMED_UTF8_DIE + MALFORMED_UTF8_WARN + MALLOC_CHECK_TAINT + MALLOC_CHECK_TAINT2 + MALLOC_INIT + MALLOC_OVERHEAD + MALLOC_TERM + MALLOC_TOO_LATE_FOR + MARKER1 + MARKER2 + MARK_NAUGHTY + MARK_NAUGHTY_EXP + MARKPOINT + MARKPOINT_next + MARKPOINT_next_fail + MARKPOINT_next_fail_t8 + MARKPOINT_next_fail_t8_p8 + MARKPOINT_next_fail_t8_pb + MARKPOINT_next_fail_tb + MARKPOINT_next_fail_tb_p8 + MARKPOINT_next_fail_tb_pb + MARKPOINT_next_t8 + MARKPOINT_next_t8_p8 + MARKPOINT_next_t8_pb + MARKPOINT_next_tb + MARKPOINT_next_tb_p8 + MARKPOINT_next_tb_pb + MARKPOINT_t8 + MARKPOINT_t8_p8 + MARKPOINT_t8_pb + MARKPOINT_tb + MARKPOINT_tb_p8 + MARKPOINT_tb_pb + MAX_ANYOF_HRx_BYTE + MAXARG + MAXARG3 + MAX_CHARSET_NAME_LENGTH + MAX_FEATURE_LEN + MAX_FOLD_FROMS + MAX_LEGAL_CP + MAX_MATCHES + MAXO + MAX_PORTABLE_UTF8_TWO_BYTE + MAX_PRINT_A + MAX_SAVEt + MAX_UNICODE_UTF8 + MAX_UNICODE_UTF8_BYTES + MAX_UTF8_TWO_BYTE + MAYBE_DEREF_GV + MAYBE_DEREF_GV_flags + MAYBE_DEREF_GV_nomg + MBOL + MBOL_t8 + MBOL_t8_p8 + MBOL_t8_pb + MBOL_tb + MBOL_tb_p8 + MBOL_tb_pb + MDEREF_ACTION_MASK + MDEREF_AV_gvav_aelem + MDEREF_AV_gvsv_vivify_rv2av_aelem + MDEREF_AV_padav_aelem + MDEREF_AV_padsv_vivify_rv2av_aelem + MDEREF_AV_pop_rv2av_aelem + MDEREF_AV_vivify_rv2av_aelem + MDEREF_FLAG_last + MDEREF_HV_gvhv_helem + MDEREF_HV_gvsv_vivify_rv2hv_helem + MDEREF_HV_padhv_helem + MDEREF_HV_padsv_vivify_rv2hv_helem + MDEREF_HV_pop_rv2hv_helem + MDEREF_HV_vivify_rv2hv_helem + MDEREF_INDEX_const + MDEREF_INDEX_gvsv + MDEREF_INDEX_MASK + MDEREF_INDEX_none + MDEREF_INDEX_padsv + MDEREF_MASK + MDEREF_reload + MDEREF_SHIFT + memBEGINPs + memBEGINs + MEMBER_TO_FPTR + memENDPs + memENDs + memGE + memGT + memLE + MEM_LOG_DEL_SV + MEM_LOG_NEW_SV + memLT + MEM_SIZE + MEM_SIZE_MAX + MEM_WRAP_CHECK + MEM_WRAP_CHECK_1 + MEM_WRAP_CHECK_s + MEOL + MEOL_t8 + MEOL_t8_p8 + MEOL_t8_pb + MEOL_tb + MEOL_tb_p8 + MEOL_tb_pb + MEXTEND + MgBYTEPOS + MgBYTEPOS_set + MGf_BYTES + MGf_GSKIP + MGf_MINMATCH + MGf_REFCOUNTED + MGf_REQUIRE_GV + MGf_TAINTEDDIR + MgPV + MgPV_const + MgPV_nolen_const + MgSV + MgTAINTEDDIR + MgTAINTEDDIR_off + MgTAINTEDDIR_on + MICRO_SIGN + MICRO_SIGN_NATIVE + MICRO_SIGN_UTF8 + MI_INIT_WORKAROUND_PACK + MINMOD + MINMOD_t8 + MINMOD_t8_p8 + MINMOD_t8_pb + MINMOD_tb + MINMOD_tb_p8 + MINMOD_tb_pb + MIN_OFFUNI_VARIANT_CP + Mkdir + MKTIME_LOCK + MKTIME_UNLOCK + M_PAT_MODS + MPH_BUCKETS + MPH_RSHIFT + MPH_VALt + msbit_pos + MSPAGAIN + MSVC_DIAG_IGNORE + MSVC_DIAG_IGNORE_DECL + MSVC_DIAG_IGNORE_STMT + MSVC_DIAG_RESTORE + MSVC_DIAG_RESTORE_DECL + MSVC_DIAG_RESTORE_STMT + MULTILINE_PAT_MOD + MUST_RESTART + MUTEX_INIT_NEEDS_MUTEX_ZEROED + my + my_binmode + MY_CXT_INDEX + MY_CXT_INIT_ARG + MY_CXT_INIT_INTERP + my_lstat + my_stat + N0 + N1 + N10 + N11 + N2 + N3 + N4 + N5 + N6 + N7 + N8 + N9 + namedclass_to_classnum + NAN_COMPARE_BROKEN + NANYOFM + NANYOFM_t8 + NANYOFM_t8_p8 + NANYOFM_t8_pb + NANYOFM_tb + NANYOFM_tb_p8 + NANYOFM_tb_pb + NATIVE8_TO_UNI + NATIVE_BYTE_IS_INVARIANT + NATIVE_SKIP + NATIVE_TO_ASCII + NATIVE_TO_I8 + NATIVE_TO_UTF + NATIVE_UTF8_TO_I8 + nBIT_MASK + nBIT_UMAX + NBOUND + NBOUNDA + NBOUNDA_t8 + NBOUNDA_t8_p8 + NBOUNDA_t8_pb + NBOUNDA_tb + NBOUNDA_tb_p8 + NBOUNDA_tb_pb + NBOUNDL + NBOUNDL_t8 + NBOUNDL_t8_p8 + NBOUNDL_t8_pb + NBOUNDL_tb + NBOUNDL_tb_p8 + NBOUNDL_tb_pb + NBOUND_t8 + NBOUND_t8_p8 + NBOUND_t8_pb + NBOUND_tb + NBOUND_tb_p8 + NBOUND_tb_pb + NBOUNDU + NBOUNDU_t8 + NBOUNDU_t8_p8 + NBOUNDU_t8_pb + NBOUNDU_tb + NBOUNDU_tb_p8 + NBOUNDU_tb_pb + NBSP_NATIVE + NBSP_UTF8 + NEED_UTF8 + NEGATE_2IV + NEGATE_2UV + NEGATIVE_INDICES_VAR + NETDB_R_OBSOLETE + New + new_body_allocated + new_body_from_arena + Newc + new_NOARENA + new_NOARENAZ + NewOp + NewOpSz + newRV_inc + new_SV + NEWSV + NEW_VERSION + new_XNV + new_XPV + new_XPVIV + new_XPVMG + new_XPVNV + Newz + NEXT_LINE_CHAR + NEXT_OFF + NOARENA + NOCAPTURE_PAT_MOD + NOCAPTURE_PAT_MODS + NODE_ALIGN + NODE_ALIGN_FILL + NODE_STEP_REGNODE + NO_ENV_ARRAY_IN_MAIN + NO_ENVIRON_ARRAY + NofAMmeth + NOLINE + NONDESTRUCT_PAT_MOD + NONDESTRUCT_PAT_MODS + NON_OTHER_COUNT + NONV + NO_POSIX_2008_LOCALE + NORETURN_FUNCTION_END + NORMAL + NOTE3 + NOTHING + NOTHING_t8 + NOTHING_t8_p8 + NOTHING_t8_pb + NOTHING_tb + NOTHING_tb_p8 + NOTHING_tb_pb + NOT_REACHED + NPOSIXA + NPOSIXA_t8 + NPOSIXA_t8_p8 + NPOSIXA_t8_pb + NPOSIXA_tb + NPOSIXA_tb_p8 + NPOSIXA_tb_pb + NPOSIXD + NPOSIXD_t8 + NPOSIXD_t8_p8 + NPOSIXD_t8_pb + NPOSIXD_tb + NPOSIXD_tb_p8 + NPOSIXD_tb_pb + NPOSIXL + NPOSIXL_t8 + NPOSIXL_t8_p8 + NPOSIXL_t8_pb + NPOSIXL_tb + NPOSIXL_tb_p8 + NPOSIXL_tb_pb + NPOSIXU + NPOSIXU_t8 + NPOSIXU_t8_p8 + NPOSIXU_t8_pb + NPOSIXU_tb + NPOSIXU_tb_p8 + NPOSIXU_tb_pb + ntohi + ntohl + ntohs + Null + Nullfp + Nullgv + Nullhe + Nullhek + Nullop + NUM_ANYOF_CODE_POINTS + NUM_CLASSES + NV_BIG_ENDIAN + NV_DIG + NV_EPSILON + NV_IMPLICIT_BIT + NV_LITTLE_ENDIAN + NV_MANT_DIG + NV_MAX + NV_MAX_10_EXP + NV_MAX_EXP + NV_MIN + NV_MIN_10_EXP + NV_MIN_EXP + NV_MIX_ENDIAN + NV_NAN_BITS + NV_NAN_IS_QUIET + NV_NAN_IS_SIGNALING + NV_NAN_PAYLOAD_MASK + NV_NAN_PAYLOAD_MASK_IEEE_754_128_BE + NV_NAN_PAYLOAD_MASK_IEEE_754_128_LE + NV_NAN_PAYLOAD_MASK_IEEE_754_64_BE + NV_NAN_PAYLOAD_MASK_IEEE_754_64_LE + NV_NAN_PAYLOAD_MASK_SKIP_EIGHT + NV_NAN_PAYLOAD_PERM + NV_NAN_PAYLOAD_PERM_0_TO_7 + NV_NAN_PAYLOAD_PERM_7_TO_0 + NV_NAN_PAYLOAD_PERM_IEEE_754_128_BE + NV_NAN_PAYLOAD_PERM_IEEE_754_128_LE + NV_NAN_PAYLOAD_PERM_IEEE_754_64_BE + NV_NAN_PAYLOAD_PERM_IEEE_754_64_LE + NV_NAN_PAYLOAD_PERM_SKIP_EIGHT + NV_NAN_QS_BIT + NV_NAN_QS_BIT_OFFSET + NV_NAN_QS_BIT_SHIFT + NV_NAN_QS_BYTE + NV_NAN_QS_BYTE_OFFSET + NV_NAN_QS_QUIET + NV_NAN_QS_SIGNALING + NV_NAN_QS_TEST + NV_NAN_QS_XOR + NV_NAN_SET_QUIET + NV_NAN_SET_SIGNALING + NV_VAX_ENDIAN + NV_WITHIN_IV + NV_WITHIN_UV + NV_X86_80_BIT + OA_AVREF + OA_BASEOP_OR_UNOP + OA_CLASS_MASK + OA_CVREF + OA_DANGEROUS + OA_DEFGV + OA_FILEREF + OA_FILESTATOP + OA_FOLDCONST + OA_HVREF + OA_LIST + OA_LOOPEXOP + OA_MARK + OA_METHOP + OA_OPTIONAL + OA_OTHERINT + OA_RETSCALAR + OA_SCALAR + OA_SCALARREF + OASHIFT + OA_TARGET + OA_TARGLEX + OA_UNOP_AUX + ObjectFIELDS + ObjectITERSVAT + ObjectMAXFIELD + OCSHIFT + OCTAL_VALUE + OFFUNI_IS_INVARIANT + OFFUNISKIP + OLD_CURRENT_HINTS + ONCE_PAT_MOD + ONCE_PAT_MODS + ONE_IF_EBCDIC_ZERO_IF_NOT + ONLY_LOCALE_MATCHES_INDEX + OOB_NAMEDCLASS + OOB_UNICODE + opASSIGN + OP_CHECK_MUTEX_INIT + OP_CHECK_MUTEX_LOCK + OP_CHECK_MUTEX_TERM + OP_CHECK_MUTEX_UNLOCK + OPCODE + OPEN + OPEN_t8 + OPEN_t8_p8 + OPEN_t8_pb + OPEN_tb + OPEN_tb_p8 + OPEN_tb_pb + OPERAND + OPERANDl + OPERANDs + OPFAIL + OPFAIL_t8 + OPFAIL_t8_p8 + OPFAIL_t8_pb + OPFAIL_tb + OPFAIL_tb_p8 + OPFAIL_tb_pb + OPf_FOLDED + OPf_KNOW + OPf_LIST + OPf_MOD + OPf_PARENS + OP_FREED + OPf_REF + OPf_SPECIAL + OPf_STACKED + OPf_WANT + OPf_WANT_LIST + OPf_WANT_SCALAR + OPf_WANT_VOID + OP_GIMME + OP_GIMME_REVERSE + OP_IS_DIRHOP + OP_IS_FILETEST + OP_IS_FILETEST_ACCESS + OP_IS_INFIX_BIT + OP_IS_NUMCOMPARE + OP_IS_SOCKET + OP_IS_STAT + OP_LVALUE_NO_CROAK + OpMySLAB + OPpALLOW_FAKE + OPpARG1_MASK + OPpARG2_MASK + OPpARG3_MASK + OPpARG4_MASK + OPpARGELEM_AV + OPpARGELEM_HV + OPpARGELEM_MASK + OPpARGELEM_SV + OPpARG_IF_FALSE + OPpARG_IF_UNDEF + OPpASSIGN_BACKWARDS + OPpASSIGN_COMMON_AGG + OPpASSIGN_COMMON_RC1 + OPpASSIGN_COMMON_SCALAR + OPpASSIGN_CV_TO_GV + OPpASSIGN_TRUEBOOL + OPpAVHVSWITCH_MASK + OPpCONCAT_NESTED + OPpCONST_BARE + OPpCONST_ENTERED + OPpCONST_NOVER + OPpCONST_SHORTCIRCUIT + OPpCONST_STRICT + OPpCONST_TOKEN_BITS + OPpCONST_TOKEN_FILE + OPpCONST_TOKEN_LINE + OPpCONST_TOKEN_MASK + OPpCONST_TOKEN_PACKAGE + OPpCONST_TOKEN_SHIFT + OPpCOREARGS_DEREF1 + OPpCOREARGS_DEREF2 + OPpCOREARGS_PUSHMARK + OPpCOREARGS_SCALARMOD + OPpDEFER_FINALLY + OPpDEREF + OPpDEREF_AV + OPpDEREF_HV + OPpDEREF_SV + OPpDONT_INIT_GV + OPpEARLY_CV + OPpEMPTYAVHV_IS_HV + OPpENTERSUB_AMPER + OPpENTERSUB_DB + OPpENTERSUB_HASTARG + OPpENTERSUB_INARGS + OPpENTERSUB_LVAL_MASK + OPpENTERSUB_NOPAREN + OPpEVAL_BYTES + OPpEVAL_COPHH + OPpEVAL_EVALSV + OPpEVAL_HAS_HH + OPpEVAL_RE_REPARSING + OPpEVAL_UNICODE + OPpEXISTS_SUB + OPpFLIP_LINENUM + OPpFT_ACCESS + OPpFT_AFTER_t + OPpFT_STACKED + OPpFT_STACKING + OPpHELEMEXISTSOR_DELETE + OPpHINT_STRICT_REFS + OPpHUSH_VMSISH + OPpINDEX_BOOLNEG + OPpINITFIELD_AV + OPpINITFIELD_HV + OPpINITFIELDS + OPpITER_DEF + OPpITER_INDEXED + OPpITER_REVERSED + OPpKVSLICE + OPpLIST_GUESSED + OPpLVAL_DEFER + OPpLVAL_INTRO + OPpLVALUE + OPpLVREF_AV + OPpLVREF_CV + OPpLVREF_ELEM + OPpLVREF_HV + OPpLVREF_ITER + OPpLVREF_SV + OPpLVREF_TYPE + OPpMAYBE_LVSUB + OPpMAYBE_TRUEBOOL + OPpMAY_RETURN_CONSTANT + OPpMETH_NO_BAREWORD_IO + op_pmflags + op_pmoffset + OPpMULTICONCAT_APPEND + OPpMULTICONCAT_FAKE + OPpMULTICONCAT_STRINGIFY + OPpMULTIDEREF_DELETE + OPpMULTIDEREF_EXISTS + OPpOFFBYONE + OPpOPEN_IN_CRLF + OPpOPEN_IN_RAW + OPpOPEN_OUT_CRLF + OPpOPEN_OUT_RAW + OPpOUR_INTRO + OPpPADHV_ISKEYS + OPpPADRANGE_COUNTMASK + OPpPADRANGE_COUNTSHIFT + OPpPAD_STATE + OPpPARAM_IF_FALSE + OPpPARAM_IF_UNDEF + OPpPV_IS_UTF8 + OPpREFCOUNTED + OPpREPEAT_DOLIST + OPpREVERSE_INPLACE + OPpRV2HV_ISKEYS + OPpSELF_IN_PAD + OPpSLICE + OPpSLICEWARNING + OPpSORT_DESCEND + OPpSORT_INPLACE + OPpSORT_INTEGER + OPpSORT_NUMERIC + OPpSORT_REVERSE + OPpSPLIT_ASSIGN + OPpSPLIT_IMPLIM + OPpSPLIT_LEX + OPpSUBSTR_REPL_FIRST + OPpTARGET_MY + OPpTRANS_ALL + OPpTRANS_BITS + OPpTRANS_CAN_FORCE_UTF8 + OPpTRANS_COMPLEMENT + OPpTRANS_DELETE + OPpTRANS_FROM_UTF + OPpTRANS_GROWS + OPpTRANS_IDENTICAL + OPpTRANS_MASK + OPpTRANS_ONLY_UTF8_INVARIANTS + OPpTRANS_SHIFT + OPpTRANS_SQUASH + OPpTRANS_TO_UTF + OPpTRANS_USE_SVOP + OPpTRUEBOOL + OPpUNDEF_KEEP_PV + OPpUSEINT + OpREFCNT_dec + OpREFCNT_inc + OP_REFCNT_INIT + OP_REFCNT_LOCK + OpREFCNT_set + OP_REFCNT_TERM + OP_REFCNT_UNLOCK + OP_SIBLING + OpSLAB + OpslabREFCNT_dec + OpslabREFCNT_dec_padok + OpSLOT + OPSLOT_HEADER + OpSLOToff + OPTIMIZED + OPTIMIZED_t8 + OPTIMIZED_t8_p8 + OPTIMIZED_t8_pb + OPTIMIZED_tb + OPTIMIZED_tb_p8 + OPTIMIZED_tb_pb + OPTIMIZE_INFTY + OP_TYPE_IS_COP_NN + OP_TYPE_IS_NN + OP_TYPE_ISNT + OP_TYPE_ISNT_AND_WASNT + OP_TYPE_ISNT_AND_WASNT_NN + OP_TYPE_ISNT_NN + OP_TYPE_IS_OR_WAS_NN + OpTYPE_set + OutCopFILE + O_VMS_DELETEONCLOSE + padadd_FIELD + padadd_NO_DUP_CHECK + padadd_OUR + padadd_STALEOK + padadd_STATE + PAD_BASE_SV + PAD_CLONE_VARS + PAD_COMPNAME + PAD_COMPNAME_FLAGS + PAD_COMPNAME_FLAGS_isOUR + PAD_COMPNAME_GEN + PAD_COMPNAME_GEN_set + PAD_COMPNAME_OURSTASH + PAD_COMPNAME_PV + PAD_COMPNAME_SV + PAD_COMPNAME_TYPE + PAD_FAKELEX_ANON + PAD_FAKELEX_MULTI + padfind_FIELD_OK + padname_dup_inc + PADNAMEf_FIELD + PadnameFIELDINFO + PadnameFLAGS + PADNAMEf_LVALUE + PADNAMEf_OUR + PADNAME_FROM_PV + PADNAMEf_STATE + PADNAMEf_TYPED + PadnameHasTYPE + PadnameIsFIELD + PadnameIsOUR + PadnameIsSTATE + PadnameIsSTATE_on + padnamelist_dup_inc + PadnamelistMAXNAMED + PadnamelistREFCNT_inc + PadnameLVALUE + PadnameLVALUE_on + PadnameOURSTASH + PadnameOURSTASH_set + PadnameOUTER + PadnamePROTOCV + PADNAMEt_LVALUE + PADNAMEt_OUR + PADNAMEt_OUTER + PADNAMEt_STATE + PADNAMEt_TYPED + PadnameTYPE + PadnameTYPE_set + padnew_CLONE + padnew_SAVE + padnew_SAVESUB + PAD_RESTORE_LOCAL + PAD_SAVE_LOCAL + PAD_SAVE_SETNULLPAD + PAD_SET_CUR + PAD_SET_CUR_NOSAVE + PAD_SETSV + PAD_SV + PAD_SVl + panic_write2 + PAREN_OFFSET + PAREN_SET + PAREN_TEST + PARENT_FAKELEX_FLAGS + PARENT_PAD_INDEX + PAREN_UNSET + PARNO + PATCHLEVEL + Pause + PBITVAL + PBYTE + PLUS + PLUS_t8 + PLUS_t8_p8 + PLUS_t8_pb + PLUS_tb + PLUS_tb_p8 + PLUS_tb_pb + PMf_BASE_SHIFT + PMf_CHARSET + PMf_CODELIST_PRIVATE + PMf_CONST + PMf_CONTINUE + PMf_EVAL + PMf_EXTENDED + PMf_EXTENDED_MORE + PMf_FOLD + PMf_GLOBAL + PMf_HAS_CV + PMf_HAS_ERROR + PMf_IS_QR + PMf_KEEP + PMf_KEEPCOPY + PMf_MULTILINE + PMf_NOCAPTURE + PMf_NONDESTRUCT + PMf_ONCE + PMf_RETAINT + PMf_SINGLELINE + PMf_SPLIT + PMf_STRICT + PMf_USED + PMf_USE_RE_EVAL + PMf_WILDCARD + PM_GETRE + PM_GETRE_raw + PmopSTASH + PmopSTASHPV + PmopSTASHPV_set + PmopSTASH_set + PM_SETRE + PM_SETRE_raw + PNf + PNfARG + PoisonPADLIST + POISON_SV_HEAD + POPMARK + POPpconstx + POPSTACK + POPSTACK_TO + POSIXA + POSIXA_t8 + POSIXA_t8_p8 + POSIXA_t8_pb + POSIXA_tb + POSIXA_tb_p8 + POSIXA_tb_pb + POSIX_CC_COUNT + POSIXD + POSIXD_t8 + POSIXD_t8_p8 + POSIXD_t8_pb + POSIXD_tb + POSIXD_tb_p8 + POSIXD_tb_pb + POSIXL + POSIXL_CLEAR + POSIXL_SET + POSIXL_t8 + POSIXL_t8_p8 + POSIXL_t8_pb + POSIXL_tb + POSIXL_tb_p8 + POSIXL_tb_pb + POSIXL_TEST + POSIXL_ZERO + POSIX_SETLOCALE_LOCK + POSIX_SETLOCALE_UNLOCK + POSIXU + POSIXU_t8 + POSIXU_t8_p8 + POSIXU_t8_pb + POSIXU_tb + POSIXU_tb_p8 + POSIXU_tb_pb + POSTPONED + PP + PP_wrapped + PREGf_ANCH + PREGf_ANCH_GPOS + PREGf_ANCH_MBOL + PREGf_ANCH_SBOL + PREGf_CUTGROUP_SEEN + PREGf_GPOS_FLOAT + PREGf_GPOS_SEEN + PREGf_IMPLICIT + PREGf_NAUGHTY + PREGf_NOSCAN + PREGf_PESSIMIZE_SEEN + PREGf_RECURSE_SEEN + PREGf_SKIP + PREGf_USE_RE_EVAL + PREGf_VERBARG_SEEN + prepare_SV_for_RV + PRESCAN_VERSION + PREV_RANGE_MATCHES_INVLIST + PRINTF_FORMAT_NULL_OK + PRIVSHIFT + ProgLen + PRUNE + PRUNE_t8 + PRUNE_t8_p8 + PRUNE_t8_pb + PRUNE_tb + PRUNE_tb_p8 + PRUNE_tb_pb + PSEUDO + PSEUDO_t8 + PSEUDO_t8_p8 + PSEUDO_t8_pb + PSEUDO_tb + PSEUDO_tb_p8 + PSEUDO_tb_pb + pthread_addr_t + pthread_attr_init + pthread_condattr_default + pthread_create + PTHREAD_GETSPECIFIC + PTHREAD_GETSPECIFIC_INT + pthread_key_create + pthread_keycreate + pthread_mutexattr_default + pthread_mutexattr_init + pthread_mutexattr_settype + pTHX_1 + pTHX_12 + pTHX_2 + pTHX_3 + pTHX_4 + pTHX_5 + pTHX_6 + pTHX_7 + pTHX_8 + pTHX_9 + pTHX__FORMAT + pTHX_FORMAT + pTHX__VALUE + pTHX_VALUE + PUSH_MULTICALL_FLAGS + PUSHSTACK + PUSHSTACKi + PUSHSTACK_INIT_HWM + PUSHTARG + pWARN_ALL + pWARN_NONE + pWARN_STD + QR_PAT_MODS + QUESTION_MARK_CTRL + RANGE_INDICATOR + RCPVf_ALLOW_EMPTY + RCPVf_NO_COPY + RCPVf_USE_STRLEN + REAL_COP_FEATURE_SIZE + RE_COMPILE_RECURSION_INIT + RE_COMPILE_RECURSION_LIMIT + RE_DEBUG_COMPILE_DUMP + RE_DEBUG_COMPILE_FLAGS + RE_DEBUG_COMPILE_MASK + RE_DEBUG_COMPILE_OPTIMISE + RE_DEBUG_COMPILE_PARSE + RE_DEBUG_COMPILE_TEST + RE_DEBUG_COMPILE_TRIE + RE_DEBUG_EXECUTE_INTUIT + RE_DEBUG_EXECUTE_MASK + RE_DEBUG_EXECUTE_MATCH + RE_DEBUG_EXECUTE_TRIE + RE_DEBUG_EXTRA_BUFFERS + RE_DEBUG_EXTRA_DUMP_PRE_OPTIMIZE + RE_DEBUG_EXTRA_GPOS + RE_DEBUG_EXTRA_MASK + RE_DEBUG_EXTRA_OPTIMISE + RE_DEBUG_EXTRA_STACK + RE_DEBUG_EXTRA_STATE + RE_DEBUG_EXTRA_TRIE + RE_DEBUG_EXTRA_WILDCARD + RE_DEBUG_FLAG + RE_DEBUG_FLAGS + REENABLE_LC_NUMERIC_CHANGES + REENTRANT_PROTO_B_B + REENTRANT_PROTO_B_BI + REENTRANT_PROTO_B_BW + REENTRANT_PROTO_B_CCD + REENTRANT_PROTO_B_CCS + REENTRANT_PROTO_B_IBI + REENTRANT_PROTO_B_IBW + REENTRANT_PROTO_B_SB + REENTRANT_PROTO_B_SBI + REENTRANT_PROTO_I_BI + REENTRANT_PROTO_I_BW + REENTRANT_PROTO_I_CCSBWR + REENTRANT_PROTO_I_CCSD + REENTRANT_PROTO_I_CII + REENTRANT_PROTO_I_CIISD + REENTRANT_PROTO_I_CSBI + REENTRANT_PROTO_I_CSBIR + REENTRANT_PROTO_I_CSBWR + REENTRANT_PROTO_I_CSBWRE + REENTRANT_PROTO_I_CSD + REENTRANT_PROTO_I_CWISBWRE + REENTRANT_PROTO_I_CWISD + REENTRANT_PROTO_I_D + REENTRANT_PROTO_I_H + REENTRANT_PROTO_I_IBI + REENTRANT_PROTO_I_IBW + REENTRANT_PROTO_I_ICBI + REENTRANT_PROTO_I_ICSBWR + REENTRANT_PROTO_I_ICSD + REENTRANT_PROTO_I_ID + REENTRANT_PROTO_I_IISD + REENTRANT_PROTO_I_ISBWR + REENTRANT_PROTO_I_ISD + REENTRANT_PROTO_I_LISBI + REENTRANT_PROTO_I_LISD + REENTRANT_PROTO_I_SB + REENTRANT_PROTO_I_SBI + REENTRANT_PROTO_I_SBIE + REENTRANT_PROTO_I_SBIH + REENTRANT_PROTO_I_SBIR + REENTRANT_PROTO_I_SBWR + REENTRANT_PROTO_I_SBWRE + REENTRANT_PROTO_I_SD + REENTRANT_PROTO_I_TISD + REENTRANT_PROTO_I_TS + REENTRANT_PROTO_I_TSBI + REENTRANT_PROTO_I_TSBIR + REENTRANT_PROTO_I_TSBWR + REENTRANT_PROTO_I_TsISBWRE + REENTRANT_PROTO_I_TSR + REENTRANT_PROTO_I_uISBWRE + REENTRANT_PROTO_I_UISBWRE + REENTRANT_PROTO_S_CBI + REENTRANT_PROTO_S_CCSBI + REENTRANT_PROTO_S_CIISBIE + REENTRANT_PROTO_S_CSBI + REENTRANT_PROTO_S_CSBIE + REENTRANT_PROTO_S_CWISBIE + REENTRANT_PROTO_S_CWISBWIE + REENTRANT_PROTO_S_ICSBI + REENTRANT_PROTO_S_ISBI + REENTRANT_PROTO_S_LISBI + REENTRANT_PROTO_S_SBI + REENTRANT_PROTO_S_SBIE + REENTRANT_PROTO_S_SBW + REENTRANT_PROTO_S_TISBI + REENTRANT_PROTO_S_TS + REENTRANT_PROTO_S_TSBI + REENTRANT_PROTO_S_TSBIE + REENTRANT_PROTO_S_TWISBIE + REENTRANT_PROTO_V_D + REENTRANT_PROTO_V_H + REENTRANT_PROTO_V_ID + REENTR_MEMZERO + ref + REF + REFCOUNTED_HE_EXISTS + refcounted_he_fetch_pvs + REFCOUNTED_HE_KEY_UTF8 + refcounted_he_new_pvs + REFF + REFFA + REFFAN + REFFAN_t8 + REFFAN_t8_p8 + REFFAN_t8_pb + REFFAN_tb + REFFAN_tb_p8 + REFFAN_tb_pb + REFFA_t8 + REFFA_t8_p8 + REFFA_t8_pb + REFFA_tb + REFFA_tb_p8 + REFFA_tb_pb + REFFL + REFFLN + REFFLN_t8 + REFFLN_t8_p8 + REFFLN_t8_pb + REFFLN_tb + REFFLN_tb_p8 + REFFLN_tb_pb + REFFL_t8 + REFFL_t8_p8 + REFFL_t8_pb + REFFL_tb + REFFL_tb_p8 + REFFL_tb_pb + REFFN + REFFN_t8 + REFFN_t8_p8 + REFFN_t8_pb + REFFN_tb + REFFN_tb_p8 + REFFN_tb_pb + REFF_t8 + REFF_t8_p8 + REFF_t8_pb + REFF_tb + REFF_tb_p8 + REFF_tb_pb + REFFU + REFFUN + REFFUN_t8 + REFFUN_t8_p8 + REFFUN_t8_pb + REFFUN_tb + REFFUN_tb_p8 + REFFUN_tb_pb + REFFU_t8 + REFFU_t8_p8 + REFFU_t8_pb + REFFU_tb + REFFU_tb_p8 + REFFU_tb_pb + REF_HE_KEY + REFN + REF_next + REF_next_fail + REF_next_fail_t8 + REF_next_fail_t8_p8 + REF_next_fail_t8_pb + REF_next_fail_tb + REF_next_fail_tb_p8 + REF_next_fail_tb_pb + REF_next_t8 + REF_next_t8_p8 + REF_next_t8_pb + REF_next_tb + REF_next_tb_p8 + REF_next_tb_pb + REFN_t8 + REFN_t8_p8 + REFN_t8_pb + REFN_tb + REFN_tb_p8 + REFN_tb_pb + REF_t8 + REF_t8_p8 + REF_t8_pb + REF_tb + REF_tb_p8 + REF_tb_pb + REG_ANY + REG_ANY_t8 + REG_ANY_t8_p8 + REG_ANY_t8_pb + REG_ANY_tb + REG_ANY_tb_p8 + REG_ANY_tb_pb + REG_CUTGROUP_SEEN + RegexLengthToShowInErrorMessages + REGEX_SET + REGEX_SET_t8 + REGEX_SET_t8_p8 + REGEX_SET_t8_pb + REGEX_SET_tb + REGEX_SET_tb_p8 + REGEX_SET_tb_pb + REG_EXTFLAGS_NAME_SIZE + REG_FETCH_ABSOLUTE + REG_GPOS_SEEN + REG_INTFLAGS_NAME_SIZE + REG_LB_SEEN + REG_LOOKBEHIND_SEEN + REG_MAGIC + REGMATCH_STATE_MAX + REGNODE_AFTER + REGNODE_AFTER_opcode + REGNODE_AFTER_PLUS + REGNODE_AFTER_PLUS_DEBUG + REGNODE_AFTER_type + REGNODE_AFTER_varies + REGNODE_ARG_LEN + REGNODE_ARG_LEN_VARIES + REGNODE_BBM_BITMAP_LEN + REGNODE_BEFORE + REGNODE_BEFORE_BASE + REGNODE_BEFORE_BASE_DEBUG + REGNODE_GUTS + REGNODE_MAX + REGNODE_NAME + REG_NODE_NUM + REGNODE_OFF_BY_ARG + REGNODE_OFFSET + REGNODE_p + REGNODE_SIMPLE + REGNODE_STEP_OVER + REGNODE_TYPE + REGNODE_VARIES + REG_PESSIMIZE_SEEN + REG_RECURSE_SEEN + REG_RUN_ON_COMMENT_SEEN + REGTAIL + REGTAIL_STUDY + REG_TOP_LEVEL_BRANCHES_SEEN + REG_UNBOUNDED_QUANTIFIER_SEEN + REG_UNFOLDED_MULTI_SEEN + REG_VERBARG_SEEN + reg_warn_non_literal_string + REG_ZERO_LEN_SEEN + RENUM + RENUM_t8 + RENUM_t8_p8 + RENUM_t8_pb + RENUM_tb + RENUM_tb_p8 + RENUM_tb_pb + REPORT_LOCATION + REPORT_LOCATION_ARGS + RE_PV_COLOR_DECL + RE_PV_QUOTED_DECL + REQUIRE_BRANCHJ + REQUIRE_PARENS_PASS + REQUIRE_UNI_RULES + REQUIRE_UTF8 + ReREFCNT_dec + ReREFCNT_inc + RESTART_PARSE + RESTORE_ERRNO + RESTORE_WARNINGS + RE_SV_DUMPLEN + RE_SV_ESCAPE + RE_SV_TAIL + RETPUSHNO + RETPUSHUNDEF + RETPUSHYES + RE_TRIE_MAXBUF_INIT + RE_TRIE_MAXBUF_NAME + RETSETNO + RETSETTARG + RETSETUNDEF + RETSETYES + RETURN + RETURN_FAIL_ON_RESTART + RETURN_FAIL_ON_RESTART_FLAGP + RETURN_FAIL_ON_RESTART_OR_FLAGS + RETURNOP + RETURNX + RExC_close_parens + RExC_contains_locale + RExC_copy_start_in_constructed + RExC_copy_start_in_input + RExC_emit + RExC_emit_start + RExC_end + RExC_end_op + RExC_flags + RExC_frame_count + RExC_frame_head + RExC_frame_last + RExC_in_lookaround + RExC_in_multi_char_class + RExC_in_script_run + RExC_lastnum + RExC_lastparse + RExC_latest_warn_offset + RExC_logical_npar + RExC_logical_to_parno + RExC_logical_total_parens + RExC_maxlen + RExC_mysv + RExC_mysv1 + RExC_mysv2 + RExC_naughty + RExC_nestroot + RExC_npar + RExC_open_parens + RExC_orig_utf8 + RExC_paren_name_list + RExC_paren_names + RExC_parens_buf_size + RExC_parno_to_logical + RExC_parno_to_logical_next + RExC_parse + RExC_parse_advance + RExC_parse_inc + RExC_parse_inc_by + RExC_parse_incf + RExC_parse_inc_if_char + RExC_parse_inc_safe + RExC_parse_inc_safef + RExC_parse_inc_utf8 + RExC_parse_set + RExC_pm_flags + RExC_precomp + RExC_precomp_end + RExC_recode_x_to_native + RExC_recurse + RExC_recurse_count + RExC_rx + RExC_rxi + RExC_rx_sv + RExC_save_copy_start_in_constructed + RExC_sawback + RExC_seen + RExC_seen_d_op + RExC_seen_zerolen + RExC_sets_depth + RExC_size + RExC_start + RExC_strict + RExC_study_chunk_recursed + RExC_study_chunk_recursed_bytes + RExC_study_chunk_recursed_count + RExC_study_started + RExC_total_parens + RExC_uni_semantics + RExC_unlexed_names + RExC_use_BRANCHJ + RExC_utf8 + RExC_warned_WARN_EXPERIMENTAL__REGEX_SETS + RExC_warned_WARN_EXPERIMENTAL__VLB + RExC_warn_text + RExC_whilem_seen + REXEC_CHECKED + REXEC_FAIL_ON_UNDERFLOW + REXEC_IGNOREPOS + REXEC_NOT_FIRST + REXEC_SCREAM + RMS_DIR + RMS_FAC + RMS_FEX + RMS_FNF + RMS_IFI + RMS_ISI + RMS_PRV + ROTL64 + ROTL_UV + ROTR32 + ROTR64 + ROTR_UV + RsPARA + RsRECORD + RsSIMPLE + RsSNARF + RUNOPS_DEFAULT + RV2CVOPCV_FLAG_MASK + RV2CVOPCV_MAYBE_NAME_GV + RV2CVOPCV_RETURN_STUB + RX_ANCHORED_SUBSTR + RX_ANCHORED_UTF8 + RX_CHECK_SUBSTR + RX_COMPFLAGS + RX_ENGINE + RX_EXTFLAGS + RXf_BASE_SHIFT + RXf_CHECK_ALL + RXf_COPY_DONE + RXf_EVAL_SEEN + RXf_INTUIT_TAIL + RXf_IS_ANCHORED + RX_FLOAT_SUBSTR + RX_FLOAT_UTF8 + RXf_MATCH_UTF8 + RXf_PMf_CHARSET + RXf_PMf_COMPILETIME + RXf_PMf_EXTENDED_MORE + RXf_PMf_FLAGCOPYMASK + RXf_PMf_NOCAPTURE + RXf_PMf_SPLIT + RXf_PMf_STD_PMMOD + RXf_PMf_STRICT + RXf_TAINTED + RXf_TAINTED_SEEN + RXf_UNBOUNDED_QUANTIFIER_SEEN + RXf_USE_INTUIT + RXf_USE_INTUIT_ML + RXf_USE_INTUIT_NOML + RX_GOFS + RXi_GET + RXi_GET_DECL + RXi_GET_DECL_NULL + RX_INTFLAGS + RXi_SET + RX_ISTAINTED + RX_LASTCLOSEPAREN + RX_LASTPAREN + RX_LOGICAL_NPARENS + RX_LOGICAL_TO_PARNO + RX_MATCH_COPIED_off + RX_MATCH_COPIED_on + RX_MATCH_COPIED_set + RX_MATCH_COPY_FREE + RX_MATCH_TAINTED + RX_MATCH_TAINTED_off + RX_MATCH_TAINTED_on + RX_MATCH_TAINTED_set + RX_MATCH_UTF8 + RX_MATCH_UTF8_off + RX_MATCH_UTF8_on + RX_MATCH_UTF8_set + RX_MINLEN + RX_MINLENRET + RX_MOTHER_RE + RX_NPARENS + RX_OFFSp + RX_PARNO_TO_LOGICAL + RX_PARNO_TO_LOGICAL_NEXT + RXp_COMPFLAGS + RXp_ENGINE + RXp_EXTFLAGS + RXp_GOFS + RXp_HAS_CUTGROUP + RXp_INTFLAGS + RXp_ISTAINTED + RXp_LASTCLOSEPAREN + RXp_LASTPAREN + RXp_LOGICAL_NPARENS + RXp_LOGICAL_TO_PARNO + RXp_MATCH_COPIED + RXp_MATCH_COPIED_off + RXp_MATCH_COPIED_on + RXp_MATCH_COPY_FREE + RXp_MATCH_TAINTED + RXp_MATCH_TAINTED_off + RXp_MATCH_TAINTED_on + RXp_MATCH_UTF8 + RXp_MATCH_UTF8_off + RXp_MATCH_UTF8_on + RXp_MATCH_UTF8_set + RXp_MINLEN + RXp_MINLENRET + RXp_MOTHER_RE + RXp_NPARENS + RXp_OFFSp + RXp_PAREN_NAMES + RXp_PARNO_TO_LOGICAL + RXp_PARNO_TO_LOGICAL_NEXT + RXp_PPRIVATE + RXp_PRE_PREFIX + RX_PPRIVATE + RXp_QR_ANONCV + RX_PRECOMP + RX_PRECOMP_const + RX_PRELEN + RX_PRE_PREFIX + RXp_SAVED_COPY + RXp_SUBBEG + RXp_SUBCOFFSET + RXp_SUBLEN + RXp_SUBOFFSET + RXp_SUBSTRS + RXp_ZERO_LEN + RX_QR_ANONCV + RX_REFCNT + RX_SAVED_COPY + RX_SUBBEG + RX_SUBCOFFSET + RX_SUBLEN + RX_SUBOFFSET + RX_SUBSTRS + RX_TAINT_on + RX_UTF8 + RX_WRAPLEN + RX_WRAPPED + RX_WRAPPED_const + RX_ZERO_LEN + safefree + SAFE_TRIE_NODENUM + SANY + SANY_t8 + SANY_t8_p8 + SANY_t8_pb + SANY_tb + SANY_tb_p8 + SANY_tb_pb + SAVEADELETE + SAVECLEARSV + SAVECOMPILEWARNINGS + SAVECOMPPAD + SAVECOPFILE + SAVECOPFILE_FREE + SAVECOPFILE_FREE_x + SAVECOPFILE_x + SAVECOPLINE + SAVECOPSTASH_FREE + SAVECURCOPWARNINGS + SAVE_ERRNO + SAVEFEATUREBITS + SAVEFREECOPHH + SAVEFREEPADNAME + SAVE_FREE_REXC_STATE + SAVEGENERICPV + SAVEHDELETE + SAVEHINTS + SAVE_MASK + SAVEOP + SAVEPADSVANDMORTALIZE + SAVEPARSER + SAVESETSVFLAGS + SAVESHAREDPV + SAVESWITCHSTACK + SAVEt_ADELETE + SAVEt_AELEM + SAVEt_ALLOC + SAVEt_APTR + SAVEt_AV + SAVEt_BOOL + SAVEt_CLEARPADRANGE + SAVEt_CLEARSV + SAVEt_COMPILE_WARNINGS + SAVEt_COMPPAD + SAVEt_CURCOP_WARNINGS + SAVEt_DELETE + SAVEt_DESTRUCTOR + SAVEt_DESTRUCTOR_X + SAVEt_FREECOPHH + SAVEt_FREEOP + SAVEt_FREEPADNAME + SAVEt_FREEPV + SAVEt_FREERCPV + SAVEt_FREE_REXC_STATE + SAVEt_FREESV + SAVEt_GENERIC_PVREF + SAVEt_GENERIC_SVREF + SAVEt_GP + SAVEt_GVSLOT + SAVEt_GVSV + SAVEt_HELEM + SAVEt_HINTS + SAVEt_HINTS_HH + SAVEt_HPTR + SAVEt_HV + SAVEt_I16 + SAVEt_I32 + SAVEt_I32_SMALL + SAVEt_I8 + SAVE_TIGHT_SHIFT + SAVEt_INT_SMALL + SAVEt_ITEM + SAVEt_IV + SAVEt_MORTALIZESV + SAVEt_NSTAB + SAVEt_OP + SAVEt_PADSV_AND_MORTALIZE + SAVEt_PARSER + SAVEt_PPTR + SAVEt_RCPV + SAVEt_READONLY_OFF + SAVEt_REGCONTEXT + SAVEt_SAVESWITCHSTACK + SAVEt_SET_SVFLAGS + SAVEt_SHARED_PVREF + SAVEt_SPTR + SAVEt_STACK_POS + SAVEt_STRLEN + SAVEt_STRLEN_SMALL + SAVEt_SV + SAVEt_SVREF + SAVEt_TMPSFLOOR + SAVEt_VPTR + SAVEVPTR + SAWAMPERSAND_LEFT + SAWAMPERSAND_MIDDLE + SAWAMPERSAND_RIGHT + sb_dstr + sb_iters + sb_m + sb_maxiters + SBOL + SBOL_t8 + SBOL_t8_p8 + SBOL_t8_pb + SBOL_tb + SBOL_tb_p8 + SBOL_tb_pb + sb_orig + SBOX32_MIX3 + SBOX32_MIX4 + SBOX32_STATE_BITS + SBOX32_STATE_BYTES + SBOX32_WARN2 + SBOX32_WARN3 + SBOX32_WARN4 + SBOX32_WARN5 + SBOX32_WARN6 + sb_rflags + sb_rx + sb_rxres + sb_rxtainted + sb_s + sb_strend + sb_targ + sC + SCAN_DEF + SCAN_REPL + SCAN_TR + SCAN_VERSION + SCF_DO_STCLASS + SCF_DO_STCLASS_AND + SCF_DO_STCLASS_OR + SCF_DO_SUBSTR + SCF_IN_DEFINE + SCF_SEEN_ACCEPT + SCF_TRIE_DOING_RESTUDY + SCF_TRIE_RESTUDY + SCF_WHILEM_VISITED_POS + Semctl + semun + SEOL + SEOL_t8 + SEOL_t8_p8 + SEOL_t8_pb + SEOL_tb + SEOL_tb_p8 + SEOL_tb_pb + set_ANYOF_SYNTHETIC + SETGRENT_R_HAS_FPTR + SETi + SET_MARK_OFFSET + SETn + SET_NUMERIC_STANDARD + SET_NUMERIC_UNDERLYING + SETp + SetProgLen + SETPWENT_R_HAS_FPTR + SET_recode_x_to_native + setregid + setreuid + SETs + setSTR_LEN + SET_SVANY_FOR_BODYLESS_IV + SET_SVANY_FOR_BODYLESS_NV + SETTARG + SET_THREAD_SELF + SETu + SF_BEFORE_EOL + SF_BEFORE_MEOL + SF_BEFORE_SEOL + SF_HAS_EVAL + SF_HAS_PAR + SF_IN_PAR + SF_IS_INF + share_hek_hek + sharepvn + SHARP_S_SKIP + SHUTDOWN_TERM + SHY_NATIVE + sI + SIMPLE + Simple_vFAIL + Simple_vFAILn + SINGLE_PAT_MOD + SIPHASH_SEED_STATE + SIPROUND + S_iv_add_may_overflow + S_iv_mul_may_overflow + S_iv_sub_may_overflow + S_IWOTH + S_IXOTH + SIZE_ALIGN + Size_t_MAX + SKIP + SKIP_IF_CHAR + SKIP_next + SKIP_next_fail + SKIP_next_fail_t8 + SKIP_next_fail_t8_p8 + SKIP_next_fail_t8_pb + SKIP_next_fail_tb + SKIP_next_fail_tb_p8 + SKIP_next_fail_tb_pb + SKIP_next_t8 + SKIP_next_t8_p8 + SKIP_next_t8_pb + SKIP_next_tb + SKIP_next_tb_p8 + SKIP_next_tb_pb + SKIP_t8 + SKIP_t8_p8 + SKIP_t8_pb + SKIP_tb + SKIP_tb_p8 + SKIP_tb_pb + SLOPPYDIVIDE + socketpair + S_PAT_MODS + specialWARN + SRCLOSE + SRCLOSE_t8 + SRCLOSE_t8_p8 + SRCLOSE_t8_pb + SRCLOSE_tb + SRCLOSE_tb_p8 + SRCLOSE_tb_pb + SROPEN + SROPEN_t8 + SROPEN_t8_p8 + SROPEN_t8_pb + SROPEN_tb + SROPEN_tb_p8 + SROPEN_tb_pb + SS_ACCVIO + SS_ADD_BOOL + SS_ADD_DPTR + SS_ADD_DXPTR + SS_ADD_END + SS_ADD_INT + SS_ADD_IV + SS_ADD_LONG + SS_ADD_PTR + SS_ADD_UV + SS_BUFFEROVF + ssc_add_cp + SSCHECK + ssc_init_zero + ssc_match_all_cp + SSC_MATCHES_EMPTY_STRING + SS_DEVOFFLINE + SSGROW + SS_IVCHAN + SSize_t_MAX + SS_MAXPUSH + SS_NOPRIV + SS_NORMAL + SSPOPBOOL + SSPOPDPTR + SSPOPDXPTR + SSPOPINT + SSPOPIV + SSPOPLONG + SSPOPPTR + SSPOPUV + SSPUSHBOOL + SSPUSHDPTR + SSPUSHDXPTR + SSPUSHINT + SSPUSHIV + SSPUSHLONG + SSPUSHPTR + SSPUSHUV + Stack_off_t_MAX + STANDARD_C + STAR + STAR_t8 + STAR_t8_p8 + STAR_t8_pb + STAR_tb + STAR_tb_p8 + STAR_tb_pb + StashHANDLER + Stat + Stat_t + STATUS_ALL_FAILURE + STATUS_ALL_SUCCESS + STATUS_CURRENT + STATUS_EXIT + STATUS_EXIT_SET + STATUS_NATIVE + STATUS_NATIVE_CHILD_SET + STATUS_UNIX + STATUS_UNIX_EXIT_SET + STATUS_UNIX_SET + STD_PAT_MODS + STD_PMMOD_FLAGS_CLEAR + STORE_LC_NUMERIC_SET_STANDARD + strBEGINs + Strerror + STRFMON_LOCK + STRFMON_UNLOCK + STRFTIME_LOCK + STRFTIME_UNLOCK + STRING + STRINGl + STRINGs + STR_LEN + STR_LENl + STR_LENs + STRLENs + STR_LEN_U8 + STR_SZ + STRUCT_OFFSET + STRUCT_SV + SUBST_TAINT_BOOLRET + SUBST_TAINT_PAT + SUBST_TAINT_REPL + SUBST_TAINT_RETAINT + SUBST_TAINT_STR + SUBVERSION + SUCCEED + SUCCEED_t8 + SUCCEED_t8_p8 + SUCCEED_t8_pb + SUCCEED_tb + SUCCEED_tb_p8 + SUCCEED_tb_pb + SUSPEND + SUSPEND_t8 + SUSPEND_t8_p8 + SUSPEND_t8_pb + SUSPEND_tb + SUSPEND_tb_p8 + SUSPEND_tb_pb + S_uv_add_overflow + S_uv_mul_overflow + S_uv_sub_overflow + sv_2bool_nomg + sv_2nv + sv_2pv_nomg + SvANY + SvARENA_CHAIN + SvARENA_CHAIN_SET + SvCANCOW + SvCANEXISTDELETE + sv_cathek + sv_catpvn_nomg_utf8_upgrade + SvCOMPILED + SvCOMPILED_off + SvCOMPILED_on + SV_CONST + SV_CONST_BINMODE + SV_CONST_CLEAR + SV_CONST_CLOSE + SV_CONST_DELETE + SV_CONST_DESTROY + SV_CONST_EOF + SV_CONST_EXISTS + SV_CONST_EXTEND + SV_CONST_FETCH + SV_CONST_FETCHSIZE + SV_CONST_FILENO + SV_CONST_FIRSTKEY + SV_CONST_GETC + SV_CONST_NEXTKEY + SV_CONST_OPEN + SV_CONST_POP + SV_CONST_PRINT + SV_CONST_PRINTF + SV_CONST_PUSH + SV_CONST_READ + SV_CONST_READLINE + SV_CONST_RETURN + SV_CONST_SCALAR + SV_CONSTS_COUNT + SV_CONST_SEEK + SV_CONST_SHIFT + SV_CONST_SPLICE + SV_CONST_STORE + SV_CONST_STORESIZE + SV_CONST_TELL + SV_CONST_TIEARRAY + SV_CONST_TIEHANDLE + SV_CONST_TIEHASH + SV_CONST_TIESCALAR + SV_CONST_UNSHIFT + SV_CONST_UNTIE + SV_CONST_WRITE + SV_COW_OTHER_PVS + SV_COW_REFCNT_MAX + SV_COW_SHARED_HASH_KEYS + SvDESTROYABLE + sv_dup_inc_NN + SvEND_set + SvENDx + SvFAKE + SvFAKE_off + SvFAKE_on + SVf_AMAGIC + SVf_BREAK + SVf_FAKE + SVf_IOK + SVf_IsCOW + SVf_IVisUV + SvFLAGS + SVf_NOK + SVf_OK + SVf_OOK + SVf_POK + SVf_PROTECT + SVf_READONLY + SVf_ROK + SVf_THINKFIRST + SvGID + SvGMAGICAL + SvGMAGICAL_off + SvGMAGICAL_on + Sv_Grow + SvGROW_mutable + SvIMMORTAL + SvIMMORTAL_INTERP + SvIMMORTAL_TRUE + SvIOK_nog + SvIOK_nogthink + SvIOKp_on + SvIsCOW_off + SvIsCOW_on + SvIsCOW_static + SvIS_FREED + SvIsUV + SvIsUV_off + SvIsUV_on + SvIV_please + SvIV_please_nomg + SvIVx + SvIVXx + SvLENx + SvMAGIC + SvMAGICAL + SvMAGICAL_off + SvMAGICAL_on + SV_MUTABLE_RETURN + SvNIOK_nog + SvNIOK_nogthink + SvNOK_nog + SvNOK_nogthink + SvNOKp_on + SvNVx + SvNVXx + SvOBJECT + SvOBJECT_off + SvOBJECT_on + SvOK_off + SvOK_off_exc_UV + SvOKp + SvOOK_on + sv_or_pv_len_utf8 + SvOURSTASH + SvOURSTASH_set + SvPADMY + SvPADMY_on + SvPAD_OUR + SVpad_OUR + SvPAD_OUR_on + SvPADSTALE + SvPADSTALE_off + SvPADSTALE_on + SvPAD_STATE + SVpad_STATE + SvPAD_STATE_on + SvPADTMP + SvPADTMP_off + SvPADTMP_on + SvPAD_TYPED + SVpad_TYPED + SvPAD_TYPED_on + SVpav_REAL + SVpav_REIFY + SvPCS_IMPORTED + SvPCS_IMPORTED_off + SvPCS_IMPORTED_on + SvPEEK + SVpgv_GP + SVphv_CLONEABLE + SVphv_HasAUX + SVphv_HASKFLAGS + SVphv_LAZYDEL + SVphv_SHAREKEYS + SVp_IOK + SVp_NOK + SvPOK_byte_nog + SvPOK_byte_nogthink + SvPOK_byte_pure_nogthink + SvPOK_nog + SvPOK_nogthink + SvPOK_or_cached_IV + SvPOKp_on + SvPOK_pure_nogthink + SvPOK_utf8_nog + SvPOK_utf8_nogthink + SvPOK_utf8_pure_nogthink + SV_POSBYTES + SVp_POK + SVppv_STATIC + SVprv_PCS_IMPORTED + SVprv_WEAKREF + SVp_SCREAM + SvPV_flags_const_nolen + sv_pvn_force_nomg + SvREFCNT_IMMORTAL + SvRMAGICAL + SvRMAGICAL_off + SvRMAGICAL_on + SvRV_const + SvRVx + SvSCREAM + SvSCREAM_off + SvSCREAM_on + sv_setgid + SvSetSV_and + SvSetSV_nosteal_and + sv_setuid + SVs_GMG + SvSHARED_HEK_FROM_PV + SvSMAGICAL + SvSMAGICAL_off + SvSMAGICAL_on + SVs_OBJECT + SVs_RMG + SVs_SMG + SvTAIL + SvTEMP + SvTEMP_off + SvTEMP_on + SVt_FIRST + SvTHINKFIRST + SvTIED_mg + SVt_MASK + SVt_PVBM + SvTRUEx_nomg + SVt_RV + SVTYPEMASK + SvUID + SV_UNDEF_RETURNS_NULL + SvUOK_nog + SvUOK_nogthink + SvUVx + SvVALID + SvWEAKREF + SvWEAKREF_off + SvWEAKREF_on + SWITCHSTACK + SYSTEM_GMTIME_MAX + SYSTEM_GMTIME_MIN + SYSTEM_LOCALTIME_MAX + SYSTEM_LOCALTIME_MIN + TAIL + TAIL_t8 + TAIL_t8_p8 + TAIL_t8_pb + TAIL_tb + TAIL_tb_p8 + TAIL_tb_pb + TARGi + TARGn + TARGu + tC + THREAD_CREATE_NEEDS_STACK + tI + TIED_METHOD_ARGUMENTS_ON_STACK + TIED_METHOD_MORTALIZE_NOT_NEEDED + TIED_METHOD_SAY + toCTRL + toFOLD_LC + toFOLD_uni + TO_INTERNAL_SIZE + toLOWER_uni + TOO_LATE_FOR + TOO_NAUGHTY + TO_OUTPUT_WARNINGS + TOPi + TOPl + TOPm1s + TOPMARK + TOPn + to_posix_FOLD + to_posix_LOWER + to_posix_UPPER + TOPp + TOPp1s + TOPpx + TOPu + TOPul + toTITLE_uni + toU8_FOLD_LC + toU8_LOWER_LC + toU8_UPPER_LC + toUPPER_LATIN1_MOD + toUPPER_LC + toUPPER_uni + toUSE_UNI_CHARSET_NOT_DEPENDS + TR_DELETE + TRIE + TRIE_BITMAP + TRIE_BITMAP_BYTE + TRIE_BITMAP_CLEAR + TRIE_BITMAP_SET + TRIE_BITMAP_TEST + TRIEC + TRIE_CHARCOUNT + TRIEC_t8 + TRIEC_t8_p8 + TRIEC_t8_pb + TRIEC_tb + TRIEC_tb_p8 + TRIEC_tb_pb + TRIE_next + TRIE_next_fail + TRIE_next_fail_t8 + TRIE_next_fail_t8_p8 + TRIE_next_fail_t8_pb + TRIE_next_fail_tb + TRIE_next_fail_tb_p8 + TRIE_next_fail_tb_pb + TRIE_next_t8 + TRIE_next_t8_p8 + TRIE_next_t8_pb + TRIE_next_tb + TRIE_next_tb_p8 + TRIE_next_tb_pb + TRIE_NODEIDX + TRIE_NODENUM + TRIE_STCLASS + TRIE_STUDY_OPT + TRIE_t8 + TRIE_t8_p8 + TRIE_t8_pb + TRIE_tb + TRIE_tb_p8 + TRIE_tb_pb + TRIE_WORDS_OFFSET + TR_OOB + TR_R_EMPTY + TR_SPECIAL_HANDLING + TRUE + TR_UNLISTED + TR_UNMAPPED + TRYAGAIN + tryAMAGICbin_MG + tryAMAGICunDEREF + tryAMAGICun_MG + TS_W32_BROKEN_LOCALECONV + tTHX + TURN_OFF_WARNINGS_IN_SUBSTITUTE_PARSE + TWO_BYTE_UTF8_TO_NATIVE + TWO_BYTE_UTF8_TO_UNI + TYPE_CHARS + TYPE_DIGITS + TZSET_LOCK + TZSET_UNLOCK + U16_MAX + U16_MIN + U32_MAX + U32_MAX_P1 + U32_MAX_P1_HALF + U32_MIN + U8_MAX + U8_MIN + U8TO32_LE + U8TO64_LE + UCHARAT + U_I + UINT + U_L + UNICODE_ALLOW_ABOVE_IV_MAX + UNICODE_ALLOW_ANY + UNICODE_ALLOW_SUPER + UNICODE_ALLOW_SURROGATE + UNICODE_BYTE_ORDER_MARK + UNICODE_DOT_DOT_VERSION + UNICODE_DOT_VERSION + UNICODE_GOT_NONCHAR + UNICODE_GOT_SUPER + UNICODE_GOT_SURROGATE + UNICODE_GREEK_CAPITAL_LETTER_SIGMA + UNICODE_GREEK_SMALL_LETTER_FINAL_SIGMA + UNICODE_GREEK_SMALL_LETTER_SIGMA + UNICODE_IS_32_CONTIGUOUS_NONCHARS + UNICODE_IS_BYTE_ORDER_MARK + UNICODE_IS_END_PLANE_NONCHAR_GIVEN_NOT_SUPER + UNICODE_IS_NONCHAR_GIVEN_NOT_SUPER + UNICODE_MAJOR_VERSION + UNICODE_PAT_MOD + UNICODE_PAT_MODS + UNICODE_SURROGATE_FIRST + UNICODE_SURROGATE_LAST + UNI_IS_INVARIANT + UNI_SEMANTICS + UNISKIP + UNKNOWN_ERRNO_MSG + UNLESSM + UNLESSM_t8 + UNLESSM_t8_p8 + UNLESSM_t8_pb + UNLESSM_tb + UNLESSM_tb_p8 + UNLESSM_tb_pb + UNLINK + UNLOCK_LC_NUMERIC_STANDARD + UNOP_AUX_item_sv + unpackWARN1 + unpackWARN2 + unpackWARN3 + unpackWARN4 + UPDATE_WARNINGS_LOC + UPG_VERSION + uproot_SV + U_S + USE_ENVIRON_ARRAY + USE_GRENT_BUFFER + USE_GRENT_FPTR + USE_GRENT_PTR + USE_HOSTENT_BUFFER + USE_HOSTENT_ERRNO + USE_HOSTENT_PTR + USE_LEFT + USE_LOCALE + USE_LOCALE_ADDRESS + USE_LOCALE_COLLATE + USE_LOCALE_CTYPE + USE_LOCALE_IDENTIFICATION + USE_LOCALE_MEASUREMENT + USE_LOCALE_MESSAGES + USE_LOCALE_MONETARY + USE_LOCALE_NAME + USE_LOCALE_NUMERIC + USE_LOCALE_PAPER + USE_LOCALE_SYNTAX + USE_LOCALE_TELEPHONE + USE_LOCALE_THREADS + USE_LOCALE_TIME + USE_LOCALE_TOD + USEMYBINMODE + USE_NETENT_BUFFER + USE_NETENT_ERRNO + USE_NETENT_PTR + USE_PL_CUR_LC_ALL + USE_PL_CURLOCALES + USE_POSIX_2008_LOCALE + USE_PROTOENT_BUFFER + USE_PROTOENT_PTR + USE_PWENT_BUFFER + USE_PWENT_FPTR + USE_PWENT_PTR + USE_QUERYLOCALE + USER_PROP_MUTEX_INIT + USER_PROP_MUTEX_LOCK + USER_PROP_MUTEX_TERM + USER_PROP_MUTEX_UNLOCK + USE_SERVENT_BUFFER + USE_SERVENT_PTR + USE_SPENT_BUFFER + USE_SPENT_PTR + USE_STAT_RDEV + USE_SYSTEM_GMTIME + USE_SYSTEM_LOCALTIME + USE_THREAD_SAFE_LOCALE + USE_TM64 + USE_UTF8_IN_NAMES + UTF + UTF8_ACCUMULATE + UTF8_ALLOW_ANY + UTF8_ALLOW_ANYUV + UTF8_ALLOW_DEFAULT + UTF8_ALLOW_FE_FF + UTF8_ALLOW_FFFF + UTF8_ALLOW_LONG_AND_ITS_VALUE + UTF8_ALLOW_SURROGATE + UTF8_DIE_IF_MALFORMED + UTF8_DISALLOW_ABOVE_31_BIT + UTF8_DISALLOW_FE_FF + UTF8_EIGHT_BIT_HI + UTF8_EIGHT_BIT_LO + UTF8_FORCE_WARN_IF_MALFORMED + UTF8_GOT_ABOVE_31_BIT + UTF8_GOT_LONG_WITH_VALUE + UTF8_IS_ABOVE_LATIN1 + UTF8_IS_ABOVE_LATIN1_START + UTF8_IS_CONTINUATION + UTF8_IS_CONTINUED + UTF8_IS_DOWNGRADEABLE_START + UTF8_IS_NEXT_CHAR_DOWNGRADEABLE + UTF8_IS_NONCHAR_GIVEN_THAT_NON_SUPER_AND_GE_PROBLEMATIC + UTF8_IS_START + UTF8_IS_START_base + UTF8_MAX_FOLD_CHAR_EXPAND + UTF8_MAXLEN + UTF8_MIN_CONTINUATION_BYTE + utf8_to_utf16 + utf8_to_utf16_reversed + UTF8_TWO_BYTE_HI + UTF8_TWO_BYTE_HI_nocast + UTF8_TWO_BYTE_LO + UTF8_TWO_BYTE_LO_nocast + UTF8_WARN_ABOVE_31_BIT + UTF8_WARN_FE_FF + UTF_ACCUMULATION_SHIFT + UTF_CONTINUATION_BYTE_INFO_BITS + UTF_CONTINUATION_MARK + UTF_CONTINUATION_MASK + UTF_EBCDIC_CONTINUATION_BYTE_INFO_BITS + UTF_FIRST_CONT_BYTE + UTF_IS_CONTINUATION_MASK + UTF_MIN_ABOVE_LATIN1_BYTE + UTF_MIN_CONTINUATION_BYTE + UTF_MIN_START_BYTE + UTF_START_BYTE + UTF_START_MARK + UTF_START_MASK + UTF_TO_NATIVE + UV_DIG + UV_MAX_P1 + UV_MAX_P1_HALF + VCMP + VERB + VERB_t8 + VERB_t8_p8 + VERB_t8_pb + VERB_tb + VERB_tb_p8 + VERB_tb_pb + vFAIL + vFAIL2 + vFAIL2utf8f + vFAIL3 + vFAIL3utf8f + vFAIL4 + VNORMAL + VNUMIFY + VOL + VOLATILE_REF + VSTRINGIFY + vTHX + VT_NATIVE + vtohl + vtohs + VTYPECHECK + VUTIL_REPLACE_CORE + VVERIFY + vWARN + vWARN3 + vWARN4 + vWARN5 + vWARN_dep + VXS + VXS_CLASS + VXSp + VXS_RETURN_M_SV + VXSXSDP + want_vtbl_bm + want_vtbl_fm + WARN_ALLstring + WARN_DEFAULTstring + WARN_NONEstring + warn_non_literal_string + WARNshift + WARNsize + what_MULTI_CHAR_FOLD_latin1_safe + what_MULTI_CHAR_FOLD_utf8_safe + WHILEM + WHILEM_A_max + WHILEM_A_max_fail + WHILEM_A_max_fail_t8 + WHILEM_A_max_fail_t8_p8 + WHILEM_A_max_fail_t8_pb + WHILEM_A_max_fail_tb + WHILEM_A_max_fail_tb_p8 + WHILEM_A_max_fail_tb_pb + WHILEM_A_max_t8 + WHILEM_A_max_t8_p8 + WHILEM_A_max_t8_pb + WHILEM_A_max_tb + WHILEM_A_max_tb_p8 + WHILEM_A_max_tb_pb + WHILEM_A_min + WHILEM_A_min_fail + WHILEM_A_min_fail_t8 + WHILEM_A_min_fail_t8_p8 + WHILEM_A_min_fail_t8_pb + WHILEM_A_min_fail_tb + WHILEM_A_min_fail_tb_p8 + WHILEM_A_min_fail_tb_pb + WHILEM_A_min_t8 + WHILEM_A_min_t8_p8 + WHILEM_A_min_t8_pb + WHILEM_A_min_tb + WHILEM_A_min_tb_p8 + WHILEM_A_min_tb_pb + WHILEM_A_pre + WHILEM_A_pre_fail + WHILEM_A_pre_fail_t8 + WHILEM_A_pre_fail_t8_p8 + WHILEM_A_pre_fail_t8_pb + WHILEM_A_pre_fail_tb + WHILEM_A_pre_fail_tb_p8 + WHILEM_A_pre_fail_tb_pb + WHILEM_A_pre_t8 + WHILEM_A_pre_t8_p8 + WHILEM_A_pre_t8_pb + WHILEM_A_pre_tb + WHILEM_A_pre_tb_p8 + WHILEM_A_pre_tb_pb + WHILEM_B_max + WHILEM_B_max_fail + WHILEM_B_max_fail_t8 + WHILEM_B_max_fail_t8_p8 + WHILEM_B_max_fail_t8_pb + WHILEM_B_max_fail_tb + WHILEM_B_max_fail_tb_p8 + WHILEM_B_max_fail_tb_pb + WHILEM_B_max_t8 + WHILEM_B_max_t8_p8 + WHILEM_B_max_t8_pb + WHILEM_B_max_tb + WHILEM_B_max_tb_p8 + WHILEM_B_max_tb_pb + WHILEM_B_min + WHILEM_B_min_fail + WHILEM_B_min_fail_t8 + WHILEM_B_min_fail_t8_p8 + WHILEM_B_min_fail_t8_pb + WHILEM_B_min_fail_tb + WHILEM_B_min_fail_tb_p8 + WHILEM_B_min_fail_tb_pb + WHILEM_B_min_t8 + WHILEM_B_min_t8_p8 + WHILEM_B_min_t8_pb + WHILEM_B_min_tb + WHILEM_B_min_tb_p8 + WHILEM_B_min_tb_pb + WHILEM_t8 + WHILEM_t8_p8 + WHILEM_t8_pb + WHILEM_tb + WHILEM_tb_p8 + WHILEM_tb_pb + WIN32SCK_IS_STDSCK + withinCOUNT + with_tp_UTF8ness + with_t_UTF8ness + WORTH_PER_WORD_LOOP + WORTH_PER_WORD_LOOP_BINMODE + WSETLOCALE_LOCK + WSETLOCALE_UNLOCK + XDIGIT_VALUE + xI + xio_any + xio_dirp + xI_offset + xiv_iv + xlv_targoff + XOPd_xop_class + XOPd_xop_desc + XOPd_xop_dump + XOPd_xop_name + XOPd_xop_peep + XOPf_xop_class + XOPf_xop_desc + XOPf_xop_dump + XOPf_xop_name + XOPf_xop_peep + XORSHIFT128_set + XPUSHTARG + XPUSHundef + xpv_len + XS_DYNAMIC_FILENAME + XTENDED_PAT_MOD + xuv_uv + xV_FROM_REF + YYEMPTY + YYSTYPE_IS_TRIVIAL + ZAPHOD32_FINALIZE + ZAPHOD32_MIX + ZAPHOD32_SCRAMBLE32 + ZAPHOD32_WARN2 + ZAPHOD32_WARN3 + ZAPHOD32_WARN4 + ZAPHOD32_WARN5 + ZAPHOD32_WARN6 + aTHXo_ + aTHXx_ + BASE_TWO_BYTE_HI_ + BASE_TWO_BYTE_LO_ + CC_ALPHA_ + CC_ALPHANUMERIC_ + CC_ASCII_ + CC_BINDIGIT_ + CC_BLANK_ + CC_CASED_ + CC_CHARNAME_CONT_ + CC_CNTRL_ + CC_DIGIT_ + CC_GRAPH_ + CC_IDFIRST_ + CC_IS_IN_SOME_FOLD_ + CC_LOWER_ + CC_MAGICAL_ + CC_mask_ + CC_mask_A_ + CC_MNEMONIC_CNTRL_ + CC_NON_FINAL_FOLD_ + CC_NONLATIN1_FOLD_ + CC_NONLATIN1_SIMPLE_FOLD_ + CC_OCTDIGIT_ + CC_PRINT_ + CC_PUNCT_ + CC_QUOTEMETA_ + CC_SPACE_ + CC_UPPER_ + CC_VERTSPACE_ + CC_WORDCHAR_ + CC_XDIGIT_ + CHECK_AND_OUTPUT_WIDE_LOCALE_CP_MSG_ + CHECK_AND_OUTPUT_WIDE_LOCALE_UTF8_MSG_ + CHECK_AND_WARN_PROBLEMATIC_LOCALE_ + CHECK_MALLOC_TOO_LATE_FOR_ + DEBUG__ + DEBUG_A_TEST_ + DEBUG_BOTH_FLAGS_TEST_ + DEBUG_B_TEST_ + DEBUG_c_TEST_ + DEBUG_C_TEST_ + DEBUG_D_TEST_ + DEBUG_f_TEST_ + DEBUG_h_TEST_ + DEBUG_i_TEST_ + DEBUG_J_TEST_ + DEBUG_l_TEST_ + DEBUG_L_TEST_ + DEBUG_Lv_TEST_ + DEBUG_m_TEST_ + DEBUG_M_TEST_ + DEBUG_o_TEST_ + DEBUG_p_TEST_ + DEBUG_P_TEST_ + DEBUG_Pv_TEST_ + DEBUG_q_TEST_ + DEBUG_r_TEST_ + DEBUG_R_TEST_ + DEBUG_s_TEST_ + DEBUG_S_TEST_ + DEBUG_t_TEST_ + DEBUG_T_TEST_ + DEBUG_u_TEST_ + DEBUG_U_TEST_ + DEBUG_Uv_TEST_ + DEBUG_v_TEST_ + DEBUG_x_TEST_ + DEBUG_X_TEST_ + DEBUG_Xv_TEST_ + DEBUG_y_TEST_ + DEBUG_yv_TEST_ + DFA_RETURN_FAILURE_ + DFA_RETURN_SUCCESS_ + DFA_TEASE_APART_FF_ + EXTEND_NEEDS_GROW_ + EXTEND_SAFE_N_ + FAIL_ + FUNCTION__ + generic_func_utf8_safe_ + generic_invlist_utf8_safe_ + generic_invlist_uvchr_ + generic_isCC_ + generic_isCC_A_ + generic_LC_ + generic_LC_base_ + generic_LC_func_utf8_safe_ + generic_LC_invlist_utf8_safe_ + generic_LC_invlist_uvchr_ + generic_LC_non_invlist_utf8_safe_ + generic_LC_utf8_safe_ + generic_LC_uvchr_ + generic_non_invlist_utf8_safe_ + generic_utf8_safe_ + generic_utf8_safe_no_upper_latin1_ + generic_uvchr_ + HAS_IGNORED_LOCALE_CATEGORIES_ + HIGHEST_REGCOMP_DOT_H_SYNC_ + inRANGE_helper_ + invlist_intersection_ + invlist_intersection_complement_2nd_ + invlist_subtract_ + invlist_union_ + invlist_union_complement_2nd_ + is_MULTI_CHAR_FOLD_utf8_safe_part0_ + is_MULTI_CHAR_FOLD_utf8_safe_part1_ + is_MULTI_CHAR_FOLD_utf8_safe_part2_ + is_MULTI_CHAR_FOLD_utf8_safe_part3_ + KEY___CLASS__ + KEY___DATA__ + KEY___END__ + KEY___FILE__ + KEY___LINE__ + KEY___PACKAGE__ + KEY___SUB__ + LC_ADDRESS_AVAIL_ + LC_COLLATE_AVAIL_ + LC_CTYPE_AVAIL_ + LC_IDENTIFICATION_AVAIL_ + LC_MEASUREMENT_AVAIL_ + LC_MESSAGES_AVAIL_ + LC_MONETARY_AVAIL_ + LC_NAME_AVAIL_ + LC_NUMERIC_AVAIL_ + LC_PAPER_AVAIL_ + LC_SYNTAX_AVAIL_ + LC_TELEPHONE_AVAIL_ + LC_TIME_AVAIL_ + LC_TOD_AVAIL_ + LOCALE_CATEGORIES_COUNT_ + LOCALE_LOCK_ + LOCALE_LOCK_DOES_SOMETHING_ + locale_panic_ + locale_panic_via_ + LOCALE_TERM_POSIX_2008_ + LOCALE_UNLOCK_ + lsbit_pos_uintmax_ + LZC_TO_MSBIT_POS_ + MBLEN_LOCK_ + MBLEN_UNLOCK_ + MBRLEN_LOCK_ + MBRLEN_UNLOCK_ + MBRTOWC_LOCK_ + MBRTOWC_UNLOCK_ + MBTOWC_LOCK_ + MBTOWC_UNLOCK_ + MEM_WRAP_CHECK_ + MEM_WRAP_NEEDS_RUNTIME_CHECK_ + MEM_WRAP_WILL_WRAP_ + msbit_pos_uintmax_ + NOT_IN_NUMERIC_STANDARD_ + NOT_IN_NUMERIC_UNDERLYING_ + NV_BODYLESS_UNION_ + o1_ + OFFUNISKIP_helper_ + PADNAME_BASE_ + PLATFORM_SYS_INIT_ + PLATFORM_SYS_TERM_ + pTHXo_ + pTHX__VALUE_ + pTHX_VALUE_ + pTHXx_ + RXf_PMf_CHARSET_SHIFT_ + RXf_PMf_SHIFT_COMPILETIME_ + RXf_PMf_SHIFT_NEXT_ + SAFE_FUNCTION__ + SBOX32_CASE_ + shifted_octet_ + STATIC_ASSERT_STRUCT_BODY_ + STATIC_ASSERT_STRUCT_NAME_ + SV_HEAD_ + SV_HEAD_DEBUG_ + SV_HEAD_UNION_ + _swab_16_ + _swab_32_ + _swab_64_ + toFOLD_utf8_flags_ + toLOWER_utf8_flags_ + TOO_LATE_FOR_ + toTITLE_utf8_flags_ + toUPPER_utf8_flags_ + type1_ + UNI_DISPLAY_TR_ + UNISKIP_BY_MSB_ + UTF8_CHECK_ONLY_BIT_POS_ + UTF8_DIE_IF_MALFORMED_BIT_POS_ + UTF8_FORCE_WARN_IF_MALFORMED_BIT_POS_ + UTF8_GOT_CONTINUATION_BIT_POS_ + UTF8_GOT_EMPTY_BIT_POS_ + UTF8_GOT_LONG_BIT_POS_ + UTF8_GOT_LONG_WITH_VALUE_BIT_POS_ + UTF8_GOT_NONCHAR_BIT_POS_ + UTF8_GOT_NON_CONTINUATION_BIT_POS_ + UTF8_GOT_OVERFLOW_BIT_POS_ + UTF8_GOT_SHORT_BIT_POS_ + UTF8_GOT_SUPER_BIT_POS_ + UTF8_GOT_SURROGATE_BIT_POS_ + UTF8_IS_SUPER_NO_CHECK_ + UTF8_NO_CONFIDENCE_IN_CURLEN_ + UTF8_NO_CONFIDENCE_IN_CURLEN_BIT_POS_ + utf8_safe_assert_ + UTF8_WARN_NONCHAR_BIT_POS_ + UTF8_WARN_SUPER_BIT_POS_ + UTF8_WARN_SURROGATE_BIT_POS_ + UTF_FIRST_CONT_BYTE_110000_ + UTF_START_BYTE_110000_ + WARN_HELPER_ + WCRTOMB_LOCK_ + WCRTOMB_UNLOCK_ + WCTOMB_LOCK_ + WCTOMB_UNLOCK_ + what_MULTI_CHAR_FOLD_utf8_safe_part0_ + what_MULTI_CHAR_FOLD_utf8_safe_part1_ + what_MULTI_CHAR_FOLD_utf8_safe_part2_ + what_MULTI_CHAR_FOLD_utf8_safe_part3_ + what_MULTI_CHAR_FOLD_utf8_safe_part4_ + what_MULTI_CHAR_FOLD_utf8_safe_part5_ + what_MULTI_CHAR_FOLD_utf8_safe_part6_ + what_MULTI_CHAR_FOLD_utf8_safe_part7_ + withinCOUNT_KNOWN_VALID_ + WRAP_U8_LC_ + XPVCV_COMMON_ + XPV_HEAD_ +); + +# This is a list of symbols that are used by the OS and which perl may need to +# define or redefine, and which aren't otherwise currently detectable by this +# program's algorithms as being such. They are not namespace pollutants +my @system_symbols = qw( + INT32_MIN + INT64_MIN + LDBL_DIG + O_CREAT + O_RDWR + O_WRONLY + S_IWGRP + S_IWUSR + S_IXGRP + S_IXUSR + __setfdccsid + __attribute__format__null_ok__ +); + +# This is a list of symbols that are needed by the ext/re module, and are not +# documented. They become undefined for any other modules. +my @needed_by_ext_re = qw( +); + +# This is a list of symbols that are needed by various ext/ modules, and are +# not documented. They become undefined for any other modules. +my @needed_by_ext = qw( +); + +my %unresolved_visibility_overrides; +$unresolved_visibility_overrides{$_} = 1 for @unresolved_visibility_overrides; + +my %system_symbols; +$system_symbols{$_} = 1 for @system_symbols; + +my %needed_by_ext_re; +$needed_by_ext_re{$_} = 1 for @needed_by_ext_re; + +my %needed_by_ext; +$needed_by_ext{$_} = 1 for @needed_by_ext; + +# Keep lists of symbols to undef under various conditions. We can initialize +# the two ones for perl extensions with the lists above. +my %always_undefs; +my %non_ext_re_undefs = %needed_by_ext_re; +my %non_ext_undefs = %needed_by_ext; + # See database of global and static function prototypes in embed.fnc # This is used to generate prototype headers under various configurations, # export symbols lists for different platforms, and macros to provide an @@ -778,6 +6221,21 @@ sub embed_h { my $embed= $_->{embed} or next; my ($flags,$retval,$func,$args) = @{$embed}{qw(flags return_type name args)}; + + # Macros with [oO] don't appear without a [Pp]erl_ prefix, so nothing + # to undef + if ($flags =~ /m/ && $flags !~ /[oO]/) { + if ($flags !~ /[ACE]/) { # No external visibility + $always_undefs{$func} = 1 + unless defined $unresolved_visibility_overrides{$func}; + } + elsif ($flags =~ /E/) { # Visible to perl extensions + $non_ext_undefs{$func} = 1 + unless defined $unresolved_visibility_overrides{$func} + or defined $needed_by_ext{$func}; + } + } + my $full_name = full_name($func, $flags); next if $full_name eq $func; # Don't output a no-op. @@ -910,15 +6368,11 @@ sub generate_embed_h { print $em <<~'END'; /* (Doing namespace management portably in C is really gross.) */ - /* By defining PERL_NO_SHORT_NAMES (not done by default) the short forms - * (like warn instead of Perl_warn) for the API are not defined. - * Not defining the short forms is a good thing for cleaner embedding. - * BEWARE that a bunch of macros don't have long names, so either must be - * added or don't use them if you define this symbol */ + /* When this symbol is defined, we undef various symbols we have defined + * earlier when this file was #included with this symbol undefined */ + #if ! defined(PERL_DO_UNDEFS) - #ifndef PERL_NO_SHORT_NAMES - - /* Hide global symbols */ + /* Create short name macros that hide any need for thread context */ END @@ -928,8 +6382,6 @@ sub generate_embed_h { print $em <<~'END'; - #endif /* #ifndef PERL_NO_SHORT_NAMES */ - #if !defined(PERL_CORE) /* Compatibility stubs. Compile extensions with -DPERL_NOCOMPAT to * disable them. @@ -956,9 +6408,7 @@ sub generate_embed_h { provides a set of compatibility functions that don't take an extra argument but grab the context pointer using the macro dTHX. */ - #if defined(MULTIPLICITY) \ - && !defined(PERL_NO_SHORT_NAMES) \ - && !defined(PERL_WANT_VARARGS) + #if defined(MULTIPLICITY) && !defined(PERL_WANT_VARARGS) END foreach (@have_compatibility_macros) { @@ -978,7 +6428,35 @@ sub generate_embed_h { print $em indent_define("Perl_${_}_nocontext", "Perl_$_", " "); } + print $em <<~EOT; + #endif /* !defined(MULTIPLICITY) */ + #elif ! defined(PERL_CORE) + EOT + + # We undefine all elements on the list of symbol names to keep from user + # name space if PERL_NO_SHORT_NAMES is in effect (which requests this), + # but override it if are compiling the core. + for my $i ( + [ "", \%always_undefs ], + [ '#ifndef PERL_EXT_RE_BUILD', \%non_ext_re_undefs ], + [ '#ifndef PERL_EXT', \%non_ext_undefs ], + ) + { + my $ifdef = $i->[0]; + my $hash = $i->[1]; + + print $em $ifdef, "\n" if $ifdef; + for my $name ( sort { lc $a cmp lc $b + or $a cmp $b + } keys %{$hash}) + { + print $em "#undef $name\n"; + } + print $em "#endif\n" if $ifdef; + } + print $em "#endif\n"; + close $em; normalize_and_print('embed.h',$embed_buffer) @@ -1016,11 +6494,203 @@ sub generate_embedvar_h { unless $error_count; } +sub recurse_conds { + + # Look through the list of conditionals that HeaderParser generates, + # looking for occurrences of the regex $pattern, returning true if found; + # false otherwise. + + my $status = 0; + my ($pattern, @conds) = @_; + for my $this_cond (@conds) { + + # Recurse if necessary + if (ref $this_cond eq 'ARRAY') { + $status |= recurse_conds($pattern, $this_cond->@*); + return $status if $status; # Early return if found + } + else { + $status |= $this_cond =~ $pattern; + return $status if $status; # Early return if found + } + } + + return 0; +} + +my %visibility; + +sub process_apidoc_lines { + + # Look through the input array of lines for ones that can declare the + # visibility of a symbol, and add those that are visible externally to + # that list; and those that are visible to perl extensions to that list + + my $group_flags; + for my $individual_line (@_) { + next unless $individual_line =~ + m/ ^=for \s+ apidoc (\b | _defn | _item) \s* (.+) /x; + my $type = $1; + + # A full-blown declaration has all these fields + my ($flags, $return_type, $name, @rest) = split /\s*\|\s*/, $2; + + # But some lines look like '=for apidoc foo' where the rest of the + # data comes from elsewhere. For these, shift. + if (! defined $return_type) { + $name = $flags; + $flags = ""; + } + + # These declarations may come in groups with the first line being + # 'apidoc', and the remaining ones 'apidoc_item'. The flags parameter + # of the 'apidoc' line applies to the rest, though those may add flags + # individually. + if ($type ne "_item" ) { + $group_flags = $flags; + } + elsif ($flags) { + $flags .= $group_flags; + } + else { + $flags = $group_flags; + } + + # If no flag indicates any external visibility, we are done with this + # one. + $flags =~ s/[^ACE]//g; + next unless $flags; + + #next if defined $needed_by_ext{$name}; + #next if defined $needed_by_ext_re{$name}; + + #die_at_end "${name}'s visibility is declared more than once" + #if defined $visibility{$name}; + $visibility{$name} = $flags; + } +} + +sub find_undefs { + + # Find all the #defines that are visible to modules and which aren't + # marked as such nor whose names indicate they are reserved for Perl's + # use. + # + # First examine the passed in data from embed.fnc; + my $all = shift; + foreach my $entry ($all->@*) { + next unless $entry->embed; + my $flags = $entry->embed->{flags}; + $flags =~ s/[^ACE]//g; + next unless $flags; # No visibility + $visibility{$entry->embed->{name}} = $flags; + } + + # Then examine every top-level header. And we also examine the top + # level dot c files looking for symbols that are supposed to be visible. + my @header_list; + my @c_list; + open my $mf, "<", "MANIFEST" or die "Can't open MANIFEST: $!"; + while (defined (my $file = <$mf>)) { + chomp $file;; + $file =~ s/ \s .* //x; + next if $file =~ m,/,; + next if defined $skip_files{$file}; + + push @header_list, $file if $file =~ / ( \.h | \.inc ) \b /x; + push @c_list, $file if $file =~ / \.c \b /x; + } + close $mf or die "Can't close MANIFEST: $!"; + + # There are a few cases where we redefine a system function to use the + # 64-bit equivalent one that has a different name. They currenty all look + # like this. These symbols would show up as #defines that shouldn't have + # external visibility. + my $has_64_pattern = qr / ( HAS | USE ) _ \w* 64 /x; + + foreach my $hdr (@header_list) { + + # Parse the header + my $lines = HeaderParser->new()->read_file($hdr)->lines(); + foreach my $line ($lines->@*) { + + # We are here looking only for #defines and visibility + # declarations + next unless $line->{type} eq 'content'; + + # First, for #defines. + if ($line->{sub_type} eq '#define') { + + # HeaderParser stripped off most everything. + my $flat = $line->{flat}; + + # Just the symbol and its definition + $flat =~ s/ ^ \s* \# \s* define \s+ //x; + + # Just the symbol, no arglist nor definition + $flat =~ s/ (?: \s | \( ) .* //x; + + # These are reserved for Perl's use, so not a problem. + next if $flat =~ / ^ PL_ /x; + next if $flat =~ /perl/i; + + # Presume that we are to keep this out of the user's namespace + $always_undefs{$flat} = 1; + + # Often perl has code to make sure various symbols that are + # always expected by the system to be defined, in fact are. + # These don't constitute namespace pollution. So, if perl + # defines a symbol only if it already isn't defined, we add it + # to the list of system symbols + my $pattern = qr/ ! \s* defined\($flat\)/x; + if ( recurse_conds($pattern, $line->{cond}->@*) + || recurse_conds($has_64_pattern, $line->{cond}->@*)) + { + $system_symbols{$flat} = 1; + } + } + else { + + # Otherwise check for a visibility declaration. + next unless $line->{sub_type} eq 'text'; + + # Only comments have apidoc lines. + next unless $line->{flat} eq ""; + + next unless $line->{line} =~ / ^ =for \s+ apidoc /mx; + process_apidoc_lines(split /\n/, $line->{line}); + } + } + } # Done with headers + + # Now look through the C and pod files + foreach my $pod (@c_list, @pod_list) { + open my $pfh, "<", $pod or die "Can't open $pod: $!"; + process_apidoc_lines(<$pfh>); + close $pfh or die "Can't close $pod: $!"; + } + + # Here, have found all the externally visible macro definitions. We will + # undef all of them that aren't expected to be visible and aren't + # otherwise needed to be visible. + foreach my $entry (keys %system_symbols, + %needed_by_ext, + %needed_by_ext_re, + %visibility, + %unresolved_visibility_overrides + ) + { + delete $always_undefs{$entry}; + } + +} + sub update_headers { my ($all, $api, $ext, $core) = setup_embed(); # see regen/embed_lib.pl generate_proto_h($all); die_at_end "$unflagged_pointers pointer arguments to clean up\n" if $unflagged_pointers; + find_undefs($all); generate_embed_h($all, $api, $ext, $core); generate_embedvar_h(); die "$error_count errors found" if $error_count;