Add switch_to_globale_locale()

This new API function is for use in applications that call alien library
routines that are expecting the old pre-POSIX 2008 locale functionality,
namely a single global locale accessible via setlocale().

This function converts the calling thread to use that global locale, if
not already there.

Revise sync_locale() for safe multi-threaded operation

This function now returns a boolean, and does not want an aTHX
parameter.  There should be no impact on code that uses the macro form
to call it.

perl.h: Add, revise some locale debugging info

lib/locale_threads.t: Add safe thread test

Add thread-safe locale handling

This (large) commit allows locales to be used in threaded perls on
platforms that support it.  This includes recent Windows and Posix 2008
ones.

perl.h: Add debugging statements for mutex ops

Latch LC_NUMERIC during critical sections

It is possible for operations on threaded perls which don't 'use locale'
to still change the locale.  This happens when calling
POSIX::localeconv() and I18N::Langinfo(), and in earlier perls, it can
happen for other operations when perl has been initialized with the
environment causing the various locale categories to not have a uniform
locale.

This commit causes the areas where the locale for this category should
predictably be in one or the other state to be a critical section where
another thread can't interrupt and change it.  This is a separate
mutex, so that only these particular operations will be held up.

Make new_numeric() static

This core-only function is now used only in one file.

vutil.c: Revise locale version handling

This can be called from applications that have changed the locale behind
perl's back.  Prior to this commit, the code kind of assumed that some
things weren't broken, and that it should update perl's records to
correspond with the status of things.  But this may be an intermediate
state, and assuming perl should know about it is assuming too much.  We
might update perl, and the application restores the state, and control
gets transferred back in the wrong state.  So simply change the locale
to what it needs to be, if necessary, and change back.

This change needs to reported upstream to 'version'

Add Perl_setlocale()

khw could not find any modules on CPAN that correctly use the C library
function setlocale().  (The very few that do try, do not use it
correctly, looking at the return value incorrectly, so they are broken.)
This analysis does not include modules that call non-Perl libaries that
may call setlocale().

And, a future commit will render the setlocale() function useless in
some configurations on some platforms.

So this commit adds Perl_setlocale(), for XS code to call, and which is
always effective, but it should not be used to alter the locale except
on platforms where the predefined variable ${^SAFE_LOCALES} evaluates to
1.

This function is also what POSIX::setlocale() calls to do the real work.

perldelta for dTHX_DEBUGGING

This documents the results of commit
2d17fb746d82c8098ef8cf0dee7d11f3844294a5

locale.c: Add critical section

This code should be protected from another thread doing the same thing
nearly simultaneously, so that the static buffer doesn't get zapped in
this system call.

locale.c: Generalize errno handling

This file had been using just errno, instead of the more general macros
that can handle vax errnos as well.

locale.c: Change some DEBUG_L to DEBUG_Lv

These are better to display only when verbose is specified.

locale.c: Suppress some compiler warnings

Cast these %.s precision specifiers to int.

perlapi: Add a caution about Perl_langinfo()

locale.c: Add debugging info

This adds some information to a debugging statement, but mostly it adds
an audit of the utf8ness cache structure, invoked under -DLv.

Add ${^SAFE_LOCALES}

This read-only variable returns a boolean as to whether it is safe to
use locales in this perl.  Without threads it returns 1; when a future
commit adds thread-safe locale handling, it will also return 1 if that
is enabled.

Add information to warning msgs

If we have nl_langinfo, this adds the codeset it returns to the messages
generated when there are anomalies in locales that are coming into
effect

locale.c: Add comments, clarify others

locale.c: White-space only

This indents properly because of changes in the previous commit

locale.c: Check for anomalies in UTF-8 locales

Perl has, for some releases now, checked for anomalies in non-UTF-8
locales and raised warnings if any are found when such a locale actually
gets used.  This came about because it turns out that vendors have
defective locale definitions (that Perl has no control over, besides
reporting them as bugs to the proper places).

I was surprised to stumble across UTF-8 locales that don't adhere
strictly to Unicode, and so this commit now checks for such things and
raises an appropriate message.

Some of this is understandable because Turkish and related languages
have a locale-dependent exemption for them in the Unicode standard, but
others are simply defective locale definitions.

Perl will use the standard Unicode rules, but the user is now warned
that these aren't what the locale specified.

An example is that there are some UTF-8 locales where the common
punctuation characters like ",", "$" aren't marked as punctuation.

locale.c: Rmv unnecessary locale toggle

I don't know why this code thought it needed to change to the C locale
for LC_CTYPE, in order to output a fully formed warning message, and
then to switch back.  So remove the toggles.

perl.h: Add dTHX_DEBUGGING

which is a NOOP except on DEBUGGING builds

ExtUtils::ParseXS/lib/perlxs.pod: Nits

This removes extra blanks following colons that don't mean the normal
thing for colons that traditionally have two spaces after them, and
capitalizes Perl.

makedef.pl: Use all #ifdefs to decide

This uses all the conditions that go in to deciding to define this
variable, instead of taking a shortcut.  (It's unfortunate that the
shortcut defined in perl.h now used elsewhere via commit
7e5377f714ebe84e0fe2599b3bfec50036f0d18f is not available to makedef.pl.
It would make sense to have this file look at perl.h and avoid
duplication).

This fixes some freebsd builds, which failed because their hints file
undef'd a different variable than this shortuct looked at.

Use proper #define to see if need PLnumeric underlying_obj

perl.h has a single #define which is the combination of several that
determines if this object should be created or not.

perl.h Move some #defines

These are used so that they appear ahead of #include intrpvar.h, so
they can be used by that file.  This enables this commit to simplify
some #ifdefs

Revise when POSIX 2008 ops on FreeBSD

It appears that bugs in FreeBSD are not fully fixed until later than we
thought, and so this commit updates the hints file to exclude POSIX 2008
operations on releases previously permitted.

See https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=211743

POSIX.xs: Fix localeconv_l()

Commit 7d5966ae3c3b8f0e43fa09554a46cb8de9c98f5f added use of
localeconv_l().  But this commit is buggy in some locales.  It needs to
find the current locale AFTER any changes have been made due to the
LC_NUMERIC locale toggling.

regcomp.c: Add cast to avoid compiler warning

Update dist/if/Changes to current version in blead.

Add MANIFEST to PathTools

Reflect what I think are the correct changesets for PathTools:

Building towards an upcoming release of PathTools, I'm documenting
based on the commits what I think is the correct Changeset.

Considering that at the time of this commit, CPAN only has
PathTools 3.62, I think we should be fine.

Correct if you see a mistake. :)

define NEED_croak_xs_usage in PathTools

ppport.h nowadays defines croak_xs_usage(), which is of course used
in the XS code, but its definition is broken unless the flag macro
NEED_croak_xs_usage was defined first.  Define the flag macro to avoid
breakage.

Add ABSTRACT, LICENSE, AUTHOR, etc. elements.

Add them conditionally so that CPAN PathTools can accommodate different
versions of ExtUtils::MakeMaker and CPAN metadata protocols.

Styled after Module-CoreList's Makefile.PL for better readability.

See: RT 132853

Ensure that all tests in t/cwd.t have descriptions.

Provide .gitignore for PathTools distribution.

Update ExtUtils-MakeMaker to CPAN version 7.32

  [DELTA]

7.32  Fri Feb 16 20:10:58 GMT 2018

    No changes since v7.31_08

7.31_08 Mon Feb 12 12:19:11 GMT 2018

    VMS fixes:
    - Fix 8-space line prefixes in MM_VMS.pm

7.31_07 Tue Jan 16 16:09:04 GMT 2018

    Bug fixes:
    - Change warning text for libscan() README.pod

7.31_06 Tue Jan 16 10:28:11 GMT 2018

    Bug fixes:
    - Teach libscan() to exclude README.pod

    Doc fixes:
    - Documented when XSMULTI and XSBUILD are available
    - Documented more version requirements for attributes

7.31_05 Sat Nov 25 09:22:51 GMT 2017 (LPW Edition)

    Doc fixes:
    - Spelling fixes
    - clarify behaviour if VENDORLIB and no VENDORARCH

7.31_04 Thu Oct  5 12:22:24 BST 2017

    Darwin/NeXT fixes:
    - Escape ld -framework flags

7.31_03 Mon Jul 10 09:34:26 BST 2017

    Bug fixes:
    - Filter out non-XS .a files for static builds

7.31_02 Mon Jun 26 13:53:15 BST 2017

    VMS fixes:
    - Fixes for .PL tests
    - VMS override for static_lib_pure_cmd
    - Make the new subdirsstatic test portable

7.31_01 Wed Jun 14 15:57:52 BST 2017

    Test fixes:
    - Skip static test unless in perl core or in a .git directory

Change name of regnode for clarity

The EXACTFA nodes are in fact not generated by /a, but by /aa.  Change
the name to EXACTFAA to correspond.

I found myself getting confused by this.

APItest: Add U8* typemap, and use it

This missiing typemap has slowed me down on numerous occasions, as I
keep forgetting it's missing

No list open on VMS as yet.

So do things the old way in openpid.t on VMS only.

don't clobber file bytes in :encoding layer

The PerlIO::encoding layer, when used on input, was creating an SvLEN==0
scalar pointing into the byte buffer, to pass to the ->decode method
of the encoding object.  Since the method mutates this scalar, for some
encodings this led to mutating the byte buffer, and depending on where
it came from that might be something visible elsewhere that should not
be mutated.  Remove the code for the SvLEN==0 scalar, instead always
using the alternate code that would copy the bytes into a separate buffer
owned by the scalar.  Fixes [perl #132833].

Fix gcc/dmake build on Windows

Remove circular dependency in makefile.mk, following the same pattern as in
GNUmakefile.

utf8.c: Silence compiler warnings

These are spurious warnings, from netbsd

avoid vivifying UNIVERSAL::isa:: in Carp

The test added to Carp by commit 915a6810d3e3198d759f025f85d1fd6f3171dd27
for UNIVERSAL::isa being loaded had the side effect of vivifying the
UNIVERSAL::isa stash.  Take more care about checking for UNIVERSAL::isa
to avoid vivifying it, as for the other checks for things in optional
modules.  Fixes [perl #132788].

ExtUtils::ParseXS::Eval: Fix variable name ALIAS in documentation

Correct name of variable is ALIAS, not Alias.

Committer: Increment all $VERSION to 3.38 for consistency (per demerphq).

Correct typo: agreement in tense.

perldelta for b6811f8d3a5c

[perl #121028] avoid creating a shell process

Win32 now has list form open, so this can now be supplied.

Update IPC-Cmd to CPAN version 1.00

  [DELTA]

1.00 Wed Feb 14 16:14:01 GMT 2018

  Bug fixes:
  - Resolve RT #91784  'run_forked("/usr/bin/echo test") captures no output'
  - Resolve RT #124415 'The 03_run_forked.t test fails (sometimes) on HPUX'

Update link in documentation.

Original link was reported dead and replacement link suggested by freethunk.

For: RT # 123859

Construct Limit.pm dependency with File::Spec.

Paths passed to WriteMakefile() will get converted to whatever
format is necessary for the make or make-like utility being used,
but paths in hard-coded extra dependencies will not.  So construct
the target name with File::Spec->catfile().

VMS does have wchar.h.

And we now need it for prototypes of functions that locale.c is
using.

regcomp.c: Under/i segregate folding vs non-folding characters

For matching sequences of characters, the regex compiler generates
various flavors of EXACT-type nodes.  The optimizer uses those nodes to
look for sequences that must be in the matched string.  In this way, the
pattern matching engine may be able to quickly rule out any possible
match altogether, or to narrow down the places in the target string that
might match.

Under /i matching, this generally has not been possible, because there
is no fixed string that the optimizer can grab onto, as something can
match, say, either 'A' or 'a', etc.  However, in many patterns that
contain text, there are characters that are fixed even under /i.  Things
like tabs, space, and punctuation, for example.

This commit segregates such folding vs non-folding characters into
separate nodes.  I proposed this 7 months ago:

http://nntp.perl.org/group/perl.perl5.porters/245342

and in talking with Yves recently, decided to go ahead with it.

In the proposal of July, I suggested that a new node type be used to
mark those nodes which are under /i but contain no characters that match
other than themselves under /i.  These nodes could be joined with either
a plain EXACT node, or an EXACTFish one to create longer nodes.

The reason for joining is that there is overhead in the engine whenever
we switch to the next node.  But the reason for not doing it is that it
is slower to match /i nodes than ones that an memEQ can be used on.

I suppose we could join short nodes, and leave longer ones separate, but
that decision can be deferred based on real-world experience.

This patch also consolidates into one place the handling of the Latin
Sharp S, in order to avoid extra #ifdefs, and cause the logic to be
linearly shown.

Upgrade Encode from version 2.94 to 2.96

(perl #127743) remove the no longer needed stacksize_in.h

I should have removed this when I changed the limits from being baked
into the binary.

(perl #132849) try to disable core files when deliberatly segfaulting

The dist/Storable/stacksize tool probes for recursion limits for
Storable, in an attempt to prevent stack overflows, and causes
segfaults when the probes exceed the available stack size.

This was leaving a core file for each failure (whether that ended
up as a single file or one for each segfault depended on the
system settings).

Try to probe for the ulimit -c option and if it doesn't cause an
error, prefix the command used to probe for recursion limits.

Ideally I could use setrlimit() for this, but we don't expose it in
core, nor in POSIX.pm, and adding it wouldn't help for the older
perls that Storable needs to build for.

podcheck.t: Recognize more forms of core files

This extends 199fc8cde4ec30a56626c0765b3b0efacb327664 to include more
common forms of core files.

.*\.core.*
core
core\..*

should all now be ignored.

bump $warnings::VERSION

since warnings.(pm|pl) was updated in 25ebbc2270

Test for _at_level functions with fh

warnings: Omit handle when $. is 0

otherwise the new _at_level functions end up including
‘at <handle> line 0’.

[Commit message by the committer.]

Don't export PL_underlying_numeric_obj if it doesn't exist.

This broke the build on VMS and probably would on anything else
with strict linking where HAS_NEW_LOCALE is not defined.

podcheck.t: Skip core files in all directories

Commit 446f12a860e9ab9b234cd6796e937fbff85adf5c only skipped files named
'core' in the top directory.  This should skip them in any directory.

podcheck.t: Skip core files

This is the likely cause of
https://rt.perl.org/Ticket/Display.html?id=132843

APItest: Fix C++ compiles

0a9f8f95112ff40e13406b3e5aab49c01487f045 introduced failures on C++
compilations.  This is a better patch, suggested by ilmari.

The issue was in cases where the pointer size is 32 bits and the word
size was 64, a (STRLEN) -1 returned as an error was getting turned into
0xFFFFFFFF instead of -1.

APItest: Correct parameter sign

Commit ae315a0a3c51e68887704d4907bb6a502a6d4e3f added tests for
utf8_to_bytes().  For testing purposes, this parameter should be signed
when it comes from perl space.

Upgrade Time::HiRes from version 1.9752 to 1.9753

Upgrade Test-Simple from version 1.302120 to 1.302122

Upgrade bignum from version 0.47 to 0.49

util.c: Fix typo in comment

(perl #127743) merge Storable work to date

This merges a large number of changes from cperl Storable, largely for
64-bit object support, and then further extends 64-bit object support
and fixes a number of other issues.

bump $Storable::VERSION to 3.06

(perl #127743) update Changes

(perl #127743) re-work recursion limit handling

Previously this worked by calculating the limits and then rebuilding
Storable.so, this meant Storable.so was built twice meaning a new make
would then rebuild its dependencies.

This was also a hard limit, so if Storable's user knew the available
stack space changed they would need to rebuild Storable to adapt.

This also allows for successful static Storable builds.

I also updated the stacksize tool to prevent popping up segfault error
messages at the user on Win32.

Since I was still seeing test failures in recurse.t on a variety of
platforms, I made the default limit calculations even more
conservative.

(perl #50608) add experimental regular expression support

This doesn't work on 5.6, but I'm not sure why.

For a bad regular expression _make_re() throws an exception, and it's
propagated back to the original caller, and execution continues.

But after the program is complete retrieve_regexp() continues
execution from the call_pv(), typically with count == -1 and dies
horribly.

(perl #127743) fix dependencies for Storable.pm

Since ad2ec6b5 Storable.pm has been generated by Storable.pm.PL from
__Storable__pm.

Unfortunately the PL_FILES EU::MM key doesn't let you specify any
dependencies beyond the .PL file, so modifications to __Storable__.pm
weren't causing Storable.pm to rebuilt.

So I've replaced PL_FILES with an empty hash (to prevent EU::MM
generating once) and added my own rule.

(perl #25933) always rethrow exceptions thrown through or by the XS implementation

Also, preserve any references thrown.

Such references could be thrown by STORABLE_freeze, STORABLE_thaw or
STORABLE_attach implementations.

Several of the wrappers in Storable.pm had code similar to:

  eval { ... };
  logcroak $@ if $@ =~ s/\.?\n$/,/;

with $@ discarded if the condition failed.

This lead to two problems:

- exceptions not ending in "\n" (which is just references without
  string overloading, or with overloading but that didn't return a
  string ending in "\n") would not be rethrown.

- thrown references that did happen to have overloading that returned
  "\n" would be converted into strings.

This behaviour appears to have been present since the initial release
of Storable.

(perl #127743) improve performance in -DDEBUGGING builds

The changes imported from cperl included a change to enable Storable's debugging
output mechanism for -DDEBUGGING builds.

When built with debugging output, Storable's TRACEME() macro fetched
the $Storable::DEBUGME global and checked its truth, this
significantly slowed down Storable, especially noticable for dumps
with large numbers of objects.

I added a cached traceme value to the Storable context object and
modified TRACEME() to used that instead.  A few TRACEME()'s that are
called before the context object is available have been replaced with
calls to TRACEMD(), a new macro that does what TRACEME() did before.

(perl #131136) clear padding before writing long doubles

This means:

- valgrind won't complain about uninitialized bytes when writing long doubles

- we get consistent output when writing equivalent data structures

(perl #118551) an empty string from _freeze() now supplies the same to _thaw()/_attach()

The retrieve_hook() code would simply pass the string length to
NEWSV(), so if the length was zero, no PV would be allocated, and the
SV would not be upgraded.

The following code would then set POK on an SV that wasn't SVt_PV (or
better), resulting in fun later down the line.

Change to always supply at least 1 as the buffer size for NEWSV(), and
always set CUR and NUL terminate the buffer.

(perl #127743) ensure gzip/gzip are available before we use them

(perl #127743) support for >= 4GB data from hooks

Though we use this mechanism for >= 2GB.

This emits an SX_LOBJECT op and writes the string length as a 64-bit
value if STORABLE_attach() returns more than 2GB of data.

The boundary is set at 2GB since older versions of Storable handle
sizes between 2GB and 4GB badly, resulting in a memory overwrite.  By
using the alternate op codes an older Storable will reject the data
instead.

We still accept such data that might have been written by an older
Storable.

(perl #131999) treat a 32-bit hook data size as unsigned

Previously retrieve_hook() treated the 32-bit hook data size as a signed value, but
the parameter to NEWSV() is treated as unsigned.  Due to promotion rules this negative
signed value is converted to a very large unsigned value running us out of memory.

Fixing this bug will let us accept previously frozen hook data in the
2GB to 4GB rannge.  The next commit will hopefully allow us to write
and read 4GB+ data correctly.

(perl #131990) treat the length for LSCALAR, LUTF8STR as unsigned

Older Storable without 64-bit object might write such objects.

A malicious file might also be provided with such a large length
to cause a resource consumption attack (allocating large amounts of
memory), but Storable explicitly doesn't protect against attacks.

we only need 64-bit object support with 64-bit pointer builds

Previously this enabled 64-bit object support with 64-bit int builds,
such as a 32-bit build with -Duse64bitint supplied to Configure,
but a 32-bit system can't realistically have more than 2**31 array
elements or hash elements.

With an operating system built or configured especially to allow it
you might be able to find a 32-bit system that supported a PV with more
than 2**31 bytes, but that seems unlikely and not a case to optimize for.

fix various 32-bit issues:

- the comparison against where_is_undef caused signed vs unsigned
  comparison warnings

- don't define get_larray() on 32-bit builds

(perl #127743) read the hash's flags for large SX_FLAG_HASH ops

Unfortunately testing this requires more memory than any machine I
have available has.

(perl #127743) we should only handle SX_LOBJECT ops on 64-bit platforms

retrieve_lobject() handled such large objects I'm assuming to handle
smaller sizes stored in a 64-bit length/count, but that can only
happen if someone isn't using Storable to generate the data.

(perl #127743) fix network order read/write of large values

This had a couple of bugs:

- W64LEN() used a union where it should have used an array or struct,
  so a network order 64-bit length was written as 4 bytes.  Oops.

  Changed to use an array.

- retrieve_lobject() always read the length in host order, so it sort
  of tried to read the length in network order on 32-bit platforms,
  but then didn't fix the order of the length it read.

  Now uses READ_U64() (which I originally messed up myself, oops.)

(perl #127743) fixes for READ_U64()

- ntohl() the low word too, doh

- if ntohl() isn't provided, then provide it, with appropriate
  wrapping.  Should be exteneded to other uses.

- only available for 64-bit builds

(perl #127743) fix some -DDEBUGGING build issues

(perl #127743) limit the number of extra refs returned by STORABLE_freeze

Ensure some over enthusiastic STORABLE_freeze() doesn't cause us to
emit a negative reference count for SX_HOOK.

This fails to be parsed by older versions and flags 64-bit ids for new
versions of Storable.

(perl #127743) fix large object ids in hook sequences

As with SX_OBJECT, if there are a large number of SVs being frozen the
object ids can exceed the 32-bit limit.

The problem here is how to indicate that we have 64-bit ids without
breaking older versions parsing our results for smaller object trees?

We don't have any room in the flags byte, currently used as:

 bits  use
 ----  ---
 0,1   type
 2     class length is > 255 bytes
 3     frozen string > 255 bytes
 4     more than 255 extra references
 5     class name has been seen before and is represented as an index
 6     an extra reference is stored next
 7     has a list of extra references

and the extra byte is only used for tied SVs.  We can't repurpose the
bits 6, 7 since it would break older readers.

I considered adding SX_LARGE_HOOK, or something similar, but we find
out that large ids are needed well after the op code has been emitted.

So how is the handling of the length + ids handled in retrieve_hook()?

    I32 len3 = 0;
    ...
        if (flags & SHF_LARGE_LISTLEN)
            RLEN(len3);
else
            GETMARK(len3);
        if (len3) {
            av = newAV();
            av_extend(av, len3 + 1); /* Leave room for [0] */
            AvFILLp(av) = len3; /* About to be filled anyway */
        }

For SHF_LARGE_LISTLEN this treats the len3 as signed - so if the
writer had more than 2**31-2 objects after the "frozen" string,
decoding is going to break anyway, as av_extend_guts() panics on "key"
values less than -1.

The code that actually reads the ids will fail to read any ids when
len3 is negative, since the for loop does a i <= len3 check.

So rather than trying to fix this, I used a negative len3 to indicate
that the object ids are 64-bit.

This means we get backward compatibility in the cases where 32-bit ids
work, and older versions of Storable will reject it.

If an older version of Storable wrote a negative len3 (due to
overflow) we'll be attempting to read 32-bit ids as typically very
large 64-bit ids (much larger than 2**32 in most cases) which won't be
found in the seen array, failing the thaw.

(perl #127743) update PERL_TEST_MEMORY requirements for the older tests

PERL_TEST_MEMORY includes any swap, it's not the minimum resident set
for the test.

(perl #127743) fix two problems with large object ids

Storable assigns an object id to every scalar it freezes, including to
unused elements in arrays.

There were two problems here:

a) in retrieve(), object ids over 2**31-1 but less than 2**32 were
   treated as signed, so the wrong object was produced in the resulting
   data structure.  Two changes we made to fix this:

  i)  retrieve() now treats object ids in the problem range as
      unsigned, so data written by older Storables is now treated
      correctly.

  ii) store() now writes object ids in the problem range as 64-bit
      ids, so that older Storables will fail rather than producing an
      incorrect result data structure.

b) once over 2**32 scalars had been output, the code still produced
   32-bit object ids when referring to previous scalars.  Fixed by
   adding support for 64-bit object ids.

There's still an issue with object ids in hook produced data.

Testing these changes requires ridiculous amounts of memory - ~32GB
for a) and ~66GB for b), and the tests take a long time to run, hence
for those tests to run you need the following in the environment;

  PERL_TEST_MEMORY >= 70
  PERL_RUN_SLOW_TESTS != 0

(perl #127743) correct some types for Win32

In a couple of places the code uses unsigned long to represent values
possibly larger than 2**32, but long is 32-bits on x64 Win32, so
use STRLEN or Ssize_t instead.

Storable 3.05_13: safe defaults

mingw fix: use safe defaults, not segfaulting defaults.
mingw fails on the stacksize binary search, leaving it empty.

(cherry picked from commit 27c613e5f8dfab7b8b43a57e93a478aa962dd9ca)

Conflicts:
dist/Module-CoreList/lib/Module/CoreList.pm
dist/Storable/Storable.pm
pod/perlcdelta.pod
t/porting/customized.dat

Storable: Analyze #304

Add a better error message on one of the possible failure causes
when the system cannot catch the stackoverflow.

(cherry picked from commit 3f655dc6444cd56d09d4a99a4be5a92c1119506b)

Storable: cygwin64 MAX_DEPTH /2

(cherry picked from commit 5c3259bf9a54c29b526cb36cdf155005d8f93236)