[p5sagit/p5-mst-13.2.git] / ext / B / t / optree_varinit.t

#!perl

BEGIN {
    if ($ENV{PERL_CORE}){
	chdir('t') if -d 't';
	@INC = ('.', '../lib', '../ext/B/t');
    } else {
	unshift @INC, 't';
	push @INC, "../../t";
    }
    require Config;
    if (($Config::Config{'extensions'} !~ /\bB\b/) ){
        print "1..0 # Skip -- Perl configured without B module\n";
        exit 0;
    }
    # require 'test.pl'; # now done by OptreeCheck
}
use OptreeCheck;
use Config;
plan tests	=> 22;
SKIP: {
skip "no perlio in this build", 22 unless $Config::Config{useperlio};

pass("OPTIMIZER TESTS - VAR INITIALIZATION");

my @open_todo;
sub open_todo {
    if (((caller 0)[10]||{})->{open}) {
	@open_todo = (skip => "\$^OPEN is set");
    }
}
open_todo;

checkOptree ( name	=> 'sub {my $a}',
	      bcopts	=> '-exec',
	      code	=> sub {my $a},
	      @open_todo,
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
# 1  <;> nextstate(main 45 optree.t:23) v
# 2  <0> padsv[$a:45,46] M/LVINTRO
# 3  <1> leavesub[1 ref] K/REFC,1
EOT_EOT
# 1  <;> nextstate(main 45 optree.t:23) v
# 2  <0> padsv[$a:45,46] M/LVINTRO
# 3  <1> leavesub[1 ref] K/REFC,1
EONT_EONT

checkOptree ( name	=> '-exec sub {my $a}',
	      bcopts	=> '-exec',
	      code	=> sub {my $a},
	      @open_todo,
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
# 1  <;> nextstate(main 49 optree.t:52) v
# 2  <0> padsv[$a:49,50] M/LVINTRO
# 3  <1> leavesub[1 ref] K/REFC,1
EOT_EOT
# 1  <;> nextstate(main 49 optree.t:45) v
# 2  <0> padsv[$a:49,50] M/LVINTRO
# 3  <1> leavesub[1 ref] K/REFC,1
EONT_EONT

checkOptree ( name	=> 'sub {our $a}',
	      bcopts	=> '-exec',
	      code	=> sub {our $a},
	      @open_todo,
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
1  <;> nextstate(main 21 optree.t:47) v
2  <#> gvsv[*a] s/OURINTR
3  <1> leavesub[1 ref] K/REFC,1
EOT_EOT
# 1  <;> nextstate(main 51 optree.t:56) v
# 2  <$> gvsv(*a) s/OURINTR
# 3  <1> leavesub[1 ref] K/REFC,1
EONT_EONT

checkOptree ( name	=> 'sub {local $a}',
	      bcopts	=> '-exec',
	      code	=> sub {local $a},
	      @open_todo,
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
1  <;> nextstate(main 23 optree.t:57) v:{
2  <#> gvsv[*a] s/LVINTRO
3  <1> leavesub[1 ref] K/REFC,1
EOT_EOT
# 1  <;> nextstate(main 53 optree.t:67) v:{
# 2  <$> gvsv(*a) s/LVINTRO
# 3  <1> leavesub[1 ref] K/REFC,1
EONT_EONT

checkOptree ( name	=> 'my $a',
	      prog	=> 'my $a',
	      bcopts	=> '-basic',
	      @open_todo,
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
# 4  <@> leave[1 ref] vKP/REFC ->(end)
# 1     <0> enter ->2
# 2     <;> nextstate(main 1 -e:1) v:{ ->3
# 3     <0> padsv[$a:1,2] vM/LVINTRO ->4
EOT_EOT
# 4  <@> leave[1 ref] vKP/REFC ->(end)
# 1     <0> enter ->2
# 2     <;> nextstate(main 1 -e:1) v:{ ->3
# 3     <0> padsv[$a:1,2] vM/LVINTRO ->4
EONT_EONT

checkOptree ( name	=> 'our $a',
	      prog	=> 'our $a',
	      bcopts	=> '-basic',
	      @open_todo,
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
4  <@> leave[1 ref] vKP/REFC ->(end)
1     <0> enter ->2
2     <;> nextstate(main 1 -e:1) v:{ ->3
-     <1> ex-rv2sv vK/17 ->4
3        <#> gvsv[*a] s/OURINTR ->4
EOT_EOT
# 4  <@> leave[1 ref] vKP/REFC ->(end)
# 1     <0> enter ->2
# 2     <;> nextstate(main 1 -e:1) v:{ ->3
# -     <1> ex-rv2sv vK/17 ->4
# 3        <$> gvsv(*a) s/OURINTR ->4
EONT_EONT

checkOptree ( name	=> 'local $a',
	      prog	=> 'local $a',
	      errs      => ['Name "main::a" used only once: possible typo at -e line 1.'],
	      bcopts	=> '-basic',
	      @open_todo,
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
4  <@> leave[1 ref] vKP/REFC ->(end)
1     <0> enter ->2
2     <;> nextstate(main 1 -e:1) v:{ ->3
-     <1> ex-rv2sv vKM/129 ->4
3        <#> gvsv[*a] s/LVINTRO ->4
EOT_EOT
# 4  <@> leave[1 ref] vKP/REFC ->(end)
# 1     <0> enter ->2
# 2     <;> nextstate(main 1 -e:1) v:{ ->3
# -     <1> ex-rv2sv vKM/129 ->4
# 3        <$> gvsv(*a) s/LVINTRO ->4
EONT_EONT

pass("MY, OUR, LOCAL, BOTH SUB AND MAIN, = undef");

checkOptree ( name	=> 'sub {my $a=undef}',
	      code	=> sub {my $a=undef},
	      bcopts	=> '-basic',
	      @open_todo,
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
5  <1> leavesub[1 ref] K/REFC,1 ->(end)
-     <@> lineseq KP ->5
1        <;> nextstate(main 641 optree_varinit.t:130) v ->2
4        <2> sassign sKS/2 ->5
2           <0> undef s ->3
3           <0> padsv[$a:641,642] sRM*/LVINTRO ->4
EOT_EOT
# 5  <1> leavesub[1 ref] K/REFC,1 ->(end)
# -     <@> lineseq KP ->5
# 1        <;> nextstate(main 641 optree_varinit.t:130) v ->2
# 4        <2> sassign sKS/2 ->5
# 2           <0> undef s ->3
# 3           <0> padsv[$a:641,642] sRM*/LVINTRO ->4
EONT_EONT

checkOptree ( name	=> 'sub {our $a=undef}',
	      code	=> sub {our $a=undef},
	      note	=> 'the global must be reset',
	      bcopts	=> '-basic',
	      @open_todo,
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
5  <1> leavesub[1 ref] K/REFC,1 ->(end)
-     <@> lineseq KP ->5
1        <;> nextstate(main 26 optree.t:109) v:{ ->2
4        <2> sassign sKS/2 ->5
2           <0> undef s ->3
-           <1> ex-rv2sv sKRM*/17 ->4
3              <#> gvsv[*a] s/OURINTR ->4
EOT_EOT
# 5  <1> leavesub[1 ref] K/REFC,1 ->(end)
# -     <@> lineseq KP ->5
# 1        <;> nextstate(main 446 optree_varinit.t:137) v:{ ->2
# 4        <2> sassign sKS/2 ->5
# 2           <0> undef s ->3
# -           <1> ex-rv2sv sKRM*/17 ->4
# 3              <$> gvsv(*a) s/OURINTR ->4
EONT_EONT

checkOptree ( name	=> 'sub {local $a=undef}',
	      code	=> sub {local $a=undef},
	      note	=> 'local not used enough to bother',
	      bcopts	=> '-basic',
	      @open_todo,
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
5  <1> leavesub[1 ref] K/REFC,1 ->(end)
-     <@> lineseq KP ->5
1        <;> nextstate(main 28 optree.t:122) v:{ ->2
4        <2> sassign sKS/2 ->5
2           <0> undef s ->3
-           <1> ex-rv2sv sKRM*/129 ->4
3              <#> gvsv[*a] s/LVINTRO ->4
EOT_EOT
# 5  <1> leavesub[1 ref] K/REFC,1 ->(end)
# -     <@> lineseq KP ->5
# 1        <;> nextstate(main 58 optree.t:141) v:{ ->2
# 4        <2> sassign sKS/2 ->5
# 2           <0> undef s ->3
# -           <1> ex-rv2sv sKRM*/129 ->4
# 3              <$> gvsv(*a) s/LVINTRO ->4
EONT_EONT

checkOptree ( name	=> 'my $a=undef',
	      prog	=> 'my $a=undef',
	      bcopts	=> '-basic',
	      @open_todo,
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
6  <@> leave[1 ref] vKP/REFC ->(end)
1     <0> enter ->2
2     <;> nextstate(main 1 -e:1) v:{ ->3
5     <2> sassign vKS/2 ->6
3        <0> undef s ->4
4        <0> padsv[$a:1,2] sRM*/LVINTRO ->5
EOT_EOT
# 6  <@> leave[1 ref] vKP/REFC ->(end)
# 1     <0> enter ->2
# 2     <;> nextstate(main 1 -e:1) v:{ ->3
# 5     <2> sassign vKS/2 ->6
# 3        <0> undef s ->4
# 4        <0> padsv[$a:1,2] sRM*/LVINTRO ->5
EONT_EONT

checkOptree ( name	=> 'our $a=undef',
	      prog	=> 'our $a=undef',
	      note	=> 'global must be reassigned',
	      bcopts	=> '-basic',
	      @open_todo,
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
6  <@> leave[1 ref] vKP/REFC ->(end)
1     <0> enter ->2
2     <;> nextstate(main 1 -e:1) v:{ ->3
5     <2> sassign vKS/2 ->6
3        <0> undef s ->4
-        <1> ex-rv2sv sKRM*/17 ->5
4           <#> gvsv[*a] s/OURINTR ->5
EOT_EOT
# 6  <@> leave[1 ref] vKP/REFC ->(end)
# 1     <0> enter ->2
# 2     <;> nextstate(main 1 -e:1) v:{ ->3
# 5     <2> sassign vKS/2 ->6
# 3        <0> undef s ->4
# -        <1> ex-rv2sv sKRM*/17 ->5
# 4           <$> gvsv(*a) s/OURINTR ->5
EONT_EONT

checkOptree ( name	=> 'local $a=undef',
	      prog	=> 'local $a=undef',
	      errs      => ['Name "main::a" used only once: possible typo at -e line 1.'],
	      note	=> 'locals are rare, probly not worth doing',
	      bcopts	=> '-basic',
	      @open_todo,
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
6  <@> leave[1 ref] vKP/REFC ->(end)
1     <0> enter ->2
2     <;> nextstate(main 1 -e:1) v:{ ->3
5     <2> sassign vKS/2 ->6
3        <0> undef s ->4
-        <1> ex-rv2sv sKRM*/129 ->5
4           <#> gvsv[*a] s/LVINTRO ->5
EOT_EOT
# 6  <@> leave[1 ref] vKP/REFC ->(end)
# 1     <0> enter ->2
# 2     <;> nextstate(main 1 -e:1) v:{ ->3
# 5     <2> sassign vKS/2 ->6
# 3        <0> undef s ->4
# -        <1> ex-rv2sv sKRM*/129 ->5
# 4           <$> gvsv(*a) s/LVINTRO ->5
EONT_EONT

checkOptree ( name	=> 'sub {my $a=()}',
	      code	=> sub {my $a=()},
	      bcopts	=> '-exec',
	      @open_todo,
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
1  <;> nextstate(main -439 optree.t:105) v
2  <0> stub sP
3  <0> padsv[$a:-439,-438] sRM*/LVINTRO
4  <2> sassign sKS/2
5  <1> leavesub[1 ref] K/REFC,1
EOT_EOT
# 1  <;> nextstate(main 438 optree_varinit.t:247) v
# 2  <0> stub sP
# 3  <0> padsv[$a:438,439] sRM*/LVINTRO
# 4  <2> sassign sKS/2
# 5  <1> leavesub[1 ref] K/REFC,1
EONT_EONT

checkOptree ( name	=> 'sub {our $a=()}',
	      code	=> sub {our $a=()},
              #todo	=> 'probly not worth doing',
	      bcopts	=> '-exec',
	      @open_todo,
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
1  <;> nextstate(main 31 optree.t:177) v:{
2  <0> stub sP
3  <#> gvsv[*a] s/OURINTR
4  <2> sassign sKS/2
5  <1> leavesub[1 ref] K/REFC,1
EOT_EOT
# 1  <;> nextstate(main 440 optree_varinit.t:262) v:{
# 2  <0> stub sP
# 3  <$> gvsv(*a) s/OURINTR
# 4  <2> sassign sKS/2
# 5  <1> leavesub[1 ref] K/REFC,1
EONT_EONT

checkOptree ( name	=> 'sub {local $a=()}',
	      code	=> sub {local $a=()},
              #todo	=> 'probly not worth doing',
	      bcopts	=> '-exec',
	      @open_todo,
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
1  <;> nextstate(main 33 optree.t:190) v:{
2  <0> stub sP
3  <#> gvsv[*a] s/LVINTRO
4  <2> sassign sKS/2
5  <1> leavesub[1 ref] K/REFC,1
EOT_EOT
# 1  <;> nextstate(main 63 optree.t:225) v:{
# 2  <0> stub sP
# 3  <$> gvsv(*a) s/LVINTRO
# 4  <2> sassign sKS/2
# 5  <1> leavesub[1 ref] K/REFC,1
EONT_EONT

checkOptree ( name	=> 'my $a=()',
	      prog	=> 'my $a=()',
	      bcopts	=> '-exec',
	      @open_todo,
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
1  <0> enter 
2  <;> nextstate(main 1 -e:1) v:{
3  <0> stub sP
4  <0> padsv[$a:1,2] sRM*/LVINTRO
5  <2> sassign vKS/2
6  <@> leave[1 ref] vKP/REFC
EOT_EOT
# 1  <0> enter 
# 2  <;> nextstate(main 1 -e:1) v:{
# 3  <0> stub sP
# 4  <0> padsv[$a:1,2] sRM*/LVINTRO
# 5  <2> sassign vKS/2
# 6  <@> leave[1 ref] vKP/REFC
EONT_EONT

checkOptree ( name	=> 'our $a=()',
	      prog	=> 'our $a=()',
              #todo	=> 'probly not worth doing',
	      bcopts	=> '-exec',
	      @open_todo,
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
1  <0> enter 
2  <;> nextstate(main 1 -e:1) v:{
3  <0> stub sP
4  <#> gvsv[*a] s/OURINTR
5  <2> sassign vKS/2
6  <@> leave[1 ref] vKP/REFC
EOT_EOT
# 1  <0> enter 
# 2  <;> nextstate(main 1 -e:1) v:{
# 3  <0> stub sP
# 4  <$> gvsv(*a) s/OURINTR
# 5  <2> sassign vKS/2
# 6  <@> leave[1 ref] vKP/REFC
EONT_EONT

checkOptree ( name	=> 'local $a=()',
	      prog	=> 'local $a=()',
	      errs      => ['Name "main::a" used only once: possible typo at -e line 1.'],
              #todo	=> 'probly not worth doing',
	      bcopts	=> '-exec',
	      @open_todo,
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
1  <0> enter 
2  <;> nextstate(main 1 -e:1) v:{
3  <0> stub sP
4  <#> gvsv[*a] s/LVINTRO
5  <2> sassign vKS/2
6  <@> leave[1 ref] vKP/REFC
EOT_EOT
# 1  <0> enter 
# 2  <;> nextstate(main 1 -e:1) v:{
# 3  <0> stub sP
# 4  <$> gvsv(*a) s/LVINTRO
# 5  <2> sassign vKS/2
# 6  <@> leave[1 ref] vKP/REFC
EONT_EONT

checkOptree ( name	=> 'my ($a,$b)=()',
	      prog	=> 'my ($a,$b)=()',
              #todo	=> 'probly not worth doing',
	      bcopts	=> '-exec',
	      @open_todo,
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
# 1  <0> enter 
# 2  <;> nextstate(main 1 -e:1) v:{
# 3  <0> pushmark s
# 4  <0> pushmark sRM*/128
# 5  <0> padsv[$a:1,2] lRM*/LVINTRO
# 6  <0> padsv[$b:1,2] lRM*/LVINTRO
# 7  <2> aassign[t3] vKS
# 8  <@> leave[1 ref] vKP/REFC
EOT_EOT
# 1  <0> enter 
# 2  <;> nextstate(main 1 -e:1) v:{
# 3  <0> pushmark s
# 4  <0> pushmark sRM*/128
# 5  <0> padsv[$a:1,2] lRM*/LVINTRO
# 6  <0> padsv[$b:1,2] lRM*/LVINTRO
# 7  <2> aassign[t3] vKS
# 8  <@> leave[1 ref] vKP/REFC
EONT_EONT

} #skip

__END__
Commit	Line	Data
724aa791	1	#!perl
	2
	3	BEGIN {
5638aaac	4	if ($ENV{PERL_CORE}){
	5	chdir('t') if -d 't';
	6	@INC = ('.', '../lib', '../ext/B/t');
	7	} else {
	8	unshift @INC, 't';
	9	push @INC, "../../t";
	10	}
9cd8f857	11	require Config;
	12	if (($Config::Config{'extensions'} !~ /\bB\b/) ){
	13	print "1..0 # Skip -- Perl configured without B module\n";
	14	exit 0;
	15	}
19e169bf	16	# require 'test.pl'; # now done by OptreeCheck
724aa791	17	}
724aa791	18	use OptreeCheck;
2ce64696	19	use Config;
724aa791	20	plan tests => 22;
2ce64696	21	SKIP: {
	22	skip "no perlio in this build", 22 unless $Config::Config{useperlio};
	23
724aa791	24	pass("OPTIMIZER TESTS - VAR INITIALIZATION");
724aa791	25
09337566	26	my @open_todo;
	27	sub open_todo {
	28	if (((caller 0)[10]\|\|{})->{open}) {
	29	@open_todo = (skip => "\$^OPEN is set");
	30	}
	31	}
	32	open_todo;
	33
724aa791	34	checkOptree ( name => 'sub {my $a}',
	35	bcopts => '-exec',
	36	code => sub {my $a},
09337566	37	@open_todo,
724aa791	38	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
	39	# 1 <;> nextstate(main 45 optree.t:23) v
	40	# 2 <0> padsv[$a:45,46] M/LVINTRO
	41	# 3 <1> leavesub[1 ref] K/REFC,1
	42	EOT_EOT
	43	# 1 <;> nextstate(main 45 optree.t:23) v
	44	# 2 <0> padsv[$a:45,46] M/LVINTRO
	45	# 3 <1> leavesub[1 ref] K/REFC,1
	46	EONT_EONT
	47
	48	checkOptree ( name => '-exec sub {my $a}',
	49	bcopts => '-exec',
	50	code => sub {my $a},
09337566	51	@open_todo,
724aa791	52	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
724aa791	53	# 1 <;> nextstate(main 49 optree.t:52) v
	54	# 2 <0> padsv[$a:49,50] M/LVINTRO
	55	# 3 <1> leavesub[1 ref] K/REFC,1
	56	EOT_EOT
724aa791	57	# 1 <;> nextstate(main 49 optree.t:45) v
	58	# 2 <0> padsv[$a:49,50] M/LVINTRO
	59	# 3 <1> leavesub[1 ref] K/REFC,1
	60	EONT_EONT
	61
	62	checkOptree ( name => 'sub {our $a}',
	63	bcopts => '-exec',
	64	code => sub {our $a},
09337566	65	@open_todo,
724aa791	66	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
724aa791	67	1 <;> nextstate(main 21 optree.t:47) v
	68	2 <#> gvsv[*a] s/OURINTR
	69	3 <1> leavesub[1 ref] K/REFC,1
	70	EOT_EOT
724aa791	71	# 1 <;> nextstate(main 51 optree.t:56) v
	72	# 2 <$> gvsv(*a) s/OURINTR
	73	# 3 <1> leavesub[1 ref] K/REFC,1
	74	EONT_EONT
	75
	76	checkOptree ( name => 'sub {local $a}',
	77	bcopts => '-exec',
	78	code => sub {local $a},
09337566	79	@open_todo,
724aa791	80	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
d5ec2987	81	1 <;> nextstate(main 23 optree.t:57) v:{
724aa791	82	2 <#> gvsv[*a] s/LVINTRO
	83	3 <1> leavesub[1 ref] K/REFC,1
	84	EOT_EOT
d5ec2987	85	# 1 <;> nextstate(main 53 optree.t:67) v:{
724aa791	86	# 2 <$> gvsv(*a) s/LVINTRO
	87	# 3 <1> leavesub[1 ref] K/REFC,1
	88	EONT_EONT
	89
	90	checkOptree ( name => 'my $a',
	91	prog => 'my $a',
	92	bcopts => '-basic',
09337566	93	@open_todo,
724aa791	94	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
	95	# 4 <@> leave[1 ref] vKP/REFC ->(end)
	96	# 1 <0> enter ->2
d5ec2987	97	# 2 <;> nextstate(main 1 -e:1) v:{ ->3
724aa791	98	# 3 <0> padsv[$a:1,2] vM/LVINTRO ->4
	99	EOT_EOT
	100	# 4 <@> leave[1 ref] vKP/REFC ->(end)
	101	# 1 <0> enter ->2
d5ec2987	102	# 2 <;> nextstate(main 1 -e:1) v:{ ->3
724aa791	103	# 3 <0> padsv[$a:1,2] vM/LVINTRO ->4
	104	EONT_EONT
	105
	106	checkOptree ( name => 'our $a',
	107	prog => 'our $a',
	108	bcopts => '-basic',
09337566	109	@open_todo,
724aa791	110	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
	111	4 <@> leave[1 ref] vKP/REFC ->(end)
	112	1 <0> enter ->2
d5ec2987	113	2 <;> nextstate(main 1 -e:1) v:{ ->3
724aa791	114	- <1> ex-rv2sv vK/17 ->4
	115	3 <#> gvsv[*a] s/OURINTR ->4
	116	EOT_EOT
	117	# 4 <@> leave[1 ref] vKP/REFC ->(end)
	118	# 1 <0> enter ->2
d5ec2987	119	# 2 <;> nextstate(main 1 -e:1) v:{ ->3
724aa791	120	# - <1> ex-rv2sv vK/17 ->4
	121	# 3 <$> gvsv(*a) s/OURINTR ->4
	122	EONT_EONT
	123
	124	checkOptree ( name => 'local $a',
	125	prog => 'local $a',
19e169bf	126	errs => ['Name "main::a" used only once: possible typo at -e line 1.'],
724aa791	127	bcopts => '-basic',
09337566	128	@open_todo,
724aa791	129	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
	130	4 <@> leave[1 ref] vKP/REFC ->(end)
	131	1 <0> enter ->2
d5ec2987	132	2 <;> nextstate(main 1 -e:1) v:{ ->3
724aa791	133	- <1> ex-rv2sv vKM/129 ->4
	134	3 <#> gvsv[*a] s/LVINTRO ->4
	135	EOT_EOT
	136	# 4 <@> leave[1 ref] vKP/REFC ->(end)
	137	# 1 <0> enter ->2
d5ec2987	138	# 2 <;> nextstate(main 1 -e:1) v:{ ->3
724aa791	139	# - <1> ex-rv2sv vKM/129 ->4
	140	# 3 <$> gvsv(*a) s/LVINTRO ->4
	141	EONT_EONT
	142
	143	pass("MY, OUR, LOCAL, BOTH SUB AND MAIN, = undef");
	144
	145	checkOptree ( name => 'sub {my $a=undef}',
	146	code => sub {my $a=undef},
	147	bcopts => '-basic',
09337566	148	@open_todo,
724aa791	149	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
0b599ae5	150	5 <1> leavesub[1 ref] K/REFC,1 ->(end)
	151	- <@> lineseq KP ->5
	152	1 <;> nextstate(main 641 optree_varinit.t:130) v ->2
	153	4 <2> sassign sKS/2 ->5
	154	2 <0> undef s ->3
	155	3 <0> padsv[$a:641,642] sRM*/LVINTRO ->4
724aa791	156	EOT_EOT
0b599ae5	157	# 5 <1> leavesub[1 ref] K/REFC,1 ->(end)
	158	# - <@> lineseq KP ->5
	159	# 1 <;> nextstate(main 641 optree_varinit.t:130) v ->2
	160	# 4 <2> sassign sKS/2 ->5
	161	# 2 <0> undef s ->3
	162	# 3 <0> padsv[$a:641,642] sRM*/LVINTRO ->4
724aa791	163	EONT_EONT
	164
	165	checkOptree ( name => 'sub {our $a=undef}',
	166	code => sub {our $a=undef},
	167	note => 'the global must be reset',
	168	bcopts => '-basic',
09337566	169	@open_todo,
724aa791	170	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
	171	5 <1> leavesub[1 ref] K/REFC,1 ->(end)
	172	- <@> lineseq KP ->5
d5ec2987	173	1 <;> nextstate(main 26 optree.t:109) v:{ ->2
724aa791	174	4 <2> sassign sKS/2 ->5
	175	2 <0> undef s ->3
	176	- <1> ex-rv2sv sKRM*/17 ->4
	177	3 <#> gvsv[*a] s/OURINTR ->4
	178	EOT_EOT
	179	# 5 <1> leavesub[1 ref] K/REFC,1 ->(end)
	180	# - <@> lineseq KP ->5
d5ec2987	181	# 1 <;> nextstate(main 446 optree_varinit.t:137) v:{ ->2
724aa791	182	# 4 <2> sassign sKS/2 ->5
	183	# 2 <0> undef s ->3
	184	# - <1> ex-rv2sv sKRM*/17 ->4
	185	# 3 <$> gvsv(*a) s/OURINTR ->4
	186	EONT_EONT
	187
	188	checkOptree ( name => 'sub {local $a=undef}',
	189	code => sub {local $a=undef},
	190	note => 'local not used enough to bother',
	191	bcopts => '-basic',
09337566	192	@open_todo,
724aa791	193	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
	194	5 <1> leavesub[1 ref] K/REFC,1 ->(end)
	195	- <@> lineseq KP ->5
d5ec2987	196	1 <;> nextstate(main 28 optree.t:122) v:{ ->2
724aa791	197	4 <2> sassign sKS/2 ->5
	198	2 <0> undef s ->3
	199	- <1> ex-rv2sv sKRM*/129 ->4
	200	3 <#> gvsv[*a] s/LVINTRO ->4
	201	EOT_EOT
	202	# 5 <1> leavesub[1 ref] K/REFC,1 ->(end)
	203	# - <@> lineseq KP ->5
d5ec2987	204	# 1 <;> nextstate(main 58 optree.t:141) v:{ ->2
724aa791	205	# 4 <2> sassign sKS/2 ->5
	206	# 2 <0> undef s ->3
	207	# - <1> ex-rv2sv sKRM*/129 ->4
	208	# 3 <$> gvsv(*a) s/LVINTRO ->4
	209	EONT_EONT
	210
	211	checkOptree ( name => 'my $a=undef',
	212	prog => 'my $a=undef',
	213	bcopts => '-basic',
09337566	214	@open_todo,
724aa791	215	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
0b599ae5	216	6 <@> leave[1 ref] vKP/REFC ->(end)
724aa791	217	1 <0> enter ->2
d5ec2987	218	2 <;> nextstate(main 1 -e:1) v:{ ->3
0b599ae5	219	5 <2> sassign vKS/2 ->6
	220	3 <0> undef s ->4
	221	4 <0> padsv[$a:1,2] sRM*/LVINTRO ->5
724aa791	222	EOT_EOT
0b599ae5	223	# 6 <@> leave[1 ref] vKP/REFC ->(end)
724aa791	224	# 1 <0> enter ->2
d5ec2987	225	# 2 <;> nextstate(main 1 -e:1) v:{ ->3
0b599ae5	226	# 5 <2> sassign vKS/2 ->6
	227	# 3 <0> undef s ->4
	228	# 4 <0> padsv[$a:1,2] sRM*/LVINTRO ->5
724aa791	229	EONT_EONT
	230
	231	checkOptree ( name => 'our $a=undef',
	232	prog => 'our $a=undef',
	233	note => 'global must be reassigned',
	234	bcopts => '-basic',
09337566	235	@open_todo,
724aa791	236	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
	237	6 <@> leave[1 ref] vKP/REFC ->(end)
	238	1 <0> enter ->2
d5ec2987	239	2 <;> nextstate(main 1 -e:1) v:{ ->3
724aa791	240	5 <2> sassign vKS/2 ->6
	241	3 <0> undef s ->4
	242	- <1> ex-rv2sv sKRM*/17 ->5
	243	4 <#> gvsv[*a] s/OURINTR ->5
	244	EOT_EOT
	245	# 6 <@> leave[1 ref] vKP/REFC ->(end)
	246	# 1 <0> enter ->2
d5ec2987	247	# 2 <;> nextstate(main 1 -e:1) v:{ ->3
724aa791	248	# 5 <2> sassign vKS/2 ->6
	249	# 3 <0> undef s ->4
	250	# - <1> ex-rv2sv sKRM*/17 ->5
	251	# 4 <$> gvsv(*a) s/OURINTR ->5
	252	EONT_EONT
	253
	254	checkOptree ( name => 'local $a=undef',
	255	prog => 'local $a=undef',
19e169bf	256	errs => ['Name "main::a" used only once: possible typo at -e line 1.'],
724aa791	257	note => 'locals are rare, probly not worth doing',
724aa791	258	bcopts => '-basic',
09337566	259	@open_todo,
724aa791	260	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
	261	6 <@> leave[1 ref] vKP/REFC ->(end)
	262	1 <0> enter ->2
d5ec2987	263	2 <;> nextstate(main 1 -e:1) v:{ ->3
724aa791	264	5 <2> sassign vKS/2 ->6
	265	3 <0> undef s ->4
	266	- <1> ex-rv2sv sKRM*/129 ->5
	267	4 <#> gvsv[*a] s/LVINTRO ->5
	268	EOT_EOT
	269	# 6 <@> leave[1 ref] vKP/REFC ->(end)
	270	# 1 <0> enter ->2
d5ec2987	271	# 2 <;> nextstate(main 1 -e:1) v:{ ->3
724aa791	272	# 5 <2> sassign vKS/2 ->6
	273	# 3 <0> undef s ->4
	274	# - <1> ex-rv2sv sKRM*/129 ->5
	275	# 4 <$> gvsv(*a) s/LVINTRO ->5
	276	EONT_EONT
	277
	278	checkOptree ( name => 'sub {my $a=()}',
	279	code => sub {my $a=()},
724aa791	280	bcopts => '-exec',
09337566	281	@open_todo,
724aa791	282	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
724aa791	283	1 <;> nextstate(main -439 optree.t:105) v
	284	2 <0> stub sP
	285	3 <0> padsv[$a:-439,-438] sRM*/LVINTRO
	286	4 <2> sassign sKS/2
	287	5 <1> leavesub[1 ref] K/REFC,1
	288	EOT_EOT
	289	# 1 <;> nextstate(main 438 optree_varinit.t:247) v
	290	# 2 <0> stub sP
	291	# 3 <0> padsv[$a:438,439] sRM*/LVINTRO
	292	# 4 <2> sassign sKS/2
	293	# 5 <1> leavesub[1 ref] K/REFC,1
	294	EONT_EONT
	295
	296	checkOptree ( name => 'sub {our $a=()}',
	297	code => sub {our $a=()},
	298	#todo => 'probly not worth doing',
	299	bcopts => '-exec',
09337566	300	@open_todo,
724aa791	301	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
d5ec2987	302	1 <;> nextstate(main 31 optree.t:177) v:{
724aa791	303	2 <0> stub sP
	304	3 <#> gvsv[*a] s/OURINTR
	305	4 <2> sassign sKS/2
	306	5 <1> leavesub[1 ref] K/REFC,1
	307	EOT_EOT
d5ec2987	308	# 1 <;> nextstate(main 440 optree_varinit.t:262) v:{
724aa791	309	# 2 <0> stub sP
	310	# 3 <$> gvsv(*a) s/OURINTR
	311	# 4 <2> sassign sKS/2
	312	# 5 <1> leavesub[1 ref] K/REFC,1
	313	EONT_EONT
	314
	315	checkOptree ( name => 'sub {local $a=()}',
	316	code => sub {local $a=()},
	317	#todo => 'probly not worth doing',
	318	bcopts => '-exec',
09337566	319	@open_todo,
724aa791	320	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
d5ec2987	321	1 <;> nextstate(main 33 optree.t:190) v:{
724aa791	322	2 <0> stub sP
	323	3 <#> gvsv[*a] s/LVINTRO
	324	4 <2> sassign sKS/2
	325	5 <1> leavesub[1 ref] K/REFC,1
	326	EOT_EOT
d5ec2987	327	# 1 <;> nextstate(main 63 optree.t:225) v:{
724aa791	328	# 2 <0> stub sP
	329	# 3 <$> gvsv(*a) s/LVINTRO
	330	# 4 <2> sassign sKS/2
	331	# 5 <1> leavesub[1 ref] K/REFC,1
	332	EONT_EONT
	333
	334	checkOptree ( name => 'my $a=()',
	335	prog => 'my $a=()',
724aa791	336	bcopts => '-exec',
09337566	337	@open_todo,
724aa791	338	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
724aa791	339	1 <0> enter
d5ec2987	340	2 <;> nextstate(main 1 -e:1) v:{
724aa791	341	3 <0> stub sP
	342	4 <0> padsv[$a:1,2] sRM*/LVINTRO
	343	5 <2> sassign vKS/2
	344	6 <@> leave[1 ref] vKP/REFC
	345	EOT_EOT
	346	# 1 <0> enter
d5ec2987	347	# 2 <;> nextstate(main 1 -e:1) v:{
724aa791	348	# 3 <0> stub sP
	349	# 4 <0> padsv[$a:1,2] sRM*/LVINTRO
	350	# 5 <2> sassign vKS/2
	351	# 6 <@> leave[1 ref] vKP/REFC
	352	EONT_EONT
	353
	354	checkOptree ( name => 'our $a=()',
	355	prog => 'our $a=()',
	356	#todo => 'probly not worth doing',
	357	bcopts => '-exec',
09337566	358	@open_todo,
724aa791	359	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
724aa791	360	1 <0> enter
d5ec2987	361	2 <;> nextstate(main 1 -e:1) v:{
724aa791	362	3 <0> stub sP
	363	4 <#> gvsv[*a] s/OURINTR
	364	5 <2> sassign vKS/2
	365	6 <@> leave[1 ref] vKP/REFC
	366	EOT_EOT
	367	# 1 <0> enter
d5ec2987	368	# 2 <;> nextstate(main 1 -e:1) v:{
724aa791	369	# 3 <0> stub sP
	370	# 4 <$> gvsv(*a) s/OURINTR
	371	# 5 <2> sassign vKS/2
	372	# 6 <@> leave[1 ref] vKP/REFC
	373	EONT_EONT
	374
	375	checkOptree ( name => 'local $a=()',
	376	prog => 'local $a=()',
19e169bf	377	errs => ['Name "main::a" used only once: possible typo at -e line 1.'],
724aa791	378	#todo => 'probly not worth doing',
724aa791	379	bcopts => '-exec',
09337566	380	@open_todo,
724aa791	381	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
724aa791	382	1 <0> enter
d5ec2987	383	2 <;> nextstate(main 1 -e:1) v:{
724aa791	384	3 <0> stub sP
	385	4 <#> gvsv[*a] s/LVINTRO
	386	5 <2> sassign vKS/2
	387	6 <@> leave[1 ref] vKP/REFC
	388	EOT_EOT
	389	# 1 <0> enter
d5ec2987	390	# 2 <;> nextstate(main 1 -e:1) v:{
724aa791	391	# 3 <0> stub sP
	392	# 4 <$> gvsv(*a) s/LVINTRO
	393	# 5 <2> sassign vKS/2
	394	# 6 <@> leave[1 ref] vKP/REFC
	395	EONT_EONT
	396
	397	checkOptree ( name => 'my ($a,$b)=()',
	398	prog => 'my ($a,$b)=()',
	399	#todo => 'probly not worth doing',
	400	bcopts => '-exec',
09337566	401	@open_todo,
724aa791	402	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
724aa791	403	# 1 <0> enter
d5ec2987	404	# 2 <;> nextstate(main 1 -e:1) v:{
724aa791	405	# 3 <0> pushmark s
	406	# 4 <0> pushmark sRM*/128
	407	# 5 <0> padsv[$a:1,2] lRM*/LVINTRO
	408	# 6 <0> padsv[$b:1,2] lRM*/LVINTRO
	409	# 7 <2> aassign[t3] vKS
	410	# 8 <@> leave[1 ref] vKP/REFC
	411	EOT_EOT
	412	# 1 <0> enter
d5ec2987	413	# 2 <;> nextstate(main 1 -e:1) v:{
724aa791	414	# 3 <0> pushmark s
	415	# 4 <0> pushmark sRM*/128
	416	# 5 <0> padsv[$a:1,2] lRM*/LVINTRO
	417	# 6 <0> padsv[$b:1,2] lRM*/LVINTRO
	418	# 7 <2> aassign[t3] vKS
	419	# 8 <@> leave[1 ref] vKP/REFC
	420	EONT_EONT
	421
2ce64696	422	} #skip
2ce64696	423
724aa791	424	__END__
724aa791	425