rpeep: maintain chain when del extra nextstates

There's code in rpeep() that eliminates duplicate nextstate ops.
E.g.

    FOO -> NEXTSTATE1 -> NULL -> ... -> NULL -> NEXTSTATE2 -> ...

becomes

    FOO --------------------------------------> NEXTSTATE2 -> ...

This code didn't leave oldoldop -> oldop -> o as a consistent chain of
adjacent op_next ops.

stop the eliding of void $pkg_var from assert fail

The code to eliminate things like our($foo); from the runtime op_next
chain in rpeep() caused the oldoldop, oldop, o vars not to form a chain of
3 adjacent ops. Instead, oldoldop and oldop ended up equal, which later
caused an assertion failure in the padrange code for something like

    my($a,$b),$x,my($c,$d);

utf8.c: Fix broken EBCDIC compilation

Commit ba6ed43c6aca7f1ff5a1b82062faa3e1c33c0582 left out a '}' which is
skipped except in EBCDIC builds.  (I meant to make sure things would
compile (by reversing the sense of the #if's) on EBCDIC, but forgot at
the time it should have been done.)

[perl #126593] make sure utf8_heavy.pl doesn't depend on itself

With ${^ENCODING} set, it did.

Partly reverts:

commit aa8f6cef961dc2009604f7464c66106421c3ae81
Author: Rafael Garcia-Suarez <rgs@consttype.org>
Date:   Wed Jun 17 13:18:59 2015 +0200

    Microoptimize some matches in utf8_heavy.pl

Perl_uvoffuni_to_utf8_flags() Combine ASCII, EBCDIC branches

This uses the underlying structure of UTF-8 and UTF-EBCDIC to unify most
of the code.  Previously, the ASCII platform version unrolled a loop,
and the EBCDIC didn't.  Now the loop is used for code points that
require 5 or more bytes to represent in UTF-8 and UTF-EBCDIC.  On ASCII
platforms, this means that all leggal Unicode code points use the
unrolled version.  I used cachegrind to find that the unrolled savings
were not large, and in the trade-off between performance and
maintainability on code points that Unicode doesn't think are legal,
maintainability wins.

I also moved the tests so that there are no unnecessary tests on ASCII
platforms.  For example, if we know that we are in a range of code
points that doesn't have surrogates, no tests for surrogates are done.
Perhaps an optimizing compiler could figure this out.  There is a
smidgeon of extra tests on EBCDIC platforms, to keep the code unified
between the two platform types.

Originally, I did try to keep the loop unrolled, which is how I found
that the performance savings wasn't great.  Here that code is (with a
space inserted before column 1 '#' chars, so git doesn't think they are
comments:

U8 *
Perl_uvoffuni_to_utf8_flags(pTHX_ U8 *d, UV uv, UV flags)
{
    PERL_ARGS_ASSERT_UVOFFUNI_TO_UTF8_FLAGS;

    /* Test for and handle 1-byte result. */
    if (OFFUNI_IS_INVARIANT(uv)) {
*d++ = LATIN1_TO_NATIVE(uv);
return d;
    }

/*  Use shorter names internally in this file */
 #define SHIFT   UTF_ACCUMULATION_SHIFT
 #undef  MARK
 #define MARK    UTF_CONTINUATION_MARK
 #define MASK    UTF_CONTINUATION_MASK

    /* Below is an unrolled version of
     *
STRLEN len  = OFFUNISKIP(uv);
U8 *p = d+len-1;
while (p > d) {
    *p-- = I8_TO_NATIVE_UTF8((uv & UTF_CONTINUATION_MASK) | UTF_CONTINUATION_MARK);
    uv >>= UTF_ACCUMULATION_SHIFT;
}
*p = I8_TO_NATIVE_UTF8((uv & UTF_START_MASK(len)) | UTF_START_MARK(len));
return d+len;
     *
     * Unrolled, it looks like:
     *
        if (uv < max_2_byte_uv) return the 2 bytes;
        if (uv < max_3_byte_uv) return the 3 bytes;
        ...
    *
    * Note that on EBCDIC we have to turn things into NATIVE_UTF8, which is a
    * no-op on ASCII platforms */

    /* Not 1-byte; test for and handle 2-byte result.   In the test immediately
     * below, the 32 is for start bytes C0-CF, D0-DF, each of which has a
     * continuation byte which contributes SHIFT bits.  This yields 0x400 on
     * EBCDIC platforms, 0x800 on ASCII */
    if (uv < (32 * (1U << SHIFT))) {
*d++ = I8_TO_NATIVE_UTF8(( uv >> SHIFT) | UTF_START_MARK(2));
*d++ = I8_TO_NATIVE_UTF8(( uv           & MASK) |   MARK);
return d;
    }

    /* Not 2-byte; test for and handle 3-byte result.   In the test immediately
     * below, the 16 is for start bytes E0-EF (which are the ones that indicate
     * 3 bytes), the 2 is for 2 continuation bytes which each contribute SHIFT
     * bits.  This yields 0x4000 on EBCDIC platforms, 0x1_0000 on ASCII, so 3
     * bytes covers the range 0x400-0x3FFF on EBCDIC; 0x800-0xFFFF on ASCII */
    if (uv < (16 * (1U << (2 * SHIFT)))) {
*d++ = I8_TO_NATIVE_UTF8(( uv >> ((3 - 1) * SHIFT)) | UTF_START_MARK(3));
*d++ = I8_TO_NATIVE_UTF8(((uv >> ((2 - 1) * SHIFT)) & MASK) |   MARK);
*d++ = I8_TO_NATIVE_UTF8(( uv  /* (1 - 1) */        & MASK) |   MARK);

 #ifndef EBCDIC  /* These problematic code points are 4 bytes on EBCDIC */
        /* The most likely code points in this range are below the surrogates.
         * Do an extra test to quickly exclude those. */
        if (UNLIKELY(uv >= UNICODE_SURROGATE_FIRST)) {
            if (UNLIKELY(   UNICODE_IS_32_NONCHARS(uv)
                         || UNICODE_IS_xFFF_E_F(uv)))
            {
                goto handle_nonchar;
            }
            if (UNLIKELY(UNICODE_IS_SURROGATE(uv))) {
                goto handle_surrogate;
            }
        }
 #endif
return d;
    }

    /* Not 3-byte; test for and handle 4-byte result.   In the test immediately
     * below, the 8 is for start bytes F0-F7, the 3 is for 3 continuation bytes
     * which each contribute SHIFT bits.  This yields 0x4_0000 on EBCDIC
     * platforms, 0x20_0000 on ASCII, so 4 bytes covers the range
     * 0x4000-0x3_FFFF on EBCDIC; 0x1_0000-0x1F_FFFF on ASCII */
    if (uv < (8 * (1U << (3 * SHIFT)))) {
*d++ = I8_TO_NATIVE_UTF8(( uv >> ((4 - 1) * SHIFT)) | UTF_START_MARK(4));
*d++ = I8_TO_NATIVE_UTF8(((uv >> ((3 - 1) * SHIFT)) & MASK) |   MARK);
*d++ = I8_TO_NATIVE_UTF8(((uv >> ((2 - 1) * SHIFT)) & MASK) |   MARK);
*d++ = I8_TO_NATIVE_UTF8(( uv  /* (1 - 1) */        & MASK) |   MARK);

 #ifdef EBCDIC  /* These problematic code points are 3 bytes on ASCII */
if (UNLIKELY(   UNICODE_IS_32_NONCHARS(uv)
                     || UNICODE_IS_xFFF_E_F(uv)))
        {
            goto handle_nonchar;
        }
if (UNLIKELY(UNICODE_IS_SURROGATE(uv))) {
            goto handle_surrogate;
        }
 #else
if (UNLIKELY(   UNICODE_IS_xFFF_E_F(uv))
                     || UNICODE_IS_10_FFF_E_F(uv))
        {
            goto handle_nonchar;
        }
        if (UNLIKELY(UNICODE_IS_SUPER(uv))) {
            goto handle_super;
        }
 #endif
return d;
    }

    /* Not 4-byte; test for and handle 5-byte result.   In the test immediately
     * below, the first 4 is for start bytes F8-FB, the second 4 is for 4
     * continuation bytes which each contribute SHIFT bits.  This yields
     * 0x40_0000 on EBCDIC platforms, 0x400_0000 on ASCII, so 5 bytes covers
     * the range 0x4_0000-0x3F_FFFF on EBCDIC; 0x20_0000-0x3FF_FFFF on ASCII */
    if (uv < (4 * (1U << (4 * SHIFT)))) {
*d++ = I8_TO_NATIVE_UTF8(( uv >> ((5 - 1) * SHIFT)) | UTF_START_MARK(5));
*d++ = I8_TO_NATIVE_UTF8(((uv >> ((4 - 1) * SHIFT)) & MASK) |   MARK);
*d++ = I8_TO_NATIVE_UTF8(((uv >> ((3 - 1) * SHIFT)) & MASK) |   MARK);
*d++ = I8_TO_NATIVE_UTF8(((uv >> ((2 - 1) * SHIFT)) & MASK) |   MARK);
*d++ = I8_TO_NATIVE_UTF8(( uv  /* (1 - 1) */        & MASK) |   MARK);

 #ifdef EBCDIC
if (UNLIKELY(   UNICODE_IS_xFFF_E_F(uv))
                     || UNICODE_IS_10_FFF_E_F(uv))
        {
            goto handle_nonchar;
        }
        if (UNLIKELY(UNICODE_IS_SUPER(uv))) {
            goto handle_super;
        }
        return d;
 #else
goto handle_super;
 #endif
    }

    /* Not 5-byte; test for and handle 6-byte result.   In the test immediately
     * below, the 2 is for start bytes FC-FD, the 5 is for 5 continuation bytes
     * which each contribute SHIFT bits.  This yields 0x400_0000 on EBCDIC
     * platforms, 0x8000_0000 on ASCII, so 6 bytes covers the range
     * 0x40_0000-0x3FF_FFFF on EBCDIC; 0x400_0000-0x7FFF_FFFF on ASCII. */
    if (uv < (2 * (1U << (5 * SHIFT)))) {
*d++ = I8_TO_NATIVE_UTF8(( uv >> ((6 - 1) * SHIFT)) | UTF_START_MARK(6));
*d++ = I8_TO_NATIVE_UTF8(((uv >> ((5 - 1) * SHIFT)) & MASK) |   MARK);
*d++ = I8_TO_NATIVE_UTF8(((uv >> ((4 - 1) * SHIFT)) & MASK) |   MARK);
*d++ = I8_TO_NATIVE_UTF8(((uv >> ((3 - 1) * SHIFT)) & MASK) |   MARK);
*d++ = I8_TO_NATIVE_UTF8(((uv >> ((2 - 1) * SHIFT)) & MASK) |   MARK);
*d++ = I8_TO_NATIVE_UTF8(( uv  /* (1 - 1) */        & MASK) |   MARK);
goto handle_super;
    }

    /* This could be moved down for EBCDIC, but not worth the complexity */
    if (   UNLIKELY(uv > MAX_NON_DEPRECATED_CP) && ckWARN_d(WARN_DEPRECATED)) {
        Perl_warner(aTHX_ packWARN(WARN_DEPRECATED),
                    cp_above_legal_max, uv, MAX_NON_DEPRECATED_CP);
    }

    /* Not 6-byte; handle 7-byte result.  There is no need for a test on
     * platforms where 7 bytes is the maximum possible, .  The FE start byte
     * can have 6 continuation bytes which each contribute SHIFT bits.  This
     * yields 0x4000_0000 on EBCDIC platforms, 0x10_0000_0000 on ASCII, so 7
     * bytes covers the range 0x400_0000-0x3FFF_FFFF on EBCDIC;
     * 0x400_0000-0xF_FFFF_FFFF on ASCII */
 #if defined(UV_IS_QUAD) || defined(EBCDIC)
    if (uv < ((UV) 1U << (6 * SHIFT)))
 #endif
    {
*d++ = I8_TO_NATIVE_UTF8(0xfe); /* Can't match U+FEFF! */
*d++ = I8_TO_NATIVE_UTF8(((uv >> ((6 - 1) * SHIFT)) & MASK) |   MARK);
*d++ = I8_TO_NATIVE_UTF8(((uv >> ((5 - 1) * SHIFT)) & MASK) |   MARK);
*d++ = I8_TO_NATIVE_UTF8(((uv >> ((4 - 1) * SHIFT)) & MASK) |   MARK);
*d++ = I8_TO_NATIVE_UTF8(((uv >> ((3 - 1) * SHIFT)) & MASK) |   MARK);
*d++ = I8_TO_NATIVE_UTF8(((uv >> ((2 - 1) * SHIFT)) & MASK) |   MARK);
*d++ = I8_TO_NATIVE_UTF8(( uv  /* (1 - 1) */        & MASK) |   MARK);
 #ifdef EBCDIC
        goto handle_super;
 #else
goto handle_above_31_bit;
 #endif
    }

    /* Below is for a 0xFF start byte.  You need a 64-bit word size to be able
     * to express this on an ASCII machine, but a 32-bit word expresses the
     * lower range on EBCDIC platforms */
 #if defined(UV_IS_QUAD) || defined(EBCDIC)
    {
        /* UTF8_MAX_BYTES result.  The 0xff start byte is followed by 13
         * continuation bytes on EBCDIC; 12 on ASCII.  These numbers of bytes
         * are essentially arbitrary, but were chosen to be enough to represent
         * 2**64 - 1 (plus an extra byte on ASCII).  */
        *d++ = I8_TO_NATIVE_UTF8(0xff); /* Can't match U+FFFE! */
 #   ifdef UV_IS_QUAD
 #      ifndef EBCDIC
*d++ =    /*      ASCII platform (12 - 1) 6 Reserved bits */    MARK;
 #      else
*d++ = I8_TO_NATIVE_UTF8(((uv >>((13 - 1) * SHIFT)) & MASK) |   MARK);
*d++ = I8_TO_NATIVE_UTF8(((uv >>((12 - 1) * SHIFT)) & MASK) |   MARK);
 #      endif
*d++ = I8_TO_NATIVE_UTF8(((uv >>((11 - 1) * SHIFT)) & MASK) |   MARK);
*d++ = I8_TO_NATIVE_UTF8(((uv >>((10 - 1) * SHIFT)) & MASK) |   MARK);
*d++ = I8_TO_NATIVE_UTF8(((uv >> ((9 - 1) * SHIFT)) & MASK) |   MARK);
*d++ = I8_TO_NATIVE_UTF8(((uv >> ((8 - 1) * SHIFT)) & MASK) |   MARK);
 #   else    /* Here, must be EBCDIC without quad */
*d++ = I8_TO_NATIVE_UTF8(    /*  (13 - 1) 5 Reserved bits */    MARK);
*d++ = I8_TO_NATIVE_UTF8(    /*  (12 - 1) 5 Reserved bits */    MARK);
*d++ = I8_TO_NATIVE_UTF8(    /*  (11 - 1) 5 Reserved bits */    MARK);
*d++ = I8_TO_NATIVE_UTF8(    /*  (10 - 1) 5 Reserved bits */    MARK);
*d++ = I8_TO_NATIVE_UTF8(    /*  ( 9 - 1) 5 Reserved bits */    MARK);
*d++ = I8_TO_NATIVE_UTF8(    /*  ( 8 - 1) 5 Reserved bits */    MARK);
 #   endif
*d++ = I8_TO_NATIVE_UTF8(((uv >> ((7 - 1) * SHIFT)) & MASK) |   MARK);
*d++ = I8_TO_NATIVE_UTF8(((uv >> ((6 - 1) * SHIFT)) & MASK) |   MARK);
*d++ = I8_TO_NATIVE_UTF8(((uv >> ((5 - 1) * SHIFT)) & MASK) |   MARK);
*d++ = I8_TO_NATIVE_UTF8(((uv >> ((4 - 1) * SHIFT)) & MASK) |   MARK);
*d++ = I8_TO_NATIVE_UTF8(((uv >> ((3 - 1) * SHIFT)) & MASK) |   MARK);
*d++ = I8_TO_NATIVE_UTF8(((uv >> ((2 - 1) * SHIFT)) & MASK) |   MARK);
*d++ = I8_TO_NATIVE_UTF8(( uv  /* (1 - 1) */        & MASK) |   MARK);
    }
 #endif

 #ifdef EBCDIC
    if (uv <= 0x7FFFFFFF) {
        goto handle_super;
    }
 #endif
    /* FALLTHROUGH */                                                           \

  handle_above_31_bit:

    if (flags & (UNICODE_WARN_ABOVE_31_BIT|UNICODE_WARN_SUPER)) {
        Perl_ck_warner_d(aTHX_ packWARN(WARN_NON_UNICODE),
                  "Code point 0x%"UVXf" is not Unicode, and not portable", uv);
        /* So won't warn twice; we have to fall through into handle_super in
         * case supers are disallowed */
        flags &= ~UNICODE_WARN_SUPER;
    }

    if (flags & UNICODE_DISALLOW_ABOVE_31_BIT) {
        return NULL;
    }

  handle_super:
    if (flags & UNICODE_WARN_SUPER) {
        Perl_ck_warner_d(aTHX_ packWARN(WARN_NON_UNICODE),
            "Code point 0x%04"UVXf" is not Unicode, may not be portable", uv);
    }

    if (flags & UNICODE_DISALLOW_SUPER) {
        return NULL;
    }
    return d;

  handle_surrogate:
    if (flags & UNICODE_WARN_SURROGATE) {
        Perl_ck_warner_d(aTHX_ packWARN(WARN_SURROGATE),
                                    "UTF-16 surrogate U+%04"UVXf, uv);
    }
    if (flags & UNICODE_DISALLOW_SURROGATE) {
        return NULL;
    }
    return d;

  handle_nonchar:
    if (flags & UNICODE_WARN_NONCHAR) {
        Perl_ck_warner_d(aTHX_ packWARN(WARN_NONCHAR),
         "Unicode non-character U+%04"UVXf" is not recommended for open interchange",
         uv);
    }
    if (flags & UNICODE_DISALLOW_NONCHAR) {
        return NULL;
    }
    return d;
}

utf8.c: Extract some code into macros

This is in preparation for a future commit, where they will be used in
more than one place.

utf8.c: White-space only

Most of these white-space only changes are outdenting, in preparation
for a later commit

utf8.c: Add some UNLIKELY()

utf8.c: Reorder some tests

When converting a code point to its UTF-8 form, the code point is
checked to be sure it is not problematic.  It turns out that all
problematic code points require at least 3 UTF-8 bytes to represent.
Already, the single-byte characters are handled before the problematic
tests.  This changes so that the two-byte ones are as well.  Further, it
now uses the canned macros that do this which are valid on both EBCDIC
and ASCII systems, instead of the previous code, which was
ASCII-specific.  This means one less test when the input code point is
representable by 2 bytes.

utf8.h: Split UNICODE_IS_NONCHAR() into smaller macros

This defines 2 macros that can be used individually to check for
non-characters when the input range is known to be restricted to not
include every possible one.  This is for future commits.

improve my rewrite of installhtml’s dir scan

Add epigraph for 5.22.1-RC4

Perl 5.22.1-RC4 today

perldelta: davem's significant stuff since 5.23.5

Fix t/op/sprintf2.t on VMS

(Passed under harness, but failed under TEST.)

Fix Emacs dir-local variables

The setting for cperl-indent-level (which sets the default indentation step
used by Emacs for Perl code) was missing a dot in the relevant cons pair.
This meant that the value set was the single-element list (4) rather than
the integer 4, so attempting to indent lines made Emacs produce an error
"Wrong type argument: number-or-marker-p, (4)".

regen charclass_invlists.h

This is needed bcause mktables changed.  A porting test did not pick
this up, and so probably should be made to.

mention $? in backticks documentation

Backticks work like system(), in that they use $? for the child exit
code. Mention that so people know to look in $? when their program
fails.

standardize on "lookahead" and "lookaround"

...not the hyphenated form

commit message by rjbs

Remove duplicate line from test

perldelta for 817e3e2c6

and a small typo fix

[perl #123991] report an error if we can't parse the number after -C

Update Math-BigInt-FastCalc to CPAN version 0.38

  [DELTA]

2015-12-02 v0.38 pjacklam
  * Use 'static double', not just 'double' in FastCalc.xs.
  * Move 'Test::More' from 'build_requires' to 'test_requires' in Makefile.PL.

utf8.h, utfebcdic.h: Comments, white-space only

hexfp: test longdblkind directly, instead of doublekind

Also, explain the gating on linux on this test.

(suggested by Aaron Crane)

Porting/Glossary: fix a set of typos

A few descriptions of floating-point formats included the word "big" before
the actual endianness.

perldelta: Add note about earlier \p{} changes

APItest: Add tests for valid_utf8_to_uvchr

t/uni/case.pl: Sort numerics with <=> to get better results

utf8.h: Remove a branch in macro for Unicode surrogates

By masking, this macro can be written so it only has one branch.
Presumably an optimizing compiler would do the same, but not necessarily
so.

utf8.h: Add some casts in macros, for safety

This also renames the macro formal parameter to uv to be clearer as to
what is expected as input, and there were cases where it was referred to
inside the macro without being parenthesized, which was dangerous.

Merge commit for removing EBCDIC special code

It's better to use the same code and definitons whenever possible for
different platforms, for ease of maintenance.  This set of commits
eliminates several cases of differing EBCDIC/ASCII definitions, so that
there is less separate code to maintain.

utf8.h: Combine EBCDIC and ASCII macros

Previous commits have set things up so the macros are the same on both
platforms.  By moving them to the common part of utf8.h, they can share
the same definition.  The difference listing shows instead other things
being moved due to the size of this move in comparison with those things
that really stayed the same.

utf8.h: Refactor macro definition

This changes to use the underlying UTF-8 structure to compute the
numbers in this macro, instead of hand-specifying the resultant ones.
Thus, this macro, with minor tweaks, is the same text on both ASCII and
EBCDIC platforms (though the resultant numbers differ), and the next
commit will change them to use it in common.

utf8.h: Combine EBCDIC and ASCII macros

The previous commits have made these macros be the exact same text, so
can be combined, and defined just once.  This requires moving them to
the portion of the file that is common with both EBCDIC and ASCII.

The commit diff shows instead other code being moved.

utf8.h: Refactor a macro

This new definition expands to the same thing as before, but now the
unexpanded text is identical to the EBCDIC definition (which expands to
something else), so the next commit can combine the ASCII and EBCDIC
ones into a single definition.

utf8.h: Use common macro to avoid repeating

This refactors two macros that have mostly the same guts to have a third
macro to define the common guts.

It also changes to use UV_IS_QUAD instead of a home-grown #define that a
future commit will remove.

utf8.h: Move #define within file

This makes 2 related definitions adjacent.

utf8.h: Combine EBCDIC and ASCII #defines

Change to use the same definition for two macros on both types of
platforms, simplifying the code, by using the underlying structure of
the encoding.

utf8.h: Move #define to earlier in the file

And use its mnemonic in other #defines instead of repeating the raw
value.

utf8.h, et.al.: Clean up some casts

By making sure the no-op macros cast the output appropriately, we can
eliminate the casts that have been added in things that call them

utf8.h: Combine ASCII and EBCDIC defines into one

By using a more fundamental value, these two definitions of the macro
can be made the same, so only need one, common to both platforms

utfebcdic.h: Use an internal macro to avoid repeating

This creates a macro that is used in portions of 2 other macros, thus
removing repetition.

utf8.h, utfebcdic.h: Fix-up UTF8_MAXBYTES_CASE defn

The definition had gotten moved away from its comments in utf8.h, and
the wrong thing was being guarded by a #error, (UTF8_MAXBYTES instead).
And it is possible to generalize to get the compiler to do the
calculation, and to consolidate the definitions from the two files into
a single one.

amigaos4: use raise() instead of kill() on ourselves

Using kill() on the same task that called kill() circumvents
Perl's signal handlers, but raise() doesn't, so use that instead.

hexfp: Use Perl_fp_class_nzero unconditionally.

Otherwise in platforms with Perl_fp_class_nzero there would be no
return for the x != 0.0 case.

hexfp: these should be tested only with uselongdouble.

Have more fallbacks for our signbit() emulation.

These help in systems which do not have signbit(), or fail to find one,
or which explicitly disable it.

The idea for the fallback implementation from Craig Berry.

[PATCH] Bump Locale-Codes from 3.36 to 3.37

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

Update Unicode-Normalize to CPAN version 1.24

  [DELTA]

1.24  Sun Nov 29 05:48:44 UTC 2015
    - Updated to use most recent GNU license file.
      ( https://rt.cpan.org/Public/Bug/Display.html?id=108003 )
    - Silence compiler warning message
      ( https://rt.cpan.org/Public/Bug/Display.html?id=109577 )
    - Add kwalitee suggested changes.

Update PathTools to CPAN version 3.60

perlxs.pod: clarify PROTOTYPES: behaviour.

The default is to disable rather than enable.

Also mention the "Please specify prototyping behavior for Foo.xs"
warning.

threads.t: make stress test less stressy

Test 10 creates 100 threads that do 'require IO'. This can use a lot
of memory and other resources. reduce it to 10.

Undo blead customization of Text-ParseWords test script

The customization simply changed DOS EOLs to UNIX EOLs, dating from a time
when the intention was to get all files in blead into UNIX EOL format.
However, since then many more files have crept in with DOS EOLs (for
example, many files under cpan/Pod-Checker, cpan/Pod-Parser and
cpan/Pod-Usage have DOS EOLs in my Git workspace (on Windows) and in the
most recent perl release tarballs (5.22.1-RC3 (made from Windows) and
5.23.5 (not made from Windows AFAIK))) and they clearly do no harm, so
there is no point in trying to make all files have UNIX EOLs and keep them
that way, and therefore no point in this customization.

The GitHub PR that was referenced in Porting/Maintainers.pl has already
been closed (not merged).

There are no changes to ParseWords.t here other than the EOLs.

Add the -Wthread-safety also only for clang 3.6 (6.1) or later.

(follow-up to bdc795f4, suggested by Aaron Crane)

Config-Perl-V bump in Maintainers.pl

Module-CoreList bump in Maintainers.pl

fix the API description of SvLEN_set()

RT #126245

Make it clearer that is the buffer length being specified, not the string
length. Also, change the 'See "SvIV_set"' to SvLEN. That appears to be a
cut and paste error.

Based on suggested wording from jazzkutya@gmail.com

Ensure 'q' works in debugger with RemotePort.

Patch submitted by Shlomi Fish.

For: RT #126735

Add epigraph for 5.22.1-RC3

Perl 5.22.1-RC3 today

Revert "Revert "Module::CoreList updates for 5.22.1""

This reverts commit 85e4652903c8054317fceac9960608e261acb7f5...
... with some manual changes to now place 5.022001 before 5.023006 instead
of before 5.023005 since 5.023006 is now the impending blead release. Also,
set a tentative 5.22.1 final $VERSION/date of Sun 6th.

Complete some unfinished Module::CoreList work from commit 7c294235c2

Bump the TSA clang minimum to 3.6 (in Applese 6.1)

Since it looks like the 3.5 (6.0) in OS X 9 didn't recognize the annotations.

For TSA we want 4 or later clang, not just later.

(Noticed by Aaron Crane.)

More notes on OS X compiler versions.

/..\G/: use chars, not bytes

In something like /..\G/, the engine should start trying to match two
chars before pos(). It was actually trying to match two bytes before.

markstack_grow(): fix debugging stuff

This is a follow-on to commit ac07059afc75:

    FOOMARK debugging macros: fix %d cast; only -Dsv

which missed fixing up the debugging statement in markstack_grow().

rpeep(): silence  compiler warning

op.c: In function ‘Perl_rpeep’:
op.c:13666:35: warning: comparison is always false due to limited range of data
type [-Wtype-limits]

This condition is always false if for example base is 32 bit and UVs are 64
bit:

    base >  (UV_MAX >> (OPpPADRANGE_COUNTSHIFT+SAVE_TIGHT_SHIFT)

silence the warning by replacing base with a constant-folded conditional

    (cond ? base : 0) > ....

where cond is false if sizeof(base) is small.

Configure: unbreak -S option now that -O is the default

As far as I can tell, using the -S and -O options together has always
yielded an error of this form:

    Configure: 2042: .: Can't open ./optdef.sh

That's because, even though optdef.sh is created in the UU directory, and
most of Configure is run in that directory, part of the -S implementation is
run in the root directory, and was therefore trying to read ./optdef.sh
instead of ./UU/optdef.sh.

As of 41d73075f0801c26794dadb1ff690f305d7e53a7, the -O mode is always
enabled, so the -S option has been broken since then. This fixes that.

move Win32's $^X code to where all other OSes' $^X code lives

Back when the code in perllib.c was first added in 1999, in
commit 80252599d4 the large define tree function that today in 2015 is
Perl_set_caret_X was an unremarkable single statement
http://perl5.git.perl.org/perl.git/blob/80252599d4b7fb26eec4e3a0f451b4387c5dcc19:/perl.c#l2658

Over the years Perl_set_caret_X grew and grew with OS specific code. Move
the Win32 $^X code to match how all the other OSes do it. Fix a problem
where full perl's $^X is always absolute because perl5**.dll uses
GetModuleFileNameW in perllib.c, but miniperl's $^X is always a relative
path because it's coming from libc/command prompt/make tool/make_ext.pl.
Win32 miniperl's $^X being relative causes inefficiencies in EUMM as a
relative $^X is wrong the moment chdir executes in any perl process.
EUMM contains code to search PATH and some other places to guess/figure out
the absolute patch to the current perl to write the absolute perl path
into the makefile. By making $^X absolute on all Win32 perl build variants,
this find absolute perl path code won't execute in EUMM. It also harmonizes
behavior with other OSes and between Win32 mini and full perl. See details
in RT ticket for this patch.

Perl_set_caret_X gv_fetch with GV_ADD can't return NULL

The GV will be created if it doesn't exist. Remove the branch for smaller
code size.

Perl_magic_set(): remove unused var 's'

This var is (mostly) unused, but is set in a couple of places, hence:

    mg.c:2657:17: warning: variable ‘s’ set but not used

In the one place it is used, declare it in a narrower scope.

hexfp: signbit() works on NVs (nv), not on long doubles (fv).

The nv value should be a valid version of the fv value.

Why the fv is a long double, not a NV, is a long (haha) story.
Short version: the printf code expects to be able to work with long
doubles, if long doubles are available, even without -Duselongdouble.

The problem became obvious in VMS which has true 128-bit long
(little-endian) doubles, and trying the signbit() on those did
not work.

op/rand.t: better test even spread of random nums

The old test evaluated int(256*rand(1)) a large number of times, and
calculated the average number of bits seen in the result. If this was too
far from 4, it failed the (single) test. This is a rather crude test, and
generated what may be false negatives quite often in smoke tests.

This commit replaces that with a more comprehensive test scheme, but which
should cause a false negative in the test script only once every 2 million
runs, assuming a fair random number generator.

As before, it calculates 256*rand(1) many times, but maintains a count of
the number of occurrences of each result. Each count is then checked
whether it is within 6 sigmas of the expected value. For example for
100_000 iterations, we expect each count to be approximately 390, with a
6-sigma range of 272..509. If any count is outside that range, it fails
one of the 256 tests.

Thus this script now does 256 tests rather than a single one, so is a lot
better at detecting bad RNGs.

With each test being 6-sigma (1 in 500e6 failures) and 256 tests, that
gives us a false negative rate of approx 1 in every 2 million runs.

t/op/rand.t: modernise tests

e.g. cmp_ok() rather than ok($x > 0), and give tests descriptions.

remove flawed tests from t/op/rand.t

There is a section of code supposedly intended to check that
d_randbits bits is sane. AFIKT, the code was flawed from the start,
and has just become more broken since.

Initially it ran rand(1) many times and recorded the min and max.
It then (in a convoluted way involving logarithms) checked that
$max wasn't greater than 1.

I suspect that this code was (at least at one point during its initial
writing) supposed to check that the number of bit of precision in rand()
matched d_randbits. If that was the case, then it certainly wasn't doing
that.

Subsequently, extra bogus tests were added, e.g. that
    $max < (2 ** $randbits)
which it always will be, since it should be < 1.

Then the main test was inadvertently broken by a precedence issue
involving '!': I don't think this does what you think it does:

    unless (ok( !$max <= 0 or $max >= (2 ** $randbits)))

Then an extra check was added after each call to rand(1) in the loop that
the result was in the range 0..1. This check made all the other checks
that follow on $min and and $max superfluous.

So this commit removes all those extra tests, and changes a couple
of 'print #...\n"' into diag("..."), since we're now in the 21st century
:-)

Eliminate PerlIOMmap_close()

This static function wasn't being used. For the justification, see

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

hexfp: printf %.13a 0.0

hexfp: printf %.13a 1.0

perldelta for deprecation of code points > IV_MAX

Commit 760c7c2f746ce3f3c3356b0a3efb017b6d0cb5b0 added this deprecation.

hexfp: printf %a for negative zero.

utf8.c: White-space, comment typos only

Deprecate Unicode code points above IV_MAX

See https://rt.perl.org/Ticket/Display.html?id=115166

perlapi: Account for EBCDIC extend UTF-8 range

These pod changes were missed for
c0236afee0c5845d3823612c5cd34eccc4d29321, which also had a typo in its
commit message:  It should have said that the previous max was 2**31 -
1.

utf8.h: Remove use of redundant flags

The ABOVE_31_BIT flags is a proper subset of the SUPER flags, so if the
latter is set, we don't have to bother setting the former.  On the other
hand, there is no harm in doing so, these changes are all resolved at
compile time.  The reason I'm changing them is that it is easier to
explain in the pod what is happening, in the next commit.

utf8.h: Add clearer #define synonyms

These names have long caused me consternation, as they are named after
the internal ASCII-platform UTF-8 representation, which is not the same
for EBCDIC platforms, nor do they convey meaning to someone who isn't
currently steeped in the UTF-8 internals.  I've added synonyms that are
platform-independent in meaning and make more sense to someone coming at
this cold.  The old names are retained for back compat.

reformat the FOOMARK macros slightly

whitespace-only changes

FOOMARK debugging macros: fix %d cast; only -Dsv

The debugging variants of POPMARK() etc: use %IVdf rather than %d
to avoid compiler warnings when sizeof(IV) != sizeof(int);
also, make these macros trigger only under -Dsv rather than just -Ds
(-v is the verbose variant).

Benchmark.t: better diagnostics

use cmp_ok() instesd of ok() where apppriate and similar things to
get better diagnostucs when things fail (e.g. display what the bad value
was, rather than just letting you know it was bad).

Also, use diag() rather than 'print STDERR "# .....\n";'

Benchmark.t/.pm: deal with short times

The number of iterations to do on various tests was set at 3 or 10
in the first incarnation of the test file 13 years ago, and hasn't
changed since. In the meantime, CPUs have gotten faster. So bump the
iteration count to 100. This makes no appreciable difference to total wall
time for the test file on my newish x86_64 platform, but will hopefully
make tests less likely to be running within the noise of  a single 100Hz
clock tick.

In particular, the NetBSD smokes were quite frequently failing tests 127
and 128, due to the CPU taken to do an empty loop being greater than that
for a full loop, thus leading to negative apparent execution time.  This
was likely to be due to the first taking "1" clock tick and the second
taking "0" ticks. Although this is less likely to happen now that the
iterations has been increased, this commit also adds a check to
Benchmark.pm for a negative apparent execution time, and if detected,
prints a "too few iterations" warning and resets it to zero.

Benchmark: move elapsed time calc into method

A couple of places do basically the same set of summing various times()
fields within a Benchmark object, so make it into a private method.

Extend UTF-EBCDIC to handle up to 2**64-1

This uses for UTF-EBCDIC essentially the same mechanism that Perl
already uses for UTF-8 on ASCII platforms to extend it beyond what might
be its natural maximum.  That is, when the UTF-8 start byte is 0xFF, it
adds a bunch more bytes to the character than it otherwise would,
bringing it to a total of 14 for UTF-EBCDIC.  This is enough to handle
any code point that fits in a 64 bit word.

The downside of this is that this extension is not compatible with
previous perls for the range 2**30 up through the previous max,
2**30 - 1.  A simple program could be written to convert files that were
written out using an older perl so that they can be read with newer
perls, and the perldelta says we will do this should anyone ask.
However, I strongly suspect that the number of such files in existence
is zero, as people in EBCDIC land don't seem to use Unicode much, and
these are very large code points, which are associated with a
portability warning every time they are output in some way.

This extension brings UTF-EBCDIC to parity with UTF-8, so that both can
cover a 64-bit word.  It allows some removal of special cases for EBCDIC
in core code and core tests.  And it is a necessary step to handle Perl
6's NFG, which I'd like eventually to bring to Perl 5.

This commit causes two implementations of a macro in utf8.h and
utfebcdic.h to become the same, and both are moved to a single one in
the portion of utf8.h common to both.

To illustrate, the I8 for U+3FFFFFFF (2**30-1) is
"\xFE\xBF\xBF\xBF\xBF\xBF\xBF" before and after this commit, but the I8
for the next code point, U+40000000 is now
"\xFF\xA0\xA0\xA0\xA0\xA0\xA0\xA1\xA0\xA0\xA0\xA0\xA0\xA0",
and before this commit it was "\xFF\xA0\xA0\xA0\xA0\xA0\xA0".

The I8 for 2**64-1 (U+FFFFFFFFFFFFFFFF) is
"\xFF\xAF\xBF\xBF\xBF\xBF\xBF\xBF\xBF\xBF\xBF\xBF\xBF\xBF", whereas
before this commit it was unrepresentable.

Commit 7c560c3beefbb9946463c9f7b946a13f02f319d8 said in its message that
it was moving something that hadn't been needed on EBCDIC until the
"next commit".  That statement turned out to be wrong, overtaken by
events.  This now is the commit it was referring to.
commit I prematurely
pushed that

toke.c: Remove soon-to-be invalid t assumption

The code in toke.c assumes that the UTF8 expansion of the string
"\x{foo}" takes no more bytes than the original input text, which
includes the 4 bytes of overhead "\x{}".  Similarly for "\o{}".  The
functions that convert to the code point actually now assert for this.
The next commit will make this assumption definitely invalid on EBCDIC
platforms.  Remove the assertions, and actually handle the case
properly.  The other places that call the conversion functions do not
make this assumption, so there is no harm in removing them from there.

Since we believe that this can't happen except on EBCDIC, we
could #ifdef this code and use just an assert on non-EBCDIC.  But it's
easier to maintain if #ifdef's are minimized.  Parsing is not a
time-critical operation, like being in an inner loop, and the extra test
gives a branch prediction hint to the compiler.

ext/XS-APItest/t/utf8.t: Change variable names for clarity

These variables are misnamed, based on the internal Perl UTF-8
representation for ASCII platforms, which is not applicable for
UTF-EBCDIC.  Rename them to something that applies to both platforms,
and lowers confusion.

Output appropriately dire warning for high code points

Code points above 2**31-1 have never been in any standard, so their use
is non-portable.  There has been a more dire warning raised at times
when decoding UTF-8 into a UV, but it wasn't getting output always when
it was appropriate.  Going the other way, into UTF-8, there was only one
type of warning output.  This commit splits that into the more dire for
higher code points.

ext/XS-APItest: Add tests for uvchr_to_utf8()

There are some TODOs added that these tests uncovered, which will be
fixed in the next commit.

Fix uvoffuni_to_utf8_flags() disallowed input

This function has the capability to refuse to accept problematic code
points, such as surrogates.  It accepted them anyway if the warnings
category wasn't enabled.  Tests for this will be introduced in the next
commit.

XS-APItest/utf8.t: Add a bunch more tests

This adds more extensive testing, and rearranges things so that the
the more fundamental tests are done earlier.  Boundary cases are
especially added.  It removes many of the EBCDIC skips.  Debug
information is output now to STDERR so that test_harness displays it,
and more gets output upon failure.  Two TODO tests were added as a
result of this catching some existing problems that hadn't been tested
for previously.

regcomp.c: White-space only

This does vertical alignment to make things clearer