regen Makefile.SH

I ran regen/lib_cleanup.pl because porting/regen.t was failing.

No I don't understand this area at all. And I don't think 'make realclean'
is doing what its supposed to be doing.
Memory leak in Storable::dclone with STORABLE_freeze hook

Storable documentation recommends using dclone shortcut in
STORABLE_freeze hook: "Unless you know better, serializing hook should
always say:
                sub STORABLE_freeze {
                    my ($self, $cloning) = @_;
                    return if $cloning; # Regular default serialization
                    ....
                }

            in order to keep reasonable dclone() semantics."

However, this causes a memory leak which is easy to observe with the
following small script:

=== storable-leak.plx ===
use Storable qw( dclone );

package Foo {
     sub new { return bless {}, __PACKAGE__ }

     sub STORABLE_freeze {
         my( $self, $cloning ) = @_;
         # Switch to regular default serialization results in memory leak
         return if $cloning;
         return 'Foo';
     }
}

my $d = Foo->new();
while(1)
{
     dclone( $d );
}
===

The leak is caused by missing cleanup of empty array value returned by
the hook. I've attached a simple patch for Storable-2.45 which fixes
this issue.

Reported in [perl #121928]

Amended to include version bump and Storable changelog entry.
refactor pp_list

-move PL_stack_sp and PL_stack_base reads into the branch in which they
 are used, this also removes 1 var from being saved across the function
 call in GIMME, which removes saving and restoring 1 non-vol register
-write SP to PL_stack_sp (PUTBACK) only if it was changed
-POPMARK is mutable, it must execute on all branches

this reduced pp_list's machine code size of the function from 0x58 to
0x53 bytes on VC 2003 -01 32 bits
For ptr masking use PTRSIZE-1, not nested conditional statement.
Accessing array before its start is dubious.

Fix by petermartini.

Fix for Coverity perl5 CID 28909:
Out-of-bounds access (ARRAY_VS_SINGLETON)
ptr_arith: Using &unsliced_keysv as an array.
This might corrupt or misinterpret adjacent memory locations.
Avoid "unused sp" if EXTEND is the last mentioning sp.

Add PERL_UNUSED_VAR(sp) in case the EXTEND (or MEXTEND)
is the last thing mentioning the sp.

Addresses Coverity perl5 CIDs 29199..29201, 29204, 29205, 29206,
29208, 29210, 29212, 29213, 29215, 29216, 29219..29221.
Add PERL_UNUSED_RESULT() and use that instead of the V_Gconvert().
perlhist: add release date for 5.21.0
Fix EXTEND changes under STRESS_REALLOC

As part of aad79b331c21c962b6e0ce7b8027aa625d7445ec, -DSTRESS_REALLOC was broken.
This should alleviate that.
Fixup for [perl #121860]: g++ and VC are pickier about what's
an expression and what's a statement.
Do not invert a NULL cp_list.

Fix for Coverity perl5 CID 28966.
UCHARAT unnecessary with isSPACE().

UCHARAT is not only unnecessary here (and no other spot in the core
seems to use UCHARAT with isFOO()), but it also narrows the type so
that some of the code in isSPACE() becomes unreachable.

Fix for Coverity perl5 CIDs 28937, 28938.
Use the C_ARRAY_LENGTH.

Use the C_ARRAY_LENGTH instead of sizeof(c_array)/sizeof(c_array[0])
or sizeof(c_array)/sizeof(type_of_element_in_c_array), and C_ARRAY_END
for c_array + C_ARRAY_LENGTH(c_array).

While doing this found potential off-by-one error in sv.c:Perl_sv_magic:
how > C_ARRAY_LENGTH(PL_magic_data)
should probably have been
how >= C_ARRAY_LENGTH(PL_magic_data)
No tests fail, but this seems to be more of an internal sanity check.
fix sv_usepvn_flags's docs

Newx != malloc, mixing Newx and malloc leads to heap corruption on some
builds like Win32, use the official Perl API for allocating memory.
Cannot rotl u32 (hek_hash) by 64 bits.

Fix for Coverity perl5 CID 28935:
Operands don't affect result (CONSTANT_EXPRESSION_RESULT)
result_independent_of_operands: (unsigned long)entry->hent_hek->hek_hash >> 47 /* 64 - 17 */ is 0 regardless of the values of its operands. This occurs as the bitwise second operand of '|'.
Off-by-one in PL_fold_locale use.

Fix for Coverity perl5 CID 29033: Out-of-bounds read
 (OVERRUN) overrun-local: Overrunning array PL_fold_locale of 256 bytes at
 byte offset 256 using index c1 (which evaluates to 256).

- the "c1 > 256" was off-by-one, it needed to be "c1 > 255",
  it could have caused the PL_fold_locale to be accessed one past the end,
  at offset 256, but we have dodged the bullet thanks to the regex engine
  optimizing the bad case away before we hit it (analysis by Karl Williamson):
  regexec.c
- comment fixes (pointed out by Karl Williamson): regexec.c
- add tests to nail down the behaviour of fold matching
  for the last of Latin-1 (0xFF, lowercase which curiously does not have
  uppercase within Latin-1). and the first pure Unicode: t/re/pat.t
Hide the VMS error identifier SS$_NOPRIV, as customary.
Use UINT64_C for UV constants.
UINT64_C/INT64_C logic shuffling.

(1) Prefer the native int/long over long long (not in C89!) or __int64.
(2) Define them only if necessary, they might be defined in <stdint.h> by C99
(3) However, note the C99.  They might not be available in strict C89.
(4) In OS X they are defined with ULL/LL, which will not be
    to the liking of C89 pedantic gcc.
g++ cleanups.

regcomp.c:11083: warning: suggest a space before ';' or explicit braces around empty body in 'for' statement

locale.c:1113: warning: comparison between signed and unsigned integer expressions