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

#!perl

BEGIN {
    chdir 't';
    @INC = ('../lib', '../ext/B/t');
    require './test.pl';
}
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},
	      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},
	      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},
	      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},
	      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',
	      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',
	      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',
	      bcopts	=> '-basic',
	      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',
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
3  <1> leavesub[1 ref] K/REFC,1 ->(end)
-     <@> lineseq KP ->3
1        <;> nextstate(main 24 optree.t:99) v ->2
2        <0> padsv[$a:24,25] sRM*/LVINTRO ->3
EOT_EOT
# 3  <1> leavesub[1 ref] K/REFC,1 ->(end)
# -     <@> lineseq KP ->3
# 1        <;> nextstate(main 54 optree.t:149) v ->2
# 2        <0> padsv[$a:54,55] sRM*/LVINTRO ->3
EONT_EONT

checkOptree ( name	=> 'sub {our $a=undef}',
	      code	=> sub {our $a=undef},
	      note	=> 'the global must be reset',
	      bcopts	=> '-basic',
	      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',
	      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',
	      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] vRM*/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] vRM*/LVINTRO ->4
EONT_EONT

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