mg_vtable.pl: Mention all generated files
silence compiler warning - casting void* to IV

This warns when void* and IV have different sizes
There is already a macro to do this conversion cleanly: PTR2IV
silence warning about use of --libpods

--lipods warns, and I don't think it is needed in this test,
so I have removed it
mro/basic.t: Squelch warning
silence override warning

The test is trying to test the behaviour being warned about,
so the code is right but the warning can be suppressed.
[perl #113020] INSTALL: Clarify CPAN::autobundle
[perl #113470] Constant folding for pack

This takes the pessimistic approach of skipping it for any first argu-
ment that is not a plain non-magical PV, just in case there is a 'p'
or 'P' in the stringified form.

Otherwise it scans the PV for 'p' or 'P' and skips the folding if either
is present.

Then it falls through to the usual op-filtering logic.

I nearly made ‘pack;’ crash, so I added a test to bproto.t.
[perl #113576] Restore err msg for &{+undef}

This ‘Can't use an undefined value as a subroutine reference’ message
used to occur for &{+undef}, until commit 15ff848f77796 in 1997.

Then it started happening only for magic variables.

Non-magical variables would treat it the same as "", possibly dying
with ‘Undefined subroutine main:: called’, and possibly calling the
subroutine with that name.

Magical variables (&{$tied_undef}) started behaving the same way
(treating undef as "") with commit 7c75014e, in 2010.

This commit restores that message.
fix RT#114068 optimizer handles MEOL in middle of pattern improperly

It seems that under certain circumstances the optimiser handles the
MEOL operator (what $ turns into under /m), improperly including
things that follow. This results in compilation like this:

    Compiling REx "( [^z] $ [^z]+ )"
    Final program:
        1: OPEN1 (3)
        3:   ANYOF[\x00-y{-\xff][{unicode}0100-INFINITY] (14)
       14:   MEOL (15)
       15:   PLUS (27)
       16:     ANYOF[\x00-y{-\xff][{unicode}0100-INFINITY] (0)
       27: CLOSE1 (29)
       29: END (0)
    anchored ""$ at 2 stclass ANYOF[\x00-y{-\xff][{unicode}0100-INFINITY]

Where the '""$ at 2' is sign of the bug. The problem is that the optimiser
does not "commit" the string when it encounters an MEOL, which means that
text that follows it is included. This has probably always been wrong as
$ is a multichar pattern (it matches before an \n or including an \n). This
failure to commit then interacts with the implementation for PLUS leading to
an incorrect offset. By adding a SCAN_COMMIT() as part of the optimisers
handling of EOL constructs this problem is avoided. Note that most uses of
$ were ok due to other reasons.
[perl #113710] Make __SUB__ work in sort block

When the peephole optimiser encounters a __SUB__, it looks to see
whether the current sub is clonable.  If it is not, it inlines the
__SUB__ as a const op.

This works most of the time.  A forward declaration will cause the sub
definition to reuse the existing stub.  When that happens, the sub
visible during compilation in PL_compcv is not the sub that the
op tree will finally be attached to.  But the peephole optimiser
is called after that, with PL_compcv set to the other CV (what
was a stub).

ck_sort was calling the peephole optimiser on the sort block ahead of
time.  So this caused __SUB__ to point to the wrong subroutine.

By removing the CALL_PEEP call from ck_sort and adding logic to the
peephole optimiser itself to traverse the sort block (it is not in the
usual op_next chain), this bug is eliminated.

I modified the DEFER macro to work as a single statement.  You don’t
want to know how much time I spent debugging the bus errors that were
occurring because if(foo) DEFER; didn’t do what I though.

It turns out that grepstart and mapstart, which also use ck_sort,
had their blocks go through the peephole optimiser twice, because
grepwhile already has special-casing in the peephole optimiser.

This also has the side-effect of making map and grep slightly more
efficient, in that they no longer execute a scope op (which is just
pp_null).  By temporarily disconnecting the subtree before running the
optimiser, ck_sort was hiding a possible optimisation (skipping the
scope op).
Disentangle ck_sort and grep

Originally, sort and grep/map used the same code for handling the
block’s ops.

But that didn’t quite work, so exceptions were added over time.  Now
the thing is a complex sprawling mess.  By folding the grep-specific
code into ck_grep, things are greatly simplified.
op.c: Missing line break
Update perlop's bignum modules list.

Removed some out-of-date modules and add Math::GMPq, Math::GMPz and
Math:GMPf.
op.c: Consistent tweak; podchecker complaints
Upgrade Socket to 2.002
op.c: Further simplify ck_sort

This code currently chases op_next pointers in the sort block to make
sure there is none that can point outside.  To avoid getting stuck in
loops, it has to check for those explicitly.

Instead of nulling out any op_next pointer that points to the leave
op, we can simply turn the leave into a null op (which we already do)
and have the leave op’s op_next pointer point to nothing.

That produces the same result in the end:  Execution of the sort block
is prevented from running rampant and escaping out of it, but exits
the runloop instead, returning control to pp_sort.
Simplify ck_grep

Back in perl 5.000, ck_grep would call ck_sort (which was still the
case until 354dd559d99 just recently) and the latter would traverse
its way through the op_next pointers to find an op that tried to
escape the block, setting its op_next pointer to null.  Then ck_grep
would traverse op_next pointers itself to find the place where ck_sort
stopped.  That caused problems for grep which were fixed in 748a93069b
(perl 5.001).  It was fixed by setting op_next to 0 on the first op,
so that the loop in ck_grep would not do anything.  But that loop was
left there.  This commit removes it.

There are also a couple of things I missed when disentangling
ck_grep and ck_sort in commit /354dd559d9.  I accidentally put
if (o->op_flags & OPf_STACKED) inside if (o->op_flags & OPf_STACKED).
And the OPf_SPECIAL flag was only being set for sort’s use, so ck_grep
doesn’t need to copy that.
pp_hot.c: Mention that pp_grepstart calls pp_pushmark
op.c: ck_grep does not need to check num of args

It calls ck_fun first, which does the same check, so it is
unnecessary.
op.c:ck_grep: Remove unnecessary op_next assignments

ck_grep is a tangled mess and I am trying to simplify it, but at each
step it is not at all obvious what is happening.

grep/map with a block starts out like this:

    grepstart
      pushmark
      null
        scope/leave
          block contents...
      arg1
      arg2
      ...

The if (o->op_flags & OPf_STACKED) at the top of ck_grep runs for
blocks.  The firstkid var refers to the null above, and gets its
op_next set (this code was in ck_sort until recently [ck_grep used to
call ck_sort], and this particular op_next assignment was specific to
grep and map).

Later, the thing is fed through ck_fun, whose OA_CVREF case transforms
the tree into this:

    grepstart
      pushmark
      null             ← new op
        null           ← original null
          scope/leave
            block contents...
      arg1
      arg2
      ...

Then cUNOPx(cLISTOP->op_first->op_sibling)->op_first gets its op_next
set.  By that point, that expression refers to the original null op,
so setting its op_next pointer to begin with seems pointless.

But it is not actually pointless.  Removing that statement breaks
things.  It turns out, as usual, that everything is more complicated
than it seems.  Setting kid->op_next = (OP*)gwop in the block-specific
if statement after setting the first null op’s op_next pointer results
in op_next pointers like this (the newly-created grepwhile doesn’t
link to the grepstart yet at this point):

  [grepwhile]
    grepstart
      pushmark
      null              -> block contents
        scope/leave     -> grepwhile
          block contents...
      arg1
      arg2
      ...

So ck_fun’s OA_CVREF handling, when it calls LINKLIST, sees that the
original null op already has its op_next set and does nothing.  With-
out it set, it copies it from the first kid, resulting in this (when
LINKLIST copies the op_next pointer out, it makes the kid it was cop-
ied from point to its sibling or its parent):

  [grepwhile]
    grepstart
      pushmark
      null
        null              -> grepwhile
          scope/leave     -> null (prev line)
            block contents...
      arg1
      arg2
      ...

That nonsensical arrangement of op_next pointers basically prevents
the block from running, because the grepwhile’s other pointer, copied
from the first null’s kid, ends up pointing to the grepwhile itself.

If we also remove the kid->op_next = (OP*)gwop assignment from the
if(OPf_STACKED) block, then we end up with this after ck_fun:

  [grepwhile]
    grepstart
      pushmark
      null
        null              -> first op in block
          scope/leave     -> null (prev line)
            block contents...
      arg1
      arg2
      ...

Then the op_next poiner from the first null’s kid is copied to
grepwhile’s op_other pointer, and everything works.

This also means we can remove the now-redundant LINKLIST call from the
if(OPfSTACKED) block, since ck_fun’s OA_CVREF handling also does that.
So now every vestige of the original call to ck_sort is gone.

This also means we no longer have to repeat NewOp(1101, gwop...).