Time-HiRes: no mutex for you due to mistyped USE

Time-HiRes: remove unused hrt_ualarm

Binary compat with 1.91 would mean roughly 2006-10, which means
either Perl 5.8.8 or 5.9.5.  Time to let go.  No hits in CPAN,
as observed by Tony Cook: http://grep.cpan.me/?q=hrt_ualarm

op.c: cosmetic comment changes

t/re/uniprops.t: Remove wrong test cases

mktables generates the file used in this test.  Unicode version 9
introduces a numeric value that is an order of magnitude closer to 0
than any previous version had.  This demonstrated a bug in mktables,
where it didn't consider the possibility of floating point numbers being
indistinguishably close to integers.  It did check for being too close
to the rational numbers used in Unicode, but omitted checking for
integers.  This adds that check, which in turn causes some wrong test
cases to not be generated for this .t.

This bug has not shown up in earlier Unicode versions, but is there
nonetheless, so I'm pushing this now instead of waiting.

APItest.xs silence compiler warning

On Solaris:
    "APItest.xs", line 1519: warning: integer overflow detected: op "<<"

regex sets: fix Solaris optimiser bug

[perl #127455]

On Solaris with -DDEBUGGING, re/regex_sets.t was failing to compile.

This appears to be due to an optimiser bug.

The code in question looked like:

  handle_operand:
    top_index = av_tindex_nomg(stack);
    if (top_index - fence >= 0) {
        ...
    }

printf()ing the value of fence after the av_tindex_nomg() showed that its
value was corrupted (compared with its expected value based on a different
platform with the same debugging print). However, putting a another printf
prior to the av_tindex_nomg() call not only displayed the correct value,
but caused the later printf() to also display the correct value. It seems
that merely accessing fence prior to av_tindex_nomg() avoids the
corruption.

Simplifying the av_tindex_nomg(), the bad behaviour could be reduced to:

    if (!stack) { __assert( "" , "", 1); }

Putting a printf after this gave a corrupted fence; a printf before
made everything work.

So this workaround commit just makes sure that fence is accessed prior to
calling av_tindex_nomg().

amigaos4: better popen() + pclose() implementation

popen(): handle better the case where the popened external
might exit before the child process manages to start.

pclose(): protect with a semaphore.

Fix various pod errors.

Mostly these are too long verbatim lines.

inline.h: Fix comment

perlvar: Add a couple links

perllocale: Nits, update for 5.24 changes

perlapi: Clarify Latin1 and ISO-8859-1

Export Winsock error constants from POSIX.pm

Export Winsock error constants from Errno.pm

Set $^E for socket errors on Windows

Better wording.

gitignore for cscope index files.

make target for cscope indexing.

CPAN release of autouse is now 1.10

this has no changes to code from 1.08; it gets in the test changes
from blead and adds a prereq for Scalar::Util with isdual

perlapi: Document ninstr() and rninstr()

t/re/reg_mesg.t: Add some more tests

use inequality when checking "tail" in trie compilation

It is possible that a node inside an alternation points out
and past the end of the alternation, using equality on tail
means we don't notice. Its not clear that this is actually
required, but it has been an issue in other contexts so lets
just always use inequalities for this purpose.

Fix Perl #126206: handle NOTHING regops and EXACTFU_SS regops in make_trie() properly

... and avoid dereffing non-EXACT nodes unnecessarily at the same
time. This fixes https://rt.perl.org/Ticket/Display.html?id=126206

utf8.c: Add missing {}

which caused an if's scope to be less than intended.

Spotted by Jarkko Hietaniemi using gcc 6 with the
'-Wmisleading-indentation' option

perldelta for c2538af7458

[perl #122287] probe in Configure whether dtrace builds an object

When building the object file, newer versions of dtrace (on Illumos
based systems at least) require an input object file that uses
at least one of the probes defined in the .d file.

The test in Makefile.SH didn't provide that definition so the test
would fail, and not build an object file, and fail to link later on,
on systems that *do* need the object file.

Moved the probe to Configure (where it probably belongs) and supplied
an object file that uses a probe.

Tested successfully on OmniOS (with the new dtrace), Solaris 11,
and darwin.

fix a skip count in cpan/IPC-SysV/t/ipcsysv.t

reported upstream as https://rt.cpan.org/Ticket/Display.html?id=112827

[perl #127533] only test semctl() if we have everything needed to use it

In a FreeBSD jail, the semctl() entry point might exist, but can be
disabled by policy, when it is disabled, the Configure code that
tests for the different structures that can be supplied to semctl()
fail.

The code that implements semctl() for perl treats semctl() as
unimplemented if neither structure is available, so avoid testing
semctl() if the structures couldn't be detected.

perlvar: Cross reference other pods

Suggested by "kes" in
http://nntp.perl.org/group/perl.perl5.porters/234447

Convert to use av_tindex_nomg()

I looked at the code I'm familiar with, and converted the av_tindex
calls on arrays I was confident don't have magic to av_tindex_nomg().
This saves a little work each time.

Add av_tindex_nomg()

This is like av_tindex, but doesn't handle magic.  I'm not documenting
it for now, in case it turns out this was not a good idea.

Inspired from an observation by Tony Cook.

regcomp.c: Silence some compiler warnings

Some compilers wrongly think these variables can be used uninitialized.

perlguts: Slight clarification

perlapi: Slight clarification

This changes to use 'transfer' to make clear that the reference count is
unchanged.  Some think that the previous wording 'take' is good as-is;
some agree with me.  Daniel Dragan has pointed out that 5 years ago I
changed this line, while retaining 'take'.  Given that 'transfer' is
unambiguous to all, while 'take' is ambiguous to some, I'm making the
change.

pod/perldelta: Add some Selected Bug Fixes

regcomp.c: Remove redundant assignment

The assignment removed here is followed immediately by a goto, and the
target of the goto repeats the assignment, so this one is redundant.

Spotted by Tony Cook

perlre: Nits, clarifications

S_study_chunk(): silence compiler warning

Mention bytes::length modern workaround re 01e331e5

Also add an emboldening and parabreak to underline the discouragement.

Make open failures little less cryptic.

add comment explaining a subtlety

Tony caught a bug I made in d5a00e4af6b155495be31a35728b8fef8e671ebe and fixed
it in 2dc40b2d7c20b0d31c4343ac23cda9799f234a65. This comment explains
the subtlety that lead to the bug: the compilation state var
RExC_npar is +1 as compared to the equivalent rex->nparens.

Add test for [perl #126405]

Commit b297756b5d78ef23f3ebf878d0342947ece424aa did not add a test, but
such a test is possible, and is added here.  The problem only showed up
on some configurations, but nonetheless, it did show up, and so will
fail the added test on those configurations, which turn out to be
regularly smoked.

Document the previous commit in Carp's Changes.

Fix RTCPAN#107225 : longmess returns 1 on ref.

See: https://rt.cpan.org/Public/Bug/Display.html?id=107225 . Also
discovered as a bug in perl -d by me (= Shlomi Fish) and reported
after the original report. longmess() returns "1" when called in scalar
context if passed a reference.

avoid reading/writing beyond the end of RExC_(open|close)_parens

Partly reverts d5a00e4af, which added this change:

-        for ( paren=0 ; paren < RExC_npar ; paren++ ) {
+        for ( paren=0 ; paren <= RExC_npar ; paren++ ) {

but RExC_(open|close)_parens are both allocated with RExC_npar entries,
making this a read/write buffer overflow.

This caused crashes during the build with GCC on Win32, and was
detectable with valgrind and -fsanitize=address on Linux.

With the change, passes all tests with -fsanitize=address -DDEBUGGING
on Linux and finishes the build with GCC on Win32.

perldelta for 99fff99d79, af4291a8594

make building without memcpy work (RT #127619)

util.c: make my_mem*/my_b* prototypes more like the originals

Update bytes.pm doc

The one legitimate use of this pragma is for debugging.  This changes to
say so, and other minor changes.

regcomp.c: fix Perl #126405, segfault regex

There was a flaw in how we scan regexes for triable sequences.
It is possible that the end of a branch points *past* the tail of
the branch sequences, which was resulting in us constructing
tries when we shouldn't. This patch changes equivalency tests for
an inequality test, which prevents this problem.

I am not sure how to test for this problem as it doesn't actually
segfault for me, but I can see the illegal read in valgrind.

regcomp.c: improve diagnostics for TRIE construction

fix Perl #126182, out of memory due to infinite pattern recursion

The way we tracked if pattern recursion was infinite did not work
properly. A pattern like

    "a"=~/(.(?2))((?<=(?=(?1)).))/

would loop forever, slowly eat up all available ram as it added
pattern recursion stack frames.

This patch changes the rules for recursion so that recursively
entering a given pattern "subroutine" twice from the same position
fails the match. This means that where previously we might have
seen fatal exception we will now simply fail. This means that

    "aaabbb"=~/a(?R)?b/

succeeds with $& equal to "aaabbb".

Unify GOSTART and GOSUB

GOSTART is a special case of GOSUB, we can remove a lot of offset twiddling,
and other special casing by unifying them, at pretty much no cost.

GOSUB has 2 arguments, ARG() and ARG2L(), which are interpreted as
a U32 and an I32 respectively. ARG() holds the "parno" we will recurse
into. ARG2L() holds a signed offset to the relevant start node for the
recursion.

Prior to this patch the argument to GOSUB would always be >=, and unlike
other parts of our logic we would not use 0 to represent "start/end" of
pattern, as GOSTART would be used for "recurse to beginning of pattern",
after this patch we use 0 to represent "start/end", and a lot of
complexity "goes away" along with GOSTART regops.

rename RExC_opend RExC_end_op for clarity

first step cleaning up regexp recursion "return" logic

When we do a GOSUB/GOSTART we need to know where the recursion
"returns" to the previous position in the pattern. Currently
this is done by comparing cur_eval->u.eval.close_paren to the
the argument of CLOSE parens, and within END blocks (for GOSTART).

However, there is a problem. The state machinery for GOSUB/GOSTART
is shared with EVAL ( implementing /(??{ ... })/ ), which also sets
cur_eval->u.eval.close_paren to 0. This for instance breaks /(?(R)YES|NO)/
by making it return true within a /(??{ ... })/ when arguably it
shouldn't. It also is confusing.

So we change the meaning of close_paren so that 0 means "from EVAL",
and that otherwise the value is "+1", so 1 means GOSTART (trigger for
END), and 2 means "CLOSE1", etc. In order to make this transparent
this patch adds the EVAL_CLOSE_PAREN_IS( cur_eval, EXPR ) macro which
does the right thing:

    ( cur_eval && cur_eval->u.eval.close_paren &&
      ( ( cur_eval->u.eval.close_paren - 1 ) == EXPR ) )

perlebcdic: Update for 5.24

Fix some typos, and most importantly remove the now-fixed items from the
BUGS section

Time-HiRes: record latest changes

Assuming that at some point a CPAN release of the new! shinier!
Time-HiRes might be a good thing.

The version bump to 1.9731 was done already in 1625f1d3.  Leave the
day of month open in case more changes come in, no need to constantly
bump the version.

PathTools: import Changes file from CPAN

amigaos4: execvp() and popen() enhancements

myexecvp()
Replaces alloca() in execvp() with IExec->AllocVecTags() with the memory
type explicitly set to MEMF_SHARED (alloca allocating on the stack which is
MEMF_PRIVATE and in theory at least you can't share that with the sub
process (in practice this isn't enforced yet, too much old software would
break, but one of these days)).

amigaos_popen()
Alters file opening order to ensure that the write end of the pipe is always
opened first.

Now attempts to pass Input() out Output() (stdin or stout) to the non-pipe
file handles rather than NIL: reverting to NIL: if the above can't be
DupFileHandled() (say if they were redirected to a file opened with an
exclusive lock).

PATCH: [perl #127262] assertion fail on malformed UTF8

Add a guard against malformed UTF-8.

Time-HiRes: refactor also nanosleep init

Time-HiRes: avoid going negative on struct timespec

Time-HiRes: refactor common timespec subtraction code

Time-HiRes: for nanosleeps, zero is success

Testing for zero makes it slightly less odd-looking than bang.

Time-HiRes: use NV_1E6 and NV_1E9 consistently

Time-HiRes: initialize the unslept timespec

Found by clang scan-build.

threads.xs: create new static fn S_jmpenv_run()

S_jmpenv_run() replaces 3 similar pieces of code that do
JMPENV_PUSH(); ... stuff ...; JMPENV_POP().

As a side effect of this commit, it gets rid of this annoying warning
under g++:

    warning: variable ‘my_perl’ might be clobbered by ‘longjmp’

rpeep(): eliminate compiler warning

    op.c: In function ‘Perl_rpeep’:
    op.c:13692:37: warning: comparison is always false due to limited
    range of data type [-Wtype-limits]
                             ? base : 0) >
                                     ^
replace the '0' with something that still always fails to match but
hopefully won't warn.

Simplify _MEM_WRAP_NEEDS_RUNTIME_CHECK()

And at the same time hopefully avoid some false-positive compiler warnings
on HP-UX

PATCH: [perl #126141]: qr/]]]]][\\/ fails to raise error

This was due to the trailing \ trying to look at the next character
without verifying that one actually existed.

regcomp.c: Fix a memory leak

This revises 5751998882d1db1c0f62a32a0b16e58176928a35 so that it works
if a called function fails to return (it was failing if there was
illegal tainting going on).

locale.c: Avoid a leak

This reorders things to allow a free to be done.  The cause was spotted
by Tony Cook.

POSIX.xs: Avoid a leak in setlocale()

Tony Cook suggested this fix.

TODO or skip certain failing locale tests on cygwin

This is a known problem which cygwin has fixed in 2.5

Tony Cook tested this and found and fixed several bugs in it before this
final version was made.

regcomp.c: Revise, add comments, white-space changes

regcomp.c: Avoid a memory leak

The croak is using heap storage for an argument.  Making that
SAVEFREEPV() will make sure it gets freed.

regcomp.c: White-space only

Outdent and reflow comments because the previous commit removed a
surrounding block.

Reinstate "PATCH: {perl #127582] Over eager warning for /[.foo.]/""

This reverts commit ab9a4aa72166b26d6c3556107c19ba08ee956a88 which
itself reverted commit a9149dfda17b511d34bb2af869948b677be52fbc, thus
reinstating the original.  But this new commit also adds a check to
avoid going off the end of a buffer, the absence of which was the cause
for the failure of the original commit with address sanitizer.

locale.c: Silence HP-UX compiler warning

Cast this flag value to a bool, which is what we want anyway here.

Warn of the "else syndrome".

Not that anyone ever reads perlport.

Clarify what AmigaOS version was broken by 5.8.0

perl5db.pl version bump

Defaulting to VMS is probably not right.

amigaos4: use CONSOLE:, not VMS sys$command

amigaos4: clean up older style / deprecated AmigaOS calls

reduce number of calls to add_cp_to_invlist()

Both S_get_ANYOF_cp_list_for_ssc() and S_put_charclass_bitmap_innards()
have tight loops that iterate over a bitmap and calls add_cp_to_invlist()
for each bit set.

add_cp_to_invlist() is a fairly wrapper around _add_range_to_invlist()
which create a new invlist to hold the range and then calls
_invlist_union() to perform the add.  This is moderately expensive.

Instead of indirectly calling _add_range_to_invlist(), where it's
simple to do so, instead look for ranges of bits set in the bitmaps
and call _add_range_to_invlist() directly.

This changed the cachegrind output from running:

  ./perl -e 'qr/_?[\W_]/;'

from:

==23406== I   refs:      1,752,149
==23406== I1  misses:        5,405
==23406== LLi misses:        3,588
==23406== I1  miss rate:      0.30%
==23406== LLi miss rate:      0.20%
==23406==
==23406== D   refs:        683,242  (414,061 rd   + 269,181 wr)
==23406== D1  misses:       13,370  (  7,646 rd   +   5,724 wr)
==23406== LLd misses:        7,025  (  3,417 rd   +   3,608 wr)
==23406== D1  miss rate:       1.9% (    1.8%     +     2.1%  )
==23406== LLd miss rate:       1.0% (    0.8%     +     1.3%  )
==23406==
==23406== LL refs:          18,775  ( 13,051 rd   +   5,724 wr)
==23406== LL misses:        10,613  (  7,005 rd   +   3,608 wr)
==23406== LL miss rate:        0.4% (    0.3%     +     1.3%  )

to:

==25041== I   refs:      1,189,412
==25041== I1  misses:        5,218
==25041== LLi misses:        3,598
==25041== I1  miss rate:      0.43%
==25041== LLi miss rate:      0.30%
==25041==
==25041== D   refs:        440,339  (283,047 rd   + 157,292 wr)
==25041== D1  misses:       11,872  (  7,257 rd   +   4,615 wr)
==25041== LLd misses:        7,024  (  3,417 rd   +   3,607 wr)
==25041== D1  miss rate:       2.6% (    2.5%     +     2.9%  )
==25041== LLd miss rate:       1.5% (    1.2%     +     2.2%  )
==25041==
==25041== LL refs:          17,090  ( 12,475 rd   +   4,615 wr)
==25041== LL misses:        10,622  (  7,015 rd   +   3,607 wr)
==25041== LL miss rate:        0.6% (    0.4%     +     2.2%  )

ie. from 1.75 million instructions to 1.19 million instructions.

PATCH: [perl #127599] Fix regcomp.c assertion

I added this assertion in cfbef7dc3.  It asserts that we have more to
parse.  The code in this function is quite complicated, and assumes in a
number of places that there is more to parse.  When we don't have more
to parse, 900 lines later, it throws an error.  It may be that you can't
get to the places where it assumes there is more to parse if this
assertion is false (I don't remember now from my tedious audit of this
code), but even if so, it is fragile to assume so, given the large
distance to where the error is thrown.  So throw the error right away
and avoid any existing or future breakage.

document args of Perl_do_sv_dump()

amigaos4: no sigaction, no si fields

pp_subst(): rename local var

make it clear that is_cow represents the original COW state (which may not
be the current state when checked later), by renaming it to was_cow.

pp_subst: fix typo

use cBOOL() in pp_subst()

Now that we have that macro, use it.

S_regmatch(): remove dead code

The 'sayNO'; follows a croak, so can never be reached.

remove some duplicate /* NOTREACHED */

In regexec.c there were several occurrences of

    /* NOTREACHED */
    NOT_REACHED; /* NOTREACHED */

where the first line isn't needed.

Revert "PATCH: {perl #127582] Over eager warning for /[.foo.]/"

This reverts commit a9149dfda17b511d34bb2af869948b677be52fbc.
This is causing failures in blead under clang, so I'm reverting it until
I can work out why.

Revert "regcomp.c: White-space only"

This reverts commit 7511771ceb229ce97939f643c6de73c6b1a371be, so that
the next commit can be cleanly reverted

bump $strict::VERSION and $warnings::VERSION

narrow the filename check in strict.pm/warnings.pm

• The code previously assumed that any filename basename besides
  `strict.pm` meant that the user mistyped `use strict` (e.g. as
  `use Strict`). But that could just mean the file was not loaded
  from the filesystem, e.g. due to naïve fatpacking.

  This is fixed by adding a guard to check that an unexpected value
  really is a mis-capitalised variant of `strict.pm`.

• The code previously insisted on either slash or backslash as the
  directory separator, which is not strictly portable (though nobody
  noticed in years; apparently nobody has tried to run a recent-ish
  on a MacOS Classic or RiscOS system).

  This is fixed by switching to \b as a best effort, to avoid going
  down the rabbit hole of platform-specific separators.

• The code previously used an `unless` statement, declared lexical
  variables inside its block, and used ${\EXPR} to interpolate the
  __PACKAGE__ constant into the regexp. Each of these increases the
  size of the optree, which is only ever executed once, then sticks
  around wasting some hundred(s) bytes in almost every single Perl
  program in the world.

  This is fixed for warnings.pm by rewriting the code with no use of
  any temporary variables and single-quoted strings instead of regexp
  literals. In strict.pm, we can do even better by moving the code to
  the BEGIN block, since BEGIN CVs are freed after running. (We do not
  add one to warnings.pm since BEGIN blocks have a creation cost.)

regcomp.c: Avoid an empty [] in -Dr output

regcomp.c: White-space only

Outdent and reflow comments because the previous commit removed a
surrounding block.