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

#!perl

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