[perl5.git] / ext / B / t / optree_varinit.t

#!perl

BEGIN {
    unshift @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},
	      strip_open_hints => 1,
	      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},
	      strip_open_hints => 1,
	      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},
	      strip_open_hints => 1,
	      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},
	      strip_open_hints => 1,
	      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',
	      strip_open_hints => 1,
	      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',
	      strip_open_hints => 1,
	      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',
	      strip_open_hints => 1,
	      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',
	      strip_open_hints => 1,
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
5  <1> leavesub[1 ref] K/REFC,1 ->(end)
-     <@> lineseq KP ->5
1        <;> nextstate(main 641 optree_varinit.t:130) v:>,<,% ->2
4        <2> sassign sKS/2 ->5
2           <0> undef s ->3
3           <0> padsv[$a:641,642] sRM*/LVINTRO ->4
EOT_EOT
# 5  <1> leavesub[1 ref] K/REFC,1 ->(end)
# -     <@> lineseq KP ->5
# 1        <;> nextstate(main 641 optree_varinit.t:130) v:>,<,% ->2
# 4        <2> sassign sKS/2 ->5
# 2           <0> undef s ->3
# 3           <0> padsv[$a:641,642] sRM*/LVINTRO ->4
EONT_EONT

checkOptree ( name	=> 'sub {our $a=undef}',
	      code	=> sub {our $a=undef},
	      note	=> 'the global must be reset',
	      bcopts	=> '-basic',
	      strip_open_hints => 1,
	      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',
	      strip_open_hints => 1,
	      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',
	      strip_open_hints => 1,
	      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
4        <0> padsv[$a:1,2] sRM*/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
# 4        <0> padsv[$a:1,2] sRM*/LVINTRO ->5
EONT_EONT

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