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