[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},
	      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',
	      errs      => ['Name "main::a" used only once: possible typo at -e line 1.'],
	      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',
	      errs      => ['Name "main::a" used only once: possible typo at -e line 1.'],
	      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=()',
	      errs      => ['Name "main::a" used only once: possible typo at -e line 1.'],
              #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	}
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},
	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',
19e169bf	112	errs => ['Name "main::a" used only once: possible typo at -e line 1.'],
724aa791	113	bcopts => '-basic',
	114	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
	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	EOT_EOT
	121	# 4 <@> leave[1 ref] vKP/REFC ->(end)
	122	# 1 <0> enter ->2
	123	# 2 <;> nextstate(main 1 -e:1) v ->3
	124	# - <1> ex-rv2sv vKM/129 ->4
	125	# 3 <$> gvsv(*a) s/LVINTRO ->4
	126	EONT_EONT
	127
	128	pass("MY, OUR, LOCAL, BOTH SUB AND MAIN, = undef");
	129
	130	checkOptree ( name => 'sub {my $a=undef}',
	131	code => sub {my $a=undef},
	132	bcopts => '-basic',
	133	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
	134	3 <1> leavesub[1 ref] K/REFC,1 ->(end)
	135	- <@> lineseq KP ->3
	136	1 <;> nextstate(main 24 optree.t:99) v ->2
	137	2 <0> padsv[$a:24,25] sRM*/LVINTRO ->3
	138	EOT_EOT
	139	# 3 <1> leavesub[1 ref] K/REFC,1 ->(end)
	140	# - <@> lineseq KP ->3
	141	# 1 <;> nextstate(main 54 optree.t:149) v ->2
	142	# 2 <0> padsv[$a:54,55] sRM*/LVINTRO ->3
	143	EONT_EONT
	144
	145	checkOptree ( name => 'sub {our $a=undef}',
	146	code => sub {our $a=undef},
	147	note => 'the global must be reset',
	148	bcopts => '-basic',
	149	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
	150	5 <1> leavesub[1 ref] K/REFC,1 ->(end)
	151	- <@> lineseq KP ->5
	152	1 <;> nextstate(main 26 optree.t:109) v ->2
	153	4 <2> sassign sKS/2 ->5
	154	2 <0> undef s ->3
	155	- <1> ex-rv2sv sKRM*/17 ->4
	156	3 <#> gvsv[*a] s/OURINTR ->4
	157	EOT_EOT
	158	# 5 <1> leavesub[1 ref] K/REFC,1 ->(end)
	159	# - <@> lineseq KP ->5
	160	# 1 <;> nextstate(main 446 optree_varinit.t:137) v ->2
	161	# 4 <2> sassign sKS/2 ->5
	162	# 2 <0> undef s ->3
	163	# - <1> ex-rv2sv sKRM*/17 ->4
	164	# 3 <$> gvsv(*a) s/OURINTR ->4
	165	EONT_EONT
	166
	167	checkOptree ( name => 'sub {local $a=undef}',
	168	code => sub {local $a=undef},
	169	note => 'local not used enough to bother',
	170	bcopts => '-basic',
	171	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
	172	5 <1> leavesub[1 ref] K/REFC,1 ->(end)
	173	- <@> lineseq KP ->5
	174	1 <;> nextstate(main 28 optree.t:122) v ->2
	175	4 <2> sassign sKS/2 ->5
	176	2 <0> undef s ->3
177	- <1> ex-rv2sv sKRM*/129 ->4
178	3 <#> gvsv[*a] s/LVINTRO ->4
179	EOT_EOT
180	# 5 <1> leavesub[1 ref] K/REFC,1 ->(end)
181	# - <@> lineseq KP ->5
182	# 1 <;> nextstate(main 58 optree.t:141) v ->2
183	# 4 <2> sassign sKS/2 ->5
184	# 2 <0> undef s ->3
185	# - <1> ex-rv2sv sKRM*/129 ->4
186	# 3 <$> gvsv(*a) s/LVINTRO ->4
187	EONT_EONT
188
189	checkOptree ( name => 'my $a=undef',
190	prog => 'my $a=undef',
191	bcopts => '-basic',
192	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
193	4 <@> leave[1 ref] vKP/REFC ->(end)
194	1 <0> enter ->2
195	2 <;> nextstate(main 1 -e:1) v ->3
196	3 <0> padsv[$a:1,2] vRM*/LVINTRO ->4
197	EOT_EOT
198	# 4 <@> leave[1 ref] vKP/REFC ->(end)
199	# 1 <0> enter ->2
200	# 2 <;> nextstate(main 1 -e:1) v ->3
201	# 3 <0> padsv[$a:1,2] vRM*/LVINTRO ->4
202	EONT_EONT
203
204	checkOptree ( name => 'our $a=undef',
205	prog => 'our $a=undef',
206	note => 'global must be reassigned',
207	bcopts => '-basic',
208	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
209	6 <@> leave[1 ref] vKP/REFC ->(end)
210	1 <0> enter ->2
211	2 <;> nextstate(main 1 -e:1) v ->3
212	5 <2> sassign vKS/2 ->6
213	3 <0> undef s ->4
214	- <1> ex-rv2sv sKRM*/17 ->5
215	4 <#> gvsv[*a] s/OURINTR ->5
216	EOT_EOT
217	# 6 <@> leave[1 ref] vKP/REFC ->(end)
218	# 1 <0> enter ->2
219	# 2 <;> nextstate(main 1 -e:1) v ->3
220	# 5 <2> sassign vKS/2 ->6
221	# 3 <0> undef s ->4
222	# - <1> ex-rv2sv sKRM*/17 ->5
223	# 4 <$> gvsv(*a) s/OURINTR ->5
224	EONT_EONT
225
226	checkOptree ( name => 'local $a=undef',
227	prog => 'local $a=undef',
19e169bf	228	errs => ['Name "main::a" used only once: possible typo at -e line 1.'],
724aa791	229	note => 'locals are rare, probly not worth doing',
	230	bcopts => '-basic',
	231	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
	232	6 <@> leave[1 ref] vKP/REFC ->(end)
	233	1 <0> enter ->2
	234	2 <;> nextstate(main 1 -e:1) v ->3
	235	5 <2> sassign vKS/2 ->6
	236	3 <0> undef s ->4
	237	- <1> ex-rv2sv sKRM*/129 ->5
	238	4 <#> gvsv[*a] s/LVINTRO ->5
	239	EOT_EOT
	240	# 6 <@> leave[1 ref] vKP/REFC ->(end)
	241	# 1 <0> enter ->2
	242	# 2 <;> nextstate(main 1 -e:1) v ->3
	243	# 5 <2> sassign vKS/2 ->6
	244	# 3 <0> undef s ->4
	245	# - <1> ex-rv2sv sKRM*/129 ->5
	246	# 4 <$> gvsv(*a) s/LVINTRO ->5
	247	EONT_EONT
	248
	249	checkOptree ( name => 'sub {my $a=()}',
	250	code => sub {my $a=()},
724aa791	251	bcopts => '-exec',
724aa791	252	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
724aa791	253	1 <;> nextstate(main -439 optree.t:105) v
	254	2 <0> stub sP
	255	3 <0> padsv[$a:-439,-438] sRM*/LVINTRO
	256	4 <2> sassign sKS/2
	257	5 <1> leavesub[1 ref] K/REFC,1
	258	EOT_EOT
	259	# 1 <;> nextstate(main 438 optree_varinit.t:247) v
	260	# 2 <0> stub sP
	261	# 3 <0> padsv[$a:438,439] sRM*/LVINTRO
	262	# 4 <2> sassign sKS/2
	263	# 5 <1> leavesub[1 ref] K/REFC,1
	264	EONT_EONT
	265
	266	checkOptree ( name => 'sub {our $a=()}',
	267	code => sub {our $a=()},
	268	#todo => 'probly not worth doing',
	269	bcopts => '-exec',
	270	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
	271	1 <;> nextstate(main 31 optree.t:177) 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	EOT_EOT
	277	# 1 <;> nextstate(main 440 optree_varinit.t:262) v
	278	# 2 <0> stub sP
	279	# 3 <$> gvsv(*a) s/OURINTR
	280	# 4 <2> sassign sKS/2
	281	# 5 <1> leavesub[1 ref] K/REFC,1
	282	EONT_EONT
	283
	284	checkOptree ( name => 'sub {local $a=()}',
	285	code => sub {local $a=()},
	286	#todo => 'probly not worth doing',
	287	bcopts => '-exec',
	288	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
724aa791	289	1 <;> nextstate(main 33 optree.t:190) 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	EOT_EOT
724aa791	295	# 1 <;> nextstate(main 63 optree.t:225) v
	296	# 2 <0> stub sP
	297	# 3 <$> gvsv(*a) s/LVINTRO
	298	# 4 <2> sassign sKS/2
	299	# 5 <1> leavesub[1 ref] K/REFC,1
	300	EONT_EONT
	301
	302	checkOptree ( name => 'my $a=()',
	303	prog => 'my $a=()',
724aa791	304	bcopts => '-exec',
	305	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
	306	1 <0> enter
	307	2 <;> nextstate(main 1 -e:1) v
	308	3 <0> stub sP
	309	4 <0> padsv[$a:1,2] sRM*/LVINTRO
	310	5 <2> sassign vKS/2
	311	6 <@> leave[1 ref] vKP/REFC
	312	EOT_EOT
	313	# 1 <0> enter
	314	# 2 <;> nextstate(main 1 -e:1) v
	315	# 3 <0> stub sP
	316	# 4 <0> padsv[$a:1,2] sRM*/LVINTRO
	317	# 5 <2> sassign vKS/2
	318	# 6 <@> leave[1 ref] vKP/REFC
	319	EONT_EONT
	320
	321	checkOptree ( name => 'our $a=()',
	322	prog => 'our $a=()',
	323	#todo => 'probly not worth doing',
	324	bcopts => '-exec',
	325	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
	326	1 <0> enter
	327	2 <;> nextstate(main 1 -e:1) v
	328	3 <0> stub sP
	329	4 <#> gvsv[*a] s/OURINTR
	330	5 <2> sassign vKS/2
	331	6 <@> leave[1 ref] vKP/REFC
	332	EOT_EOT
	333	# 1 <0> enter
	334	# 2 <;> nextstate(main 1 -e:1) v
	335	# 3 <0> stub sP
	336	# 4 <$> gvsv(*a) s/OURINTR
	337	# 5 <2> sassign vKS/2
	338	# 6 <@> leave[1 ref] vKP/REFC
	339	EONT_EONT
	340
	341	checkOptree ( name => 'local $a=()',
	342	prog => 'local $a=()',
19e169bf	343	errs => ['Name "main::a" used only once: possible typo at -e line 1.'],
724aa791	344	#todo => 'probly not worth doing',
	345	bcopts => '-exec',
	346	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
	347	1 <0> enter
	348	2 <;> nextstate(main 1 -e:1) v
	349	3 <0> stub sP
	350	4 <#> gvsv[*a] s/LVINTRO
	351	5 <2> sassign vKS/2
	352	6 <@> leave[1 ref] vKP/REFC
	353	EOT_EOT
	354	# 1 <0> enter
	355	# 2 <;> nextstate(main 1 -e:1) v
	356	# 3 <0> stub sP
	357	# 4 <$> gvsv(*a) s/LVINTRO
	358	# 5 <2> sassign vKS/2
	359	# 6 <@> leave[1 ref] vKP/REFC
	360	EONT_EONT
	361
	362	checkOptree ( name => 'my ($a,$b)=()',
	363	prog => 'my ($a,$b)=()',
	364	#todo => 'probly not worth doing',
	365	bcopts => '-exec',
	366	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
	367	# 1 <0> enter
	368	# 2 <;> nextstate(main 1 -e:1) v
	369	# 3 <0> pushmark s
	370	# 4 <0> pushmark sRM*/128
	371	# 5 <0> padsv[$a:1,2] lRM*/LVINTRO
	372	# 6 <0> padsv[$b:1,2] lRM*/LVINTRO
	373	# 7 <2> aassign[t3] vKS
	374	# 8 <@> leave[1 ref] vKP/REFC
	375	EOT_EOT
	376	# 1 <0> enter
	377	# 2 <;> nextstate(main 1 -e:1) v
	378	# 3 <0> pushmark s
	379	# 4 <0> pushmark sRM*/128
	380	# 5 <0> padsv[$a:1,2] lRM*/LVINTRO
	381	# 6 <0> padsv[$b:1,2] lRM*/LVINTRO
	382	# 7 <2> aassign[t3] vKS
	383	# 8 <@> leave[1 ref] vKP/REFC
	384	EONT_EONT
	385
2ce64696	386	} #skip
2ce64696	387
724aa791	388	__END__
724aa791	389