POSIX::setlocale(LC_NUMERIC) returns proper locale

Commit 4c28b29c7a1549f173177cdf69e91cc1acaa0969 broke calling setlocale
with a single parameter and hoping to get the correct LC_NUMERIC
property returned from it (including LC_ALL calls).  This is because the
numeric locale is now kept as C except around the code that wants it to
be the underlying locale.  It turns out that querying the current locale
is such a code area, so LC_NUMERIC is now set to the underlying locale
around this.

locale.c: White-space only

Outdent because the previous commit removed the enclosing block.

locale.c: Remove conditionals.

These two functions are supposed to normally be called through macro
interfaces which check whether they actually should be called or not.
That means the conditionals removed by this commit are redundant from
the normal interface.   By removing them, we allow the exceptional case
where the code should be executed unconditionally, to happen, by just
calling the functions directly, not using the macro interface.

locale.c: Keep better track of C/non-C locale

Perl uses three interpreter-level (but private) variables to keep track
of numeric locales.  PL_numeric name is the current underlying locale.
PL_standard is a boolean to indicate if we are switched to the C (or
POSIX) locale, and PL_local is a boolean to indicate if we are switched
to the underlying one.  The reason there are two booleans is if the
underlying locale is C, both can be true at the same time.  But the code
that is being changed by this commit didn't realize this, and
could unnecessarily set the booleans to FALSE.  This could cause
unnecessary switching of locales.

locale.c: Make a common idiom into a macro

lib/locale.t: Fix debug statement

This was printing using the wrong function.  It is a string, and should
use the string output function.

utf8.h: Add comment

Update which stable release series are now "officially" supported

Fix typo in op.h

This caused all OP structures to be larger than intended; for example, it
made `struct op` 48 bytes rather than 40 on Mac OS X x86-64.

[Merge] add support for ops to link to parent

This series of commits provides experimental support for ops in the optree
to be able to locate their parent op, if any.

First, it adds a new general-purpose function, op_sibling_splice(),
which allows for general manipulation of an op_sibling chain by analogy
with the perl splice() function. op.c has then been heavily refactored to
use this function rather than manipulating ops directly.

Then the boolean field op_lastsib has been added to OPs. Within the core,
this is set on the last op in an op_sibling chain (so it is synonymous
with op_sibling being null). By default, its value is set but not used.

In addition, a new build define has been added (not yet enabled by default),
-DPERL_OP_PARENT, that forces the core to use op_lastsib to detect the
last op in a sibling chain, rather than op_sibling being NULL. This frees
up the last op_sibling pointer in the chain, which rather than being set
to NULL, is now set to point back to the parent of the sibling chain (if
any).

Then add a C-level op_parent() function and B parent() method; under
default builds they just return NULL, under PERL_OP_PARENT they return the
parent of the current op.

Collectively this provides a facility not previously available from B:: nor
C, of being able to follow an op tree up as well as down.

Also, some assertions are added to finalize_op() that check the
consistency of the optree; in particular that op_last points to the last
sibling. Under -DPERL_OP_PARENT, more checks are enabled.

avoid adding two OP_HINTSEVAL ops

Under argless eval (i.e. defaults to $_) in the presence of hints,
the perl core was recursively calling ck_eval, which had the side-effect
of attempting to append an OP_HINTSEVAL op twice. Formerly due to the way
the appending was done, the first OP_HINTSEVAL op was silently discarded;
after doing things "properly" with op_sibling_splice(), both ops ended up
being appended, and at run-time, the hints hash would be interpreted as
the SV to eval.

This wasn't tested in the core tests, and just ended up sometimes failing
warnings.t or Digest-SHA tests (but never on my system!)

minor fixups to new op_sibling work

remove pTHX args to op_parent() and op_sibling_splice() since they don't
use them, and cast an op type assignment. Also, minor fixups to the pod
for op_sibling_splice().

Improve optree sanity checking code in finalize_op

The previous couple of commits added DEBUGGING code to finalize_op() that
checked, for BINOP/LISTOPs etc, that all the op's children had consistent
flags and that op_last pointed to the last op (and vice-versa under
PERL_OP_PARENT).  Extend most of this consistency checking to the various
classes of OP that have op_first but not op_last (like UNOP, LOGOP).

add op_lastsib and -DPERL_OP_PARENT

Add the boolean field op_lastsib to OPs. Within the core, this is set
on the last op in an op_sibling chain (so it is synonymous with op_sibling
being null). By default, its value is set but not used.

In addition, add a new build define (not yet enabled by default),
-DPERL_OP_PARENT, that forces the core to use op_lastsib to detect the
last op in a sibling chain, rather than op_sibling being NULL. This frees
up the last op_sibling pointer in the chain, which rather than being set
to NULL, is now set to point back to the parent of the sibling chain (if
any).

This commit also adds a C-level op_parent() function and B parent()
method; under default builds they just return NULL, under PERL_OP_PARENT
they return the parent of the current op.

Collectively this provides a facility not previously available from B:: nor
C, of being able to follow an op tree up as well as down.

Ensure that op_last always points to last sibling

Add a big DEBUGGING-only check to S_finalize_op() that for list ops,
checks whether op_last points to the last sibling. Then fix up the places
where this isn't true.

It turns out that convert() and force_list() didn't update op_first, so
fix them. Also, the 'x' (repeat) op in list context is a binary op with
op_last set to null, which is a bit bizarre, but too complex to fix for
now. So just skip the test on that one.

add op_sibling_splice() fn and make core use it

The op_sibling_splice() is a new general-purpose OP manipulation
function designed to edit the children of an op, in an analogous
manner in which the perl splice() function manipulates arrays.

This commit also edits op.c and a few other places to remove most direct
manipulation of op_sibling, op_first and op_last, and replace that with
calls to op_sibling_splice().

This has two advantages. First, by using the one function consistently
throughout, it makes it clearer what a particular piece of of code is
doing, rather than having to decipher lots of of ad-hoc

    cLISTOPo->op_first = OP_SIBLING(kid);

style stuff. Second, it will make it easier to later add a facility for
child OPs to find their parent, since the changes now only need to be made
in a few places.

In theory this commit should make no functional change to the code.

Devel::Peek: test 2-arg form of Dump

the 'Dump var, limit' form wasn't being tested.

macroise op_sibling in Perl_ck_fun()

This is logically part of the previous commit, but since Perl_ck_fun()
took the address of o->op_sibling, it wasn't straightforward to simply
replace op_sibling with the relevant macros. So we now do it as a separate
commit.

It's basically trying to insert a new op into the sibling chain, and
depending on whether it inserts at the front or not, it updates
&cLISTOPo->op_first or &kid->op_sibling.

Rather than taking the address, make each assignment check whether the
destination is op_first or op_sibling. Slightly less elegant, but hey, it
works!

wrap op_sibling field access in OP_SIBLING* macros

Remove (almost all) direct access to the op_sibling field of OP structs,
and use these three new macros instead:

    OP_SIBLING(o);
    OP_HAS_SIBLING(o);
    OP_SIBLING_set(o, new_value);

OP_HAS_SIBLING is intended to be a slightly more efficient version of
OP_SIBLING when only boolean context is needed.

For now these three macros are just defined in the obvious way:

    #define OP_SIBLING(o)          (0 + (o)->op_sibling)
    #define OP_HAS_SIBLING(o)      (cBOOL((o)->op_sibling))
    #define OP_SIBLING_set(o, sib) ((o)->op_sibling = (sib))

but abstracting them out will allow us shortly to make the last pointer in
an op_sibling chain point back to the parent rather than being null, with
a new flag indicating whether this is the last op.

Perl_ck_fun() still has a couple of direct uses of op_sibling, since it
takes the field's address, which is not covered by these macros.

libperl.t + ASAN + -DPERL_GLOBAL_STRUCT_PRIVATE

One of the t/porting/libperl.t tests was failing under
-DPERL_GLOBAL_STRUCT_PRIVATE with clang and address sanitizer,
since that combo added a data symbol to each object file:

    0000000000000000 d __unnamed_1

which contradicted the test of not having any global data.
Simply ignore that symbol for the purposes of the test.

faster constant hash key lookups ($hash{const})

On something like $hash{constantstring}, at compile-time the
PVX string on the SV attached to the OP_CONST is converted into a
HEK (with an appropriate offset shift).

At run-time on hash keying, this HEK is used to speed up the bucket
search; however it turns out that this can be improved. Currently,
the main bucket loop does:

    for (; entry; entry = HeNEXT(entry)) {
if (HeHASH(entry) != hash)
    continue;
if (HeKLEN(entry) != (I32)klen)
    continue;
if (HeKEY(entry) != key && memNE(HeKEY(entry),key,klen))
    continue;
if ((HeKFLAGS(entry) ^ masked_flags) & HVhek_UTF8)
    continue;

The 'HeKEY(entry) != key' test is the bit that allows us to skip the
memNE() when 'key' is actually part of a HEK. However, this means that in
the const HEK scenario, for a match, we do pointless hash, klen and
HVhek_UTF8 tests, when HeKEY(entry) == key is sufficient for a
match. Conversely, in the non-const-HEK scenario, the 'HeKEY(entry) !=
key' will always fail, and so it's just dead weight in the loop.

To work around this, this commit splits the code into two separate bucket
search loops; one for const-HEKs that just compare HEK pointers, and a
general loop that now doesn't have do the 'HeKEY(entry) != key' test.

Analysing this code with cachegrind shows that with this commit, lookups
of constant keys that exist (e.g. the typical perl object scenario,
$self->{somefield}) takes 15% less instruction reads in hv_common(), 14%
less data reads and 27% less writes.

A lookup with a non-existing constant key ($hash{not_exist}) is about the
same as before (0.7% improvement).

Non-constant existing lookup ($hash{$existing_key}) is about 5% less
instructions, while $hash{$non_existing_key} is about 0.7%.

Add description to tests lacking them.

Explain why 'nomethod' special key is invoked.

add the standards of conduct to perlpolicy

perldelta for e45636ee0875

static misc things in /dist/threads/threads.xs

there is no reason for these functions to be exported on a linux build,
since they aren't exported on Win32, also consting ithread_vtbl allows
more memory to be shared between perl procs

Update experimental to CPAN version 0.008

  [DELTA]

0.008     2014-07-05 13:58:28+02:00 Europe/Amsterdam
          Give better perl version formatting
          Fix smartmatch/switch description

regcomp.c: Add assertion, remove case: statements

This routine should never be called unless the new assertion is true,
which removes the need for the removed cases in the switch.

Updates to the HP-UX compilation warning.

pod/perlre.pod: fix typo in example code

Filter::Simple: eliminate /\C/

Since that construct is now deprecated, don't use it. It turns out that
it's usage was almost certainly wrong anyway, and a simple /./s is better.

It was temporarily converting literals within the src text to "$;NNNN$;"
where the Ns are 4 octets that encode the index of the literal.  It was
then using /(\C{4})/ to later extract those octets. But since the octets
were originally inserted as chars anyway, they should be extracted as
chars too.

I suspect the original code could have failed on utf8 source once the
number of literals exceeded 0x80.

Update IO-Socket-IP to CPAN version 0.30

  [DELTA]

0.30    2014/07/03 23:28:43
        [CHANGES]
         * Invoke $self->connect fully-qualified in case of subclasses with
           override (RT95983)
         * Added extra diag() call in t/15io-socket.t (RT96914)

Don't add unnecessary linespace.

And don't add trailing whitespace ever!  (Committer's error.)

Supply description for only test lacking one.

Wording of description taken from 'perlvar.pod' section on $EVAL_ERROR ($@).

Avoid unused warnings from locale-less systems.

From Brian Fraser: "Technically, any Perl compiled with
-Accflags="-UUSE_LOCALE", or -Ui_locale -Ud_setlocale...
realistically, for Android".

Deprecate /\C/

This character class matches a single byte within a multi-byte utf8 char,
and so breaks encapsulation. It is buggy, and can corrupt utf8 strings.

This deprecation was agreed in the thread starting

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

Update Pod-Usage to CPAN version 1.64

  [DELTA]

1.64 (marekr)
- CPAN#93170: Abstract in pod doesn't follow convention
    fixed the NAME section
- CPAN#86932: documentation does not work with use strict
    rewritten parts of the DESCRIPTION section
- CPAN#86776: "pod2usage -verbose 2 FILE" is broken when perldoc is missing
    verified that pod2usage acts decently if perldoc is missing
    note: a Perl installation without perldoc is like a haunted house
    without ghosts

Sync Storable version for CPAN release

perldelta for 3f7602fa4cd6

extra tests for grok_number(_flags)()

[perl #3330] warn on increment of an non number/non-magically incable value

The original version of this patch, introduced in
v5.19.2-389-g8140a7a, warned confusingly when incrementing strings
like "123abc".  This version includes the fix patch from [perl

universal.c gv_stashpv -> gv_stashpvs

avoids a strlen()

s///e on tainted utf8 strings got pos() messed up

RT #122148: In 5.20, commit 25fdce4a165 changed the way pos() was stored
in magic attached to SVs from being a byte offset to a char offset,
*except* that, for efficiency, strings being used for pattern matching
were kept as byte offsets (with a flag indicating thus), *except* where
the SV already had magic attached (such as taint, as in the bug report and
in this commit's test), in which case it kept it as chars.

The code that updated pos() after an iteration of s///e was faulty: the
string buffer it used for converting byte legnths to char lengths (via
utf8_length()) was the wrong buffer: rather than using the src string
being matched against, it was using the destination string being built up
via iterations of s///. Once double-byte utf8 chars were involved, all the
pos() calculations went wrong, and utf8 warnings started mysteriously
appearing.

Enable _FORTIFY_SOURCE only if optimizing, as specified.

As noticed by Dave Mitchell.

Update ChangeLog before release

passthrough make options to make -s can speed up the build

also quieten make_ext.pl by default

pass through -s if supplied, instead of defaulting to it

allow the build to specify verbose make_ext.pl

Support faster make -s

Skip chdir messages by passing make -s through
Also silence make_ext.pl to speed up the build process. use -v or --verbose

Module::CoreList::TieHashDelta stop massive recursion

On machines with very limited memory, EXISTS calling EXISTS caused a very
high number of C stack frames, magic stack swaps, and Perl call stack
frames leading to memory exhaustion. Turn the recursion into a loop. See
[perl #121974].

allow test.pl tests to use C<< plan skip_all => $reason >>

This pointless incompatibility with Test::More has resulted in
many annoyingly broken test scripts.

avoid an undefined value warning from libperl.t

and fix a doubly broken C<< plan skil_all => "no GNU nm"; >>

perldelta for 5afb921fc188

Make the "no name list" catcher more relaxed.

If building with DTrace, the dtrace header is required.

It's generated and its a dependency, so make depend seems like a natural
fit for it.

Some more cppsymbols to scan.

Weirdly, BYTEORDER/BYTE_ORDER was missing.  Note that  __BYTE_ORDER__
might be '1234' even though longs are 64 bit, since probably the symbol
is used to tell the order in a "word", which still is "int", not "long".
In other words, Perl's BYTEORDER will likely be longer the the cppsymbol.

Gleaned some extra CPUs and OSes from
http://sourceforge.net/p/predef/wiki/Architectures/, though didn't go
all crazy on platforms with many variants like ARM, HPPA, SH.

ANSI prototypes for Berkeley DB API testing.

So that g++ doesn't go apoplectic.  K&R prototypes in 2014?  Impressive.

In nonblock test do not ignore the syscall returns.

Makes for less whining with warn_unused_result.

-D_FORTIFY_SOURCE is no more a todo.

Mention -D_FORTIFY_SOURCE in perldelta.

Add -D_FORTIFY_SOURCE=2 when applicable.

Added only if available (gcc 4.*) and not already there.

Not already there might be explicit via ccflags, or less explicitly
via cppsymbols: for example in OS X 10.5+ the -D_FORTIFY_SOURCE=2
is already the default with the system cc (gcc earlier, now clang).

Some Linux distros (e.g. Fedora) also have enabled it for years,
either for all user code, or for their own builds.

Assert before deref due to possible NULL.

Coverity perl5 CID 68587.

Coverity 45351 - Refactor to skip a loop iteration

The loop in this case will remove an element from a list,
so it keeps a pointer to the previous element.  Before this
change, the pointer to the previous element was only initialized
at the end of the first pass, so Coverity flagged the code
as potentially using a NULL pointer.  It's a false positive
because the first element in the list is always a pushmark, so
the branch that actually used that pointer would never be hit
while it's still NULL, but changing the code to explicitly set
lasto before entering the loop (and asserting that its a PUSHMARK)
makes the logic clearer to both humans and Coverity.

Cosmetic consistency on "unimplemented function" deaths.

libperl.t: Allow tetss to pass if perl was compiled with -fno-common

If Perl was compiled with -fno-common, there will be no common
section in nm's output; the symbols we're looking for will be
under bss ('unknown').

regcomp.c: Rewrite S_put_byte() which dumps regex []

This routine is used to display what the latin1 portions of a bracketed
character class matches.  It is what used, for example,  under -Dr to
display [] contents.  I noticed that the display had more hex characters
than needed, which are less intelligible than just printing out ASCII
printables.  And hence was harder to discern what is really going on.
This improves that, see the comments for more details.

toke.c: White-space alignment, add comment

pod/.gitignore: delete entries for now-unsupported arch-specific pods

The build process creates a symlink pod/perl$platform.pod pointing to
README.$platform for each relevant platform, and we therefore want Git to
ignore those generated symlinks. Where we no longer support a given
platform, there's no need to have a gitignore entry for it.

Capture the stderr of "nm libperl.a".

Ignore one known darwin seemingly harmless whine,
but die if otherwise unexpected stderr output.

Cannot do simply 2>&1 because buffering conflicts.

skip works only with SKIP.

Cannot do POSIX::blah() unless POSIX loaded ok.

(Makes freshly built "minitest" to pass again.)

Increment to $VERSION in ext/Hash-Util/lib/Hash/Util.pm.

Change to ext/Hash-Util/Util.xs requires this.

Fix like/is problem in perl5db.t.

aaa63daea7f8ece changed like to is, which turned out not to be
quite the same thing for these tests on VMS, where the last line
of a file always gets a newline before EOF willy nilly.  So keep
is but make the newline explicit.

Guard cur_curlyx at least with an assert.

Keep on keeping Coverity happy (Coverity perl5 CID 45352).

hv can be left uninitialized.

Stronger statement would be assert(), even stronger croak(),
but don't know the code well enough.

Coverity perl5 CIDs 68584 and 68585.

printf formats are hard.

Coverity perl5 CID 68582.

assert(*p = '#');  /* Spot the oops. */

Triggered new Coverity perl5 CIDs 68580, 68581 and 68583.
(Side effect in assertion, and assignment where comparison
probably indented, the last twice because of ext/re.)

Time functions in time64.c need thread context on VMS.

In order to support the C<vmsish 'time'> pragma, the wrappers for
gmtime and localtime need thread context, which in the case of
localtime was removed in 23491f1decae17401c5.  Add it back but
make it VMS-specific and turn the comment indicating why it's
there into a more direct statement.

regexec.c: Move some macro definitions around

This puts them in a more logical order

PATCH: [perl #122090] Non-word-boundary doesn't match EOS

The root cause of this is that the loop is a "< strend" instead of a
"<=".  However, the macro that is called to form the loop is used
elsewhere where "<" is appropriate.  So I opted to just repeat the
small salient portions of the loop right after it so it gets executed
one final time in the final position.

This code:
 if ((!prog->minlen && tmp) && (reginfo->intuit || regtry(reginfo, &s))) \
           goto got_it;
had the effect previously of causing \b to look at the position just
after the string, but not \B.  By doing it the other way, this is no
longer needed, except I don't understand the prog->minlen portion.  It
isn't used anywhere else in the tests which see if one should goto
got_it, nor do any test suite tests fail by removing it.  I think it is
a relic, but if a bisect should end up blaming this commit, I'd start
with that.

regexec.c: Comments and white-space only

regexec.c: Exchange 2 lines of code and add comments

This reorders things to avoid unnecessary work, as the now-first line
may jump, making the assignment that used to be unconditional irrelevant

regexec.c: More cleaning of FBC macro/code interface

The definition of \w is now compiled into the Perl core.  This allows
the complicated swash_fetch function call to be replaced by
isWORDCHAR_utf8, which takes a single parameter, so the interface can be
simplified. [1].

This macro will execute faster on Latin1-range inputs, as it doesn't do
a swash_fetch on them, but slower on other code points due to function
call overhead, and some currently in-place error checking that wasn't
done previously.  This overhead could be removed by using inline
functions, and perhaps a different interface for known non-malformed
input (though I'm actually not sure the input is known to be well-formed
in this case).

These macros still depend on and modify outside variables.  That could
be cleaned up by adding additional parameters to them, but I'm not going
to do it now.  I don't like these kinds of code-generating macros, and
have been tempted to rewrite these as inline functions, but it's not a
trivial task to do.

[1] I hadn't realized it before, but the interface could have been
cleaned up instead by introducting a macro that makes it look like a
single parameter is used uniformly to existing macros, looking like
 #define FBC_BOUND_SWASH_FETCH(s)  \
    cBOOL(swash_fetch(PL_utf8_swash_ptrs[_CC_WORDCHAR], s, utf8_target))
But it seems better to me to use isWORDCHAR_utf8 as it is faster for
Western European languages, and can be made nearly the same speed as the
alternative if experience tells us that this is a slow spot that should
be sped up.

regexec.c: Clean up macro/code interface slightly

These code-generating macros are a pain to maintain.  These have side
effects and use variables outside the macros.  This commit cleans up the
interface slightly by separating the operand of a function from the
function, so the code outside doesn't have to know as much about the
macro as before.  The next commit will fix up the remaining parameter
like this.

regexec.c: Change names of 4 macros

The names were misleading; they were not for general use, but only for
this FBC area of the code, and they no longer have to do with having to
load utf8 or not.

regexec.c: Change MiXeD cAsE formal macro parameters

I find these a pain to type and read, and there is no reason for them.
As formal parameters there is no possibility of conflict with the code
outside them.  And I'm about to do some editing of these, so this change
will make that easier.

Sync Module-CoreList version in Maintainers.pl for CPAN release

Follow-up to 51f14a05: not ignoring my_snprintf return values.

Glossary for d_ptrdiff_t

Add a small test case for c445c5b

Add t/porting/libperl.t

For sanity checking libperl.a on those platforms that have one,
and extra checking for the rare configurations of -DPERL_GLOBAL_STRUCT
and -DPERL_GLOBAL_STRUCT_PRIVATE which restructure the symbol exports.

Remove or downgrade unnecessary dVAR.

You need to configure with g++ *and* -Accflags=-DPERL_GLOBAL_STRUCT
or -Accflags=-DPERL_GLOBAL_STRUCT_PRIVATE to see any difference.
(g++ does not do the "post-annotation" form of "unused".)

The version code has some of these issues, reported upstream.

Unused snprintf results noticed by clang in Linux.

A bit dubious to ignore the snprintf results, but at least
for these cases it looks acceptable.  We could assign the
length and croak if not expected, but it seems that with
gcc brace groups we already do that.

Fix RT #122171, lookahead issues with .*

Patterns of the form /(?=.*X)X/ were getting the IMPLICIT flag set,
which does not work with lookahead.

This used to not be a problem as we did not look at the contents of
lookahead patterns in the start-class optimizer. In 07be1b83a6b2d24
I changed this, and this case would break. That it took this long
to come to light is probably because the pattern does not really make
sense.

https://rt.perl.org/Public/Bug/Display.html?id=122171

perldelta for 0f9d28587772, cd293174fae5

bump dist/Math-BigInt/ $VERSIONS to 1.9996

CPAN RT 96254 and 96329: Correct the handling of subclasses.

Don't check for an exact class name; trust inheritance.

bump $XS::APItest::VERSION to 0.62

Under GLOBAL_STRUCT mgvtbl-s are const, which angers g++.

See also 31114fe99.

Unused contexts found under PERL_GLOBAL_STRUCT.

Drop debugging, and handle HP-UX opt flags.

Further hpux hints simplifying suggested by H.Merijn.