This is a live mirror of the Perl 5 development currently hosted at
7 years agoRevert "op.c: Don’t keep looping when we see potential common vars"
Father Chrysostomos [Sun, 12 Oct 2014 18:22:49 +0000 (11:22 -0700)]
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.

7 years agoOptimise "@_" to a single join
Father Chrysostomos [Sun, 12 Oct 2014 15:10:41 +0000 (08:10 -0700)]
Optimise "@_" to a single join

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

7 years agoopt.t: Test split-to-array optimisation
Father Chrysostomos [Sun, 12 Oct 2014 13:58:11 +0000 (06:58 -0700)]
opt.t: Test split-to-array optimisation

7 years agoperldiag: Fix typo
Karl Williamson [Sun, 12 Oct 2014 15:53:24 +0000 (09:53 -0600)]
perldiag: Fix typo

7 years agodump.c: Dump pmop patterns without trailing )
Father Chrysostomos [Sun, 12 Oct 2014 13:48:08 +0000 (06:48 -0700)]
dump.c: Dump pmop patterns without trailing )

7 years agoUse full name for Perl_tmps_grow_p in EXTEND_MORTAL
Father Chrysostomos [Sun, 12 Oct 2014 13:36:31 +0000 (06:36 -0700)]
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.

7 years agoTest that my($self)=@_ uses no-common-vars optimisation
Father Chrysostomos [Sat, 11 Oct 2014 17:40:52 +0000 (10:40 -0700)]
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).

7 years agoFold join to const or stringify where possible
Father Chrysostomos [Sat, 11 Oct 2014 08:21:12 +0000 (01:21 -0700)]
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.

7 years agoOptimise my(@array)=split
Father Chrysostomos [Sun, 12 Oct 2014 07:20:26 +0000 (00:20 -0700)]
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.

7 years agoOptimise @lexarray = split...
Father Chrysostomos [Sun, 12 Oct 2014 06:33:40 +0000 (23:33 -0700)]
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.

7 years agoperlref: Document lvalue slice refs
Father Chrysostomos [Sun, 12 Oct 2014 06:24:00 +0000 (23:24 -0700)]
perlref: Document lvalue slice refs

Something I missed.

7 years agoClarify two panic perldiag entries
Father Chrysostomos [Sun, 12 Oct 2014 06:22:24 +0000 (23:22 -0700)]
Clarify two panic perldiag entries

7 years agopp.c:pp_split: Remove redundant !s
Father Chrysostomos [Sun, 12 Oct 2014 06:17:43 +0000 (23:17 -0700)]
pp.c:pp_split: Remove redundant !s

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

7 years agoFix ()=@a=split
Father Chrysostomos [Sun, 12 Oct 2014 00:17:32 +0000 (17:17 -0700)]
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

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

This breaks one of my JAPHs:

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

7 years agoinfnan: test overflows and underflows.
Jarkko Hietaniemi [Thu, 9 Oct 2014 21:35:32 +0000 (23:35 +0200)]
infnan: test overflows and underflows.

7 years ago[Merge] Lvalue references
Father Chrysostomos [Sat, 11 Oct 2014 17:24:33 +0000 (10:24 -0700)]
[Merge] Lvalue references

• 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).

7 years agoDocument lvalue references
Father Chrysostomos [Sat, 11 Oct 2014 07:00:55 +0000 (00:00 -0700)]
Document lvalue references

7 years agoMake Deparse.t more tolerant of our @F vs our(@F)
Father Chrysostomos [Sat, 11 Oct 2014 05:16:38 +0000 (22:16 -0700)]
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.

7 years agoExtend lex alias detection to foreach, too
Father Chrysostomos [Sat, 11 Oct 2014 04:52:37 +0000 (21:52 -0700)]
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.

7 years agoSkip no-common-vars optimisation for lex aliases
Father Chrysostomos [Sat, 11 Oct 2014 04:48:48 +0000 (21:48 -0700)]
Skip no-common-vars optimisation for lex aliases

7 years agoop.c: Move common vars check into the peephole optimiser
Father Chrysostomos [Fri, 10 Oct 2014 23:44:58 +0000 (16:44 -0700)]
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.

7 years agoUpdate B-Debug’s tests for split optimisation
Father Chrysostomos [Fri, 10 Oct 2014 23:37:00 +0000 (16:37 -0700)]
Update B-Debug’s tests for split optimisation

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

7 years agoop.c: Distangle split and common-vars
Father Chrysostomos [Fri, 10 Oct 2014 15:45:29 +0000 (08:45 -0700)]
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.)

7 years agoMake split temporarily refcnt its argument
Father Chrysostomos [Fri, 10 Oct 2014 15:39:49 +0000 (08:39 -0700)]
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.

7 years agoop.c:newASSIGNOP: Rmv LINKLIST call
Father Chrysostomos [Fri, 10 Oct 2014 05:05:15 +0000 (22:05 -0700)]
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.

7 years agoop.c: Don’t keep looping when we see potential common vars
Father Chrysostomos [Fri, 10 Oct 2014 04:54:12 +0000 (21:54 -0700)]
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.

7 years agolvref.t: Remove special TODO code
Father Chrysostomos [Thu, 9 Oct 2014 22:53:53 +0000 (15:53 -0700)]
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.

7 years agoStore internal state of state vars separately
Father Chrysostomos [Thu, 9 Oct 2014 22:51:18 +0000 (15:51 -0700)]
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.

7 years agolvref.t: More list and cond tests
Father Chrysostomos [Thu, 9 Oct 2014 21:07:35 +0000 (14:07 -0700)]
lvref.t: More list and cond tests

7 years agoDeparse lvalue references
Father Chrysostomos [Tue, 7 Oct 2014 05:12:27 +0000 (22:12 -0700)]
Deparse lvalue references

7 years agolvref.t: Remove temporary eval & skip
Father Chrysostomos [Sat, 4 Oct 2014 13:35:29 +0000 (06:35 -0700)]
lvref.t: Remove temporary eval & skip

7 years agolvref.t: Fix hash elem tests
Father Chrysostomos [Sat, 4 Oct 2014 13:31:11 +0000 (06:31 -0700)]
lvref.t: Fix hash elem tests

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

7 years agoHandle state vars correctly in ref assignment
Father Chrysostomos [Sat, 4 Oct 2014 02:50:45 +0000 (19:50 -0700)]
Handle state vars correctly in ref assignment

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

7 years agolvref.t: Tests for \my assignment and scope exit
Father Chrysostomos [Fri, 3 Oct 2014 23:33:55 +0000 (16:33 -0700)]
lvref.t: Tests for \my assignment and scope exit

7 years agoRework lvref.t foreach tests
Father Chrysostomos [Fri, 3 Oct 2014 19:40:23 +0000 (12:40 -0700)]
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.)

7 years agoGet foreach \&foo working
Father Chrysostomos [Fri, 3 Oct 2014 19:29:35 +0000 (12:29 -0700)]
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.

7 years agoforeach \$var
Father Chrysostomos [Fri, 3 Oct 2014 05:38:27 +0000 (22:38 -0700)]
foreach \$var

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

7 years agoAdd OPpLVREF_ITER flag
Father Chrysostomos [Fri, 3 Oct 2014 04:49:28 +0000 (21:49 -0700)]

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

7 years agoFix err message for $cond ? \bad : ... = ...
Father Chrysostomos [Thu, 2 Oct 2014 03:18:06 +0000 (20:18 -0700)]
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.

7 years agoSubroutine reference assignment
Father Chrysostomos [Thu, 2 Oct 2014 03:00:10 +0000 (20:00 -0700)]
Subroutine reference assignment

7 years agolvref.t: Repeat bad ref tests with list assignment
Father Chrysostomos [Thu, 2 Oct 2014 01:15:16 +0000 (18:15 -0700)]
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.

7 years agolvref.t: do-block err msg is no longer to-do
Father Chrysostomos [Wed, 1 Oct 2014 05:28:48 +0000 (22:28 -0700)]
lvref.t: do-block err msg is no longer to-do

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

7 years agoMake \( ?: ) assignment work
Father Chrysostomos [Wed, 1 Oct 2014 05:20:56 +0000 (22:20 -0700)]
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.)

7 years agolvref.t: Remove unnecessary evals
Father Chrysostomos [Tue, 30 Sep 2014 17:28:32 +0000 (10:28 -0700)]
lvref.t: Remove unnecessary evals

7 years agoGet basic $cond ? \$a : \$b = ... working
Father Chrysostomos [Tue, 30 Sep 2014 17:27:34 +0000 (10:27 -0700)]
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.)

7 years agoAssignment to \(@array)
Father Chrysostomos [Tue, 30 Sep 2014 05:21:21 +0000 (22:21 -0700)]
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.

7 years agolvavref needs OPpLVAL_INTRO and OPpPAD_STATE
Father Chrysostomos [Tue, 30 Sep 2014 05:23:22 +0000 (22:23 -0700)]
lvavref needs OPpLVAL_INTRO and OPpPAD_STATE

7 years agoAdd lvavref op type
Father Chrysostomos [Tue, 30 Sep 2014 04:43:53 +0000 (21:43 -0700)]
Add lvavref op type

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

7 years agolvref is actually a baseop/unop
Father Chrysostomos [Tue, 30 Sep 2014 04:40:28 +0000 (21:40 -0700)]
lvref is actually a baseop/unop

When used for pad vars, it is childless.

7 years agoList assignment to array and hash refs
Father Chrysostomos [Tue, 30 Sep 2014 01:03:57 +0000 (18:03 -0700)]
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.

7 years agoRenumber OPpLVREF_TYPE
Father Chrysostomos [Mon, 29 Sep 2014 22:48:24 +0000 (15:48 -0700)]

to avoid conflicting with OPpPAD_STATE.

7 years agoAssignment to \local @array and \local %hash
Father Chrysostomos [Mon, 29 Sep 2014 05:17:27 +0000 (22:17 -0700)]
Assignment to \local @array and \local %hash

Doesn’t work with lhs parentheses yet.

7 years agolvref.t: Tests for localised arrays and hashes
Father Chrysostomos [Sun, 28 Sep 2014 18:45:57 +0000 (11:45 -0700)]
lvref.t: Tests for localised arrays and hashes

7 years agolvref.t: Test assigning non-array to array
Father Chrysostomos [Sun, 28 Sep 2014 07:53:19 +0000 (00:53 -0700)]
lvref.t: Test assigning non-array to array

Same with hashes.

7 years agoSimple \@array and \%hash assignment
Father Chrysostomos [Sun, 28 Sep 2014 07:52:45 +0000 (00:52 -0700)]
Simple \@array and \%hash assignment

Parentheses do not work yet.  Neither does local.

7 years agolvref.t: To-do tests for hashes
Father Chrysostomos [Sun, 28 Sep 2014 07:42:09 +0000 (00:42 -0700)]
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.

7 years agoAdd priv flags for the type of lvalue ref
Father Chrysostomos [Sun, 28 Sep 2014 05:03:25 +0000 (22:03 -0700)]
Add priv flags for the type of lvalue ref

7 years agolvref.t: To-do tests for array ref assignment
Father Chrysostomos [Sun, 28 Sep 2014 01:44:57 +0000 (18:44 -0700)]
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.

7 years agopp.c: Fold SvIV into S_localise_aelem_lval
Father Chrysostomos [Sat, 27 Sep 2014 21:17:09 +0000 (14:17 -0700)]
pp.c: Fold SvIV into S_localise_aelem_lval

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

7 years agopp.c: Some branch prediction hints
Father Chrysostomos [Sat, 27 Sep 2014 21:15:50 +0000 (14:15 -0700)]
pp.c: Some branch prediction hints

7 years agoAssignment to hash element refs
Father Chrysostomos [Sat, 27 Sep 2014 21:15:00 +0000 (14:15 -0700)]
Assignment to hash element refs

7 years agopp.c: Consolidate some local aelem code
Father Chrysostomos [Sat, 27 Sep 2014 18:07:35 +0000 (11:07 -0700)]
pp.c: Consolidate some local aelem code

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

7 years agopp.c:pp_lvrefslice: Unused var
Father Chrysostomos [Sat, 27 Sep 2014 17:49:46 +0000 (10:49 -0700)]
pp.c:pp_lvrefslice: Unused var

7 years ago\local $a[$ix] assignment
Father Chrysostomos [Sat, 27 Sep 2014 17:49:24 +0000 (10:49 -0700)]
\local $a[$ix] assignment

7 years ago\@array[@slice] assignment
Father Chrysostomos [Fri, 26 Sep 2014 17:40:19 +0000 (10:40 -0700)]
\@array[@slice] assignment

plus changes to the aelem tests to check rhs context.

I did \local @a[@s] at the same time, since I was practically copying
and pasting code from aslice (ok, not quite).

7 years agopp.c: Dodge compiler warning
Father Chrysostomos [Fri, 26 Sep 2014 05:13:33 +0000 (22:13 -0700)]
pp.c: Dodge compiler warning

7 years agolvrefslice gets OPpLVAL_INTRO
Father Chrysostomos [Fri, 26 Sep 2014 05:10:39 +0000 (22:10 -0700)]
lvrefslice gets OPpLVAL_INTRO

7 years agoAdd lvrefslice op type
Father Chrysostomos [Fri, 26 Sep 2014 05:08:15 +0000 (22:08 -0700)]
Add lvrefslice op type

7 years agoAssignment to array elem refs
Father Chrysostomos [Fri, 26 Sep 2014 03:34:11 +0000 (20:34 -0700)]
Assignment to array elem refs

7 years ago\local $scalar assignment
Father Chrysostomos [Thu, 25 Sep 2014 23:10:14 +0000 (16:10 -0700)]
\local $scalar assignment

7 years agoMake \($x,$y) assignment work
Father Chrysostomos [Thu, 25 Sep 2014 20:10:22 +0000 (13:10 -0700)]
Make \($x,$y) assignment work

This applies to \ with multiple kids (refgen).  Up till now,
op_lvalue_flags only handled srefgen (single refgen).

Before I was converting srefgen to lvref and nulling the kid op:




Now I’m converting the kid instead and nulling the srefgen:


so that the same code can apply to refgen:




7 years agoList assignment to lexical scalar refs
Father Chrysostomos [Thu, 25 Sep 2014 15:19:13 +0000 (08:19 -0700)]
List assignment to lexical scalar refs

\($x,$y)=... does not work yet, but \(my $x) and (\$x, \$y) do.

7 years agoFix assertion failure with ... ? \$a : \$b = ...
Father Chrysostomos [Thu, 25 Sep 2014 05:13:01 +0000 (22:13 -0700)]
Fix assertion failure with ... ? \$a : \$b = ...

Because both branches have a srefgen, this was treated as a scalar
reference assignment, which is usually handled by refassign.  But
refassign expects the thing on the lhs to be srefgen, not a cond_expr.

The logic for propagating the assignment type must not propagate the
‘ASSIGN_REF’ type outward.  Only list context propagates outward.
Eventually, this will be handled by sassign and the cond_expr will
have lvref kids.  (It’s too complicated for refassign, which is the
optimised form that combines \ and = into one op.)

For now, this commit just fixes the assertion failure without making
this type of assignment work yet.

7 years agoop.c: Apply spair optimisation to \% \@ \&
Father Chrysostomos [Wed, 24 Sep 2014 23:21:03 +0000 (16:21 -0700)]
op.c: Apply spair optimisation to \% \@ \&

The ‘spair’ (scalar/single pair) optimisation applies to a few operat-
ors for which there are actually pairs of ops, one for scalars or sin-
gle items, the other for lists.  refgen is one of them.

When taking references, hashes, arrays and subroutines are single
items, just like scalars, so they can go through the ‘single’ code and
benefit, too.

refassign will also benefit from this, as \@a = [] (not yet imple-
mented) should provide scalar context to the right-hand side, and this
avoids the need for special cases (because srefgen with the initial s
provides scalar context).

(This optimisation could have applied to aggregates passed to cho(m)p,
but it results in incorrect messages like ‘Uninitialized value in sca-
lar chomp’ for chomp @_, so I’ve left it for now.)

7 years agoUse ‘Can’t modify reference to...’ for refassign, too
Father Chrysostomos [Mon, 29 Sep 2014 05:50:57 +0000 (22:50 -0700)]
Use ‘Can’t modify reference to...’ for refassign, too

7 years agoop.c: diag_listed_as for ‘Can't modify ref’
Father Chrysostomos [Wed, 24 Sep 2014 21:22:38 +0000 (14:22 -0700)]
op.c: diag_listed_as for ‘Can't modify ref’

7 years agolvref.t: Test ‘Can't modify reference to...’
Father Chrysostomos [Wed, 24 Sep 2014 21:20:48 +0000 (14:20 -0700)]
lvref.t: Test ‘Can't modify reference to...’

7 years agoList assignment to package scalar ref
Father Chrysostomos [Wed, 24 Sep 2014 20:22:49 +0000 (13:22 -0700)]
List assignment to package scalar ref

\ on the lhs returns a special magical scalar with set-magic that does
the aliasing.

I considered having a separate abind op that would be like aassign,
but different.  However, I realised that for ($x, \$y) = ... to work
it would have to duplicate all of aassign.  So I went with the sim-
pler magic implementation.

7 years agoCapitalise magic descriptions consistently
Father Chrysostomos [Wed, 24 Sep 2014 08:45:47 +0000 (01:45 -0700)]
Capitalise magic descriptions consistently

7 years agoAdd lvref magic type
Father Chrysostomos [Wed, 24 Sep 2014 08:42:30 +0000 (01:42 -0700)]
Add lvref magic type

I just couldn’t resist using the backslash for the character, even
though I had to tweak to make it work.

7 years agoAdd lvref op type
Father Chrysostomos [Wed, 24 Sep 2014 07:58:23 +0000 (00:58 -0700)]
Add lvref op type

7 years agolvref.t: More parenthesized scalar ref tests
Father Chrysostomos [Wed, 24 Sep 2014 07:19:33 +0000 (00:19 -0700)]
lvref.t: More parenthesized scalar ref tests

These tests are actually nonsensical with the evals, but they currently
cause syntax errors.  Ultimately they are placeholders and reminders,
so it doesn’t matter.

7 years agolvref.t: Some assignments with mixed lhs
Father Chrysostomos [Wed, 24 Sep 2014 05:33:09 +0000 (22:33 -0700)]
lvref.t: Some assignments with mixed lhs

7 years agoImplement \my $x = ...
Father Chrysostomos [Mon, 22 Sep 2014 06:11:32 +0000 (23:11 -0700)]
Implement \my $x = ...

7 years agolvref.t: Test \$foo = \*bar
Father Chrysostomos [Sun, 21 Sep 2014 23:04:23 +0000 (16:04 -0700)]
lvref.t: Test \$foo = \*bar

7 years agolvref.t: To-do tests for foreach \
Father Chrysostomos [Sun, 21 Sep 2014 22:04:20 +0000 (15:04 -0700)]
lvref.t: To-do tests for foreach \

7 years agolvret.t: To-do tests for \local $scalar=
Father Chrysostomos [Sun, 21 Sep 2014 21:58:15 +0000 (14:58 -0700)]
lvret.t: To-do tests for \local $scalar=

7 years agoWhen making lex alias, don’t free old var too soon
Father Chrysostomos [Sun, 21 Sep 2014 21:43:37 +0000 (14:43 -0700)]
When making lex alias, don’t free old var too soon

It could be exactly the same variable, and the reference on the rhs
could be weak:

use feature ":all";
use Scalar::Util 'weaken';
my $a;
weaken($r = \$a);
\$a = $r;
Lvalue references are experimental at - line 5.
Segmentation fault: 11

7 years agolvref.t: To-do test for PADSTALE handling
Father Chrysostomos [Sun, 21 Sep 2014 21:23:00 +0000 (14:23 -0700)]
lvref.t: To-do test for PADSTALE handling

7 years agoSimple package scalar lvalue refs
Father Chrysostomos [Sun, 21 Sep 2014 20:56:01 +0000 (13:56 -0700)]
Simple package scalar lvalue refs

\$::x = ... works, but not \local $x yet.

7 years agolvref.t: Tests for error massages
Father Chrysostomos [Sun, 21 Sep 2014 19:29:30 +0000 (12:29 -0700)]
lvref.t: Tests for error massages

7 years agolvref.t: Remove to-do and eval from passing test
Father Chrysostomos [Sun, 21 Sep 2014 18:19:41 +0000 (11:19 -0700)]
lvref.t: Remove to-do and eval from passing test

This one passing test was failing inside the eval because closures
are not yet supported.  (That’s why I added explicit closure tests
in the previous commit.)

7 years agolvref.t: To-do tests for closures
Father Chrysostomos [Sun, 21 Sep 2014 18:16:33 +0000 (11:16 -0700)]
lvref.t: To-do tests for closures

7 years agoDocument lvalue ref diagnostics
Father Chrysostomos [Sun, 21 Sep 2014 07:22:41 +0000 (00:22 -0700)]
Document lvalue ref diagnostics

Also, use ‘a SCALAR reference’ rather than ‘a scalar reference’, to
match the style used elsewhere.

7 years agoFirst stab at lexical scalar aliases
Father Chrysostomos [Sat, 20 Sep 2014 21:49:04 +0000 (14:49 -0700)]
First stab at lexical scalar aliases

No \my$x= yet.  Only my $x; \$x =....

It does not work properly with variables closed over from outside;
hence, all the to-do tests fail still, since they do the assign-
ment in evals.

But this much works:

$ ./miniperl -Ilib -Mfeature=:all -e 'my $m; \$m = \$n; warn \$m; warn \$n'
Lvalue references are experimental at -e line 1.
SCALAR(0x7fa04b805510) at -e line 1.
SCALAR(0x7fa04b805510) at -e line 1.

7 years agoop.c: In newBINOP, set up op_last before CHECKOP
Father Chrysostomos [Sun, 21 Sep 2014 06:33:26 +0000 (23:33 -0700)]
op.c: In newBINOP, set up op_last before CHECKOP

Set up op_last pointers in newBINOP before calling the op-specific
ck_* routine.

That way, since this op sub-tree is well-formed from the outset, we
don’t need as much fix-up code elsewhere to account for the case where
the binop has been embedded inside a larger op tree (state var ini-

The repetition operator is an odd bird.  If the lhs is a list of one
item, it is effectively an unop, though still of class binop.  Though
op_last would usually point to the last immediate child, it ended
up null instead.  B::Deparse was written to expect that, so let’s
keep it that way by setting it to null in ck_repeat, now that the
last = first->sibling assignment in newBINOP (which used to do it)
happens earlier.

7 years agoIncrease $Opcode::VERSION to 1.29
Father Chrysostomos [Sat, 20 Sep 2014 20:48:48 +0000 (13:48 -0700)]
Increase $Opcode::VERSION to 1.29

7 years agoAdd refassign op type
Father Chrysostomos [Sat, 20 Sep 2014 20:47:58 +0000 (13:47 -0700)]
Add refassign op type

7 years agoop.c:ck_spair: Remove redundant checks
Father Chrysostomos [Sat, 20 Sep 2014 20:27:47 +0000 (13:27 -0700)]
op.c:ck_spair: Remove redundant checks

Neither the av nor the hv ops have the OA_RETSCALAR flag, so these
checks are unreachable.

These checks go all the way back to a0d0e21e (perl 5.000).

7 years agoTo-do tests for scalar lvalue refs
Father Chrysostomos [Sat, 20 Sep 2014 18:46:14 +0000 (11:46 -0700)]
To-do tests for scalar lvalue refs