[perl5.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');
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',
	      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');
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',
	      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 JC	1	#!perl
	2
	3	BEGIN {
5638aaac SM	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 NC	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 JC	17	}
724aa791 JC	18	use OptreeCheck;
2ce64696	19	use Config;
724aa791	20	plan tests => 22;
2ce64696 JC	21	SKIP: {
	22	skip "no perlio in this build", 22 unless $Config::Config{useperlio};
	23
724aa791 JC	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 JC	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 JC	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 JC	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 JC	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 JC	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 JC	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 JC	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');
0b599ae5 RGS	134	5 <1> leavesub[1 ref] K/REFC,1 ->(end)
	135	- <@> lineseq KP ->5
	136	1 <;> nextstate(main 641 optree_varinit.t:130) v ->2
	137	4 <2> sassign sKS/2 ->5
	138	2 <0> undef s ->3
	139	3 <0> padsv[$a:641,642] sRM*/LVINTRO ->4
724aa791	140	EOT_EOT
0b599ae5 RGS	141	# 5 <1> leavesub[1 ref] K/REFC,1 ->(end)
	142	# - <@> lineseq KP ->5
	143	# 1 <;> nextstate(main 641 optree_varinit.t:130) v ->2
	144	# 4 <2> sassign sKS/2 ->5
	145	# 2 <0> undef s ->3
	146	# 3 <0> padsv[$a:641,642] sRM*/LVINTRO ->4
724aa791 JC	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');
0b599ae5	197	6 <@> leave[1 ref] vKP/REFC ->(end)
724aa791 JC	198	1 <0> enter ->2
724aa791 JC	199	2 <;> nextstate(main 1 -e:1) v ->3
0b599ae5 RGS	200	5 <2> sassign vKS/2 ->6
	201	3 <0> undef s ->4
	202	4 <0> padsv[$a:1,2] sRM*/LVINTRO ->5
724aa791	203	EOT_EOT
0b599ae5	204	# 6 <@> leave[1 ref] vKP/REFC ->(end)
724aa791 JC	205	# 1 <0> enter ->2
724aa791 JC	206	# 2 <;> nextstate(main 1 -e:1) v ->3
0b599ae5 RGS	207	# 5 <2> sassign vKS/2 ->6
	208	# 3 <0> undef s ->4
	209	# 4 <0> padsv[$a:1,2] sRM*/LVINTRO ->5
724aa791 JC	210	EONT_EONT
	211
	212	checkOptree ( name => 'our $a=undef',
	213	prog => 'our $a=undef',
	214	note => 'global must be reassigned',
	215	bcopts => '-basic',
	216	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
	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	EOT_EOT
	225	# 6 <@> leave[1 ref] vKP/REFC ->(end)
	226	# 1 <0> enter ->2
	227	# 2 <;> nextstate(main 1 -e:1) v ->3
	228	# 5 <2> sassign vKS/2 ->6
	229	# 3 <0> undef s ->4
	230	# - <1> ex-rv2sv sKRM*/17 ->5
	231	# 4 <$> gvsv(*a) s/OURINTR ->5
	232	EONT_EONT
	233
	234	checkOptree ( name => 'local $a=undef',
	235	prog => 'local $a=undef',
19e169bf	236	errs => ['Name "main::a" used only once: possible typo at -e line 1.'],
724aa791 JC	237	note => 'locals are rare, probly not worth doing',
	238	bcopts => '-basic',
	239	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
	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	EOT_EOT
	248	# 6 <@> leave[1 ref] vKP/REFC ->(end)
	249	# 1 <0> enter ->2
	250	# 2 <;> nextstate(main 1 -e:1) v ->3
	251	# 5 <2> sassign vKS/2 ->6
	252	# 3 <0> undef s ->4
	253	# - <1> ex-rv2sv sKRM*/129 ->5
	254	# 4 <$> gvsv(*a) s/LVINTRO ->5
	255	EONT_EONT
	256
	257	checkOptree ( name => 'sub {my $a=()}',
	258	code => sub {my $a=()},
724aa791 JC	259	bcopts => '-exec',
724aa791 JC	260	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
724aa791 JC	261	1 <;> nextstate(main -439 optree.t:105) v
	262	2 <0> stub sP
	263	3 <0> padsv[$a:-439,-438] sRM*/LVINTRO
	264	4 <2> sassign sKS/2
	265	5 <1> leavesub[1 ref] K/REFC,1
	266	EOT_EOT
	267	# 1 <;> nextstate(main 438 optree_varinit.t:247) v
	268	# 2 <0> stub sP
	269	# 3 <0> padsv[$a:438,439] sRM*/LVINTRO
	270	# 4 <2> sassign sKS/2
	271	# 5 <1> leavesub[1 ref] K/REFC,1
	272	EONT_EONT
	273
	274	checkOptree ( name => 'sub {our $a=()}',
	275	code => sub {our $a=()},
	276	#todo => 'probly not worth doing',
	277	bcopts => '-exec',
	278	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
	279	1 <;> nextstate(main 31 optree.t:177) v
	280	2 <0> stub sP
	281	3 <#> gvsv[*a] s/OURINTR
	282	4 <2> sassign sKS/2
	283	5 <1> leavesub[1 ref] K/REFC,1
	284	EOT_EOT
	285	# 1 <;> nextstate(main 440 optree_varinit.t:262) v
	286	# 2 <0> stub sP
	287	# 3 <$> gvsv(*a) s/OURINTR
	288	# 4 <2> sassign sKS/2
	289	# 5 <1> leavesub[1 ref] K/REFC,1
	290	EONT_EONT
	291
	292	checkOptree ( name => 'sub {local $a=()}',
	293	code => sub {local $a=()},
	294	#todo => 'probly not worth doing',
	295	bcopts => '-exec',
	296	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
724aa791 JC	297	1 <;> nextstate(main 33 optree.t:190) v
	298	2 <0> stub sP
	299	3 <#> gvsv[*a] s/LVINTRO
	300	4 <2> sassign sKS/2
	301	5 <1> leavesub[1 ref] K/REFC,1
	302	EOT_EOT
724aa791 JC	303	# 1 <;> nextstate(main 63 optree.t:225) v
	304	# 2 <0> stub sP
	305	# 3 <$> gvsv(*a) s/LVINTRO
	306	# 4 <2> sassign sKS/2
	307	# 5 <1> leavesub[1 ref] K/REFC,1
	308	EONT_EONT
	309
	310	checkOptree ( name => 'my $a=()',
	311	prog => 'my $a=()',
724aa791 JC	312	bcopts => '-exec',
	313	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
	314	1 <0> enter
	315	2 <;> nextstate(main 1 -e:1) v
	316	3 <0> stub sP
	317	4 <0> padsv[$a:1,2] sRM*/LVINTRO
	318	5 <2> sassign vKS/2
	319	6 <@> leave[1 ref] vKP/REFC
	320	EOT_EOT
	321	# 1 <0> enter
	322	# 2 <;> nextstate(main 1 -e:1) v
	323	# 3 <0> stub sP
	324	# 4 <0> padsv[$a:1,2] sRM*/LVINTRO
	325	# 5 <2> sassign vKS/2
	326	# 6 <@> leave[1 ref] vKP/REFC
	327	EONT_EONT
	328
	329	checkOptree ( name => 'our $a=()',
	330	prog => 'our $a=()',
	331	#todo => 'probly not worth doing',
	332	bcopts => '-exec',
	333	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
	334	1 <0> enter
	335	2 <;> nextstate(main 1 -e:1) v
	336	3 <0> stub sP
	337	4 <#> gvsv[*a] s/OURINTR
	338	5 <2> sassign vKS/2
	339	6 <@> leave[1 ref] vKP/REFC
	340	EOT_EOT
	341	# 1 <0> enter
	342	# 2 <;> nextstate(main 1 -e:1) v
	343	# 3 <0> stub sP
	344	# 4 <$> gvsv(*a) s/OURINTR
	345	# 5 <2> sassign vKS/2
	346	# 6 <@> leave[1 ref] vKP/REFC
	347	EONT_EONT
	348
	349	checkOptree ( name => 'local $a=()',
	350	prog => 'local $a=()',
19e169bf	351	errs => ['Name "main::a" used only once: possible typo at -e line 1.'],
724aa791 JC	352	#todo => 'probly not worth doing',
	353	bcopts => '-exec',
	354	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
	355	1 <0> enter
	356	2 <;> nextstate(main 1 -e:1) v
	357	3 <0> stub sP
	358	4 <#> gvsv[*a] s/LVINTRO
	359	5 <2> sassign vKS/2
	360	6 <@> leave[1 ref] vKP/REFC
	361	EOT_EOT
	362	# 1 <0> enter
	363	# 2 <;> nextstate(main 1 -e:1) v
	364	# 3 <0> stub sP
	365	# 4 <$> gvsv(*a) s/LVINTRO
	366	# 5 <2> sassign vKS/2
	367	# 6 <@> leave[1 ref] vKP/REFC
	368	EONT_EONT
	369
	370	checkOptree ( name => 'my ($a,$b)=()',
	371	prog => 'my ($a,$b)=()',
	372	#todo => 'probly not worth doing',
	373	bcopts => '-exec',
	374	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
	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	EOT_EOT
	384	# 1 <0> enter
	385	# 2 <;> nextstate(main 1 -e:1) v
	386	# 3 <0> pushmark s
	387	# 4 <0> pushmark sRM*/128
	388	# 5 <0> padsv[$a:1,2] lRM*/LVINTRO
	389	# 6 <0> padsv[$b:1,2] lRM*/LVINTRO
	390	# 7 <2> aassign[t3] vKS
	391	# 8 <@> leave[1 ref] vKP/REFC
	392	EONT_EONT
	393
2ce64696 JC	394	} #skip
2ce64696 JC	395
724aa791 JC	396	__END__
724aa791 JC	397