Sync IO-Compress with CPAN version 2.074.

CUSTOMIZED array no longer needed in this distro's entry in
Porting/Maintainers.pl; removed.

lib/File/GlobMapper.pm lacks a $VERSION; compensate for that by adding an
entry in Porting/cmpVERSION.pl.

From Changes file (since last version distributed with core):

  2.074 19 Feb 2017

      * Fix bad 2.073 release

  2.073 18 Feb 2017

      * #120239: [PATCH] ISA fixes for c3

  2.072 12 Feb 2017

      * Makefile.PL
        #120084: Need Fix for Makefile.PL depending on . in @INC

  2.070 28 Dec 2016

      * File::GlobMapper
        #117675: Fix prototype errors while lazy loading the module

      * zipdetails
        #116538: CVE-2016-1238: avoid loading optional modules from default .

Ensure that lib is built before IO-Compress

POSIX.pod: Remove obsolete text

Sync Compress-Raw-Zlib with CPAN version 2.074.

Sync Compress-Raw-Bzip2 with CPAN version 2.074.

utf8.c: Don't use Newx in decoding UTF-8

The bottom level UTF-8 decoding routine can be used during periods when
using Newx is prohibited, as diagnosed by Dave Mitchell for perl #130921
(see that ticket for his explanation).

This particular use of Newx was unnecessary, as it is just large enough
to hold a single character, and that can be done by an automatic
variable on the C stack.  The variable is used only upon rare error
conditions, but its only 14 bytes (15 on EBCDIC).

perlop.pod: Clarify, expand /a description

perlop: Fix spelling error

PATCH: [perl #128302] Document split pat mods

perlfunc: Add missing ')'

ExtUtils-ParseXS: bump all $VERSION 3.33->3.34

The previous commit only changed a pod file, but there have also been a
few other minor commits too since the last version bump, so give a fresh
version for the 5.26.0 release.

perlxstut.pod: s/newRV/newRV_inc/g

newRV_inc() and newRV_noinc() are the preferred forms since 5.004;
newRV is #deffed to newRV_inc and is only kept for backwards
compatibility.

Spotted by KES.

perlfunc: fix documentation for UTF-8 vec()

The documentation previously claimed that the internal UTF-8 buffer is
used even if the string is downgradeable. But the current behaviour is to
downgrade the buffer to the single-byte representation, and use the UTF-8
behaviour only if that fails.

That's been the case since commit 33b454808819084359e76a3f223a41b842c180b7,
from 7th September 2000.

There was also a period of a few days before that when a failed downgrade
yielded an exception; see commit 246fae53ea6ae12991e7653f136a0f797ce002d4.

Ensure that documentation works under 'use strict'.

In response to discussion at
http://stackoverflow.com/questions/42486716/perl-inline-selection-of-fd-as-in-docs-does-not-work-with-strict-refs/42486952#42486952

Add additional email address for author.

perlfunc: Fix awkward wording

Correct hv_iterinit's return value documentation

Update Config::Perl::V to 0.28

- add default_inc_excludes_dot

RT#123754 Add security note to File::Spec::no_upwards

As discussed with Dave Mitchell in private email.

S_do_op_dump_bar(): don't print TRANS op_pv field

My recent commit v5.25.9-32-gabd07ec made dump.c display the op_pv
string of OP_NEXT, OP_TRANS etc ops. However, for OP_TRANS/OP_TRANSR,
the string is basically a 256-byte potentially non null-temrinated array.
This was causing a buffer read overrun and garbage to be displayed.

The simple solution is to only display the address but not contents
for a trans op. OP_NEXT ec labels continue to be displayed.

RT#130624: heap-use-after-free in 4-arg substr

S_gv_stashsvpvn_cached(): add asserts

RT #130344

PL_stashcache holds SvIOK() scalars whose integer values are hidden
pointers to HVs. Add asserts that this is indeed the case.

(perl #130856) deal with unpack_sockaddr_un() croaking

because pack_sockaddr_un() returned an invalid address.

Upgrade to threads 2.15

Remove trailing whitespace.

This is as a precursor to the next commit in which I'll convert all "\t"s
there to spaces.

Upgrade to threads::shared 1.55

fix VMS test fail

d7186add added a runperl() test that breaks command line length limits for
VMS. Switch to fresh_perl() instead, so the prog is put in a file for us.

Add "default_inc_excludes_dot" to "perl -V" output

As proposed by Andreas Koenig++ in this message:

http://www.nntp.perl.org/group/perl.perl5.porters/2017/02/msg243256.html

Documentation fixes for '.' possibly no longer being in @INC

embed.fnc: _byte_dump_string is core-only

This commit, made during the freeze, was approved by the pumpking

Followup on a4570f51 for t/porting/extrefs.t

More functions have appeared that are PERL_STATIC_INLINE, but the
porting/extrefs.t compiles with -DPERL_NO_INLINE_FUNCTIONS, which
means no bodies are visible, but the Tru64 cc takes static inline
seriously, requiring the bodies.

Instead of the manual tweak of adding #ifndef PERL_NO_INLINE_FUNCTIONS
to embed.fnc, fix the problem in embed.pl so that 'i' type inserts the
required ifndef.  Remove the manual PERL_NO_INLINE_FUNCTIONS insertions
made in a4570f51 (note that the types of some have diverged).
Now the extrefs.t again works in Tru64 (and no other compiler
has ever tripped on this).

Clean up temporary directories after testing.

Signed-off-by: James E Keenan <jkeenan@cpan.org>

Forgotten static declarations

Signed-off-by: James E Keenan <jkeenan@cpan.org>

Make Perl_abort_execution flagged as not returning

Revert "ext/VMS-Stdio: switch to using macros designed for string constant args"

This reverts commit c0dea56fe487504493d97df5a7a6be57a2d2834d.

The new macros introduced here have now just been rendered invisible
by 8f71649941d02d5bdfe4f.  Using macros that we can't see breaks the
build, so revert this for now.  It can be reintroduced when the macro
names are settled and no longer hidden.

perldelta for 853eb961c1a3

update comment in test_bootstrap.pl

Add t/comp/parser_run.t to MANIFEST.

To keep t/porting/test_bootstrap.t happy, we need to declare the new test file
as an exception in that it says 'require test.pl' which tests in t/comp/ are
normally not permitted to do.

[perl #130814] update pointer into PL_linestr after lookahead

Looking ahead for the "Missing $ on loop variable" diagnostic can reallocate
PL_linestr, invalidating our pointer. Save the offset so we can update it
in that case.

[perl #130814] Add testcase, and new testfile t/comp/parser_run.t

Sometimes it's useful to have test.pl around, but it seems inappropriate
to pollute the existing t/comp/parser.t with that.

Are friends electric?

update Module::CoreList for 5.25.11

bump version number in lib/B/Op_private.pm

this was achieved with 'make regen'

bump version to 5.25.11

Merge branch 'blead' of ssh://perl5.git.perl.org/perl into blead

new perldelta for 5.25.11

add 5.25.10 epigraph

(perl #130822) fix an AV leak in Perl_reg_named_buff_fetch

Originally noted as a scoping issue by Andy Lester.

Tick release in the release schedule

Merge branch 'release-5.25.10' into blead

finalize perldelta

perlre, perlrecharclass, Fix overlooked typos

I thought I had committed these nits, pointed out to me by reviewers,
but I hadn't done so properly.

perlrebackslash: Clarify

"Character class for non vertical whitespace." wasn't meant to mean match
whitespace that isn't vertical.

perlre: Revamp portions

This commit folds in the after-thought section on Version 8 regexes into
the rest of the document, making most of it part of a gentler "Basics"
section.  Some redundancies from the auxiliary pods have been removed
(these being perlrebackslash and perlrecharclass, created, I presume,
to allow this document to be shorter).

perlre: Some clarifications, small corrections

perlre: Nits involving C<>, I<>

This standardizes the usage of single characters inside C<> to be
C<"x">, which was the most common usage previously in this pod.

It italicizes e.g., etc.

It removes trailing blanks on a few lines

perlre: Don't name exact max non-consume depth

In a couple of places, this pod says that 50 is the recursion limit in
patterns without consuming any input, but that it is changeable by
recompiling perl.  Therefore, we shouldn't specify the quantity, because
it might not be the correct value.  Further, 50 is currently wrong.

perlrecharclass: A few clarifications

perlretut: "-" is sometimes a metacharacter

perlretut: Cleanup, nits

This adds some C<>, I<>, changes non-literal text from C<> to I<>.
It changes some phrases that are enclosed in single quotes to the more
idiomatic double quotes.

It standardizes on single characters within C<> to be C<'x'>.  This is
not standardized in our documentation, and people change it back and
forth.  I prefer the extra quotes, as it otherwise blends in to the
background on html displays.

It converts the few 'regex' terms to 'regexp'.

It fixes some numbered lists to display not so uglily

It removes the cautions about the features that are no longer experimental

It corrects some grammar

Pods: Standardize on one pattern mod style

There were about 40 cases in pods where //m is used to represent the
pattern modifier 'm', but nearly 400 where /m is used.  Convert to the
most common representation.

Implement --help|--usage.

Also understand the output of "make test_harness".

Be more verbose about what failed and from which input.

Update Module::CoreList for 5.25.10

perldelta

re/fold_grind.t: Allow watchdog timeout to vary

If someone is running on a slow system, and they want fold_grind to
complete, they can now set an environment variable based on the relative
slowness of their system, that will be factored in to the length of the
timer.

Split XS-APItest/t/utf8.t

This test file is one of the longest running ones.  It has three main
semi-independent parts.  Two of them are split off into 2 files with a
common file required.  The other part is still long running, so it is
split so that a common file is used to run the tests, but it is called
with a chunk number and it only executes based on that chunk.  The
number of chunks is based on the environment variable TEST_JOBS, up to
10.  Each chunk executes 1/TEST_JOBS of the total test.  If TEST_JOBS is
not set, it reverts to 1 chunk.  The alternative would be to revert to
10, but since there is overhead associated with each new chunk, I chose,
for now, 1.

There may be a better solution later on, but I think this is good enough
for now.

Split APItest/t/handy.t

This is a very long running test.  This commit splits it into smaller
chunks, based on the environment variable TEST_JOBS, up to 10.   Each
chunk executes 1/TEST_JOBS of the total test.  If TEST_JOBS is not set,
it reverts to 1 chunk.  The alternative would be to revert to 10, but
since there is overhead associated with each new chunk, I chose, for
now, 1.

There may be a better solution later on, but I think this is good enough
for now.

handy.h: Guard controversial macro name

This is so their use cannot spread easily until we have sorted things
out in 5.27

perlretut: Note when metacharacters become ordinary

Revise documentation of eval and evalbytes

Clarify "User-visible changes"

The pumpking agreed with this wording

Balance uniprops tests

Commit 5656b1f654bb034c561558968ed3cf87a737b3e1 split the tests
generated by mktables so that 10 separate files each execute 10% of the
tests.  But it turns out that some tests are much more involved than
others, so that some of those 10 files still took much longer than
average.  This commit changes the split so that the amount of time each
file takes is more balanced.  It uses a natural breaking spot for the
tests for the \b{} flavors, except that GCB and SB are each short (so
are combined into being tested from one file), and LB is very long, so
is split into 4 test groups.

Inline foldEQ, foldEQ_latin1, foldEQ_locale

These short functions are called in inner loops and regex backtracking.

op.c: Add comment

perlrecharclass: Simplify by referring to other pod

The (?[...] has 're strict' rules.  Slightly reword to more directly
refer to the documentation on that.

perldelta for e7a8a8aac45d

Add another reneeb alias

(perl #129340) copy the source when inside the dest in sv_insert_flags()

Some version numbers in INSTALL were wrong

perldelta for commit 1f664ef5314fb6e438137c44c95cf5ecdbdb5e9b

Add support for VS2015 (VC++ 14.0)

Due to the rewritten CRT in this version of Visual C++ it is no longer
possible (or at least not at all easy) to make use of the ioinfo struct,
which commit b47a847f62 (re-)introduced in order to fix RT#120091/118059.
Therefore, we effectively revert commit b47a847f62 for VS2015 onwards on
the basis that being able to build with VS2015 onwards is more important
than the RT#120091/118059 bug fix. This does unfortunately mean that perls
built with <=VS2013 will not be compatible with perls built with >=VS2015,
but they may well not have been compatible anyway because of the CRT
rewrite, and certainly wouldn't be compatible if perl builds with VS2015
were not supported!

See RT#125714 for more discussion about this.

davem's perldelta entries for 5.25.10

bump test count in t/comp/parser.t

(the previous commit forgot to)

pp_formline(): revert recent buffer growth changes

This commit reverts the following (except for the additions to
t/op/write.t):

    3b1d752 pp_formline(): add empty body to empty while loop
    f62fd06 pp_formline(): avoid buffer overrun
    90c3aa0 pp_formline: simplify growing of PL_formtarget

90c3aa0 was intended to make the code for growing the buffer simpler and
more robust with less possibility of obscure edge cases, while the
follow-up commit fixed an issue introduced by that commit, and the next
was a tweak for a compiler warning. But

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

shows that there are still issues with the new code and I've decided to
abandon the effort and leave things how they were originally - i.e.
happily working, but probably with some still undiscovered edge cases.

[perl #130815] fix ck_return null-pointer deref on malformed code

pp_formline(): add empty body to empty while loop

my previous commit in this function added a block that happened
to follow directly after a bodiless while loop, i.e. 'while(...);'.
clang spotted this and warned. So add an empty body '{}' after the
while to visually disambiguate it.

Show sub name in signature arity-check error messages

Moving variables to their innermost scope.

Some vars have been tagged as const because they do not change in their
new scopes. In pp_reverse in pp.c, I32 tmp is only used to hold a char,
so is changed to char.

pp_multideref: tweak an assertion

My recent commit v5.25.9-89-g43dbb3c added an assertion to the effect that
in

    @{ local $a[0]{b}[1] } = 1;

the 'local' could only appear at the end of a block and so asserted that the
next op should be OP_LEAVE. However, this:

    @{1, local $a[0]{b}[1] } = 1;

inserts an OP_LIST before the OP_LEAVE.

Improve the assert to cope with any number of OP_NULL or OP_LISTs before
the OP_LEAVE.

pp_formline(): avoid buffer overrun

RT #130703

My recent commit v5.25.9-77-g90c3aa0 attempted to simplify buffer growth
in pp_formline(), but missed the operators which append data to
PL_formtarget *without* doing 'goto append'. These ops either append a
fieldsize's worth of bytes, or a \n (FF_NEWLINE). So grow by fieldsize
whenever we fetch something new, and for each FF_NEWLINE.

Updates CPAN.pm to ANDK/CPAN-2.17-TRIAL2.tar.gz

Upgrade to Thread::Queue 3.12

regexec.c: Fix comment typos

avoid a leak in list assign from/to magic values

RT #130766

A leak in list assignment was introduced by v5.23.6-89-gbeb08a1 and
extended with v5.23.6-90-g5c1db56.

Basically the code in S_aassign_copy_common() which does a mark-and-sweep
looking for common vars by temporarily setting SVf_BREAK on LHS SVs then
seeing if that flag was present on RHS vars, very temporarily removed that
flag from the RHS SV while mortal copying it, then set it again. After
those two commits, the "resetting" code could set SVf_BREAK on the RHS SV
even when it hadn't been been present earlier.

This meant that on exit from S_aassign_copy_common(), some SVs could be
left with SVf_BREAK on. When that SV was freed, the SVf_BREAK flag meant
that the SV head wasn't planted back in the arena (but PL_sv_count was
still decremented). This could lead to slow growth of the SV HEAD arenas.

The two circumstances that could trigger the leak were:

1) An SMG var on the LHS and a temporary on the RHS, e.g.

    use Tie::Scalar;
    my ($s, $t);
    tie $s, 'Tie::StdScalar'; # $s has set magic
    while (1) {
        ($s, $t) = ($t, map 1, 1, 2); # the map returns temporaries
    }

2) A temporary on the RHS which has GMG, e.g.

    my $s = "abc";
    pos($s) = 1;
    local our ($x, $y);
    while (1) {
        my $pr = \pos($s); # creates a ref to a TEMP with get magic
        ($x, $y) = (1, $$pr);
    }

Strictly speaking a TEMP isn't required for either case; just a situation
where there's always a fresh SV on the RHS for each iteration that will
soon get freed and thus leaked.

This commit doesn't include any tests since I can't think of a way of
testing it. svleak.t relies on PL_sv_count, which in this case doesn't
show the leak.

Improve handling pattern compilation errors

Perl tries to continue parsing in the face of errors for the convenience
of the person running the script, so as to batch up as many errors as
possible, and cut down the number of runs.  Some errors will, however,
have a cascading effect, resulting in the parser getting confused as to
the intent.  Perl currently aborts parsing if 10 errors accumulate.

However, some things are reparsed as compilation continues, in
particular tr///, s///, and qr//.  The code that reparses has an
expectation of basic sanity in what it is looking at, and so reparsing
with known errors can lead to segfaults.  Recent commits have tightened
this up to avoid reparsing, or substitute valid stuff before reparsing.
This all works, as the code won't execute until all the errors get
fixed.

Commit f065e1e68bf6a5541c8ceba8c9fcc6e18f51a32b changed things so that
if there is an error in parsing a pattern, the whole compilation is
immediately aborted.  Since then, I realized it would be relatively
simple to instead, skip compilation of that particular pattern, but
continue on with the parsing of the program as a whole, up to the
maximum number of allowed errors.  And again the program will refuse to
execute after compilation if there were any errors.

This commit implements that, the benefit being that we don't try to
reparse a pattern that failed the original parse, but can go on to find
errors elsewhere in the program.

Revert "Upgrade to Thread::Queue 3.12"

This reverts commit 57c819f845c985ed9979bfa76b1b8ca1708370f0.

Reverting to give us time to explore possible race condition.  See:
https://rt.perl.org/Ticket/Display.html?id=130777

[MERGE] regex (?{...}) and WHILEM scope fixups

S_regmatch: eliminate WHILEM_A_min paren saving

In something like

    "a1b2c3d4..." =~ /(?:(\w)(\d))*..../

A WHILEM state is pushed for each iteration of the '*'. Part of this
state saving includes the previous indices for each of the captures within
the body of the thing being iterated over. So we save the following sets of
values for $1,$2:

    ()()
    (a)(1)
    (b)(2)
    (c)(3)
    (d)(4)

Then if at any point we backtrack, we can undo one or more iterations and
restore the older values of $1,$2.

However, when the match is non-greedy, as in A*?B, then on failure of B
and backtracking we attempt *more* A's rather than removing some already
matched A's. So there's never any need to save all the current paren state
for each iteration.

This eliminates a lot of per-iteration overhead for minimal WHILEMs and
makes the following run about 25% faster:

$s = ("a" x 1000);
$s =~ /^(?:(.)(.))*?[XY]/ for 1..10_000;

S_regmatch: eliminate WHILEM_B paren saving

In something like

    "a1b2c3d4..." =~ /(?:(\w)(\d))*..../

A WHILEM state is pushed for each iteration of the '*'. Part of this
state saving includes the previous indices for each of the captures within
the body of the thing being iterated over. So we save the following sets of
values for $1,$2:

    ()()
    (a)(1)
    (b)(2)
    (c)(3)
    (d)(4)

Then if at any point we backtrack, we can undo one or more iterations and
restore the older values of $1,$2.

For /A*B/ where A is a complex sub-pattern like (\w)(\d), we currently save
the paren state each time we're about to attempt to iterate another A.
But it turns out that for non-greedy matching, i.e. A*?B, we also
save the paren state before executing B. This is unnecessary, as
B can't alter the capture state of the parens within A. So eliminate it.

If in the future some sneaky regex is found which this commit breaks,
then as well as restoring the old behaviour, you should look carefully
to see whether similar paren-saving behaviour for B should be added to
greedy matches too, i.e. A*B. It was partly the discrepancy between
saving for A*?B but not for A*B which made me suspect it was redundant.