UCD.pm: Convert num() to use new fcn

A new function that reads mktables files has been created.  Switch to
use this.

A test is added to make sure it's working right

UCD.pm: Add internal fcn for reading mktables file

Update Maintainers.pl and perldelta for Math::BigInt::FastCalc update

[perl #85118] [PATCH] Update Math::BigInt::FastCalc to CPAN version 0.28

Add Perl v5.6 compatibility code to FastCalc.xs (Closes RT #63859).

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

Point people to perlop for here doc errors

This makes this long warning slightly more useful:

    Can't find string terminator %s anywhere before EOF

Note here docs need a line separator after the last token

regex: Remove obsolete code

This code has been rendered obsolete in 5.14 by using a different
mechanism altogether.  This functionality is now provided at run-time,
user-selectable, via the /u and /d regex modifiers.  This code was
for compile-time selection of which to use.

fold_grind: Remove more tests under /d

This removes tests that cross the boundary between ascii and above latin1,
under /d, as they aren't testing different code than already tested under
/u

fold_grind.t: Reduce some tests.

/d executes different code form /u really only when there are things in the
latin1 range; so the successes/failures of it should match those of /u for
things outside that

fold_grind.t: Clarify comment

fold_grind.t: fix confusingly-named variable

regexec.c: remove no longer needed code

The code dealing with the sharp ss is now handled by the ANYOFV node,
and shouldn't appear here.

regcomp.c: white space only

A previous commit collapsed nested blocks.  This outdents the nested
part

regcomp.c: collapse two blocks

An earlier commit removed code so that these two blocks can be written
as one.

regcomp.c: Remove temporary code

This code was inserted to make sure no tests failed in the intermediate
commits leading up to d50a4f90cab527593b2dd218f71b66a6be555490, and
should have been removed in that commit, but I forgot to.

Update CPANPLUS to CPAN version 0.9102

  [DELTA]

  Changes for 0.9102      Mon Feb 28 11:35:43 2011
  ================================================
  * Only send NAs for a 'perl' prereq when it actually is
    Not Applicable

Update CPANPLUS::Dist::Build to CPAN version 0.54

  [DELTA]

  0.54 Mon Feb 28 11:52:04 GMT 2011
    - Only skip 'perl' as a prereq when CPANPLUS version is
      less than 0.9102

Convert the taint.t Fcntl tests to use tempfile(), instead of "foo".

tempfile() also automatically deletes all of its temporary files.

Fix a grammar nit in perlfaq8

Correct taint.t to skip the truncate test if $Config{d_truncate} is false.

Previously it had a comment, present since 5.003_92, that "There is no feature
test in $Config{} for truncate, so we allow for the possibility that it's
d missing."

This was never correct, as 5.000 had d_truncate, and taint.t had analogous
tests for $Config{d_chown} etc.

Corrected an incredibly small error in perlport.pod

Ignore ExtUtils::Command release tests

Upgrade Devel::DProf from version 20110225.01 to 20110228.00

Ignore DProf release tests

Upgrade ExtUtils::Command from version 1.16 to 1.17

Simplify the regression tests added in 3e6bd4bfcd175c61.

Unwind the innermost loop, used only for reporting, and remove the array @s,
only used to accumulate results for that loop. Fewer lines, less complexity,
better diagnostics, and with the same failure cases on 3e6bd4bfcd175c61^.

Handle [folds] of 0-255 without swashes

Commit 56ca34cada940c7f6aae9a59da266e541530041e had the side effect of
causing regular expressions with things like [a-z], or even just [k] to
go out to disk to read tables to create swashes because it knew that
some of those characters matched outside the bitmap (and due to
l1_char_class_tab.h it knew which ones had those matches), but it didn't
know what the characters were that participated in those folds.

This patch hard-codes the Unicode 6.0 rules into regcomp.c for the
code points 0-255, so that the very slow utf8_heavy is not invoked on
them.  (Code points above 255 will continue to invoke it.)  It would,
of course, be better if these rules could be regen'd into regcomp.c, as
there is a risk that the standard will change, and the code will not.
But I don't think that has ever happened; in other words, I think that
the rules haven't changed so far since Day 1 of Unicode.  (That would
not be the case if we were doing simple case folding, as the capital
sharp ss which folds to U+00DF was added later.)  And the Standard is
getting more stable in this area.  I believe one of their stability
policies now forbid them from adding something that simply folds to
one of the characters that already has a fold, such as M and m.
Ligatures are frowned on, and I doubt that new ones would be encoded,
so that leaves a new Unicode character that folds to a Latin-1 plus some
sort of mark.  For those, this code is a no-op, so those aren't a
problem either.

regcomp.c: Add deprecation macro with extra param

regcomp.c: More prep for bitmap/nonbitmap folds

This sets things up in preparation for a future commit that will
move calculating all folds involving characters in the bit map.

regcomp.c: Place marker for 2nd inversion list

The set_regclass_bit functions will be adding to a new inversion list.
This declares that list and passes it to them.

Change to use new add_cp_to_invlist()

regcomp.c: Add parameters to fcns

A pointer to the list of multi-char folds in an ANYOF node is now passed
to the routines that set the bit map.  This is in preparation for those
routines to add to the list

regcomp.c: Convert old-style to inversion list

The code that handles a false range in a [character class] hadn't been
converted to use inversion lists

regcomp.c: Add fcn add_cp_to_invlist()

This is just an inline shorthand when a single code point is all that is
needed.  A macro could have been used instead, but this just seemed nicer.

regcomp.c: Move code to common place

THis is part of the refactoring of the code that sets the alternate array
for multi-char folds.  Changing the node type to ANYOFV can be done at
the last second, in pass 2, as it doesn't change any sizing, etc.

regcomp.c: Factor code into a function.

A future commit uses this same code, so put it into a common place.

Add #defines for 2 Latin1 chars

These will be used in a future commit; the ordinals are different on
EBCDIC vs. ASCII

Move some #defines

These were defined in a .c, but now there is need for them in another .c,
so move them to a header.

regcomp.c: Remove no longer necessary tests

A previous commit changed add_range_to_invlist() to do the creation
that these lines did.

regcomp.c: accept NULL as inversion list param

Change the function add_range_to_invlist() to accept NULL as the
inversion list, in which case it creates it.  A common usage of this
function is to create the list if it doesn't exist before calling it, so
this just makes that code once.

Eliminate tests for tainting of globs, skipped since 1999.

Commit 72b166521443a1b8 changed perl to using File::Glob to implement the glob
builtin. Previously glob was implemented by spawning a csh, hence globbing was
not allowed on tainted values. The test for this was skipped, but never removed.

In gv_autoload4(), ensure set magic is called on $...::AUTOLOAD if necessary.

Without this, if $...::AUTOLOAD ever becomes tainted, it will never
subsequently become properly untainted. This fixes an omission in change
5d121f7f3e622b95.

Maintainers.pl and perldelta updates for Math::BigInt::FastCalc upgrade

Update Math::BigInt::FastCalc to CPAN version 0.25

# New Ticket Created by  (Peter J. Acklam)
# Please include the string:  [perl #84982]
# in the subject line of all future correspondence about this issue.
# <URL: http://rt.perl.org/rt3/Ticket/Display.html?id=84982 >

Remove _new() from XS code and use _new() in Math::BigInt::Calc
instead. The XS _new() doesn't handle integers that are too large to
be represented exactly as floating point numbers, but small enough
to be represented as 64 bit integers. E.g., even with 64 bit integer
support, applying _num() to 18446744073709551615 (= 2**64-1) gives
1.84467440737096e+19, not 18446744073709551615. The XS _new() also
returns nan, not inf, when it overflows. This closes RT #63335 and
RT #49569.

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

Added GNU/kFreeBSD to list of systems where 5.12.x builds

[perl #76814] FETCH called twice - ||

The || case in t/op/tie_fetch_count.t is not a bug, as there are two
separate operators operating on it in the test script. In

  $dummy = $x || $y

The || does mg_get($x). If it’s true it returns it and the = does
mg_get($x). If $x is false, then $y is returned, so magic is called
once on each of $x and $y. Similarly, && will seemingly call
mg_get($x) twice if $x is false.

If you just write:

  $x || $y

then magic is only called once on $x.

This patch corrects the test.

[perl #79442] A #line "F" in a string eval doesn't update *{"_<F"}

There are two problems here.

String evals do not populate @{"_<..."} arrays the way parsed streams
do. The lines are all put into the array before the parse. Commit
e66cf94 added the code to copy (actually alias, but whatever) the
lines into the new array when a #line directive is encountered. Inte-
restingly, the following commit (8a5ee59) wrapped that code in an
#ifndef USE_ITHREADS block, because ‘[c]hange 25409 [e66cf94] wasn’t
necessary for threaded perls’. It seems it *was* necessary for
threaded perls after all, because the lines are simply not copied.

In non-threaded perls it wasn’t working properly either. The array
in the new glob was the same array as the old (aliased), so the line
numbers would be off if the #line directive contained a line number
that differed.

This commit does three things:
• It removes the #ifndef,
• It checks whether the line number has changed and aliases the indi-
  vidual elements of the array.
• The breakpoints hash is not copied if the line number differs, as
  setting a breakpoint on (eval 1):1 (warn 1) in
    eval qq{warn 1;\n#line 1 "foo"\nwarn 2;}
  should not also set a breakpoint on foo:1 (warn 2).

regexec.c: Array declared 1 too small

The bounds of this array were being exceeded causing smoke failures on
netbsd

Modern cygwin often has empty $ENV{CYGWIN}

Fixes Use of uninitialized value $ENV{"CYGWIN"} in concatenation (.) or string
at /usr/lib/perl5/5.13.10/i686-cygwin/Config_heavy.pl line 54

Stop aelemfast from crashing on GVs with null AVs

As reported at nntp://nntp.perl.org/1298599236.4753.72.camel@p100 (and
respaced for readability):

#!perl5.12.0
$r=q/
      print __FILE__;
      local *dbline = $main::{"_<".__FILE__};
      print $dbline[0]
/;
eval $r;'
__END__
(eval 1)
Bus error

This only seems to happen in non-threaded perls.

It can be reduced to this:

*d = *a;  print $d[0];

The $d[0] is optimised into an aelemfast op (instead of the usual aelem
with an rv2av kid). pp_aelemfast is at fault, as evidenced by the fact
that this does not crash (the ${\...} prevents the optimisation):

*d = *a;  print $d[${\0}];

pp_aelemfast uses GvAV instead of GvAVn. Usually $d[0] will autovivify
@d, but the glob assignment leaves $d[0] pointing to a glob (*d) with
no array. Then pp_alemfast passes a null pointer around.

Don't include commit IDs in generated delta entries

We don't usually reference git commits anymore in perldelta, so let's stop
git-deltatool from generating entries like that.

Hack to allow git-deltatool to spawn 'emacsclient -t'

My $EDITOR is 'emacsclient -t'. system('emacsclient -t', 'more', 'args') won't
do the right thing.

Allow reviewing of diffs in the deltatool

The pager code is mostly stolen from Prophet::CLI.

Reword perltie/READLINE and correct example

[perl #84942] perltie.pod READLINE list context

In perltie.pod the handle READLINE says

    The method should return undef when there is no more data.

which made me think that's what it should always do, and didn't need to
pay attention to wantarray().

If I'm not mistaken in list context READLINE should return empty list
for no more data.  It'd be good if the docs noted that, and perhaps
cross referenced to perlfunc for the gory details of what readline
should do.

Maybe something like the following, unless someone can think of a better
contrivance for the sample.

Add Kevin Ryde to AUTHORS

[perl #84746] Accessing $2 causes the interpreter to crash

Actually, it doesn’t. The original test case was:

#!/usr/bin/perl

my $rx = qr'\$ (?| {(.+?)} | (.+?); | (.+?)(\s) )'x;
my $test = '/home/$USERNAME ';
die unless $test =~ $rx;
print "1: $1\n";
print "2: $2\n" if defined $2;

This crashes even if I put an ‘exit’ right after the pattern match.

What’s happening is that regcomp miscounts the number of capturing
parenthesis pairs (cf. [perl #59734]), so the execution of the regular
expression causes a buffer overflow which overwrites the op_sibling
field of the regcreset op, causing a crash when the op is freed. (The
exact failure may differ between builds, platforms, etc., of course.)

S_reg in regcomp.c keeps a count of the parenthesised groups in a
(?|...) construct, which it updates after each branch, if that branch
has more captures than any previous branch. But it was not updating
the count after the last branch.

So this bug would occur if the last branch had more capturing paren-
theses than any previous branch.

Commit ee91d26, which fixed bug #59734, only solved the problem when
there was just one branch (by updating the count before the loop that
deals with subsequent branches was entered).

This commit changes the code at the end of S_reg to take into account
that RExC_npar (the current paren count) might have been increased by
the last branch.

Since the loop to deal with subsequent branches resets the count
*before* each branch, the code that commit ee91d26 added is no longer
necessary, so this commit removes it.

bleadperl breaks RCLAMP/Text-Glob

This was from commit f424400810b6af341e96230836690da51c37b812
which came from needing a bit in an already-full flags field,
and my faulty analysis that two bits could be shared.  I found another
mechanism to free up another bit, and now can separate these shared
bits again.

Free up bit in ANYOF flags

This is the foundation for fixing the regression RT #82610.  My analysis
was wrong that two bits could be shared, at least not without further
work.  This changes to use a different mechanism to pass needed
information to regexec.c so that another bit can be freed up and, in a
later commit, the two bits can become unshared again.

The bit that is freed up is ANYOF_UTF8, which basically said there is
something that is matched outside the ANYOF bitmap, and requires the
target string to be in utf8.  This changes things so the existence of
something besides the bitmap indicates this, and so no flag is needed.
The flag bit ANYOF_NONBITMAP_NON_UTF8 remains to indicate that there is
something that should be matched outside the bitmap even if the target
string isn't in utf8.

regcomp.c: ANYOF node handle range to UV_MAX

regcomp.c: Move inversion list conversion code

This just moves the code to later in the subroutine, in preparation for future commits

regcomp.c: Use more precise ANYOF flag

As the comment above the changed line says, \p doesn't have to match only
utf8, but it sets the flag that is two bits, meaning UTF8.  Set just the
one flag.

regcomp.c: Add comment

Upgrade Tie::RefHash from version 1.38 to 1.39

Upgrade Devel::DProf to version 20110225.01

We needed another upload to fix a PAUSE indexing problem.

DProf is now maintained on CPAN, not by p5p anymore

Remove DProf's Changes file

From now on all changes will go through CPAN first and the Changes file is being
maintained there. No need to keep it around in the core.

Remove DProf's Makefile.PL

make_ext.pl can generate it for us.

Maintainers.pl and perldelta updates for Math::BigInt update

Update Math::BigInt to CPAN version 1.993

# New Ticket Created by  (Peter J. Acklam)
# Please include the string:  [perl #84844]
# in the subject line of all future correspondence about this issue.
# <URL: http://rt.perl.org/rt3/Ticket/Display.html?id=84844 >

Change default backend library from Math::BigInt::FastCalc to
Math::BigInt::Calc, which is included in the Math-BigInt distro.
This avoids recursive distribution dependency (RT #65976).

Eliminate $::PatchId from t/re/*.t.

It was only being used in four places across two files, to add perforce
revision numbers to test descriptions. Replace this with the git commit hash
in the tests' descriptions.

Remove now-unnecessary C<use File::Spec> from t/op/inccode.t

This has been vestigial since 1c25d394345c1b97 converted it to using test.pl's
tempfile().

Migrate t/op/{fork,runlevel,tie}.t to use run_multiple_progs().

The addition of "OPTION random" to all fork.t's tests might be overkill, given
that run_multiple_progs() can specify "random" per test, but as the previous
code in fork.t always sorted before comparison, we are no *worse* off than we
were.

Migrate the test running logic from t/lib/common.pl to t/test/pl

This will make it available to several tests in t/op, which currently duplicate
it.

Convert t/lib/common.pl to lexical filehandles and 3-arg open.

Remove the unused lexical variable %tempfiles. It would be good to lint
everything - I suspect that there are quite a few unused lexicals stowing away
in the core tests.

In t/lib/common.pl, load File::Path on demand.

This will facilitate a subsequent refactoring.

fold_grind.t: Skip some /aa tests.

This skips some tests that aren't likely to provide new information,
where both elements being compared are ASCII.

fold_grind.t: Skip some ASCII-only tests in /l

This is to cut down somewhat on the number of tests. These are not
likely to add new information to other tests.

fold_grind.t: Add comment

fold_grind.t: White space only

A previous commit introduced a block, but didn't increase the indent
within it to avoid confusion.

fold_grind.t: Run every charset on non-folds

fold_grind: fix comment

regcomp.h: Remove obsolete define

intrpvar.h: Add comment about PERLVARI

Detect unsafe signals more reliably on BSD/Solaris

Previous versions of the Posix spec allowed the struct siginfo_t*
parameter passed to the signal handler to be NULL in certain cases. More
recent Posix specifications (SUSv3) have rescinded this: Now this
parameter is required always to be non-NULL. However we use this
parameter to differentiate between safe and unsafe signals, as in the
former it will always be NULL and in the latter case it should have been
non-NULL.

This patch fixes this issue by also relying on the ucontext_t*
parameter.  This should reliably be non-NULL when using unsafe signals
handlers.

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

In t/lib/common.pl, inline print_err_line into its only caller.

In t/lib/common.pl, inline RandomMatch() into its only caller.

speedup t/porting/authors.t

This reduces it from 7.5s to 2.5s on my debugging build.
This works by doing a minimal parse on the output of git log
that just grabs the Author: field.

speed up t/porting/filenames.t

This reduces it from about 5 seconds to <1 second on my debugging
build.

Chiefly by avoiding expensive test functions for every component of
every MANIFEST filename.

In test.pl, change _fresh_perl* to avoid using closures.

Whilst closures are definitely a more elegant general solution, the intent of
the initial testing code is to avoid as many "complex" features as possible,
in case they aren't working as intended.

Further consolidate static logical name routines in vms/vms.c

sys_trnlnm was a copy-and-paste clone of simple_trnlnm and
sys_crelnm was never used, so nuke them.

lib/locale.t: big speedup

This fix reduces the time for this test script on my debugging build
from 45 seconds to 6 seconds.

Basically, the structure of the main loop for test 117 now looks like:

    foreach my $x (keys %UPPER) {
        push @f, $x if (... something bad about $x...)
    }
    foreach my $x (keys %lower) {
        push @f, $x if (... something bad about $x...)
    }
    ok(!@f);

Whereas before it looked like:

    foreach my $x (keys %UPPER) {
        push @f, $x if (... something bad about $x...)
        foreach my $x (keys %lower) {
            push @f, $x if (... something bad about $x...)
        }
    }
    ok(!@f);

i.e. the %lower tests were inadvertently repeated many times

t/re/fold_grind.t: slight speed up

Hoist a 'next' up a few levels from the innnermost loop, where its
condition is invariant. This shaves a few seconds off the execution time.

t/re/fold_grind.t: tidy up a bit

The previous commit unwrapped an eval; now that the eval's removed,
the code can be tidied up a bit. No functional changes, but it strips
a further few seconds off the execution time.

make  t/re/fold_grind.t even faster

This is currently the slowest test in the suite. On my debugging build,
it takes 3 minutes. This commit reduces it to 1.5 minutes.

This is done by removing the eval in the innermost loop and just
executing the bits it would do directly.

make  t/re/fold_grind.t faster

This is currently the slowest test in the suite. On my debugging build,
it takes 4 minutes. This commit reduces it to 3 minutes.

This is done by removing the second layer of eval: The tests are
constructed as strings to be evaled, but were then wrapped in a second
eval to handle TODO etc. This second eval turned out to be unnecessary.

Move the tests that blow away %ENV to the end of t/op/magic.t

If %ENV is cleared, some platforms can't spawn new processes, which prevents
the use of fresh_perl_*().

No need to sort {non_,}bincompat_options in Config, as they are always sorted.

t/porting/bincompat.t tests that they are in order, so no need to sort them.

Test that perl.c reports {non_,}bincompat_options in sorted order.

Whilst the actual order doesn't matter semantically, ensuring that they are
always in a sorted order means that string comparison can be used to validate
that two sets of options are identical. This will be useful in the near future
for improved load-time extension compatibility checking.

Update Test-Simple to CPAN version 0.98

  [DELTA]

  0.98  Wed, 23 Feb 2011 14:38:02 +1100
    Bug Fixes
    * subtest() should not fail if $? is non-zero. (Aaron Crane)

    Docs
    * The behavior of is() and undef has been documented. (Pedro Melo)