locale.c: Refactor static fcn to save work

This adds a parameter to the function that sets the radix character for
floating point numbers.  We know that the radix by default is a dot, so
no need to calculate it in that case.

This code was previously using localeconv() to find the locale's decimal
point.  The just added my_nl_langinfo() fcn does the same with an easier
API, and is more thread safe, and automatically switches to use
localeconv() when n nl_langinfo() isn't available, so revise the
conditional compilation directives that previously were necessary, and
collapse directives that were unnecessarily nested.

And adjust indentation

locale.c: Create extended internal Perl_langinfo()

This extended version allows it to be called so that it uses the current
locale for the LC_NUMERIC, instead of toggling to the underlying one.
(This can be useful when in the middle of things.)

This ability won't be used until the next commit

locale.c: Rmv redundant fcn call

This function is called as part of the call made in the line before.  No
need to do it twice.

locale.c: White-space, comment, rearrange some #else

This file is full of conditional compilation, due to the fact that
locale support has been highly variable in the OSes Perl has operated
on.  This commit properly indents nested compiler directives, and makes
sure there is a blank line between the directives and real code.  I find
that much easier to read.  It also re-orders some

    #ifdef some_feature
        Many lines of code handling feature
    #else
        1 to 3 lines of trivial code to avoid compilation warnings
    #endif

to

    #ifndef some_feature
        1 to 3 lines of trivial code to avoid compilation warnings
    #else
        Many lines of code handling feature
    #endif

Otherwise the trivial code may be hundreds of lines from the original
'#if', which makes it hard to grok.

This commit also clarifies and fixes typos in comments, and removes some
obsolete comments.

Merge branch 'BO' into blead

Make it simpler to divine if modules are there because of loading B/O or
because the actual program used them.

NPD

ext/B/t/strict.t: Assure B.pm and O.pm pass strict and warnings checks.

We need to test these in unit tests since they do not load these modules to
prevent pollution of the stash in compilers.

Fix warnings (used once) for O.pm

Fix warnings (used once) for B.pm

Remove unnecessary module loads from B and O

This commit removes multiple unnecessary modules so that
perl -MO= can hand back to compile as cleanly as possible.

This change caused significant jitter in tests for B::Concise. While updating
the test to the new reality, OptreeCheck.pm was corrected to stop stripping
regexes off $got when it started failing so it would be easier to see where
the failure happened.

Simplify travis.yml config for Continuous Integration

The goal is to have a quick smoke on travis smokers
to plug in short future CI for any new commits/PR.

NPD

restore error message for unterminated strings

The previous strchr/memchr changes inadvertently broke the error message
for perl -e '"'. Instead of

    Can't find string terminator '"' anywhere before EOF

it became

    Can't find string terminator """ anywhere before EOF

disable t/porting/authors.t for distro packaging

NPD

disable t/porting/podcheck.t for distro packaging

NPD

Allow custom PL_strtab hash in perl_construct.

Such a patch allow PL_strtab optimizations at compile time
to statically malloc PL_strtab to an optimized size at startup.

Custom entries can then be added (after PL_hash_seed initialization)
without risking the hash to be reset by perl_construct.

PERL_STRLEN_ROUNDUP: parenthesize macro parameter

Also:
- factor out common expression
- remove redundant double parens
- add spaces to expression

toke.c: Fix wrong use of memrchr

This was a replacement of strchr(), so should not have used the
find-right-most memrchr.

This was spotted by Christian Hansen.  I don't know what the
implications are, but thought I should get a fix in immediately.

Blead breaks DBD::SQLite

This partially reverts 0f12654f40.

The particular spot being reverted is in gv.c, and the change did not
take into account all the nuances involved, so simply revert it.  I
believe what is happening is that a negative number is being generated
and treated as a very large number.  Instead the code should retain the
original test that it was ok to do the subtraction, before actually
doing it.

Two fix-ups following b59bf0b288.

In one case, memEQs was missing a length parameter, and in the
other, two opening braces had been removed but only one closing
brace.

toke.c: use my_memrchr helper for portability [round 2]

compilation broken on darwin using clang

Use my_memrchr helper for portability

Recent commit '8725053bce' breaks darwin compilation.

We should use my_memrchr helper to avoid
portability issues, instead of calling
directly memrchr.

Merge branch 'convert strchr to memchr' into blead

Using C string functions on Perl strings doesn't work properly if they
contain embedded NULs.  This can happen with Perl program text, for
example, and even if the NUL is illegal, the generated diagnostics are
likely to be misleading as the parsing would have terminated
prematurely.

I have done an audit on core for cases where C string functions are used
in contexts where a Perl string is being processed.  This came down to
uses of strchr() and strrchr().  This branch changes many of them to
memchr() and memrchr() respectively.  Not all uses of these functions
need change, as there are places where C strings are what is being
processed, such as dealing with OS strings that are NUL terminated.
File paths and environ are two examples.

Also, memchr and memrchr tend to be faster than their str equivalents,
as they only need to look for one termination condition, and there may
be hardware assistance on some platforms.  Further, memrchr knows
exactly where to start looking, instead of having to find the NUL ending
the string (strrchr is likely to be implemented as iterating over the
string using strchr from the left, over and over until it fails).

I may have converted some str functions to mem ones unnecessarily, as I
didn't check in full detail if some were operating only on C strings, but
given that the mem ones are faster, this is OK

toke.c: Convert some strchr to memchr

This allows things to work properly in the face of embedded NULs.
See the branch merge message for more information.

toke.c use memBEGINs with prev commit

toke.c: Add limit parameter to 3 static functions

This will make it possible to fix to handle embedded NULs in the next
commits.

regcomp.c: Convert some strchr to memchr

This allows things to work properly in the face of embedded NULs.
See the branch merge message for more information.

perl.c: Use memchr instead of strchr

This allows things to work properly in the face of embedded NULs.
See the branch merge message for more information.

op.c: Use memchr,memrchr instead of strchr,strrchr

This allows things to work properly in the face of embedded NULs.
See the branch merge message for more information.

mg.c: Use memchr instead of strchr

This allows things to work properly in the face of embedded NULs.
See the branch merge message for more information.

doio.c: Change strchr to memchr

This allows things to work properly in the face of embedded NULs.
See the branch merge message for more information.

pp_sys.c; Use memchr instead of strchr

This allows things to work properly in the face of embedded NULs.
See the branch merge message for more information.

utf8.c: Use memchr instead of strchr

This allows things to work properly in the face of embedded NULs.
See the branch merge message for more information.

dquote.c: Use memchr() instead of strchr()

This allows \x and \o to work properly in the face of embedded NULs.
A limit parameter is added to each function, and that is passed to
memchr (which replaces strchr).  See the branch merge message for more
information.

locale.c: Tighten what is considered a LC variable

Things like LC_CTYPE are locale variables, but not LC_ctype nor
LC__CTYPE.  Prior to this commit all were treated as locale variables.
Many platforms have more locale variables than Perl knows about, e.g.,
LC_PAPER, and the code tries to catch all possibilities.

locale.c: White space, extra braces only

Align vertically, and indent blocks to standard.  It adds braces for
clarity.

Merge branch for new string comparison macros into blead

See thread beginning with
     http://nntp.perl.org/group/perl.perl5.porters/244335

This branch creates various new macros that are easier to read and use
than the underlying code, and uses them in blead

handy.h: Add comments

This adds a description of the naming conventions to be used for any new
string comparison macros.

Make new macros private

Until we decide these weren't a bad idea

ext/attributes/attributes.xs is PERL_EXT

handy.h: Make uniform the defns of strFOO, memFOO

For consistency

Remove _memEQs, _memNEs

All uses of these private macros have been replaced by other calls.

Add memENDPs and use it in core

This corresponds to memBEGINPs

Add memBEGINPs() to core and use it

This macro is like memBEGINs(), but the 'P' signifies we want a proper
substring, meaning that the 2nd string parameter must not be the entire
first parameter.

Use memENDs() in core

Use memBEGINs() in core

Change some strBEGINs() to memBEGINs()

The latter is generally faster when the length is already known.

This commit also changes a few hard-coded numbers to use sizeof().

Add memBEGINs(), memENDs() and use them in APItest

memBEGINs() is like strBEGINs(), but can be used for buffers without
trailing NULs.  It can also be used when there is a trailing NUL, and
the length is known, as it should be somewhat faster, only having to
check for one ending condition.

Same for memENDs vs strENDs

Change some strncmp(), etc. to strBEGINs()

The latter is much clearer as to what's going on, and the programmer and
program reader don't have to count characters.

Use memEQs, memNEs in core files

Where the length is known, we can use these functions which relieve
the programmer and the program reader from having to count characters.
The memFOO functions should also be slightly faster than the strFOO
equivalents.

In some instances in this commit, hard coded numbers are used.  These
come from the 'case' statement values that apply to them.

Rename strEQs to strBEGINs; remove strNEs

The original names are confusing.

See thread beginning with
http://nntp.perl.org/group/perl.perl5.porters/244335

The two macros are mapped into just that one, complementing the result
for the few cases where strNEs was used.

g++ 4.0 supports __attribute__((unused))

Fix deparsing of transliterations with unprintable characters.

RT #132405

Signed-off-by: Nicolas R <atoomic@cpan.org>

support -nre in t/harness, exclude files by regex

add assertions about format lexing

[perl #132158] describes a situation in which a weird kind of unterminated
format caused the parser to crash.  Add some assertions that catch the
messed up parser state before it actually crashes.

deparse implicit ~~ as explicit with -x2

Fixes [perl #91362].

Revert "Speed up Carp.pm when backtrace arguments are references"

This reverts commit 7a831b721c469aeccfe1110a2d177dd115d5998d.  It was
buggy and mostly pointless, and following criticism on p5p it should
never have been committed.

initialisation of simple aggregate state variables

We now recognise the basic cases of aggregate state variables, to
permit initialisations of the form "state @a =" or "state @a :shared =".
Initialisation of state variable lists remains forbidden, because the
op flags don't let us distinguish "state(...)" from "(state(...))" in
most cases.

Add comment to explain why we want to probe for statfs() et al

pp_multiconcat: don't stringify LHS overload arg

RT #132385

In something like

    $a1 . $a2

where $a2 is overloaded, the concat overload method was being called
like

    concat($a2, "$a1", 1);

(The 1 indicated that the args are reversed).

This commit changes it so that it's called as

    concat($a2, $a1, 1);

i.e. that the original arg is passed in rather than a stringified copy
of it. This is important if for example $a1 is a ref.

perldelta for b3937e202aaf1 (Carp & ISA constant)

Avoid unique REGCOMP in dynaloader

Dynaloader has 4 unique regex's that cannot be de-duplicated
by perlcc.  Switch them to index/substr

References: CPANEL-15683

Signed-off-by: Nicolas R <atoomic@cpan.org>

Speed up Carp.pm when backtrace arguments are references

Avoid downgrading the string when not required.

Author: J. Nick Koston <nick@cpanel.net>
References: CPANEL-15140

Avoid a segfault when untying an object

Check if the tied object has a stash set
before calling UNTIE method.

(perl #131895) fail stat on names with \0 embedded

Also lstat() and the file test ops.

yada-yada is a term, not an operator

document qw's whitespace rules

qw only splits on ASCII whitespace, like primary tokenisation, but
nowadays unlike the split() formulation with which it's documented.
Document this additional difference from split().  Fixes [perl #132272].

toke.c: Rmv useless code

This code is unreachable because the code above makes sure that the
variable can't be larger than PL_bufend, and the code is only executed
if it is larger.

toke.c: White space only

Fix up some white space, including outdenting a block that was doubly
indented

multiconcat: use append_utf8_from_native_byte()

This small inline function does what my code was doing manually in a
couple of places. Should be no functional difference, just makes the code
tidier.

Suggested by Karl.

sprintf-as-multiconcat: fix \x80 issue

My recent OP_MULTICONCAT merge which (amongst other things) converts
sprintfs with a constant format that only containing %s's into a
multiconcat op, miscounted variant chars (i.e. chars like \x80, which if
upgraded to utf8, expand the number of bytes they require).
This could cause buffer overruns.

Spotted by Karl Williamson++

NPD

Increase $Carp::Heavy::VERSION to 1.44

Increase $Carp::VERSION to 1.44

Carp: Don’t choke on ISA constant

This broke some time between 1.29 (perl 5.18) and 1.3301 (perl 5.20):

$ perl5.20.1 -e 'package Foo { use constant ISA => 42; Bar::f() } package Bar { use Carp; sub f { carp "tun syn" } }'
Not a GLOB reference at /usr/local/lib/perl5/5.20.1/Carp.pm line 560.

and still persisted in bleadperl (Carp 1.43) until this commit.

The code that goes poking through the symbol table needs to take into
account that not all stash elements are globs.

customized.dat: Add generator note

So that people like me who do not do this very often can see just
by looking at the file how it got generated.

Porting/Maintainers.pl: vutil.c is no longer CUSTOMIZED

Revert "vutil.c: use new SvPVCLEAR and constant string friendly macros"

This reverts commit 7394beb1401a6ac5e5e19cff7f08486e5141126c.

This change to vutil.c is unnecessary and makes it differ needlessly
from the CPAN release (CPAN *is* upstream for this file), making syn-
chronisation harder.

metaconfig.h: Rmv HAS_MEMRCHR

This is now used in code, and hence no longer needed in this file

metaconfig.h: Rmv HAS_THREAD_SAFE_NL_LANGINFO_L

This is now used in code, and hence no longer needed in this file

Add my_memrchr() implementation of memrchr()

On platforms that have memrchr(), my_mrchr() maps to use that instead.

This is useful functionality, lacking on many platforms.  This commit
also uses the new function in two places in the core where the comments
previously indicated it would be advantageous to use it if we had it.

It is left usable only in core, so that if this turns out to have been a
bad idea, it can be easily removed.

APItest.xs: Omit unused variable

utf8.c: Rmv obsolete comment

This was no longer true

fix Perl_get_cvn_flags() return value

One branch returned an SV* when it should return CV*.
This upset g++.

fix ext/B/t/optree_samples.t

The recent OP_MULTICONCAT merge broke it under PERL_UNICODE=""

Make get_cv cope with subrefs

When called with GV_NOADD_NOINIT, get_cv will fail an assertion if the
thingy in the stash is not a GV.

While calling with GV_NOADD_NOINIT is a strange thing to do, neverthe-
less Cpanel::JSON::XS does it with "Encode::decode", which is not an
unreasonable thing to do if it is known that the sub already exists.

This commit makes get_cv take sub refs into account, so that, when we
reënable the optimisation reverted by 9bceb75b8d9, Cpanel::JSON::XS
will continue to work with bleadperl.

(Currently, the optimisation only applies to the main package, which
is why I am able to test this now.)

Basic tests for get_cvn_flags

[MERGE] add OP_MULTICONCAT and optimize_optree()

This branch contains one main commit which adds the new OP_MULTICONCAT op,
plus a few prior commits to provide support; in particular, adding an extra
top-down optree scan phase to allow extra optimisation opportunities, just
before the peephole optimiser is run.

See the OP_MULTICONCAT for more details, but in summary it:
allows multiple OP_CONCAT, OP_CONST ops, plus optionally an OP_SASSIGN
or OP_STRINGIFY, to be combined into a single OP_MULTICONCAT op, which can
make things a *lot* faster: 4x or more.

perldelta entry for OP_MULTICONCAT

Add OP_MULTICONCAT op

Allow multiple OP_CONCAT, OP_CONST ops, plus optionally an OP_SASSIGN
or OP_STRINGIFY, to be combined into a single OP_MULTICONCAT op, which can
make things a *lot* faster: 4x or more.

In more detail: it will optimise into a single OP_MULTICONCAT, most
expressions of the form

    LHS RHS

where LHS is one of

    (empty)
    my $lexical =
    $lexical    =
    $lexical   .=
    expression  =
    expression .=

and RHS is one of

    (A . B . C . ...)            where A,B,C etc are expressions and/or
                                 string constants

    "aAbBc..."                   where a,A,b,B etc are expressions and/or
                                 string constants

    sprintf "..%s..%s..", A,B,.. where the format is a constant string
                                 containing only '%s' and '%%' elements,
                                 and A,B, etc are scalar expressions (so
                                 only a fixed, compile-time-known number of
                                 args: no arrays or list context function
                                 calls etc)

It doesn't optimise other forms, such as

    ($a . $b) . ($c. $d)

    ((($a .= $b) .= $c) .= $d);

(although sub-parts of those expressions might be converted to an
OP_MULTICONCAT). This is partly because it would be hard to maintain the
correct ordering of tie or overload calls.

The compiler uses heuristics to determine when to convert: in general,
expressions involving a single OP_CONCAT aren't converted, unless some
other saving can be made, for example if an OP_CONST can be eliminated, or
in the presence of 'my $x = .. ' which OP_MULTICONCAT can apply
OPpTARGET_MY to, but OP_CONST can't.

The multiconcat op is of type UNOP_AUX, with the op_aux structure directly
holding a pointer to a single constant char* string plus a list of segment
lengths. So for

    "a=$a b=$b\n";

the constant string is "a= b=\n", and the segment lengths are (2,3,1).
If the constant string has different non-utf8 and utf8 representations
(such as "\x80") then both variants are pre-computed and stored in the aux
struct, along with two sets of segment lengths.

For all the above LHS types, any SASSIGN op is optimised away. For a LHS
of '$lex=', '$lex.=' or 'my $lex=', the PADSV is optimised away too.

For example where $a and $b are lexical vars, this statement:

    my $c = "a=$a, b=$b\n";

formerly compiled to

    const[PV "a="] s
    padsv[$a:1,3] s
    concat[t4] sK/2
    const[PV ", b="] s
    concat[t5] sKS/2
    padsv[$b:1,3] s
    concat[t6] sKS/2
    const[PV "\n"] s
    concat[t7] sKS/2
    padsv[$c:2,3] sRM*/LVINTRO
    sassign vKS/2

and now compiles to:

    padsv[$a:1,3] s
    padsv[$b:1,3] s
    multiconcat("a=, b=\n",2,4,1)[$c:2,3] vK/LVINTRO,TARGMY,STRINGIFY

In terms of how much faster it is, this code:

    my $a = "the quick brown fox jumps over the lazy dog";
    my $b = "to be, or not to be; sorry, what was the question again?";

    for my $i (1..10_000_000) {
        my $c = "a=$a, b=$b\n";
    }

runs 2.7 times faster, and if you throw utf8 mixtures in it gets even
better. This loop runs 4 times faster:

    my $s;
    my $a = "ab\x{100}cde";
    my $b = "fghij";
    my $c = "\x{101}klmn";

    for my $i (1..10_000_000) {
        $s = "\x{100}wxyz";
        $s .= "foo=$a bar=$b baz=$c";
    }

The main ways in which OP_MULTICONCAT gains its speed are:

* any OP_CONSTs are eliminated, and the constant bits (already in the
  right encoding) are copied directly from the constant string attached to
  the op's aux structure.

* It optimises away any SASSIGN op, and possibly a PADSV op on the LHS, in
  all cases; OP_CONCAT only did this in very limited circumstances.

* Because it has a holistic view of the entire concatenation expression,
  it can do the whole thing in one efficient go, rather than creating and
  copying intermediate results. pp_multiconcat() goes to considerable
  efforts to avoid inefficiencies. For example it will only SvGROW() the
  target once, and to the exact size needed, no matter what mix of utf8
  and non-utf8 appear on the LHS and RHS.  It never allocates any
  temporary SVs except possibly in the case of tie or overloading.

* It does all its own appending and utf8 handling rather than calling
  out to functions like sv_catsv().

* It's very good at handling the LHS appearing on the RHS; for example in

    $x = "abcd";
    $x = "-$x-$x-";

  It will do roughly the equivalent of the following (where targ is $x);

    SvPV_force(targ);
    SvGROW(targ, 11);
    p = SvPVX(targ);
    Move(p,   p+1,  4, char);
    Copy("-", p,    1, char);
    Copy("-", p+5,  1, char);
    Copy(p+1, p+6,  4, char);
    Copy("-", p+10, 1, char);
    SvCUR(targ) = 11;
    p[11] = '\0';

  Formerly, pp_concat would have used multiple PADTMPs or temporary SVs to
  handle situations like that.

The code is quite big; both S_maybe_multiconcat() and pp_multiconcat()
(the main compile-time and runtime parts of the implementation) are over
700 lines each. It turns out that when you combine multiple ops, the
number of edge cases grows exponentially ;-)

overload.t: add more concat tests

The '.' and '.=' string concatenation overload methods don't seem to be
heavily tested. Add some more tests, especially with an eye to things that
might break when multiple concat ops are optimised into a single op
(as I intend to do shortly).

fix a benchmarks sprintf entry

an sprintf entry in t/perf/benchmarks was missing two %s's due to an
earlier cut+paste error. Also, it was being constant folded, so
use vars rather literals for the arguments.

add extra optimization phase

Add the function optimize_optree(). Optree optimization/finalization is
now done in three main phases:

    1) optimize_optree(optree);
    2) CALL_PEEP(*startp);
    3) finalize_optree(optree);

(1) and (3) are done in top-down order, while (2) is done in execution
order.

Note that this function doesn't actually optimize anything yet; this
commit is just adding the necessary infrastructure.

Adding this extra top-down phase allows certain combinations of ops
to be recognised in ways that the peephole optimizer would find hard.

For example in

    $a = expression1 . expression2 . expression3 . expression4

the top-down tree looks like

    sassign
        concat
            concat
                concat
                    expression1
                        ...
                    expression2
                        ...
                expression3
                    ...
            expression4
                ...
        padsv[$a]

so its easy to see the nested concats, while execution order looks like

    ... lots of ops for expression1 ...
    ... lots of ops for expression2 ...
    concat
    ... lots of ops for expression3 ...
    concat
    ... lots of ops for expression4 ...
    concat
    padsv[$a]
    sassign

where its not at all obvious that there is a chain of nested concats.

Similarly, trying to do this in finalize_optree() is hard because the
peephole optimizer will have messed things up. Also it will be too
late to remove nulled-out ops from the execution path.

panic if a freed op is called

On debugging builds, when freeing an op, set its op_ppaddr to point to
a function which dies. That way if a freed op accidentally remains in the
execution path, you'll know immediately, rather than crashing sometime
later with a stack underflow or whatever.

regen/opcode.pl: display duplicate bit name

change this error message:

    addbits(): bit 4 of multiconcat already specified  at ...

to

    addbits(): bit 4 of multiconcat already specified (OPpTARGET_MY) at ...

Use nl_langinfo_l() if available

This function allows us to avoid using a mutex and changing the locale.

make_ext.pl: Use version.pm for version cmp

We do a version comparison to determine whether Makefile.PL needs to
be run (in case a module version changed).  The simple string compar-
ison we have done up till now fails if the two version numbers differ
simply by a trailing zero (as currently happens with DB_File, which
is at version 1.840, with XS_VERSION set to 1.84.  Since version.pm’s
routines are compiled into miniperl, there is no reason not to do this
‘properly’, and it stops multiple ‘make’ invocations from rebuilding
DB_File again, and again....

perldeprecation: Change some uses of "in Perl $version" to "as of Perl $version"

In present and present perfect tense sentences, this makes it clearer
that it doesn't just apply to that version, but subsequent versions
too.  Sentences in simple past tense have been left as is.

The AIX doubledouble longdouble has been left broken for three years.

I must have left the test in the wrong position while
working on getting it to work, and never tested it since.
My apologies.

With this simple trick the following failing tests start to work.

        ../cpan/Math-Complex/t/Complex.t
        ../cpan/Math-Complex/t/Trig.t
        ../cpan/Math-Complex/t/underbar.t
        ../cpan/Scalar-List-Utils/t/uniq.t
        ../ext/POSIX/t/math.t
        ../lib/warnings.t
        op/sprintf2.t
        op/time.t

Or rather, the broken part of the functionality, Infinity,
starts being avoided, as it should be.  See the comment above
about the known brokenness of long doubles and infinity in AIX.

Note that even after this fix the following are still broken in
this AIX (the perl5 aix machine), but these are unrelated to infnan:

        ../cpan/ExtUtils-MakeMaker/t/03-xsstatic.t
        ../dist/Storable/t/store.t
        ../ext/XS-APItest/t/handy00.t
        re/uniprops01.t
        re/uniprops02.t
        re/uniprops03.t
        re/uniprops04.t
        re/uniprops05.t
        re/uniprops06.t
        re/uniprops07.t
        re/uniprops08.t
        re/uniprops09.t
        re/uniprops10.t

(as of blead 4faa3060)

perldelta for e8d55f27af46, ebcc725e3f7e

(perl #132245) don't leak on \N{}

get_and_check_backslash_N_name() failed to free its working SV if
the name was empty.

(perl #132245) don't try to process a char range with no preceding char

A range like \N{}-0 eventually results in compilation failing, but
before that, get_and_check_backslash_N_name() attempts to treat
the memory before the empty output of \N{} as a character.

Show that '/o' modifier no longer has adverse effects on 'split'.

    The underlying problem was already fixed in
    3cb4cde3dd4d2af2f5065053905708bffa5168f9 (Jul 4 2017).  For clarity, adding
    test adapted from original poster in RT 132334.

    Add Harald Jörg to Perl AUTHORS.