POSIX: add lround() to the :math_h_c99 export tag

Closes RT#127821.

perlbug: wrap overly long lines

Mail transport agents limit the length of message lines at SMTP time.
One observed limit is 1000 characters per line. Mail user agents typically
work around these limits by MIME-encoding the message. Since perlbug
doesn't do that, it needs to limit the length of its lines manually to
make sure bug reports get delivered.

The longest lines in perlbug reports normally come from Config::myconfig
output, particularly 'config_args', which has been observed to exceed
1000 characters on some configurations, causing report rejection. While
less likely, the list of local patches is another potential source of
overly long lines.

Use Text::Wrap (if available) to wrap the body of the report at an
arbitrarily chosen and hopefully safe limit of 900 characters. No
indentation or continuation line markers are added, though it would
be easy to add those if desired. Attachments and mail headers are not
wrapped.

Bug-Debian: https://bugs.debian.org/822463

perlbug: Refactor duplicated file reading code

_send_message_mailsend() needs to build the message itself rather than
calling build_complete_message() like the other backends, but they can
still share the file reading code, and so can the 'display report' part.

perlbug: Add unit tests

Some of these tests have to mimic the interactive interface, which is
probably rather fragile. However, as long as -F overrides any actual
sending, no mail bombs will hopefully result.

perlbug: Allow subjects without whitespace in test mode

Passing whitespace in an option through test.pl runperl() doesn't seem
to work, so relax the check in test mode (-t) for noninteractive testing.

perlbug: quit main loop on empty answer / eof in test mode

This makes it possible to drive perlbug noninteractively
without having it go to an infinite loop on end of file.

The change has no effect in non-test mode, where the default answer is
the empty string.

This is groundworks for perlbug unit tests.

perlbug: Allow noninteractive use in test mode (-t option)

This is groundworks for perlbug unit tests.

Not all of the interactive questions can be overridden on
the command line, so we will have to pipe in commands.

Adapt the test mode ("-t"), which used to just override the
recipient address, for this rather than inventing one more
new option.

Correct info in Maintainers.pl for dists already on CPAN

Update Digest-MD5 to CPAN version 2.55

  [DELTA]

2016-03-09   Gisle Aas <gisle@ActiveState.com>

   Release 2.55

   Gordon Stanton (2):
      Make use warnings work including test cases.
      Initial Travis config

   Gisle Aas (1):
      Avoid warning: 'static' is not at beginning of declaration [RT#105646]

Update IPC-Cmd to CPAN version 0.94

  [DELTA]

0.94 Fri Feb 12 18:55:05 GMT 2016

  Bug fixes:
  * move __END__ above POD in documentation (plicease)
  * Don't clobber $SIG{__DIE__} and $SIG{__WARN__} in open3_run() (avar)
  * Fix 'terminate_on_signal' segfaulting (Petya Kohts)
  * Fix usage of fcntl(..., F_GETFL, ...) (tonyc)

Update Archive-Tar to CPAN version 2.08

[perl #128052] make t/test.pl compatible with older Perls

The RT ticket points out that the threads and threads::shared libraries,
among other CPAN modules, copy t/test.pl and must operate on older versions
of Perl; but that the version in threads 2.07 and threads::shared 1.51
contains constructs that require Perl 5.10.

This change restores 5.8 compatibility in t/test.pl, ready for reimporting
into the CPAN releases of those modules.

I can't see a way to test that this compatibility doesn't get accidentally
broken in the future, unfortunately.

upgrade Module-Metadata to 1.000032

fix typo in RMG

Maxwell Carey is now a perl author

Clarify description of sprintf "%.1g"

sprintf "%.1g" sets the number of *significant* digits, not the
maximum number of digits to show. Added examples for values less
than 1.

Fix Scalar-List-Utils build on C89 compilers; patch sent upstream

Fix Scalar-List-Utils build on C++ compilers; patch sent upstream

[cpan#100183] Add missing "<FH> chunk #" phrase to Carp messages

Commit 89988fbd2f7d8a44526a3cd9ab671b3102898bc9 added the relevant phrase for
line-oriented filehandles; this extends that to also cover chunk-oriented
ones.

The patch was supplied by Chris R Donnelly <chris.donnelly@vauto.com> on the
rt.cpan.org ticket; I have extended it to include a test.

Upgrade to Scalar-List-Utils 1.45 from CPAN

Upgrade to DB_File 1.838 from CPAN.

sv.c: fix missing word in apidoc

[perl #128086] Test the prev commit

[perl #128086] Fix precedence in hv_ename_delete

A stash’s array of names may have null for the first entry, in which
case it is not one of the effective names, and the name count will
be negative.

The ‘count > 0’ is meant to prevent hv_ename_delete from trying to
read that entry, but a precedence problem introduced in 4643eb699
stopped it from doing that.

[This commit message was written by the committer.]

inline.h: Suppress g++ warning under threads

In file included from perl.h:5853,
                 from op.c:103:
inline.h:712: warning: unused parameter 'my_perl'

Dump empty-string ENAMEs as empty strings

They were coming out as ‘(null)’, which is incorrect and confusing.

op.c: Remove special cases for array funcs

We no longer need special cases for the prototypes for array functions,
since autodef has been removed, and these are now perfectly regular.

Make barewords constant-foldable

Commit 11fa937b2766784f0f812687a7f81dd3761e605f, from August 1999, changed
constant folding to treat barewords as unfoldable. Public mailing-list
archives from that period are incomplete, unfortunately, and this change in
particular is no longer well documented; the only message still available
seems to be <199907140903.CAA07505@activestate.com>, with subject "Re:
Unwanted perl helpfullness". That message quotes a bug reporter pointing out
that a constant-folded bareword would fail to trigger the "not allowed while
strict subs in use" error under "use strict".

However, there's no information available about why the bug was fixed in this
way, rather than by merely ensuring that constant folding would produce that
error when necessary. The no_bareword_allowed() routine did already exist at
that point, for example. This change therefore adopts that approach.

This causes one minor change in behaviour: since barewords now take part in
constant folding, concatenating a bareword with another constant in void
context now produces a warning for the concatenated string, rather than for
the concatenation op. This seems like an acceptable change, given that
non-bareword constants already behave in the same way.

S_fold_constants(): refactor foldability detection

[perl #127952] misoptimization for negated constant-ish on lhs of logop

Negations were being incorrectly deleted from the op tree for an OP_AND or
OP_OR (corresponding to Perl code with any of `&& || and or`, or postfix
"if" or "unless") whose left-hand side looks like "!BAREWORD" or "!do {
'const' }" and whose right-hand side is a non-constant-foldable negation.

The symptom in the reported case was an assertion failure in ck_refassign
for an srefgen op, caused by such an OP_NOT having been nulled. But other
cases exist that instead yielded incorrect results.

The underlying cause is that two optimisations in S_new_logop() were
partially interfering with each other. One of those attempts to optimise
code like "!$x && !$y" to the equivalent of "!($x || $y)", saving a
negation op; this is valid by De Morgan's laws. If it detects code of
this form, it nulls out the negations on each side of the "&&", and makes
a note to wrap the op it generates inside a new OP_NOT.

The other optimisation looks at the left-hand arm, and if it's a constant at
compile time, avoids the entire logop in favour of directly evaluating the
lhs or rhs as appropriate, and eliding whichever arm is no longer needed.
This optimisation is important for code like this:

    use constant DEBUG => …;
    print_debug_output() if DEBUG;

because it allows the entire statement to be eliminated when DEBUG is false.

When both conditions were true simultaneously, the De Morgan optimisation
was applied before the constant-based arm elision. But the arm elision
involved returning early from S_new_logop(), so the code later in that
function that wraps the generated op in a new OP_NOT never had a chance to
run. This meant that "!X && !Y" when X is constant was being compiled as if
it were in fact "X || Y", which is clearly incorrect.

This is, however, a very rare situation: it requires the lhs to be an OP_NOT
that dominates an OP_CONST (possibly with some intervening OP_LINESEQ or
similar). But OP_NOT is constant-foldable, so that doesn't normally happen.
The two ways for it to happen are:

- The constant is a bareword (since even though barewords are constants,
  they don't currently participate in constant folding)

- The constant is hidden inside one or more layers of do{} (since that
  serves as a barrier to constant folding, but the arm-elision optimisation
  is smart enough to search recursively through the optree for the real
  constant)

The fix is much simpler than the explanation: apply the optimisations in the
opposite order, so that when arm elision returns early, the negation ops
haven't yet been nulled.

op.c: add some explanatory comments to S_new_logop()

Delete dead null-pointer check in op.c

Code above this point has already used this variable without checking
whether it's null, so this can't accomplish anything.

Fix misleading indentation in op.c

fix symbol detection with gcc 6 link-time optimization (RT #128131)

perldelta: OP_PARENT, and require ::Foo::Bar

add PERL_OP_PARENT to 'perl -V' output

enable PERL_OP_PARENT by default.

This makes the last op_sibling field in a chain of OP siblings
point back the parent node rather than being NULL, with the endness
instead being indicated by a flag.

See http://nntp.perl.org/group/perl.perl5.porters/235635

sv.c: Add comment

Use memmem() if available on the platform for Perl_ninstr()

Merge branch to not require mathoms special cases into blead

mathoms.c: Remove special casing from instr()

This function was recently moved to mathoms.  Now that various changes
have been made to the system, the special casing needed to get things to
compile can be removed.  Also, it can just call the macro
implementation, instead of what the macro expands to.

Make two functions for 5.005 backcompat MATHOMS

The functions sv_setpviv() and sv_setpviv_mg() exist only for backcompat
with 5.005. (verified with Jarkko and Nicholas).  Make them compile only
when mathoms is present.  They can't be moved to mathoms.c because they
both call a static function visible only in sv.c.

embed.fnc: Alter 'b' flag meaning

This commit changes this flag to mean that the backward compatibility
functions are compiled unless the -DNO_MATHOMS cflag is specified to
Configure.  Previously the meaning was sort of like that but not
precisely.

Doing this means that the prototypes that needed to be manually added to
mathoms.c are no longer needed.  No special parameter assertions have to
be made.  makedef.pl no longer needs to parse mathoms.c and have special
cases for it.  And several special case entries in embed.fnc can be
non-special cased.

embed.fnc: Temporarily remove backcompat flag for 2 fcns

Otherwise, the next commit could potentially cause errors when bisecting
under -DNO_MATHOMS.  They will be restored 2 commits hence.

regen/embed.pl: Don't: #define FOO FOO

Doing so would be useless.  This doesn't currently happen, but would in
a couple of commits.

embed.fnc: Change 'b' flag to not imply 'p' flag

By doing this, we make it more general, which will be useful in a few
commits.

embed.fnc: Indicate ninstr(), rninstr() have documentation

mathoms.c: Fix prototype

This would probably have refused to compile if anyone were actually
using this function in a threaded build.

regen/embed.pl: Verify flags field of embed.fnc

Make sure that the specified flags are legal.

embed.fnc: Remove improper flag character

This was introduced by efaf36747029c85b4d8825318cb4d485a0bb350e;
apparently a typo.

POSIX.pod: Fix grammar

README.freebsd: Add some L<>, C<> to pod

Croak on unimplemented already at import time

For example

  perl -MPOSIX=atexit -e 1

is never going to work in runtime, so why should it work in compile time.

This will probably break a lot of CPAN code, that have "good reasons"
for their strange imports.

Also the error messages change format, which will no doubt  break another
set of equally righteous CPAN modules.

Remove the deprecated POSIX::tmpnam as unsafe

Sort the %replacement and %reimpl

update GNUmakefile for Test2 too

Update to the latest Test-Simple cpan dist

fix link to crosby paper on hash complexity attack

document the ?pair option to beforemaintrelease

[perl #128106] Fix reset with non-globs

reset with a string argument was assuming that anything in a
stash would be a glob.  It crashed on anything else.

Sync Config::Perl::V with release 0.26

Update Archive-Tar to CPAN version 2.06

  [DELTA]

2.06  24/04/2016 (ISHIGAKI && BOOK)
- changed some of the "A"s in the UNPACK constant to "a"
  to allow trailing whitespaces in an archived filename
- roundtrip tests

Update perlfaq to CPAN version 5.021011

  [DELTA]

5.021011    20162016-03-04 20:04:08Z
  * update info on Perl 6
  * fix LICENSE address and update prereq for its content
  * excluded README.pod from the shipped tarball distribution

Update Locale-Codes to CPAN version 3.38

[MERGE] disallow 'require ::Foo::Bar' etc

load-module.t: re-indent and add some comments.

No functional changes.

make 'require ::Foo::Bar' die

Originally, 'require ::Foo::Bar' would try to load /Foo/Bar.pm.

The previous commit changed it so that  ::Foo::Bar mapped to Foo::Bar,
and so loaded Foo/Bar.pm in the @INC path.

This commit takes the different approach of, instead of mapping, making
any bareword require that starts with '::' into an error instead.

It introduces a new error message:

    $ perl -e'require ::Foo::Bar'
    Bareword in require must not start with a double-colon: "::Foo::Bar"
    $

See the thread at:
    http://www.nntp.perl.org/group/perl.perl5.porters/2012/07/msg189909.html

( I originally used '"::"' rather than 'a double-colon', but that
made the message a bit unpenetrable:

    Bareword in require must not start with "::": "::Foo::Bar"
)

Validate the 'require Bare::Word' pathname.

At runtime in require, validate the generated filename after translation
of '::' to '/' (and possible conversion from VMS to Unix format) to keep
the code simpler.  Reject empty module names, module names starting with
'/' or '.'  (ie absolute paths, hidden files, and '..'), and module names
containing NUL bytes or '/.' (ie hidden files and '..').

Add a test for Perl_load_module(), and check that it now rejects module
names which fall foul of the above rules.

Most of these can't trigger for a sinple bareword require since the
illegal module name will already have been rejected during parsing. However,
the Perl_load_module() fakes up a rquire optree including a bareword
OP_CONST, which *isn't* restricted by the lexer.

Note that this doesn't apply to non-bareword pathnames: these are both
unaffected:

    require "/foo/bar.pm";
    $x =  "/foo/bar.pm"; require $x;

[ This is cherry-picked from a branch Nicholas wrote 4 years ago, but
which was never merged. I've kept the body of the diff the same, modulo
rebasing, but re-worded the commit title and message.
Only one test was changed: the final one in load-module.t, since a
\0 in a pathname is now trapped earlier and gives a "can't locate" error
instead. For the same reason, it also required the addition of
"no warnings 'syscalls';".
- DAPM ]

Treat require ::foo::bar; the same as  foo::bar;

[ This is cherry-picked from a branch Nicholas wrote 4 years ago, but
which was never merged. In the meantime it was agreed that 'require
::foo' should die instead of doing 'require foo'; but I've pulled it in
anyway as an interim commit, to make later cherry-picks easier. The die
will come in a later commit.
]

reindent S_require_version()

Whitespace-only change.

Split the guts of pp_require into two static fns

S_require_version() and S_require_file() do the 'require 5.010001'
and 'require Foo::Bar' actions respectively.

This makes it clear that pp_require is effectively 2 disjoint functions,
and that all the local variables previously declared at the start of
pp_require actually belong exclusively to the file loading functionality.

This is based on a patch by Nicholas from 4 years ago, except that
I did the split from scratch since pp_require has been touched quite a
bit since then.

This commit splits it in such a way that the diff is kept as small as
possible. The next commit will re-indent.

fix #128109 - do not move RExC_open_parens[0] in reginsert

In d5a00e4af6b155495be31a35728b8fef8e671ebe I merged GOSUB and GOSTART,
part of which involved making RExC_open_parens[0] refer to the start of
the pattern, and RExC_close_parens[0] referring to the end of the pattern.

This tripped up in reginsert in a subtle way, the start of the pattern
cannot and should not move in reginsert(). Unlike a paren that might
be at the start of the pattern which should move when something is inserted
in front of it, the start is a fixed point and should never move.

This patches fixes this up, and adds an assert to check that reginsert()
is not called once study_chunk() starts, as reginsert() does not adjust
RExC_recurse.

This was noticed by hv while debugging [perl #128085], thanks hugo!

fix #128085 - SIGSEGV in S_regmatch with S_study_chunk: Assertion "!frame" failed.

The goto target should have been before the if (frame) block.

Clearly this code is not well tested in our test suite. This patch
does NOT include tests.

(perl #127923) add blacklists/whitelists to Locale::Maketext

(perl #127923) note priority between the white and blacklist

(perl #127923) pass porting tests

- update MANIFEST, AUTHORS
- bump $Locale::Maketext::VERSION

Add blacklist and whitelist support to Locale::Maketext.

Format string attacks against Locale::Maketext have been discovered in
several popular web applications and addresed by pre-filtering maketext
strings before they are fed into the maketext() method. It is now
possible to restrict the allowed bracked notation methods directly in
Maketext.

This commit also introduces a default blacklist that prevents using the
object and class methods in the Locale::Maketext namespace that were not
intended as bracked notation methods.

perldelta for e71f25b35412

I'm not sure that's in the right section, but I think it's a better
fit than the others I considered.

fix make test failures in -Accflags=-DPERL_TRACE_OPS

builds with -DPERL_TRACE_OPS currently fail make test, on ~124 files,
for both normal & -DDEBUGGING, and plain & threaded configs.  These
tests fail because they check STDERR content, and reject the extra
output issued by perl_destruct() in these builds.  It turns out that
"Trace of all OPs executed:" by itself is enough to cause the failures.

The easiest fix is to silence -DPERL_TRACE_OPS printing by default,
and enable it if $ENV{PERL_TRACE_OPS} > 0.  Due to various aspects of
the design, this is also the best fix.

 - OP-counting is only done in runops_debug(). runops_standard()
   avoids all counting overhead, so the only 'cost' then is the extra
   space in the interpreter structure.

 - use of runops_debug() vs runops_standard() varies at build, with -DDEBUGGING,
   and can be changed at runtime, with -MDevel::Peek -e 'BEGIN{runops_debug(0 or 1)}'

 - when runops_standard is used, perl_destruct() reports ALL-0s
   OP-exec-counts.  This is wrong, silence is better.

 - when runops_* is toggled, OP-counts will only reflect part of the work done.

Given the flexibilty of use, perl_destruct() cannot really know the
counts are good, and shouldnt just spew them to STDERR.  With this
patch, the user asks for the output at runtime.

 - with patch, the build is not noisy, more usable, no stderr to deal with.
   miniperl is also silent, reducing `make` output too.

 - via simple XS, data can be read, cleared, at any compilation phase.
   with this, data to stderr is just a convienience, not "the way" to get data.
   Ive got Devel::TraceOps on-deck.

I also took the liberty of suppressing "<optype>: 0" prints entirely.

 - no real info provided (0 count is inferrable by silence)
 - 0 is usually wrong, unless other OP-counts (from same interp) are non-0
 - `make test` on a non-debug threaded build emits 5 million of them

And now './perl -e 'print "foo\n"' becomes readably small:
foo
Trace of all OPs executed:
  pushmark: 1
  gvsv: 1
  nextstate: 1
  enter: 1
  leave: 1
  print: 1

NOTES:

Since the PERL_TRACE_OPs counting overhead is runtime selectable, it
seemed useful to measure and report it:

 function run_trace_overhead() {
    for i in seq 1 2; do
perf stat -r5 -- ./perl -Ilib -MDevel::Peek -e 'BEGIN{runops_debug(0)}' -e 'for (1..9_999_999){$i++}'
perf stat -r5 -- ./perl -Ilib -MDevel::Peek -e 'BEGIN{runops_debug(1)}' -e 'for (1..9_999_999){$i++}'
    done 2>&1 | grep -E 'Performance|instructions'
 }

bench.pl couldnt do this, not without different --perlargs per contestant.

[jimc@popeye perl]$ run_trace_overhead
 Performance counter stats for './perl -MDevel::Peek -e BEGIN{runops_debug(0)} -e for (1..9_999_999){$i++}' (5 runs):
     3,460,280,502      instructions              #    1.57  insns per cycle          (25.01%)
 Performance counter stats for './perl -MDevel::Peek -e BEGIN{runops_debug(1)} -e for (1..9_999_999){$i++}' (5 runs):
     3,857,253,945      instructions              #    2.00  insns per cycle          (25.07%)
 Performance counter stats for './perl -MDevel::Peek -e BEGIN{runops_debug(0)} -e for (1..9_999_999){$i++}' (5 runs):
     3,437,504,999      instructions              #    1.57  insns per cycle          (25.07%)
 Performance counter stats for './perl -MDevel::Peek -e BEGIN{runops_debug(1)} -e for (1..9_999_999){$i++}' (5 runs):
     3,859,640,318      instructions              #    2.00  insns per cycle          (25.09%)

IE: when swapping runops_debug for runops_standard, the instruction
count predictably goes up: by 3.8/3.4 = 1.12 in these results.
Subject to many caveats, this is a reasonable estimate of the
worst-case cost overhead of OP-counting.

NB: the insns per cycle above are garbage, on this older 32bit box.
but the instruction counts look plausible (I didnt look at the
assembly code), and the per-cycle numbers are sane on a 64bit cpu
(with a newer PMU).

perldelta for 23695c073f41

Fix the Configure escape with usecrosscompile but no targethost

Commit 97076f2 added a graceful exit to Configure when targethost is
not defined but usecrosscompile is. However, this is not reached because
there is a similar check a bit earlier that makes Configure bail out.

Make the earlier check warn instead of croaking.

The use case for this combination is supplying an external config.sh
suitable for the target platform, avoiding the need for configuration
probes.

Update to IPC-SysV 2.07 from CPAN

No functional changes (the customized 2.06_01 already had them).

Fix test failure in lib/perl5db.t when mandoc is installed

locale.c, sv.c: Add, fix some comments

And a couple empty lines

locale.c: Some nano-optimizations

Reorder two branches so the most likely is tested before the much less
likely, and add some UNLIKELY()

locale.c: Clarify a debugging statement

POSIX.pod: Add some caveats about strcoll(), strxfrm()

Finish mathomizing Perl_instr.

fea1d2dd5d210564d4 turned instr into a macro.  It also left the
actual function in util.c while commenting out the prototype
in proto.h (via the m flag in embed.fnc).

A function compiled without a prototype under C++ does not get
declared with extern "C" and thus gets mangled, which breaks the
build with a strict linker (VMS, possibly AIX) because the
expected symbol name is no longer produced.  Without a strict
linker, it just breaks the binary compatibility that was presumably
the nominal reason for leaving the function around in the first
place.

So move the function into mathoms.c and put its prototype in the
extern "C"-guarded section at the top of the same file.

We also have to fake the PERL_ARGS_ASSERT_INSTR macro since its
original declaration in proto.h is commented out but the porting
test t/porting/args_assert.t will take revenge if it doesn't
find the macro being used somewhere.

Reinstate "Make instr() a macro"

This reverts commit 2e08dfb2b133af0fbcb4346f8d096ca68454ca54, thus
reinstating the commit it reverted.   This was delayed until 5.25.  The
next commit will solve some problems with c++ that this commit causes

Require literal '{' in patterns to be escaped

This has been deprecated since v5.16, with a deprecation message
displayed starting in v5.22.

ext/B/t/OptreeCheck.pm: Escape literal pattern '{'

The deprecated warnings were getting suppressed, but literal '{' in
patterns needs to be escaped.

Make deprecated qr//xx fatal

This has been deprecated since v5.22

Remove deprecated literal control char variable names

These were deprecated in v5.20

toke.c: Fix comment

Stop accepting deprecated NBSP in \N{}

As scheduled for 5.26, this construct will no longer be accepted.

mktables: Don't destroy a data structure too soon.

It can happen that one table depends on another table for its
contents.  This adds a crude mechanism to prevent the depended-upon
table from being destroyed prematurely.  So far this has only shown up
during debugging, but it could have happened generally.

mktables: Add info under -annotate option

This adds some helpful text when this option is used, which is for examining the Unicode database in great detail

mktables: Add stack trace facility

This can be used for debugging.

Call PERL_ASYNC_CHECK when we backtrack in the regex engine

[perl #127877] Emit undef warning on sassign+concat

Code like this:

    my $x;
    $x .= 'a';

is specifically exempted from "use of uninitialized value" warnings,
according to the "Declarations" section of perlsyn, to allow the idiom of
building up a value piecemeal. The same is true of the += and -= operators.
However, breaking the combined assignment up into the underlying operator
and a simple assignment, as in this code:

    my $x;
    $x = $x . 'a';

*should* produce a warning.

That warning was correctly being emitted for addition and subtraction, but
concatenation was behaving as the ".=" case, because "$x = $x . EXPR" is
optimized to the equivalent of "$x .= EXPR".

So we now explicitly detect this case, and emit the desired warning.