[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{'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=()},
              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	}
2799c206	11	if ($Config{'extensions'} !~ /\bData\/Dumper\b/) {
	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=()},
cc02ea56	249	todo => 'apparently done, by patch #?',
724aa791	250	bcopts => '-exec',
724aa791	251	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
724aa791	252	1 <;> nextstate(main -439 optree.t:105) v
	253	2 <0> stub sP
	254	3 <0> padsv[$a:-439,-438] sRM*/LVINTRO
	255	4 <2> sassign sKS/2
	256	5 <1> leavesub[1 ref] K/REFC,1
	257	EOT_EOT
	258	# 1 <;> nextstate(main 438 optree_varinit.t:247) v
	259	# 2 <0> stub sP
	260	# 3 <0> padsv[$a:438,439] sRM*/LVINTRO
	261	# 4 <2> sassign sKS/2
	262	# 5 <1> leavesub[1 ref] K/REFC,1
	263	EONT_EONT
	264
	265	checkOptree ( name => 'sub {our $a=()}',
	266	code => sub {our $a=()},
	267	#todo => 'probly not worth doing',
	268	bcopts => '-exec',
	269	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
	270	1 <;> nextstate(main 31 optree.t:177) v
	271	2 <0> stub sP
	272	3 <#> gvsv[*a] s/OURINTR
	273	4 <2> sassign sKS/2
	274	5 <1> leavesub[1 ref] K/REFC,1
	275	EOT_EOT
	276	# 1 <;> nextstate(main 440 optree_varinit.t:262) v
	277	# 2 <0> stub sP
	278	# 3 <$> gvsv(*a) s/OURINTR
	279	# 4 <2> sassign sKS/2
	280	# 5 <1> leavesub[1 ref] K/REFC,1
	281	EONT_EONT
	282
	283	checkOptree ( name => 'sub {local $a=()}',
	284	code => sub {local $a=()},
	285	#todo => 'probly not worth doing',
	286	bcopts => '-exec',
	287	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
724aa791	288	1 <;> nextstate(main 33 optree.t:190) v
	289	2 <0> stub sP
	290	3 <#> gvsv[*a] s/LVINTRO
	291	4 <2> sassign sKS/2
	292	5 <1> leavesub[1 ref] K/REFC,1
	293	EOT_EOT
724aa791	294	# 1 <;> nextstate(main 63 optree.t:225) v
	295	# 2 <0> stub sP
	296	# 3 <$> gvsv(*a) s/LVINTRO
	297	# 4 <2> sassign sKS/2
	298	# 5 <1> leavesub[1 ref] K/REFC,1
	299	EONT_EONT
	300
	301	checkOptree ( name => 'my $a=()',
	302	prog => 'my $a=()',
cc02ea56	303	todo => 'apparently done, by patch #?',
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=()',
	343	#todo => 'probly not worth doing',
	344	bcopts => '-exec',
	345	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
	346	1 <0> enter
	347	2 <;> nextstate(main 1 -e:1) v
	348	3 <0> stub sP
	349	4 <#> gvsv[*a] s/LVINTRO
	350	5 <2> sassign vKS/2
	351	6 <@> leave[1 ref] vKP/REFC
	352	EOT_EOT
	353	# 1 <0> enter
	354	# 2 <;> nextstate(main 1 -e:1) v
	355	# 3 <0> stub sP
	356	# 4 <$> gvsv(*a) s/LVINTRO
	357	# 5 <2> sassign vKS/2
	358	# 6 <@> leave[1 ref] vKP/REFC
	359	EONT_EONT
	360
	361	checkOptree ( name => 'my ($a,$b)=()',
	362	prog => 'my ($a,$b)=()',
	363	#todo => 'probly not worth doing',
	364	bcopts => '-exec',
	365	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
	366	# 1 <0> enter
	367	# 2 <;> nextstate(main 1 -e:1) v
368	# 3 <0> pushmark s
369	# 4 <0> pushmark sRM*/128
370	# 5 <0> padsv[$a:1,2] lRM*/LVINTRO
371	# 6 <0> padsv[$b:1,2] lRM*/LVINTRO
372	# 7 <2> aassign[t3] vKS
373	# 8 <@> leave[1 ref] vKP/REFC
374	EOT_EOT
375	# 1 <0> enter
376	# 2 <;> nextstate(main 1 -e:1) v
377	# 3 <0> pushmark s
378	# 4 <0> pushmark sRM*/128
379	# 5 <0> padsv[$a:1,2] lRM*/LVINTRO
380	# 6 <0> padsv[$b:1,2] lRM*/LVINTRO
381	# 7 <2> aassign[t3] vKS
382	# 8 <@> leave[1 ref] vKP/REFC
383	EONT_EONT
384
2ce64696	385	} #skip
2ce64696	386
724aa791	387	__END__
724aa791	388