[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");

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