Fix diagnostic.pm’s backtraces

Currently a user-defined error message is printed out like this:

-----
Uncaught exception from user code:
panick:  at -e line 1.
 at -e line 1
main::baz() called at -e line 1
main::bar() called at -e line 1
main::foo() called at -e line 1
-----

Errors generated from perl itself are printed like this:

-----
panic:  at -e line 1 (#1)
    (P) An internal error.

Uncaught exception from user code:
panic:  at -e line 1.
 at -e line 1
main::baz() called at -e line 1
main::bar() called at -e line 1
main::foo() called at -e line 1
-----

By using Carp::confess(), we end up with a screwy backtrace.  Some-
times it just ends up repeating the error and line number:

-----
panic:  at -e line 1 (#1)
    (P) An internal error.

Uncaught exception from user code:
panic:  at -e line 1.
 at -e line 1
-----
Uncaught exception from user code:
panick at -e line 1.
 at -e line 1
-----

This commit cleans these up to print like this:

-----
Uncaught exception from user code:
panick:  at -e line 1.
main::baz() called at -e line 1
main::bar() called at -e line 1
main::foo() called at -e line 1
-----
panic:  at -e line 1 (#1)
    (P) An internal error.

Uncaught exception from user code:
panic:  at -e line 1.
main::baz() called at -e line 1
main::bar() called at -e line 1
main::foo() called at -e line 1
-----
panic:  at -e line 1 (#1)
    (P) An internal error.

Uncaught exception from user code:
panic:  at -e line 1.
-----
Uncaught exception from user code:
panick at -e line 1.
-----

You might ask:  Why not remove the ‘uncaught exception’ message alto-
gether after an error description.  It’s because the error description
is a diagnostic, which only prints once for each error or warning
encountered.  So you could have eval { die } somewhere else in the
code, which causes a description to be printed.  And later you have a
die() that exits the program, but nothing gets printed.

In other words, the description of the message does not replace
the error.

Consistent use of spaces after dots in diagnostics.pm

Increase $diagnostics::VERSION to 1.27

Convert diagnostics.t to test.pl

so that runperl is available

Fix two (er, four) sub:lvalue { &$x } bugs

The lvalue context that the last statement of an lvalue subroutine
provides, when applied to entersub, causes the ops below the entersub
to be complied oddly.  Compare regular subs and lvalue subs:

$ ./perl -Ilib -MO=Concise,bar,foo -e 'sub bar { &$x } sub foo:lvalue { &$x }'
main::bar:
5  <1> leavesub[1 ref] K/REFC,1 ->(end)
-     <@> lineseq KP ->5
1        <;> nextstate(main 1 -e:1) v ->2
4        <1> entersub[t2] K/TARG ->5
-           <1> ex-list K ->4
2              <0> pushmark s ->3
-              <1> ex-rv2cv vK ->-
-                 <1> ex-rv2sv sK/1 ->-
3                    <#> gvsv[*x] s ->4
main::foo:
b  <1> leavesublv[1 ref] K/REFC,1 ->(end)
-     <@> lineseq KP ->b
6        <;> nextstate(main 2 -e:1) v ->7
a        <1> entersub[t2] K/LVINTRO,TARG,INARGS ->b
-           <1> ex-list K ->a
7              <0> pushmark s ->8
9              <1> rv2cv vK/NO() ->a
-                 <1> ex-rv2sv sK/1 ->9
8                    <#> gvsv[*x] s ->9
-e syntax OK

Notice that, in the second case, the rv2cv is not being optimised
away.  Under strict mode, this allows a sub call on a string, since
rv2cv is not subject to strict refs.

It’s this code in op.c:op_lvalue_flags that is to blame:

if (kid->op_type != OP_GV) {
    /* Restore RV2CV to check lvalueness */
  restore_2cv:
    if (kid->op_next && kid->op_next != kid) { /* Happens? */
okid->op_next = kid->op_next;
kid->op_next = okid;
    }
    else
okid->op_next = NULL;
    okid->op_type = OP_RV2CV;
    okid->op_targ = 0;
    okid->op_ppaddr = PL_ppaddr[OP_RV2CV];
    okid->op_private |= OPpLVAL_INTRO;
    okid->op_private &= ~1;
    break;
}

This code is a little strange.  Using rv2cv to check lvalueness causes
the problem with strict refs.  The lvalue check could just as well go
in entersub.

The way this is currently written (and this is something I missed when
supposedly fixing lvalue subs), the rv2cv op will reject a non-lvalue
subroutine even when the caller is not called in lvalue context.

So we actually have two bugs.

Presumably the check was done in rv2cv to keep entersub fast.  But the
code I quoted above is only part of it.  There is also a special block
to create an rv2cv op anew to deal with method calls.

This commit fixes both issues by moving the run-time lvalueness check
to entersub.  I put it after PUSHSUB for speed in the most common
case (when there is no error).  PUSHSUB already calls a function
(was_lvalue_sub) to determine whether the current sub call is happen-
ing in lvalue context.  So the check I am adding after it only has to
check a couple of flags, instead of calling was_lvalue_sub itself.

This also fixes a bug I introduced earlier in the 5.15.x series.  This
is supposed to die (in fact, I made the mistake earlier of changing
tests that were checking for this, but so many tests were wrong back
then it was an easy mistake to make):

$ ./perl -Ilib -e 'sub bar {$x} sub foo:lvalue { bar}; foo=3'

And a fourth bug I discovered when writing tests:

sub AUTOLOAD :lvalue { warn autoloading; $x }
sub _102486 { warn "called" }
&{'_102486'} = 72;
warn $x
__END__
autoloading at - line 1.
72 at - line 4.

And it happens even if there is an lvalue sub defined under that name:

sub AUTOLOAD :lvalue { warn autoloading; $x }
sub _102486 :lvalue { warn "called" }
&{'_102486'} = 72;
warn $x
__END__
autoloading at - line 1.
72 at - line 4.

Since the sub cannot be seen at compile time, the lvalue check in
rv2cv, as mentioned above.  The autoloading is happening in rv2cv,
too, instead of entersub (the code is repeated), but the sub is not
checked for definition first.  It was put in rv2cv because it had to
come before the lvalue check.  Putting the latter in entersub lets us
delete that repeated autoload code, which is completely wrong anyway.

perldiag: Remove msg deleted in 5.8.0

Skip failing DD tests under 5.6

Fix DD’s vstring tests unter 5.6

Make DD dump *{''} correctly under 5.6

5.6 is strangely buggy, in that *{""} stringifies as "*main::\0".  And
then there are some other strange eval bugs that the tests have to
work around.

perldiag: Make 2 errors match the actual message

Make DD dump *{''} properly

This typeglob is an oddity, in that it stringifies as *main::,
but cannot be reached under that name, because *main:: produces
*main::main::.  The former is $::{""}; the latter $::{"main::"}.

I was inadvertently triggering this in 5.8 when I added a test a while
back for typeglobs will nulls in their names.

Update concise-xs.t for recent DD change

[perl #101162] DD support for vstrings

This commit adds support for vstrings to Data::Dumper, in both Perl
and XS implementations.

Since the actual vstring cannot be obtained from pure Perl, there is a
new _vstring XS function that the PP implementation uses, falling back
to sprintf "%vd" if XS is not available.  The former dumps v1.2_3 cor-
rectly, while the latter produces v1.23.  (I could make it use B to
extract the correct string, but XS is likely to be unavailable in
those circumstances where B is also unavailable [i.e., miniperl], so
it didn’t seem worth the effort.)

Some Perl versions (read: *all* released versions as of this message)
let vstring magic linger too long on strings that have been modified.
So that is checked for, but the bug is probed at compile time and the
code is #ifdeffed or use-constanted out when the bug is not present.

Due to the definition of the _bad_vsmg constant, I had to move
XSLoader::load into the BEGIN block.  Since I was putting it there,
I combined it, the $Useperl = 1 and the eval{} into one statement,
for speed.

Since I was putting XSLoader::load into a BEGIN block, $VERSION needed
to be in one, too.

Increase $Data::Dumper::VERSION to 2.135_02

Supress warning in XS::APItest’s hash.t

sv.c:dirp_dup: Avoid compiler warning

Some compilers complain, because -1 is being assigned to an unsigned
variable.  This variable is not actually used before being assigned
to, but we have to initialise it as some other compilers cannot
detect that.

diag.t: Remove documented entry

It was only listed here because originally the perldiag entry had
nonexistent spelt correctly, while the perl source had it hyphenated.
That was corrected a while ago.

[perl #99426] op.c: Remove dead code from ck_sort

The op that the else block (see the diff) is trying to null is already
a null.  So this else block can be deleted.

The null I’m referring to is

$ perl -MO=Concise -e 'sort $fo @fo'
8  <@> leave[1 ref] vKP/REFC ->(end)
1     <0> enter ->2
2     <;> nextstate(main 1 -e:1) v:{ ->3
7     <@> sort vKS ->8
3        <0> pushmark s ->4
-        <1> null K/1 ->5                  <-- over here.
-           <1> ex-rv2sv sK/1 ->-
4              <#> gvsv[*fo] s ->5
6        <1> rv2av[t3] lK/1 ->7
5           <#> gv[*fo] s ->6
-e syntax OK

Document ‘Attempt to clear deleted array’ in perldiag

Add diag_listed_as for non-numeric warnings

PerlIO::get_layers: Treat numbers as strings

PerlIO::get_layers should not be ignoring an argument like 12, but
treating "12" (the string) as a filehandle, as those are both the
same value.

It’s an instance of the string/num bug, which is a bit like the
Unicode Bug.

This commit takes the conservative approach of expanding it to flat
scalars in general, but not references (in case we decide to do
something interesting later on, even though I think that would be a
bad idea).

[perl #97956] PerlIO::get_layers: call get-magic

Run more substr tests under a new thread

Yours truly added tests to substr.t outside of sub run_tests.

select() can return undef when defoutgv is set

If PL_defoutgv has been deleted from its stash, select() returns it
as a ref, but if the stash has been freed (even though the gv still
exists), it returns undef.

That makes no sense.

This is one of those nice cases where simplifying the code
fixes a bug.

select() sometimes returns invalid string

The return value from select() is sometimes a string, and sometimes a
globref.  It was originally always a string, but typeglobs not to be
found under their names in their stashes started being returned as
references in 5.002 beta 1 (4633a7c4b).  The logic is a little faulty,
though, as sometimes the name that is returned cannot be used to find
the glob:

$ perl -le '
    open "foo::bar", ">/dev/ttys009";
    select foo::bar;
    my $handle = \*foo::bar;
    my $stash = \%foo::bar;
    *foo:: = *bar::;
    print "hello";
    select select;
    print "hello" or warn $!
'
Bad file descriptor at -e line 9.

In this example, /dev/ttys009 is another terminal window.  "hello"
only appears once, not twice.

Add basic tests for select()

[perl #86060] $( $| $) need braces in regexps

feature.pl: Get HINT_UNI_8_BIT from perl.h

Since feature.pm is now a generated file, there is no reason to hard-
code constants from perl.h into it.  We can get them from perl.h auto-
matically.

coresubs.t: Call done_testing with an arg

coreamp.t: Call done_testing with an arg

deparse.t: Automatically count __DATA__ tests

I didn’t know that done_testing could take an argument.  This elimi-
nates the manual fiddling of the test count every time a test is added
to __DATA__.  For other tests, which are the exception, we still have
the safety of a test count to make sure the tests actually run.

Deparse the /d flag with implicit features

Before the recent feature revamp (2fc860ee1e0), loading the
unicode_strings feature would always set the feature_unicode %^H ele-
ment, even though the core did not actually use it.  Now it is some-
times not set.  So we have to check the hint bits as well.  Since
feature.pm has it hardcoded, load feature.pm to get the right bit.

The stuff with $feature_bundle_mask is redundant, but it avoids load-
ing feature.pm unnecessarily.

Deparse /$#a/ correctly

This is related to 4b58603b60.

This time it’s this op tree that pure_string can’t handle:

8     </> match() vK/RTIME ->9
7        <|> regcomp(other->8) sK/1 ->8
3           <1> regcreset sK/1 ->4
6              <1> av2arylen sK/1 ->7
5                 <1> rv2av[t2] sKR/1 ->6
4                    <#> gv[*a] s ->5

In writing a test for this, I triggered a case that 415d4c68d missed
(only $a and $b are exempt from strict vars, not @a and @b), so that
is fixed in the same commit.

Don’t warn for open(foo::bar)

Deparse.pm: Document that strict vars and subs work

Port regen/regen_lib.pl to 5.6.2

Since the regen scripts use the system perl, I thought I might as
well test regen/feature.pl with 5.6.2, the earliest I have installed.
It failed.

[perl #24027] Deparse strict vars and subs

B::Deparse only supported strict refs till now, and not the other two.
The hints were always present, but were being ignored.  It was more
complicated than simply printing out the pragma settings.  Variables
have to be qualified, too, under strict vars.

Fix Deparse ambient_pragmas/strict regression

This commit fixes a regression introduced by b50b2058.
ambient_pragmas makes changes to %^H, which affect the currently com-
piling scope.

    BEGIN {
new B'Deparse -> ambient_pragmas strict => 'all';
    }
    use 5.012;
    # no strict here

B::Deparse really does know too much about perl’s internals.  It is
calling strict.pm’s internal routines, which now set %^H, so Deparse
has to localise it.

Since it is very easy to write tests in evals that simply do not run
(I actually did that when trying to test this, and was puzzled as to
why everything was passing anyway), I have restored the test count.
Sorry, Nicholas.

Don’t crash when writing to null hash elem

It’s possible for XS code to create hash entries with null values.
pp_helem and pp_slice were not taking that into account.  In fact,
the core produces such hash entries, but they are rarely visible from
Perl.  It’s good to check for them anyway.

hv.c: Make newHVhv work on tied hashes

*Now* increase $XS::APItest::VERSION to 0.35

without touching anything else.

Deparse.pm: Document that use feature is supported

Deparse all features with ‘use/no feature’

[Merge] Feature-loading revamp

Features can now be loaded by version declarations without feature.pm
having to be loaded.

feature.pm is now a generated file.  feature.h is a new file with mac-
ros to make this work.  regen/feature.pl is a new script to generate
those two files.

A few hint bits are used to represent the current feature bundle.  If
the ‘custom’ bundle is active, this means that the hint hash is used,
as before.

There is no longer any need for ‘negative’ features--those whose
entries in %^H turn them off.  The only feature in that category was a
default feature.  Now we use the default bundle in PL_hints, which is
indicated by 0 (see feature.h), so we don’t even have to set it.

feature.pm, when it sees bundle hints active, updates %^H to match
and then sets the current bundle to ‘custom’, before enabling or disa-
bling features.

rmg: feature.pl needs to be run

Deparse implicit with ‘use feature’

When a version declaration has been seen, it’s not possible to deparse
the code perfectly correctly, but using ‘no feature; use feature
"5.14"’ is a reasonable tradeoff.  See also commit 1c74777c25.

This necessitated sorting %^H keys that are output to keep tests pass-
ing.  Previously they were relying on phases of the moon.

Deparse CORE::say, etc., when bundle hints are in use

use VERSION needs to enable uni8bit hint

Update rmg concerning feature bundles

The data are now to be modified in regen/feature.pl, rather than
lib/feature.pm.

Update perlfunc/use: feature.pm is not loaded

feature.pl: Make the perl.h search more resilient

In case #define is changed to # define some day.  (Not likely, but
this will make things easier for future maintainers.)

feature.pl: Mention perl.h as a source

toke.c: Add assertion to feature_is_enabled

This should now only be called by macros in feature.h when PL_hints
indicates that %^H is where the features are.

Make MAX_FEATURE_LEN reflect reality

unicode_strings was not the longest string.  We can determine it auto-
matically, now that this macro is in a generated file.

feature.h: FEATURE_IS_ENABLED can use CURRENT_HINTS

feature.pl: Remove unused var

Fix up t/lib/feature/implicit

Some tests were relying on the side effect of ‘use 5.9.5’ loading
feature.pm.

feature.pm: Move hint normalisation to separate function

PL_hints/$^H can hold feature bundle hints that cause %^H to be
ignored when features are looked up.

When feature->import and ->unimport are invoked, they set bits in $^H
such that %^H is used once more.  But they have to modify %^H to con-
tain what the bits in $^H imply.

Up till now, unimport was delegating to import, which meant that more
work was being done than necessary, because import would then detect
the special condition of $^H and repeat (some of) that work.

op.c: Use new feature bundle hints

Now ‘use v5.22’ and ‘use 5.005’ no longer have to load feature.pm
to enable the current feature bundle.  All they do is twiddle bits
in PL_hints.

Since version declarations no longer call feature->unimport, there
may be junk left over in %^H (which we leave for speed’s sake), so
feature.pm has to delete that junk before enabling features.

feature.h: Function for enabling bundles

Move FEATURE_IS_ENABLED to feature.h

It makes little sense to have it in perl.h any more.  (Until
recently, feature.h didn’t exist.)

toke.c: include feature.h

It’s going to need it in the next commit.

Eliminate ‘negative’ features

Now that we have hints in $^H to indicate the default feature bun-
dle, there is no need for entries in %^H that turn features off by
their presence.

feature.pl: Tweak comment

so that people as crazy as I won’t try to add internal
names like ~~_--~!_.

feature.h: Avoid compiler warning

unsigned >= 0 produces a warning, even if the 0 is actually a macro.

Use new feature-testing macros

Instead of using FEATURE_IS_ENABLED("say"), etc., now use
FEATURE_SAY_IS_ENABLED instead.  These new macros, in feature.h, also
check feature bundle hints in PL_hints, so we can start using those
hints.  Two commits ago, feature.pm started setting them.

Exclude regen/feature.pl from podcheck.t

feature.pm: Set bundle hints when dis/enabling features

The core does not use these hints just yet, but feature.pm can start
setting them.

Currently, the hint bits for feature bundles (CURRENT_FEATURE_BUNDLE
in feature.h) are equal to FEATURE_BUNDLE_DEFAULT (0) by default.
feature.pm sets them to FEATURE_BUNDLE_CUSTOM when modifying
hint settings.

feature.pm: Add function for getting the current bundle

This is for when we switch over to using hints in $^H for feature bun-
dles.  When $bundle_number == $hint_mask, it means that the hints in
%^H apply.

feature.pl: Use @HintedBundles for generating feature.h

This variable, added in the previous commit for feature.pm’s sake,
also makes generating constants in feature.h simpler.

Give feature.pm the bundle hints

It’s going to need them, in order to determine which list of features
is currently enabled.

feature.pl: Generate list of feature bundles in pod

feature.pl: Add section headers

This commit adds comments that give this file some semblance of
structure.

feature.pl: Move hint-checking code up

This puts it with the other code that generates ‘global’ variables
used by generation code.

Add macros for checking individual features

feature.pl: %BundleRanges

This hash will be used by subsequent commits to generate macros for
checking individual features.

regen.t: update test count

feature.h: Add macros for current hints

CURRENT_HINTS is not specific to features, but for now will be used by
nothing else.  It returns the compile-time or run-time hints, depend-
ing on whether PL_curcop points to &PL_compiling.

CURRENT_FEATURE_BUNDLE extracts the feature bundle number from the
current hints.

feature.h: Parenthesise macro definition

Make feature.pl executable

Use only \w+ for internal feature names

This will make it possible to create macros for each.

feature.pl: Remove the feature_ prefix from the data

It’s not necessary to repeat it, as we can simply add it to feature.pm
when we generate it.

Removing it makes these data usable for feature.h, too.

feature.pl: Gen %feature_bundle from %UniqueBundles

%UniqueBundles was added for generating constants in feature.h, but
we can use it for feature.pm’s %feature_bundle as well, simplify-
ing the code.

This eliminates this piece of code in feature.pm, spelling it
out longhand:

# Each of these is the same as the previous bundle
for (12,13,14,16) {
    $feature_bundle{"5.$_"} = $feature_bundle{"5.".($_-1)}
}

While that code might be neat, it would make the generation code
unduly complex.  (It was designed for hand-editing anyway.)

Add lib/feature.pm to makerel’s writables

Add feature.h, with constants for feature bundles

Parse the feature hint bits & assert their usability

Set aside hint bits for feature bundles

Create regen/feature.pl

This script generates lib/feature.pm.  Soon it will be made to gener-
ate other files, too.

Increase $feature::VERSION to 1.25

Eliminate a couple more suidperl and sperl references.

Remove a superfluous C<LD_LIBRARY_PATH=`pwd`> - make test does this
automatically.

Merge the refactoring of Pod scanning code in installman and buildtoc.

Some tidying in installman.

Avoid the unnecessary lexicals $xnew and $xold.
Use lexicals for file handles, and check the return of close.
Why import mkpath() from File::Path and then comment its provenance at the
point of use?
Remove an exit(0) which is only 20 lines from the end of the script.
Note why we can't re-use a file handle open on the Pod file we're currently
processing.

Add x2p/a2p.pod to the 'master' array returned by get_pod_metadata().

This makes installman install it correctly. Flagging it as 'toc_omit' means
that everything else ignores it. This eliminates the last remaining use of the
"pod =" feature of utils.lst, permitting related code to be removed from
installperl and installman.

This change has the possibly unfortunate cosmetic side effect of installman
now installing a2p.1 first, before perl.1

Avoid installman warning about "no documentation in pod/perldoc.pod"

Since commit a2afbef4476f724a in July 2011 moved perldoc.pod from pod/ to
dist/Pod-Perldoc/lib/ installman will have been warning
"no documentation in pod/perldoc.pod", having already installed the perldoc
man page earlier in the process.

However, the reference in utils.lst has actually been arguably erroneous
since it was added in commit cd0cddc9814dd65e (July 2003) to stop installman
installing an empty perldoc.1 manpage. (Which it had been doing since commit
1a67fee7d910c677 (December 2002), as a side effect of overwriting the
correct file (sourced from pod/perldoc.pod) with an incorrect file (sourced
from scanning utils/perldoc for Pod). The fix "worked" by causing perldoc.1
to be written correctly twice, both times sourced from pod/perldoc.pod :-)

The best fix seems to be to remember the names of the manpages we install
in man1, and automatically skip processing for any utility whose manpage
has already been installed.

In pods_to_install(), use $File::Find::prune to skip t/ directories.

We don't want to install anything within a t/ directory. Previously the code
was determining this based on pattern matching the path. Instead of rejecting
what we find, it's more efficient to avoid scanning the directory tree in the
first place.

Move the common Pod scanning code from installman and buildtoc to pod_lib.pl

The unified code to scan lib/ for Pod is now in pods_to_install().
It returns found Pods partitioned into 'MODULE' and 'PRAGMA', as buildtoc
needs this distinction. installman installs Pods in the same order as before,
as 'PRAGMA' sort lexically after 'MODULE'.

Refactor buildtoc's use of File::Find::find() to converge with installman's.

Refactor installman's use of File::Find::find() to converge with buildtoc's.

Revert "Increase $XS::APItest::VERSION to 0.35"

This reverts commit d54b00ad7f0e9db12ac11e897406b8888fd895bf.

I didn’t mean to push that yet, and it was more than a
version bump.

Increase $XS::APItest::VERSION to 0.35