[perl #89940] File::Spec->tmpdir and env changes

If the environment changes, File::Spec->tmpdir should respect that and
recalculate the temp directory.

The only objection raised in the ticket was that File::Spec is already
accused of being too slow, so removing the cache would not be a good
idea.  So I put in a check to see whether the relevant environment
variables have changed since the last call to tmpdir.

File::Spec::Epoc: Small pod clean-up

Flush PL_stashcache on glob-to-glob assignment

Commit dc93d7fb33f6b2093 says this:

    Flush PL_stashcache when assigning a file handle to a typeglob.

    File handles take priority over stashes for method dispatch.
    Assigning a file handle to a typeglob potentially creates a file
    handle where one did not exist before.  As PL_stashcache only con-
    tains entries for names which unambiguously resolve to stashes,
    such a change may mean that PL_stashcache now contains an invalid
    entry.  As it’s hard to work out exactly which entries might be
    affected, simply flush the entire cache and let it rebuild itself.

But it only applied to io-to-glob assignment.  This commit extends it
to glob-to-glob assignment.

pp_hot.c: Correct comment

At this point, ob holds the object the reference points to, not the
reference itself.

podcheck.t: Output fixed problems as passing to-do tests

Improve fileno example

Quoting from the fileno section of this document:

"[...]  If there is no real file descriptor at the OS level, as can
happen with filehandles connected to memory objects via "open" with a
reference for the third argument, -1 is returned."

Update the example to cater for this situation. Thanks to
Niels Thykier for the suggestion.

Bug-Debian: http://bugs.debian.org/706749

add 1 to SvGROW under COW (and fix svleak.t)

the new COW scheme uses SvPVX(sv)[SvLEN(sv)-1] (if spare)
to store the COW reference count. If this byte isn't spare, the string is
copied rather than COWed.  So, when built under the new COW, allocate one
more byte than asked for in sv_grow(), to make it likely this byte is
always spare: and thus make more strings COW-able. If the new size is a
big power of two, don't bother: we assume the caller wanted a nice 2^N
sized block and will be annoyed at getting 2^N+1 or more.

Note that sv_grow() already rounds up. For example: formerly, strings of
length 1..15 were allocated 16 bytes, 16..31 allocated 32 bytes, etc
(usually allowing +1 for trailing \0).

Now its 1..14 => 16, 15..30 => 32 etc.

As a side-effect, this should fix a bizarre occasionally failing svleak.t
test under COW. This test,

    '"too many errors" from constant overloading returning undef'

basically twice evals some code that is expected to fail. If over the
course of the second eval the total number of allocated SVs grows, then
the test fails. This particular eval uses overload::constant, and that
module has this code:

    "$_[1]" !~ /(^|=)CODE\(0x[0-9a-f]+\)$/

i.e. match against a stringified reference. Now, if it stringifies to a
15-char string (e.g. "CODE(0x1234567)"), then SvCUR is 15 and SvLEN is 16,
and there isn't a spare byte (after allowing for \0) for the COW ref
count, so the string can't be COWed. Now, if during the first eval,
addresses are in the range 0x1000000..0xfffffff, then COW doesn't kick in.
If during the second eval they fall outside this range, COW kicks in, and
a new SV (which is a COW copy of the string) is attached to the regex, for
capture info. This new SV won't be released until the regex is released,
and so appears to be a leak. If COW kicks in during the first eval then
this isn't an issue, as it will just be reused during the second eval.

This was exceedingly difficult to reliably reproduce, as it was heavily
affected by kernel address randomisation (on linux); plus part of the test
file used rand(); plus of course the hash randomisation and perturbation
feature in 5.18.

I eventually cracked it by: tweaking the hash randomisation; hacking the
perl seed code to use an ENV var rather than /dev/urandom; hacking the
perl startup to display the initial system brk(), then when it failed,
hacked it again to set that particular brk().

[perl #117941] reset crashes when current stash is freed

perldiag: typo

[perl #117941] eval crashes when current stash is freed

[perl #117941] Blessing into freed current stash

If the current stash has been freed, bless() with one argument will
cause a crash when the object’s ‘stash’ is accessed.  Simply disallow-
ing this is the easiest fix.

[perl #117941] Handle vivification crashing w/freed stash

open’s handle vivification could crash if the current stash was freed,
so check before passing a freed stash to gv_init.

Stop using PL_sortstash

Originally, the value of PL_sortstash was used to determine whether
PL_firstgv and PL_secondgv (which point to *a and *b in the current
package) needed to be updated (involving symbol lookup).  PL_sortstash
would contain the last package sorted in.  If PL_sortstash did not
point to the current stash, then they would be updated, along with
PL_sortstash.

Sort was made reëntrant in 2000 in commit 8e664e1028b.  This involved
saving and restoring the values of PL_firstgv and PL_secondgv via the
savestack.  The logic introduced by that commit was thus:

+               if (PL_sortstash != stash || !PL_firstgv || !PL_secondgv) {
+                   SAVESPTR(PL_firstgv);
+                   SAVESPTR(PL_secondgv);
+                   PL_firstgv = gv_fetchpv("a", TRUE, SVt_PV);
+                   PL_secondgv = gv_fetchpv("b", TRUE, SVt_PV);
+                   PL_sortstash = stash;
+               }

PL_firstgv and PL_secondgv would be null if no sort were already hap-
pening, causing this block to be executed.  For a nested sort, this
would only be executed if the nested sort were in a different package
from the outer sort.

Because the value of PL_sortstash was not being restored, this block
would not trigger the second time the outer sort called the inner sort
(in a different package).  This was bug #36430 (a duplicate of #7063).

This was fixed in commit 9850bf21fc4e, which did not explain anything
in its commit message.  A preliminary version of the patch was submit-
ted for review in <20051026173901.GA3105@rpc142.cs.man.ac.uk>, which
mentions that the patch fixes bug #36430.

It fixed the bug by localising the value of PL_sortstash, causing the
if() condition to become redundant, so that was removed.

Now, it happened that that if() condition was the only place that
PL_sortstash was used.  So if we are going to localise PL_firstgv
and PL_secondgv unconditionally when sorting, PL_sortstash serves
no purpose.

While I could restore the if() condition and leave the localisation of
PL_sortstash in place, that would only benefit code that does nested
sort calls in the same package, which is rare, and the resulting
speed-up is barely measurable.

PL_sortstash is referenced by some CPAN modules, so I am taking
the cautious route of leaving it in for now, though the core
doesn’t use it.

[perl #24482] Fix sort and require to treat CORE:: as keyword

Allow qr/(?[ [a] ])/ interpolation in (?[...])

Interpolation fails if the interpolated extended character class con-
tains any bracketed character classes itself.

The sizing pass looks for [ and passes control to the regular charac-
ter class parser.  When the charclass is finished, it begins scanning
for [ again.  If it finds ], it assumes it is the end.

That fails with (?[  (?a:(?[  [a]  ]))  ]).  The sizing pass hands
[  [a]  ]... off to the charclass parser, which parses [  [a] and
hands control back to the sizing pass.  It then sees ‘  ]))  ])’,
assumes that the first ]) is the end of the entire construct, so the
main regexp parser sees the parenthesis following and dies.

If we change the sizing pass to look for ?[ we can simply record the
depth (depth++) and then when we see ] decrement the depth or exist
the loop if it is zero.

perldiag: Correct descr of ‘Expecting '(?flags:(?[...'’

I did not realise at first that (?:(?[...])) is forbidden.

Include the Encode extension in the ALL_STATIC build on Win32 for VC++

Thanks to Jan Dubois and Nicholas Clark for pointing out that Encode has
subextensions which need statically linking too, and that Configure has
a special case for handling this which we can mimic in config_sh.PL.

Unfortunately, however, while this works for VC++, with MinGW it gives
undefined reference errors to three symbols from Encode/CN.o
(_cp936_encoding, _euc_cn_encoding and MacChineseSimp_encoding) and two
from Encode/JP.o (_cp932_encoding and _euc_jp_encoding), so we must retain
the exclusion on Encode for MinGW for now, much like the Compress/Raw/Bzip2
problem found before. Hopefully these are all fixable soon.

Include the Win32 extension in the ALL_STATIC build on Win32

Many of Win32's Perl level functions are pre-defined (even without a "use
Win32" statement), while the implementation is in a dynamically linked
module. This is done via the statically linked Win32CORE wrapper that will
load Win32 on demand. The initialization of Win32CORE (init_Win32CORE()) is
called -- dynamically, via GetProcAddress(), since miniperl.exe doesn't
include it -- from Perl_init_os_extras() and normally relies on the DLL's
HANDLE having been set in the DLL_PROCESS_ATTACH case of DllMain() in
perllib.c. We must use a different HANDLE when the functions are located in
perl-static.exe since DllMain() is not called in that case, and, in fact,
it is sensible to consider other parts of DllMain() which
Perl_init_os_extras() might also need to do...

The #ifdef DEFAULT_BINMODE section can be scrapped completely since the
symbol is not defined, never mentioned anywhere else and not documented.
The DisableThreadLibraryCalls() call is not applicable for code that
doesn't reside in a DLL. That just leaves set_w32_module_name(), but that
is not required either, and may actually be redundant in the DllMain() case
too (maybe I will remove it later).

The last-but-one thing to do is to arrange for init_Win32CORE to be
exported from perl-static.exe (as it already is from perl519.dll, courtesy
of makedef.pl) otherwise GetProcAddress() won't find it. I see no harm in
always specifying __declspec(dllexport) in Win32CORE.c (except in one
existing Cygwin case which doesn't want it, which I'm not touching to
minimize regression risk). I thought that the .def file entry written by
makedef.pl for perl519.dll would then become redundant, and whilst the VC++
build worked fine without it, the MinGW build didn't: init_Win32CORE no
longer got exported from perl519.dll, thus breaking the normal build, so
I've therefore left makedef.pl alone.

The very last thing to do in some future change is to improve the
ALL_STATIC build so that Win32 functions like CopyFile() do not go
through Win32CORE's w32_CORE_all forwarding function as they currently do:
it isn't necessary when Win32 is statically linked as well! I will revisit
this part very soon...

Thanks to Jan Dubois and all the others in the following thread for
invaluable assistance in this and other recent changes in this area:
http://www.xray.mpe.mpg.de/mailing-lists/perl5-porters/2013-06/msg00016.html

version bumps and perldelta for debugger depth

adjust $DB::deep from 100 to 1000

$DB::deep defaults to 100; this means that when the debugger gets 100
levels deep in subroutine calls, it automatically breaks execution.
While this might have been appropriate in 1989, in modern Perl programs,
the debugger might break before the program is even compiled.

This patch adjusts the default value up to 1000.

I was not able to find the default value documented anywhere.

Stop delete local $ENV{foo} from leaking

It was only leaking when the env var did not already exist.

The code in question in pp.c:S_do_delete_local was calling hv_delete
to delete the element, which autovivifies, deletes, and returns a mag-
ical mortal for magical hashes.  It was assuming that if a value was
returned the element must have existed, so it was calling SvREFCNT_inc
on the returned mortal to de-mortalize it (since it has to be
restored).  Whether the element had existed previously was already
recorded in a bool named ‘preeminent’ (strange name).  This variable
should be checked before the SvREFCNT_inc.

I found the same bug in the array code path, potentially affecting
@- and @+, so I fixed it.  But I didn’t write a test, as that would
involve a custom regexp engine.

hv.c: Clarify uvar comment

It was not clear that it referred to uvar magic.

Don’t leak when compiling /(?[\d\d])/

The ‘Operand with no preceding operator’ error was leaking the last
two operands.

Free operand when encountering unmatched ')' in (?[])

I only need to free the operand (current), not the left-paren token
that turns out not to be a paren (lparen).

For lparen to leak, there would have to be two operands in a row on
the charclass parsing stack, which currently never happens.

Stop /(?[\p{...}])/ compilation from leaking

The swash returned by utf8_heavy.pl was not being freed in the code
path to handle returning character classes to the (?[...]) parser
(when ret_invlist is true).

Add a note to Win32's BUILD_STATIC configuration to include Win32CORE

Win32CORE needs to be included for the on-demand loading of Win32 to work.
(Many of Win32's Perl level functions are pre-defined (even without a "use
Win32" statement), while the implementation is in a dynamically linked
module.)

Exclude Compress/Raw/Bzip2 from ALL_STATIC extensions for MinGW for now

The ALL_STATIC=define build succeeds with VC++, but with MinGW it gives an
error about _BZ2_compressBlock (referenced from bzlib.o) being undefined.
I do not know why, so just exclude this extension from the list for now,
and add a note about it.

Simplify recipes for making perl-static.exe on Win32

There is no need to link the static extension libraries as well as the
static perl library because the entire contents of all the static extension
libraries have been put into the static perl library anyway.

Also put the list of objects and libraries which perl.exe and
perl-static.exe link against in the same order as each other, and in both
makefiles, and (in makefile.mk) for both compilers, so that the
similarities and differences are more readily seen.

Fix creation of libperl519s.a on Win32 with MinGW

The "ar rc" command created an invalid static perl library by putting the
static extension libraries themselves into the library rather than putting
the objects from each static extension library into it as intended (like
the VC++ "link -lib" command does).

We now extract each static extension library's objects into a temporary
directory and put the objects from there into the static perl library.

Remove /PDB:NONE linker option from Win32 makefiles

The /PDB linker option syntax changed from /PDB:{filename|NONE} to just
/PDB:filename from VC7 onwards. We do not use /PDB:NONE for most targets
anyway, so just remove it from the one place it is present to avoid
accidentally creating a file called "NONE" with all but VC6.

Ensure Win32 [nd]make builds the 'static' target when ALL_STATIC=define

Stop (?[]) operators from leaking

When a (?[]) extended charclass is compiled, the various operands are
stored as inversion lists in separate SVs and then combined together
into new inversion lists.  The functions that take care of combining
inversion lists only ever free one operand, and sometimes free none.
Most of the operators in (?[]) were trusting the invlist functions to
free everything that was no longer needed, causing (?[]) compilation
to leak invlists.

perldiag: Document ‘Expecting '(?flags:(?[...'’

perldiag: Clarify why ‘False [] range’ can be F

Merge remote-tracking branch 'remotes/origin/smoke-me/env-instead-of-echo' into blead

perldiag: Correct severity/category for ‘False [] range’

This can now be a fatal error or a warning.  diag.t is still not
smart enough to verify this, so it is still in its exception list.

diag.t: Don’t confuse the two exception listse

The second exception list is for things listed in perldiag whose cate-
gories are in need of correction or are too baffling for diag.t to
check correctly (it’s not very smart).

Due to my careless implementation in commit 62f5f54d, the second list
was also treated effectively as an addendum to the first.  Things not
listed in perldiag could be listed in the second exception list and
make tests pass.

diag.t: Remove commented obsoleted by 62f5f54dc2d

Alphabetize perltrap

Before 9b12f83b0b6, the programming languages other than Perl were in
alphabetical order.

In regcomp.c, Set_Node_Cur_Length() uses parse_start, so explicitly pass it.

The macro Set_Node_Cur_Length() had been referring to the variable
parse_start within its body. This somewhat secret reference is potentially
risky, as it was always taking a parameter node, hence one might assume that
that was all that it used, and change the value stored in parse_start.
(Specifically, one place that assigns RExC_parse - 1 to parse_start, and later
uses parse_start + 1, which looks like an obvious cleanup candidate)

So make parse_start an explicit parameter.

Also, eliminate the never-used macro Set_Cur_Node_Length. This was added as
part of commit fac927409d5ddf11 (April 2001) but never used.

In S_regatom, declare parse_start when RE_TRACK_PATTERN_OFFSETS is defined.

Commit 779fedd7c3021f01 (March 2013) moved code which unconditionally used
parse_start into another block. Hence the variable is now only needed when
RE_TRACK_PATTERN_OFFSETS is defined, so wrap its declaration in #ifdef/#endif
to avoid C compiler warnings.

Don’t leak the /(?[])/ parsing stack on error

Instead of creating the parsing stack and then freeing it after pars-
ing the (?[...]) construct (leaking it whenever one of the various
errors scattered throughout the parsing code occurs), mortalise it to
begin with and let the mortals stack take care of it.

perldelta for #114576 (XS lvalue subs)

perldelta: typo

Update CPAN-Meta to CPAN version 2.131560

  [DELTA]

2.131560  2013-06-05 15:26:36 America/New_York

  [DOCUMENTATION]

  - Replaced CPAN::Meta SYNOPSIS with code that actually works

use 'env' instead of 'echo' for %ENV tests in magic.t

To prevent using weird echo commands (it can be a binary in the $PATH)
or shell quoting (Windows has env too?), use the env command.

The env command showed perfect content on old HP-UX 11.00 where the echo
command usage got it seriously wrong.

require.t: handle parallel runs

There are random smoke failures in this test script, which are consistent
with multiple processes running the same test script in parallel, and
writing/unlinking the same (hard-coded) temp files.

As a temp hack, add a sleep(20) if this looks like its happening,
and see if the smoke issues go away.

make some tests TODO under -DPERL_NO_COW

Since it's Copy-on-Write that fixed those tests, we expect them to fail
without COW.

Remove the unused env parameter from a2p's main, and the associated pragma.

a2p's main has had the traditional Unix third parameter (env) forever.
Commit 24801a4b9a14a562 in May 2005 increased the strictness of the Tru64
compiler, and added pramgas where necessary to counter its warnings.
However, a2p's main doesn't actually *use* the env parameter, so a better
solution is to remove it. Which means that the pragma can be removed too.

dtrace.t: Don’t rely on installed strict.pm

It was failing to load strict.pm if perl had not been installed yet.

[perl #118297] Fix interpolating downgraded variables into upgraded regexp

The code alredy upgraded the pattern if interpolating an upgraded
string into it, but not vice versa.  Just use sv_catsv_nomg() instead
of sv_catpvn_nomg(), so that it can upgrade as necessary.

-l $handle warning: globs, iorefs, utf8

The warning restored in commit cd22fad3cbcea only applied to globrefs,
not to globs or iorefs.  The warning message was also not utf8-clean.
This commit fixes both.

This resolves ticket #117595.

Interix seems to have multi-arch so ask gcc where stuff is

remove obsolete STRUCT_MGVTBL_DEFINITION from mg.h

STRUCT_MGVTBL_DEFINITION was added in commit 0f4eea8fa1 in 5.004_67 as
part of ML thread "[PATCH 5.004_67] Fixes for broken MS compiler" and
stopped being used in commit acfe0abced in 5.7.2. STRUCT_MGVTBL_DEFINITION
was used to provide binary compatibility between C++ objs and C structs,
where extra  C++ data was stored with each function * raising the member
size to 16 bytes instead of 4 on a 32 bit build, also see
http://social.msdn.microsoft.com/Forums/en-US/vcgeneral/thread/2793a64f-ec09-495c-b995-4f5b98a26321

The define in struct mgvtbl is a left over that wasn't removed. Remove it
to improve code readability.

perlipc: remove some confusing text.

See: https://rt.perl.org/rt3/Ticket/Display.html?id=114444#txn-1220111

[perl #115112] avoid repeated calls to path_is_absolute() and rename it

A micro-optimization inspired by bulk88's perl #115112.

The original proposal suggested applying a two changes that removed the
duplicate calls, and then explicitly inlined path_is_absolute().

This version removes the duplicate calls, renames the function to better
match it's purpose and asks the compiler to inline it.

Typo fix in perlfunc [RT#118093]

This addresses an earlier fix which incorrectly changed "syntax fancy" to "fancy fancy" instead of "fancy syntax".

Stop making assumptions about uids and gids.

The code dealt rather inconsistently with uids and gids. Some
places assumed that they could be safely stored in UVs, others
in IVs, others in ints; All of them should've been using the
macros from config.h instead. Similarly, code that created
SVs or pushed values into the stack was also making incorrect
assumptions -- As a point of reference, only pp_stat did the
right thing:

 #if Uid_t_size > IVSIZE
mPUSHn(PL_statcache.st_uid);
 #else
 #   if Uid_t_sign <= 0
mPUSHi(PL_statcache.st_uid);
 #   else
mPUSHu(PL_statcache.st_uid);
 #   endif
 #endif

The other places were potential bugs, and some were even causing
warnings in some unusual OSs, like haiku or qnx.

This commit ammends the situation by introducing four new macros,
SvUID(), sv_setuid(), SvGID(), and sv_setgid(), and using them
where needed.

[perl #117531] Deparse elements of %# correctly

They can only be referred to as $# {foo} and ${#}{foo}, not as $#{foo},
as that means $#foo.

Traps for the unwary JS programmer (perltrap.pod)

This is part of ticket #117507 or #109408, whichever you like.

This incorporates suggestions and corrections from Ronald Kimball and
Tom Christiansen.  Thank them!

deparse.t: Fix test count

add a special case for VOS handling of argv[0] in magic.t

remove an obsolete special case for VOS handling of permissions in AnyDBM_File.t

add a special case for VOS handling of file position after open in tell.t

remove an obsolete VOS special case and add a new one in fs.t

change svpeek.t to append the VOS executable suffix to $^X

change DynaLoader.t to know VOS has no libc library

remove obsolete VOS special cases from eu_command.t

Add Heiko Eissfeldt to AUTHORS

[perl #117311] B::Deparse with option -l leaves formfeed characters in its output

op.h: Corrent comment about entersub strictures

Flag 2 on entersub is HINT_STRICT_REFS, not _SUBS.

Fix internal inconsistencies in style in utf8.pm docs

FAIL_OK looks too much like a constant [RT##118279]

PATCH: Bump Locale-Codes from 3.25 to 3.26

I just released Locale-Codes-3.26 which contains the core modules
Locale::Country, Locale::Language, and Locale::Currency.  The patch is
attached to this message.

====
Background:

The core modules Locale::Country, Locale::Language, and Locale::Currency
(all part of the Locale-Codes distribution) should be updated on a
regular basis. They contain "codes" from various internet standards
which change over time.

I plan on releasing new versions at 4 times a year to keep the codes
up-to-date. At this point, I'm not planning on any significant code
changes (other than bug fixes), so the only significant changes
between releases should be to update the codes.

>From a6cfe877326aa21c73be694f3a9d7dbe1f17961b Mon Sep 17 00:00:00 2001
From: Sullivan Beck <sbeck@cpan.org>
Date: Mon, 3 Jun 2013 10:55:38 -0400
Subject: [PATCH] Bump Locale-Codes from 3.25 to 3.26

Signed-off-by: Chris 'BinGOs' Williams <chris@bingosnet.co.uk>

Adjust documentation for removal of splice warning

avoid undeflow in regex poscache count

reginfo->poscache_iter is used to count down to zero; at zero, the
superlinear cache is enabled; and for values below zero the cache is
tested. After I32_MAX iterations the count might wrap to a positive value
on 32-bit systems. So don't do that.

perldelta for 285a3ca13

[perl #118175] avoid making pointers outside of objects

In a couple of cases, when strings were allocated above the 2GB line
on 32-bit CPUs, this could cause regexps to act strangely - not matching
or crashing perl.

The final patch in the set prevents pointer creation which the C standard
describes as undefined behaviour, but is typically safe (as long as the
pointer isn't derefed)

[perl #118175] avoid making a pointer outside a string

Simply adding scan + max causes undefined behaviour per ANSI C if the
result points outside of the object scan points at.

[perl #118175] prevent a similar overflow for CANY

[perl #118175] prevent a similar overflow for POSIXA

[perl #118175] avoid overflowing a pointer for repeated EXACT nodes

eliminate an unused variable

perldelta: changed intuit API

[MERGE] get rid of (most) regex engine global state

Historically, perl's regex engine was based on Henry Spencer's regex code,
which was all contained within a single file and used a bunch of static
variables to maintain the state of the current regex compile or execution.

This was perfectly adequate when only a single thread could execute a
regex, and where the regex engine couldn't be called re-entrantly.

In 5.0, these vars were promoted to be full global vars as perl became
embeddable; then in 5.5 they became part of the perl interpreter struct
when MULTIPLICITY was introduced.

In 5.6, the Perl_save_re_context() function was introduced that did a
whole bunch of SAVEPPTR(PL_bostr) type stuff, and was called in various
places where it was possible that the engine may be re-entered, to avoid
overwriting the global state of the currently executing regex. This was
particularly important now that Unicode had been introduced, and certain
character classes could trigger a call to the perl-level SWASH code, which
could itself execute a regex; and where /(?{ ... })/ code blocks could be
called which could do likewise.

In 5.10, The various PL_foo variables became fields within the new
re_save_state struct, and a new interpreter var, PL_reg_state, was
introduced which was of type struct re_save_state. Thus, all the
individual vars were still global state, but it became easier to save them
en-mass in Perl_save_re_context() by just copying the re_save_state stuct
onto the save stack and marking it with the new SAVEt_RE_STATE type.
Perl_save_re_context() was also expanded to be responsible for saving all
the current $1 values.

Up until now, that is roughly how things have remained, except for bug
fixes such as discovering more places where Perl_save_re_context() needs
to be called.

Note that, philosophically speaking at least, this is broken in two ways.
First, there's no good reason for the internal current state of the
executing regex engine to be stored in a bunch of global vars; and
secondly we're relying on potential callers of the regex engine (like the
magic tie code for example), to be responsible for being aware that they
*might* trigger re-entrancy in the regex engine, and to thus do
Perl_save_re_context() as a precaution. This is error-prone and hard to
prove correct.  (As an example, Perl_save_re_context() is only called in
the tie code if the tie code in question is doing a tied PRINT on STDERR;
clearly an unusual use case that someone spotted was buggy at some point).

The obvious fix, and the one performed by the series of commits in this
merge, is to make all the global state local to the regex engine instead.
Indeed, there is already a struct, regmatch_info, that is allocated as a
local var in regexec(), then passed as an argument to the various
lower-level functions called from regexec(). However, it only had limited
use previously, so here we expand the number of functions where it is
passed as an argument. In particular, it is now also created by
re_intuit_start(), the other main run-time entry point to the regex
engine.

However, there is a problem with this, in that various regex vars need
cleaning up on croak (e.g. they point to a malloced buffer). Since the
regmatch_info struct is just a local var on the C stack, it will be lost
by the longjmp done by a croak() before leave_scope() can clear up.

To handle this, some fields that logically should go in regmatch_info,
are instead added to two new structs: regmatch_info_aux and
regmatch_info_aux_eval; the first represents all the normal fields that
need some sort of cleanup handling; the second represents extra fields
(also possibly needing cleanup) that are only only needed if the pattern
contains /(?{})/ code blocks. These two structs are allocated in the next
two free PL_regmatch_state stack slots - since these slots are allocated
in 4K slabs anyway, they are essentially free of charge. A single
destructor function, S_cleanup_regmatch_info_aux() is then used with
SAVEDESTRUCTOR_X() to perform all cleanup at the end of execution.

In addition, all state and cleanup setup has been consolidated into a
single point near the start of regexec(); previously it was spread across
regexec(), regtry() and regmatch(). This used also to result in various
inefficencies, such as PL_regmatch_state stack freeing all higher unused
slabs at the end of each call to regmatch(), which might be called
multiple times by regexec(). Now it just frees once.

As part of this series of fixes it was necessary to change the API of
Perl_re_intuit_start(). This is because the API was broken: unlike
Perl_regexec_flags(), it didn't have a strbeg arg, and would try to guess
it from the SV (if any) passed to it. This could fail on overloaded SVs
for example, or where its called without an SV (not done from core, but
officially supported by the API). Note that this is likely to break
Re::Engine plugins, plus any code which directly calls intuit.

Finally, note that although struct re_save_state and SAVEt_RE_STATE are
gone, Perl_save_re_context() still does something useful: the equivalent
of local($1,$2...). Fixing that properly is a whole separate kettle of
fish, not addressed here.

As far as I'm aware, the only remaining global vars associated with the
regex engine are

    PL_reg_curpm, PL_regmatch_state, PL_regmatch_slab, PL_colors, PL_colorset

None of these are effected by re-entrancy. The state stack is, erm, a stack,
so it can handle re-entrancy quite happily, and the others are safe too.

document fields of regmatch_info struct

tidy up init code in regexec() and intuit_start()

Slightly reorganise the set-up code in these two functions,
for example by gathering all 'reginfo->foo =' assignments into a single
block. This is just swapping the order of a few lines, and shouldn't make
any functional difference.

better comment the remaining PL_ regex vars

eliminate PL_regdummy

This global (per-interpreter) var is just used during regex compilation as
a placeholder to point RExC_emit at during the first (non-emitting) pass,
to indicate to not to emit anything. There's no need for it to be a global
var: just add it as an extra field in the RExC_state_t struct instead.

eliminate PL_reg_state

This is a struct that holds all the global state of the current regex
match.
The previous set of commits have gradually removed all the fields of this
struct (by making things local rather than global state). Since the struct
is now empty, the PL_reg_state var can be removed, along with the
SAVEt_RE_STATE save type which was used to save and restore those fields
on recursive re-entry to the regex engine.

Eliminate PL_reg_starttry

Its only used for printing debugging messages, and its value is already
available as the startpos local var in S_regmatch().

Whoo hoo! This var was the last field within the PL_reg_state global state
struct.

make PL_reg_curpm global

Currently PL_reg_curpm is actually #deffed to a field within PL_reg_state;
promote it into a fully autonomous perl-interpreter variable.

PL_reg_curpm points to a fake PMOP that's used to temporarily point
PL_curpm to, that we can hang the current regex off, so that this works:

    "a" =~ /^(.)(?{ print $1 })/ # prints 'a'

It turns out that it doesn't need to be saved and restored when we
recursively enter the regex engine; that is already handled by saving and
restoring which regex is currently attached to PL_reg_curpm.
So we just need a single global (per interpreter) placeholder.

Since we're shortly going to get rid of PL_reg_state, we need to move it
out of that struct.

better document the regex super-linear pos cache

eliminate PL_reg_poscache, PL_reg_poscache_size

Eliminate these two global vars (well, fields in the global
PL_reg_state), that hold the regex super-liner cache.

PL_reg_poscache_size gets replaced with a field in the local regmatch_info
struct, while PL_reg_poscache (which needs freeing at end of pattern
execution or on croak()), goes in the regmatch_info_aux struct.

Note that this includes a slight change in behaviour.
Each regex execution now has its own private poscache pointer, initially
null.  If the super-linear behaviour is detected, the cache is malloced,
used for the duration of the pattern match, then freed.

The former behaviour allocated a global poscache on first use, which was
retained between regex executions. Since the poscache could between 0.25
and 2x the size of the string being matched, that could potentially be a
big buffer lying around unused. So we save memory at the expense of a new
malloc/free for every regex that triggers super-linear behaviour.

The old behaviour saved the old pointer on reentrancy, then restored the
old one (and possibly freed the new buffer) at exit. Except it didn't for
(?{}), so /(?{ m{something-that-triggers-super-linear-cache} })/ would
leak each time the inner regex was called. This is now fixed
automatically.

use new cleanup for PL_regmatch_state

The previous commit reorganised state save and cleanup at the end of regex
execution. Use this new mechanism, by recording the original values
of PL_regmatch_slab and PL_regmatch_state in the regmatch_info_aux struct,
and restoring them and freeing higher slabs as part of the general
S_cleanup_regmatch_info_aux() destructor, rather than pushing the old
values directly onto the savestack and using another specific destructor.

Also, make the initial allocating of (up to) 3 PL_regmatch_state slots
more efficient by doing it in a loop.

We also skip the first slot; this may already be in use if we're called
reentrantly.

try 1

unify regmatch_info data

Previously the regmatch_info struct was allocated as a local var on the C
stack, while some extra state (only needed for regexes having (?{})) was
malloced (as a regmatch_eval_state struct) as needed - and a destructor set
up to clean it up afterwards. This being because the stuff being cleaned
up couldn't be allocated on the C stack as it needed to hang around after
a croak().

Reorganise this so that:

* regmatch_info is on the C stack as before.

* a new struct, regmatch_info_aux is allocated within the first slot of the
  regmatch_state stack, for fields which must always exist but which need
  cleanup afterwards. This is currently unused, but will be shortly.

* a new struct, regmatch_info_aux_eval (which is just a renamed
  regmatch_eval_state struct), is optionally allocated in the second
  slot of regmatch_state. This is logically part of regmatch_info_aux,
  except that splitting it in two stops it being too large to fit in a
  regmatch_state slot (we can fit it in two instead).

(The second and third structs aren't allocated when we're intuit()
rather than regexec()).

Doing it like this simplifies allocation and cleanup: there's no need for
a malloc(), and we are already going to allocate a slab's worth of
regmatch_state slots, so using an extra one of two of them is effectively
free; and the cleanup just requires calling a single overall destructor.

In the next few commits, more of the regexec() state setup and tear-down
will be integrated into this new regime. And in particular, the new
regmatch_info_aux struct will give us somewhere to hang things like
PL_reg_poscache once it stops being global (it being local state that
needs cleanup).

move eval_state init from regtry() to regexec()

regexec() calls regtry() for each match start position until a match is
found. regtry() has some code that says: "if this regex contains (?{})'s,
and if we haven't done so already, set up the extra state needed".

Move the setup one level higher, into regexec(). Here, we just do it once,
and don't have to keep checking whether we've already done it.

This is part of an effort to consolidate all regex state initialisation
into one place.

move savestack restore from regmatch to regexec

Currently, S_regmatch() has, in its outermost scope:

    oldsave = PL_savestack_ix;
    SAVEDESTRUCTOR_X(S_clear_backtrack_stack, NULL);
    SAVEVPTR(PL_regmatch_slab);
    SAVEVPTR(PL_regmatch_state);

    ... rest of function ....

    /* clean up; in particular, free all slabs above current one */
    LEAVE_SCOPE(oldsave);

This means that at the end of regmatch(), all slabs in the regmatch_state
stack above where we started, are freed.

Hoist this two levels higher into Perl_regexec_flags().  Now, since
a) the main activity of regexec() is call regmatch() (via regtry()) for
each possible string start position until a match is found;
b) there isn't any other savestack manipulation between the two functions;
the main affect of this change is that higher slabs in the regmatch_state
stack are only freed at the end of all match attempts from all positions,
rather than after each fail at a particular start point. Since the
repeated calls to regmatch() are likely to have a similar pattern of
regmatch_state stack usage, this should usually be an efficiency win.

It is also part of plan to consolidate all the setting up of local match
state in one place.

eliminate PL_reg_maxiter, PL_reg_leftiter

Move these two fields of PL_reg_state into the regmatch_info struct, so
they are local to each match.

Rationalise RX_MATCH_UTF8_set()

Now that the RXf_MATCH_UTF8 flag on a regex is just used to indicate
whether the captures on a successful match are utf8, only set
this flag at the end of a successful match, rather than at the start of
the match.

This should make no functional difference the way things stand at the
moment, but makes things conceptually cleaner.