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