op.c: Skip priv flags assert if ppaddr changes

because an XS module is probably installing its own ppaddr, in which
case it knows more about the private flags than we do.

speed up building with less disk IO pod moves+__END__+misc

In Cwd.pm, dont search for pwd on Win32.

Also trim down the list of makefile suffixes on Win32 so it doesn't try
searching for av.pas and perl.f90 and hash.cbl on disk.

Add __END__ tokens to stop the last read() call on the handle which
returns 0 bytes at EOF.

remove excess whitespace from warnings.pm

Some lines end with spaces, remove that, use tabs instead of spaces in code
so the perl code is less bytes to read from disk. This patch saved 183
bytes. Part of [perl #122955].

move POD in warnings.pm to end of file to reduce module load I/O calls

warnings.pm is the hottest file/takes the most read() calls of any
module during a make all. By moving POD to the end, ~40KB of OS read()
IO was reduced to ~16KB of OS read() IO calls. Also the parser doesn't need
to search for Perl code in the POD further lessining load time because of
the __END__ token. Filed as [perl #122955].

silence warning after "Fold join to const or stringify where possible"

VC 2003
op.c(4022) : warning C4244: '=' : conversion from 'unsigned short' to
'char', possible loss of data

[perl #122965] aelemfast in list assignment

I accidentally broke ($_[0],$_[1])=($_[1],$_[0]) in be9de18, which was
only supposed to be a refactoring.  Since it now happens later in the
compilation phase when optimisations like aelemfast have happened, the
search for common vars needs to take aelemfast into account.

perldelta for 73f4c4f

perldelta for 987c969

perldelta for afc8007

perldelta for split-to-array

4ecee20 op.c: Distangle split and common-vars
fd017c0 Optimise @lexarray = split...
ef7999f Optimise my(@array)=split
4574270 opt.t: Test split-to-array optimisation

perldelta for 821956c

perldelta for de183bb

perldelta for bcff414

perldelta for deparsing with CORE:: prefix

3188a82 Deparse with CORE:: to avoid lex sub conflicts
e54915d Deparse sub calls quietly
7741cee Finish deparsing ‘my sub if; CORE::if...’

perldelta for a21eb52

perldelta for 4c62787/#122771

perldelta for f8a7cce and 88a758b

perldelta for 2258401

perldelta for f351564 and 5f4d849

perldelta for c8ec376

perldelta for c997e36 and 6bd144e0f

perldelta for 157fb5a

perldelta for 1e9a122

perldelta for 8fb0127

Update perlguts for PADMY changes

perlguts typo

perldelta for PADMY changes

145bf8e Remove most uses of PADMY
a9f1090 Peek.t should not expect PADMY under 5.21.5
c068384 Stop setting PADMY; renumber PADSTALE

perldelta for ecf05a5

B: Document GPFLAGS

perldelta for 14d9114

perldelta for 926f5fc

perldelta for a623f8939

Tru64: S_mulexp10 overflow help.

infnan: if the mulexp10 value goes to zero, return it.

perldelta for e78728e52f52

Add support for Linux pipe buffer size fcntl commands

This lets us make t/io/eintr.t more reliable by making sure we're
actually writing more than the buffer size.

Test croaks inadvertently rmvd by bd2688c4c

Revert "op.c: Don’t keep looping when we see potential common vars"

This reverts commit bd2688c4c50527e5796ba4bc132c379f11e57112.

It seemed like an obvious optimisation, until it dawned on me that
this loop is doing two things, not just searching for common vars.

Optimise "@_" to a single join

instead of stringify(join(...)).

opt.t: Test split-to-array optimisation

perldiag: Fix typo

dump.c: Dump pmop patterns without trailing )

Use full name for Perl_tmps_grow_p in EXTEND_MORTAL

For functions only exported and not public, we can’t use the short
forms in pubic macros.

Test that my($self)=@_ uses no-common-vars optimisation

IIRC, this was broken in 5.10.0, but I don’t have a 5.10.0 around to
confirm (only 5.10.1).

Fold join to const or stringify where possible

Due to the exigencies of the implementation, "$_->$*" ends up with a
join op (join $", $$_), which is unnecessary.  This gave me the idea
of folding it where possible (instead of trying to tackle it in
toke.c), which would also make explicit joins benefit, too.

If the arguments are a simple scalar or constant followed by a
single-item list, then the join can become a stringify, and the sepa-
rator can simply disappear.

Further (and this is unrelated to "$_->$*"), if all of join’s argu-
ments are constant, the whole thing can be folded to a const op.

Optimise my(@array)=split

Even though we can’t optimise away the array op for my(@array),
local(@array), and @{foo()}, we can still optimise away the assign-
ment.  Just have split pop the array off the stack and Bob’s
your Uncle.

Optimise @lexarray = split...

‘@pkgary = split //, $foo’ gets optimised such that the split writes
directly to the array and the assignment doesn’t have to happen.

This commit makes it work also with lexical arrays.  It only works for
arrays declared previously; ‘my @a = split’ doesn’t get optimised,
just as ‘local @a = split’ doesn’t.

The pad offset is stored in the op_targ field of the pushre op, just
as the GV is stored in its op_pmreplrootu field.

perlref: Document lvalue slice refs

Something I missed.

Clarify two panic perldiag entries

pp.c:pp_split: Remove redundant !s

SvPV always returns something (or croaks), so s cannot be null here.

Fix ()=@a=split

@a=split//,$foo gets optimised such that split writes directly to
the array and the list assignment doesn’t happen.  In fact, the list
assignment is completetly removed from the op tree:

$ ./perl -Ilib -MO=Concise -e '@a=split//,$foo'
7  <@> leave[1 ref] vKP/REFC ->(end)
1     <0> enter ->2
2     <;> nextstate(main 1 -e:1) v:{ ->3
6     <@> split[t2] vK/IMPLIM ->7
3        </> pushre(/""/ => @a) s/RTIME ->4
-        <1> ex-rv2sv sK/1 ->5
4           <$> gvsv(*foo) s ->5
5        <$> const(IV 0) s ->6
-e syntax OK

(There would have been aassign where you see split if the optimisation
had not happened.)

($a,$b,$c) = split... optimises split by setting its limit argument
automatically so it doesn’t bother splitting into more parts than
necessary.

The latter optimisation was doing the wrong thing for () = @a = split,
because the @a=split on the rhs was being optimised down to a split
op.  Then the limit optimisation would see an empty (or short) list on
the lhs and a split op on the rhs and see it as a candidate for lim-
ited split.  So too few items would be assigned to the array.

We need to check whether the split on the rhs is a split-to-array
first before doing the limit optimisation.  (If it is, then don’t
optimise.)

This breaks one of my JAPHs:

()=@==split" ","Just another Perl hacker,\n";
print reverse@=

infnan: test overflows and underflows.

[Merge] Lvalue references

Also:
• Single refgen optimisation now applies to \@ \% \& as well.
• split-to-array no longer runs the risk of clobbering its argument
  and returning junk.
• The split-to-array optimisation happens more often than before.
• foreach my $x is no longer subject to the list-assignment-after-ali-
  asing bug (#89646).

Document lvalue references

Make Deparse.t more tolerant of our @F vs our(@F)

Currently B::Deparse deparses ‘our @F;’ as ‘our @F;’, but ‘our @F =...’
as ‘our(@F) = ...’, adding parentheses.  For split-to-array, it just
happens to omit the parentheses, because there is no list op for it
to process, and it is when processing a list op that it decides to put
them there.  While it could be changed to omit the parentheses for the
list or add them for split-to-array, for now just make the test more
tolerant, as this is just a cosmetic difference.

Extend lex alias detection to foreach, too

Now that I have added a mechanism for detecting lexical aliases in
list assignments, we can extend that to foreach, too, to fix another
instance of the list-assignment-after-aliasing bug.

Skip no-common-vars optimisation for lex aliases

op.c: Move common vars check into the peephole optimiser

Putting it this late in the compilation phase will facilitate checking
for lexical aliases, too.

Update B-Debug’s tests for split optimisation

This will have to be submitted upstream after this branch is merged.

op.c: Distangle split and common-vars

The split-to-array optimisation was being skipped if the assignment
referenced the same variable on both sides, or if it referenced @_
(since @_ aliases other vars).  This was to prevent split from freeing
its own argument when writing to the array.

As the previous commit shows, that didn’t actually work properly, and
so that commit used a different means to work around that problem.

So now there is no reason to skip the optimisation in such cases.

    @_ = split;
    @a = split //, $a[0];

now optimise away the assignment.

(This also allows me to move the common-vars check into the peep-
hole optimiser, where it needs to be to work correctly with lexi-
cal aliases.)

Make split temporarily refcnt its argument

In this example, the @a=split... is optimised so that split writes to
@a directly:

*a = *b;
$a[1] = "foobarbaz";
@a = split //, $b[1];
print "@a\n";

But since @a and @b are the same, $b[1] gets freed even before the
split occurs.  This just happens to work, because copy-on-write saves
the day, since the buffer is still valid, the "foobarbaz" constant
still holding on to it.

This modified example gives me junk:

*a = *b;
$a[1] = "foobarbaz";
$a[1] .= "";
@a = split //, $b[1];
print "@a\n";

The easiest solution is to make pp_split hold a temporary reference
count on the SV.

This will also allow the split optimisation to be disentangled from
the common-vars pessimisation (which fails here anyway).  And *that*
will allow the common-vars pessimisation to take lexical aliases
into account.

op.c:newASSIGNOP: Rmv LINKLIST call

Originally, aassign_common_vars used LINKLIST itself because it
was following op_next pointers.  That changed in 3023b5f30, so the
LINKLIST was moved outside that function.

The LINKLIST call could not simply have been deleted, because the
split optimisation that follows assumes that it has been called and
fixes up an op_next pointer.

If we remove the LINKLIST call *and* the op_next fix-up, then every-
thing works.  The op_next fix-up was only happening to begin with
because of LINKLIST.

op.c: Don’t keep looping when we see potential common vars

When we loop through the list in LIST=..., once we have decided that
we need to do the more thorough check for common vars we don’t reverse
that decision based on subsequent ops, so there is no point in con-
tinuing to loop through them.

lvref.t: Remove special TODO code

We no longer have a plethora of to-do tests, so this specialised code
no longer gains us anything.

Store internal state of state vars separately

Use a separate pad entry to record whether a state variable has been
initialised, instead of using a flag on the value.

This prevents \$state_var = \$some_other_var from interfering with
that internal state.  It probably also fixes some cases with foreach
as well, but I have not confirmed.

lvref.t: More list and cond tests

Deparse lvalue references

lvref.t: Remove temporary eval & skip

lvref.t: Fix hash elem tests

I was testing against a package hash for the ‘lexical’ tests.

Handle state vars correctly in ref assignment

Only \state(@_) was handling this correctly, as pp_lvavref
calls pp_padav.

lvref.t: Tests for \my assignment and scope exit

Rework lvref.t foreach tests

Remove the to-do marker.

Add tests for package vars, too.

Redo the \my &a test.  I’ve decided not to bother with the ‘my &a’
syntax for now (if at all).  It is problematic and needs discussion.
(If ‘my &a’ is allowed in foreach, then it should be allowed else-
where, but ‘my &a;’ would call a stub.)

Get foreach \&foo working

Previously these would crash.  Usually, &foo is wrapped in an entersub
op which gets converted to rv2cv when refgen applies lvalue context.
In foreach \&foo, there is no need for us to go the entersub route;
rather we pass the original rv2cv op directly to refgen without the
entersub wrapping.  So the resulting op tree is different.  S_lvref
was not expecting this alternate op tree.

foreach \$var

Some passing tests are still marked to-do.  We need more tests still.

Add OPpLVREF_ITER flag

An lvalue reference used as an iterator variable will be implemented
using an lvref op with this flag set.

Fix err message for $cond ? \bad : ... = ...

The error message code in S_lvref was assuming that it only handled
list assignment (which was originally the case), but

    $condition ? \pos : whatever = ...

goes through that same code path, and that is a scalar assignment.

So pass the assignment type through to S_lvref.

Subroutine reference assignment

lvref.t: Repeat bad ref tests with list assignment

List assignment goes through a different code path.  The errors come
from magic_setlvref in that case, not pp_refassign.

lvref.t: do-block err msg is no longer to-do

The previous commit’s rearrangement of things fixed this, too.

Make \( ?: ) assignment work

When I first implemented list assignment to lvalue references, I
thought I could simply modify the kids of the refgen op (\) in one
spot.  But things like ?: make it necessary to do this recursively.
So all that code for turning thingies into lvrefs has been moved into
a separate function patterned after op_lvalue but handling only the
lvref cases.

(I thought about combining it with op_lvalue’s switch statement, but
that would require ‘if(type == OP_LVREF) goto nomod;’ too many times,
which would be harder to maintain.)

lvref.t: Remove unnecessary evals

Get basic $cond ? \$a : \$b = ... working

When I started working on lvalue references, I envisioned having all
scalar assignments pass through pp_refassign.  A refassign op repre-
sents the initial backslash on the lhs *and* the equals sign.  For
cases like this, there is no single refgen on the lhs.  It turns out
that the approach I am using for list assignments (where the lhs
becomes an lvref op that returns a magic scalar that does the aliasing
when assigned to) is the easiest way to get this working, too.

All this commit has to do is allow ‘sassign’ lvalue context to apply
to srefgen and fix the completely broken to-do tests.  (I have a ten-
dency to write broken to-do tests, as I have no way of testing them at
the time.)

Assignment to \(@array)

This is a slurpy lvalue that gobbles up all the rhs elements, which
are expected to be references.  So \(@a)=\(@b) makes @a share the
same elements as @b.

We implement this by pushing a null on to the stack as a special
marker that pp_aassign will recognise.

I decided to change the wording for the \local(@a)=... error
slightly, from what my to-do tests had.

Some of the other to-do tests were badly written and had to be
fixed up a bit.

lvavref needs OPpLVAL_INTRO and OPpPAD_STATE

Add lvavref op type

This will be used for slurpy array ref assignments.  \(@a) = \(@b)
will make @a share the same elements as @b.

lvref is actually a baseop/unop

When used for pad vars, it is childless.

List assignment to array and hash refs

(\@a,\%h)=... works, but \(@a) and \(%h) do not.  \(%h) correctly
croaks.  (\local @a, \local %h)=... also works.

Renumber OPpLVREF_TYPE

to avoid conflicting with OPpPAD_STATE.

Assignment to \local @array and \local %hash

Doesn’t work with lhs parentheses yet.

lvref.t: Tests for localised arrays and hashes

lvref.t: Test assigning non-array to array

Same with hashes.

Simple \@array and \%hash assignment

Parentheses do not work yet.  Neither does local.

lvref.t: To-do tests for hashes

Concerning the error message tests, ‘parenthesized hash’ would be more
helpful than ‘hash dereference’ or ‘private hash’ (as would be provided
by OP_DESC), as %foo doesn’t look like a hash dereference and ‘private
hash’ suggests that \%foo= won’t work, whereas it will.

Add priv flags for the type of lvalue ref

lvref.t: To-do tests for array ref assignment

The evals are temporary.  Some of the tests don’t even make sense
with the evals; they are more placeholders and reminders for now
that tests.

pp.c: Fold SvIV into S_localise_aelem_lval

All three callers were doing SvIV, so we can do it in one spot.

pp.c: Some branch prediction hints

Assignment to hash element refs

pp.c: Consolidate some local aelem code

In the process, avoid a redundant av_fetch for \local$a[0]= and
\local($a[0])=.

pp.c:pp_lvrefslice: Unused var