[perl5.git] / ext / B / t / optree_samples.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	=> 20;
SKIP: {
    skip "no perlio in this build", 20 unless $Config::Config{useperlio};

pass("GENERAL OPTREE EXAMPLES");

pass("IF,THEN,ELSE, ?:");

checkOptree ( name	=> '-basic sub {if shift print then,else}',
	      bcopts	=> '-basic',
	      code	=> sub { if (shift) { print "then" }
				 else       { print "else" }
			     },
	      strip_open_hints => 1,
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
# 7  <1> leavesub[1 ref] K/REFC,1 ->(end)
# -     <@> lineseq KP ->7
# 1        <;> nextstate(main 665 optree_samples.t:24) v:>,<,% ->2
# -        <1> null K/1 ->-
# 3           <|> cond_expr(other->4) K/1 ->8
# 2              <0> shift s* ->3
# -              <@> scope K ->-
# -                 <0> ex-nextstate v ->4
# 6                 <@> print sK ->7
# 4                    <0> pushmark s ->5
# 5                    <$> const[PV "then"] s ->6
# d              <@> leave KP ->7
# 8                 <0> enter ->9
# 9                 <;> nextstate(main 663 optree_samples.t:25) v:>,<,% ->a
# c                 <@> print sK ->d
# a                    <0> pushmark s ->b
# b                    <$> const[PV "else"] s ->c
EOT_EOT
# 7  <1> leavesub[1 ref] K/REFC,1 ->(end)
# -     <@> lineseq KP ->7
# 1        <;> nextstate(main 665 optree_samples.t:24) v:>,<,% ->2
# -        <1> null K/1 ->-
# 3           <|> cond_expr(other->4) K/1 ->8
# 2              <0> shift s* ->3
# -              <@> scope K ->-
# -                 <0> ex-nextstate v ->4
# 6                 <@> print sK ->7
# 4                    <0> pushmark s ->5
# 5                    <$> const(PV "then") s ->6
# d              <@> leave KP ->7
# 8                 <0> enter ->9
# 9                 <;> nextstate(main 663 optree_samples.t:25) v:>,<,% ->a
# c                 <@> print sK ->d
# a                    <0> pushmark s ->b
# b                    <$> const(PV "else") s ->c
EONT_EONT

checkOptree ( name	=> '-basic (see above, with my $a = shift)',
	      bcopts	=> '-basic',
	      code	=> sub { my $a = shift;
				 if ($a) { print "foo" }
				 else    { print "bar" }
			     },
	      strip_open_hints => 1,
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
# b  <1> leavesub[1 ref] K/REFC,1 ->(end)
# -     <@> lineseq KP ->b
# 1        <;> nextstate(main 666 optree_samples.t:70) v:>,<,% ->2
# 4        <2> sassign vKS/2 ->5
# 2           <0> shift s* ->3
# 3           <0> padsv[$a:666,670] sRM*/LVINTRO ->4
# 5        <;> nextstate(main 670 optree_samples.t:71) v:>,<,% ->6
# -        <1> null K/1 ->-
# 7           <|> cond_expr(other->8) K/1 ->c
# 6              <0> padsv[$a:666,670] s ->7
# -              <@> scope K ->-
# -                 <0> ex-nextstate v ->8
# a                 <@> print sK ->b
# 8                    <0> pushmark s ->9
# 9                    <$> const[PV "foo"] s ->a
# h              <@> leave KP ->b
# c                 <0> enter ->d
# d                 <;> nextstate(main 668 optree_samples.t:72) v:>,<,% ->e
# g                 <@> print sK ->h
# e                    <0> pushmark s ->f
# f                    <$> const[PV "bar"] s ->g
EOT_EOT
# b  <1> leavesub[1 ref] K/REFC,1 ->(end)
# -     <@> lineseq KP ->b
# 1        <;> nextstate(main 666 optree_samples.t:72) v:>,<,% ->2
# 4        <2> sassign vKS/2 ->5
# 2           <0> shift s* ->3
# 3           <0> padsv[$a:666,670] sRM*/LVINTRO ->4
# 5        <;> nextstate(main 670 optree_samples.t:73) v:>,<,% ->6
# -        <1> null K/1 ->-
# 7           <|> cond_expr(other->8) K/1 ->c
# 6              <0> padsv[$a:666,670] s ->7
# -              <@> scope K ->-
# -                 <0> ex-nextstate v ->8
# a                 <@> print sK ->b
# 8                    <0> pushmark s ->9
# 9                    <$> const(PV "foo") s ->a
# h              <@> leave KP ->b
# c                 <0> enter ->d
# d                 <;> nextstate(main 668 optree_samples.t:74) v:>,<,% ->e
# g                 <@> print sK ->h
# e                    <0> pushmark s ->f
# f                    <$> const(PV "bar") s ->g
EONT_EONT

checkOptree ( name	=> '-exec sub {if shift print then,else}',
	      bcopts	=> '-exec',
	      code	=> sub { if (shift) { print "then" }
				 else       { print "else" }
			     },
	      strip_open_hints => 1,
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
# 1  <;> nextstate(main 674 optree_samples.t:125) v:>,<,%
# 2  <0> shift s*
# 3  <|> cond_expr(other->4) K/1
# 4      <0> pushmark s
# 5      <$> const[PV "then"] s
# 6      <@> print sK
#            goto 7
# 8  <0> enter 
# 9  <;> nextstate(main 672 optree_samples.t:126) v:>,<,%
# a  <0> pushmark s
# b  <$> const[PV "else"] s
# c  <@> print sK
# d  <@> leave KP
# 7  <1> leavesub[1 ref] K/REFC,1
EOT_EOT
# 1  <;> nextstate(main 674 optree_samples.t:129) v:>,<,%
# 2  <0> shift s*
# 3  <|> cond_expr(other->4) K/1
# 4      <0> pushmark s
# 5      <$> const(PV "then") s
# 6      <@> print sK
#            goto 7
# 8  <0> enter 
# 9  <;> nextstate(main 672 optree_samples.t:130) v:>,<,%
# a  <0> pushmark s
# b  <$> const(PV "else") s
# c  <@> print sK
# d  <@> leave KP
# 7  <1> leavesub[1 ref] K/REFC,1
EONT_EONT

checkOptree ( name	=> '-exec (see above, with my $a = shift)',
	      bcopts	=> '-exec',
	      code	=> sub { my $a = shift;
				 if ($a) { print "foo" }
				 else    { print "bar" }
			     },
	      strip_open_hints => 1,
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
# 1  <;> nextstate(main 675 optree_samples.t:165) v:>,<,%
# 2  <0> shift s*
# 3  <0> padsv[$a:675,679] sRM*/LVINTRO
# 4  <2> sassign vKS/2
# 5  <;> nextstate(main 679 optree_samples.t:166) v:>,<,%
# 6  <0> padsv[$a:675,679] s
# 7  <|> cond_expr(other->8) K/1
# 8      <0> pushmark s
# 9      <$> const[PV "foo"] s
# a      <@> print sK
#            goto b
# c  <0> enter 
# d  <;> nextstate(main 677 optree_samples.t:167) v:>,<,%
# e  <0> pushmark s
# f  <$> const[PV "bar"] s
# g  <@> print sK
# h  <@> leave KP
# b  <1> leavesub[1 ref] K/REFC,1
EOT_EOT
# 1  <;> nextstate(main 675 optree_samples.t:171) v:>,<,%
# 2  <0> shift s*
# 3  <0> padsv[$a:675,679] sRM*/LVINTRO
# 4  <2> sassign vKS/2
# 5  <;> nextstate(main 679 optree_samples.t:172) v:>,<,%
# 6  <0> padsv[$a:675,679] s
# 7  <|> cond_expr(other->8) K/1
# 8      <0> pushmark s
# 9      <$> const(PV "foo") s
# a      <@> print sK
#            goto b
# c  <0> enter 
# d  <;> nextstate(main 677 optree_samples.t:173) v:>,<,%
# e  <0> pushmark s
# f  <$> const(PV "bar") s
# g  <@> print sK
# h  <@> leave KP
# b  <1> leavesub[1 ref] K/REFC,1
EONT_EONT

checkOptree ( name	=> '-exec sub { print (shift) ? "foo" : "bar" }',
	      code	=> sub { print (shift) ? "foo" : "bar" },
	      bcopts	=> '-exec',
	      strip_open_hints => 1,
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
# 1  <;> nextstate(main 680 optree_samples.t:213) v:>,<,%
# 2  <0> pushmark s
# 3  <0> shift s*
# 4  <@> print sK
# 5  <|> cond_expr(other->6) K/1
# 6      <$> const[PV "foo"] s
#            goto 7
# 8  <$> const[PV "bar"] s
# 7  <1> leavesub[1 ref] K/REFC,1
EOT_EOT
# 1  <;> nextstate(main 680 optree_samples.t:221) v:>,<,%
# 2  <0> pushmark s
# 3  <0> shift s*
# 4  <@> print sK
# 5  <|> cond_expr(other->6) K/1
# 6      <$> const(PV "foo") s
#            goto 7
# 8  <$> const(PV "bar") s
# 7  <1> leavesub[1 ref] K/REFC,1
EONT_EONT

pass ("FOREACH");

checkOptree ( name	=> '-exec sub { foreach (1..10) {print "foo $_"} }',
	      code	=> sub { foreach (1..10) {print "foo $_"} },
	      bcopts	=> '-exec',
	      strip_open_hints => 1,
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
# 1  <;> nextstate(main 443 optree.t:158) v:>,<,%
# 2  <0> pushmark s
# 3  <$> const[IV 1] s
# 4  <$> const[IV 10] s
# 5  <#> gv[*_] s
# 6  <{> enteriter(next->d last->g redo->7) lKS/8
# e  <0> iter s
# f  <|> and(other->7) K/1
# 7      <;> nextstate(main 442 optree.t:158) v:>,<,%
# 8      <0> pushmark s
# 9      <$> const[PV "foo "] s
# a      <#> gvsv[*_] s
# b      <2> concat[t4] sK/2
# c      <@> print vK
# d      <0> unstack s
#            goto e
# g  <2> leaveloop K/2
# h  <1> leavesub[1 ref] K/REFC,1
EOT_EOT
# 1  <;> nextstate(main 444 optree_samples.t:182) v:>,<,%
# 2  <0> pushmark s
# 3  <$> const(IV 1) s
# 4  <$> const(IV 10) s
# 5  <$> gv(*_) s
# 6  <{> enteriter(next->d last->g redo->7) lKS/8
# e  <0> iter s
# f  <|> and(other->7) K/1
# 7      <;> nextstate(main 443 optree_samples.t:182) v:>,<,%
# 8      <0> pushmark s
# 9      <$> const(PV "foo ") s
# a      <$> gvsv(*_) s
# b      <2> concat[t3] sK/2
# c      <@> print vK
# d      <0> unstack s
#            goto e
# g  <2> leaveloop K/2
# h  <1> leavesub[1 ref] K/REFC,1
EONT_EONT

checkOptree ( name	=> '-basic sub { print "foo $_" foreach (1..10) }',
	      code	=> sub { print "foo $_" foreach (1..10) }, 
	      bcopts	=> '-basic',
	      strip_open_hints => 1,
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
# g  <1> leavesub[1 ref] K/REFC,1 ->(end)
# -     <@> lineseq KP ->g
# 1        <;> nextstate(main 445 optree.t:167) v:>,<,% ->2
# f        <2> leaveloop K/2 ->g
# 6           <{> enteriter(next->c last->f redo->7) lKS/8 ->d
# -              <0> ex-pushmark s ->2
# -              <1> ex-list lK ->5
# 2                 <0> pushmark s ->3
# 3                 <$> const[IV 1] s ->4
# 4                 <$> const[IV 10] s ->5
# 5              <#> gv[*_] s ->6
# -           <1> null K/1 ->f
# e              <|> and(other->7) K/1 ->f
# d                 <0> iter s ->e
# -                 <@> lineseq sK ->-
# b                    <@> print vK ->c
# 7                       <0> pushmark s ->8
# -                       <1> ex-stringify sK/1 ->b
# -                          <0> ex-pushmark s ->8
# a                          <2> concat[t2] sK/2 ->b
# 8                             <$> const[PV "foo "] s ->9
# -                             <1> ex-rv2sv sK/1 ->a
# 9                                <#> gvsv[*_] s ->a
# c                    <0> unstack s ->d
EOT_EOT
# g  <1> leavesub[1 ref] K/REFC,1 ->(end)
# -     <@> lineseq KP ->g
# 1        <;> nextstate(main 446 optree_samples.t:192) v:>,<,% ->2
# f        <2> leaveloop K/2 ->g
# 6           <{> enteriter(next->c last->f redo->7) lKS/8 ->d
# -              <0> ex-pushmark s ->2
# -              <1> ex-list lK ->5
# 2                 <0> pushmark s ->3
# 3                 <$> const(IV 1) s ->4
# 4                 <$> const(IV 10) s ->5
# 5              <$> gv(*_) s ->6
# -           <1> null K/1 ->f
# e              <|> and(other->7) K/1 ->f
# d                 <0> iter s ->e
# -                 <@> lineseq sK ->-
# b                    <@> print vK ->c
# 7                       <0> pushmark s ->8
# -                       <1> ex-stringify sK/1 ->b
# -                          <0> ex-pushmark s ->8
# a                          <2> concat[t1] sK/2 ->b
# 8                             <$> const(PV "foo ") s ->9
# -                             <1> ex-rv2sv sK/1 ->a
# 9                                <$> gvsv(*_) s ->a
# c                    <0> unstack s ->d
EONT_EONT

checkOptree ( name	=> '-exec -e foreach (1..10) {print qq{foo $_}}',
	      prog	=> 'foreach (1..10) {print qq{foo $_}}',
	      bcopts	=> '-exec',
	      strip_open_hints => 1,
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
# 1  <0> enter 
# 2  <;> nextstate(main 2 -e:1) v:>,<,%,{
# 3  <0> pushmark s
# 4  <$> const[IV 1] s
# 5  <$> const[IV 10] s
# 6  <#> gv[*_] s
# 7  <{> enteriter(next->e last->h redo->8) lKS/8
# f  <0> iter s
# g  <|> and(other->8) vK/1
# 8      <;> nextstate(main 1 -e:1) v:>,<,%
# 9      <0> pushmark s
# a      <$> const[PV "foo "] s
# b      <#> gvsv[*_] s
# c      <2> concat[t4] sK/2
# d      <@> print vK
# e      <0> unstack v
#            goto f
# h  <2> leaveloop vK/2
# i  <@> leave[1 ref] vKP/REFC
EOT_EOT
# 1  <0> enter 
# 2  <;> nextstate(main 2 -e:1) v:>,<,%,{
# 3  <0> pushmark s
# 4  <$> const(IV 1) s
# 5  <$> const(IV 10) s
# 6  <$> gv(*_) s
# 7  <{> enteriter(next->e last->h redo->8) lKS/8
# f  <0> iter s
# g  <|> and(other->8) vK/1
# 8      <;> nextstate(main 1 -e:1) v:>,<,%
# 9      <0> pushmark s
# a      <$> const(PV "foo ") s
# b      <$> gvsv(*_) s
# c      <2> concat[t3] sK/2
# d      <@> print vK
# e      <0> unstack v
#            goto f
# h  <2> leaveloop vK/2
# i  <@> leave[1 ref] vKP/REFC
EONT_EONT

checkOptree ( name	=> '-exec sub { print "foo $_" foreach (1..10) }',
	      code	=> sub { print "foo $_" foreach (1..10) }, 
	      bcopts	=> '-exec',
	      strip_open_hints => 1,
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
# 1  <;> nextstate(main 445 optree.t:167) v:>,<,%
# 2  <0> pushmark s
# 3  <$> const[IV 1] s
# 4  <$> const[IV 10] s
# 5  <#> gv[*_] s
# 6  <{> enteriter(next->c last->f redo->7) lKS/8
# d  <0> iter s
# e  <|> and(other->7) K/1
# 7      <0> pushmark s
# 8      <$> const[PV "foo "] s
# 9      <#> gvsv[*_] s
# a      <2> concat[t2] sK/2
# b      <@> print vK
# c      <0> unstack s
#            goto d
# f  <2> leaveloop K/2
# g  <1> leavesub[1 ref] K/REFC,1
EOT_EOT
# 1  <;> nextstate(main 447 optree_samples.t:252) v:>,<,%
# 2  <0> pushmark s
# 3  <$> const(IV 1) s
# 4  <$> const(IV 10) s
# 5  <$> gv(*_) s
# 6  <{> enteriter(next->c last->f redo->7) lKS/8
# d  <0> iter s
# e  <|> and(other->7) K/1
# 7      <0> pushmark s
# 8      <$> const(PV "foo ") s
# 9      <$> gvsv(*_) s
# a      <2> concat[t1] sK/2
# b      <@> print vK
# c      <0> unstack s
#            goto d
# f  <2> leaveloop K/2
# g  <1> leavesub[1 ref] K/REFC,1
EONT_EONT

pass("GREP: SAMPLES FROM PERLDOC -F GREP");

checkOptree ( name	=> '@foo = grep(!/^\#/, @bar)',
	      code	=> '@foo = grep(!/^\#/, @bar)',
	      bcopts	=> '-exec',
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
# 1  <;> nextstate(main 496 (eval 20):1) v:{
# 2  <0> pushmark s
# 3  <0> pushmark s
# 4  <#> gv[*bar] s
# 5  <1> rv2av[t4] lKM/1
# 6  <@> grepstart lK
# 7  <|> grepwhile(other->8)[t5] lK
# 8      </> match(/"^#"/) s/RTIME
# 9      <1> not sK/1
#            goto 7
# a  <0> pushmark s
# b  <#> gv[*foo] s
# c  <1> rv2av[t2] lKRM*/1
# d  <2> aassign[t6] KS/COMMON
# e  <1> leavesub[1 ref] K/REFC,1
EOT_EOT
# 1  <;> nextstate(main 496 (eval 20):1) v:{
# 2  <0> pushmark s
# 3  <0> pushmark s
# 4  <$> gv(*bar) s
# 5  <1> rv2av[t2] lKM/1
# 6  <@> grepstart lK
# 7  <|> grepwhile(other->8)[t3] lK
# 8      </> match(/"^\\#"/) s/RTIME
# 9      <1> not sK/1
#            goto 7
# a  <0> pushmark s
# b  <$> gv(*foo) s
# c  <1> rv2av[t1] lKRM*/1
# d  <2> aassign[t4] KS/COMMON
# e  <1> leavesub[1 ref] K/REFC,1
EONT_EONT


pass("MAP: SAMPLES FROM PERLDOC -F MAP");

checkOptree ( name	=> '%h = map { getkey($_) => $_ } @a',
	      code	=> '%h = map { getkey($_) => $_ } @a',
	      bcopts	=> '-exec',
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
# 1  <;> nextstate(main 501 (eval 22):1) v:{
# 2  <0> pushmark s
# 3  <0> pushmark s
# 4  <#> gv[*a] s
# 5  <1> rv2av[t8] lKM/1
# 6  <@> mapstart lK*
# 7  <|> mapwhile(other->8)[t9] lK
# 8      <0> enter l
# 9      <;> nextstate(main 500 (eval 22):1) v:{
# a      <0> pushmark s
# b      <0> pushmark s
# c      <#> gvsv[*_] s
# d      <#> gv[*getkey] s/EARLYCV
# e      <1> entersub[t5] lKS/TARG,1
# f      <#> gvsv[*_] s
# g      <@> list lK
# h      <@> leave lKP
#            goto 7
# i  <0> pushmark s
# j  <#> gv[*h] s
# k  <1> rv2hv[t2] lKRM*/1
# l  <2> aassign[t10] KS/COMMON
# m  <1> leavesub[1 ref] K/REFC,1
EOT_EOT
# 1  <;> nextstate(main 501 (eval 22):1) v:{
# 2  <0> pushmark s
# 3  <0> pushmark s
# 4  <$> gv(*a) s
# 5  <1> rv2av[t3] lKM/1
# 6  <@> mapstart lK*
# 7  <|> mapwhile(other->8)[t4] lK
# 8      <0> enter l
# 9      <;> nextstate(main 500 (eval 22):1) v:{
# a      <0> pushmark s
# b      <0> pushmark s
# c      <$> gvsv(*_) s
# d      <$> gv(*getkey) s/EARLYCV
# e      <1> entersub[t2] lKS/TARG,1
# f      <$> gvsv(*_) s
# g      <@> list lK
# h      <@> leave lKP
#            goto 7
# i  <0> pushmark s
# j  <$> gv(*h) s
# k  <1> rv2hv[t1] lKRM*/1
# l  <2> aassign[t5] KS/COMMON
# m  <1> leavesub[1 ref] K/REFC,1
EONT_EONT

checkOptree ( name	=> '%h=(); for $_(@a){$h{getkey($_)} = $_}',
	      code	=> '%h=(); for $_(@a){$h{getkey($_)} = $_}',
	      bcopts	=> '-exec',
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
# 1  <;> nextstate(main 505 (eval 24):1) v
# 2  <0> pushmark s
# 3  <0> pushmark s
# 4  <#> gv[*h] s
# 5  <1> rv2hv[t2] lKRM*/1
# 6  <2> aassign[t3] vKS
# 7  <;> nextstate(main 506 (eval 24):1) v:{
# 8  <0> pushmark sM
# 9  <#> gv[*a] s
# a  <1> rv2av[t6] sKRM/1
# b  <#> gv[*_] s
# c  <1> rv2gv sKRM/1
# d  <{> enteriter(next->o last->r redo->e) lKS/8
# p  <0> iter s
# q  <|> and(other->e) K/1
# e      <;> nextstate(main 505 (eval 24):1) v:{
# f      <#> gvsv[*_] s
# g      <#> gv[*h] s
# h      <1> rv2hv sKR/1
# i      <0> pushmark s
# j      <#> gvsv[*_] s
# k      <#> gv[*getkey] s/EARLYCV
# l      <1> entersub[t10] sKS/TARG,1
# m      <2> helem sKRM*/2
# n      <2> sassign vKS/2
# o      <0> unstack s
#            goto p
# r  <2> leaveloop KP/2
# s  <1> leavesub[1 ref] K/REFC,1
EOT_EOT
# 1  <;> nextstate(main 505 (eval 24):1) v
# 2  <0> pushmark s
# 3  <0> pushmark s
# 4  <$> gv(*h) s
# 5  <1> rv2hv[t1] lKRM*/1
# 6  <2> aassign[t2] vKS
# 7  <;> nextstate(main 506 (eval 24):1) v:{
# 8  <0> pushmark sM
# 9  <$> gv(*a) s
# a  <1> rv2av[t3] sKRM/1
# b  <$> gv(*_) s
# c  <1> rv2gv sKRM/1
# d  <{> enteriter(next->o last->r redo->e) lKS/8
# p  <0> iter s
# q  <|> and(other->e) K/1
# e      <;> nextstate(main 505 (eval 24):1) v:{
# f      <$> gvsv(*_) s
# g      <$> gv(*h) s
# h      <1> rv2hv sKR/1
# i      <0> pushmark s
# j      <$> gvsv(*_) s
# k      <$> gv(*getkey) s/EARLYCV
# l      <1> entersub[t4] sKS/TARG,1
# m      <2> helem sKRM*/2
# n      <2> sassign vKS/2
# o      <0> unstack s
#            goto p
# r  <2> leaveloop KP/2
# s  <1> leavesub[1 ref] K/REFC,1
EONT_EONT

checkOptree ( name	=> 'map $_+42, 10..20',
	      code	=> 'map $_+42, 10..20',
	      bcopts	=> '-exec',
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
# 1  <;> nextstate(main 497 (eval 20):1) v
# 2  <0> pushmark s
# 3  <$> const[AV ] s
# 4  <1> rv2av lKPM/1
# 5  <@> mapstart K
# 6  <|> mapwhile(other->7)[t5] K
# 7      <#> gvsv[*_] s
# 8      <$> const[IV 42] s
# 9      <2> add[t2] sK/2
#            goto 6
# a  <1> leavesub[1 ref] K/REFC,1
EOT_EOT
# 1  <;> nextstate(main 511 (eval 26):1) v
# 2  <0> pushmark s
# 3  <$> const(AV ) s
# 4  <1> rv2av lKPM/1
# 5  <@> mapstart K
# 6  <|> mapwhile(other->7)[t4] K
# 7      <$> gvsv(*_) s
# 8      <$> const(IV 42) s
# 9      <2> add[t1] sK/2
#            goto 6
# a  <1> leavesub[1 ref] K/REFC,1
EONT_EONT

pass("CONSTANTS");

checkOptree ( name	=> '-e use constant j => qq{junk}; print j',
	      prog	=> 'use constant j => qq{junk}; print j',
	      bcopts	=> '-exec',
	      strip_open_hints => 1,
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
# 1  <0> enter 
# 2  <;> nextstate(main 71 -e:1) v:>,<,%,{
# 3  <0> pushmark s
# 4  <$> const[PV "junk"] s
# 5  <@> print vK
# 6  <@> leave[1 ref] vKP/REFC
EOT_EOT
# 1  <0> enter 
# 2  <;> nextstate(main 71 -e:1) v:>,<,%,{
# 3  <0> pushmark s
# 4  <$> const(PV "junk") s
# 5  <@> print vK
# 6  <@> leave[1 ref] vKP/REFC
EONT_EONT

} # skip

__END__

#######################################################################

checkOptree ( name	=> '-exec sub a { print (shift) ? "foo" : "bar" }',
	      code	=> sub { print (shift) ? "foo" : "bar" },
	      bcopts	=> '-exec',
	      expect	=> <<'EOT_EOT', expect_nt => <<'EONT_EONT');
   insert threaded reference here
EOT_EOT
   insert non-threaded reference here
EONT_EONT
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;
cc02ea56	14	plan tests => 20;
2ce64696	15	SKIP: {
cc02ea56	16	skip "no perlio in this build", 20 unless $Config::Config{useperlio};
724aa791 JC	17
	18	pass("GENERAL OPTREE EXAMPLES");
	19
	20	pass("IF,THEN,ELSE, ?:");
	21
	22	checkOptree ( name => '-basic sub {if shift print then,else}',
	23	bcopts => '-basic',
	24	code => sub { if (shift) { print "then" }
	25	else { print "else" }
	26	},
be2b1c74	27	strip_open_hints => 1,
724aa791	28	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
538f5756 RZ	29	# 7 <1> leavesub[1 ref] K/REFC,1 ->(end)
538f5756 RZ	30	# - <@> lineseq KP ->7
4e2ac264	31	# 1 <;> nextstate(main 665 optree_samples.t:24) v:>,<,% ->2
724aa791	32	# - <1> null K/1 ->-
538f5756 RZ	33	# 3 <\|> cond_expr(other->4) K/1 ->8
538f5756 RZ	34	# 2 <0> shift s* ->3
724aa791	35	# - <@> scope K ->-
538f5756 RZ	36	# - <0> ex-nextstate v ->4
	37	# 6 <@> print sK ->7
	38	# 4 <0> pushmark s ->5
	39	# 5 <$> const[PV "then"] s ->6
	40	# d <@> leave KP ->7
	41	# 8 <0> enter ->9
4e2ac264	42	# 9 <;> nextstate(main 663 optree_samples.t:25) v:>,<,% ->a
538f5756 RZ	43	# c <@> print sK ->d
	44	# a <0> pushmark s ->b
	45	# b <$> const[PV "else"] s ->c
724aa791	46	EOT_EOT
538f5756 RZ	47	# 7 <1> leavesub[1 ref] K/REFC,1 ->(end)
538f5756 RZ	48	# - <@> lineseq KP ->7
4e2ac264	49	# 1 <;> nextstate(main 665 optree_samples.t:24) v:>,<,% ->2
724aa791	50	# - <1> null K/1 ->-
538f5756 RZ	51	# 3 <\|> cond_expr(other->4) K/1 ->8
538f5756 RZ	52	# 2 <0> shift s* ->3
724aa791	53	# - <@> scope K ->-
538f5756 RZ	54	# - <0> ex-nextstate v ->4
	55	# 6 <@> print sK ->7
	56	# 4 <0> pushmark s ->5
	57	# 5 <$> const(PV "then") s ->6
	58	# d <@> leave KP ->7
	59	# 8 <0> enter ->9
4e2ac264	60	# 9 <;> nextstate(main 663 optree_samples.t:25) v:>,<,% ->a
538f5756 RZ	61	# c <@> print sK ->d
	62	# a <0> pushmark s ->b
	63	# b <$> const(PV "else") s ->c
724aa791 JC	64	EONT_EONT
	65
	66	checkOptree ( name => '-basic (see above, with my $a = shift)',
	67	bcopts => '-basic',
	68	code => sub { my $a = shift;
	69	if ($a) { print "foo" }
	70	else { print "bar" }
	71	},
be2b1c74	72	strip_open_hints => 1,
724aa791	73	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
538f5756 RZ	74	# b <1> leavesub[1 ref] K/REFC,1 ->(end)
538f5756 RZ	75	# - <@> lineseq KP ->b
4e2ac264	76	# 1 <;> nextstate(main 666 optree_samples.t:70) v:>,<,% ->2
538f5756 RZ	77	# 4 <2> sassign vKS/2 ->5
	78	# 2 <0> shift s* ->3
	79	# 3 <0> padsv[$a:666,670] sRM*/LVINTRO ->4
4e2ac264	80	# 5 <;> nextstate(main 670 optree_samples.t:71) v:>,<,% ->6
724aa791	81	# - <1> null K/1 ->-
538f5756 RZ	82	# 7 <\|> cond_expr(other->8) K/1 ->c
538f5756 RZ	83	# 6 <0> padsv[$a:666,670] s ->7
724aa791	84	# - <@> scope K ->-
538f5756 RZ	85	# - <0> ex-nextstate v ->8
	86	# a <@> print sK ->b
	87	# 8 <0> pushmark s ->9
	88	# 9 <$> const[PV "foo"] s ->a
	89	# h <@> leave KP ->b
	90	# c <0> enter ->d
4e2ac264	91	# d <;> nextstate(main 668 optree_samples.t:72) v:>,<,% ->e
538f5756 RZ	92	# g <@> print sK ->h
	93	# e <0> pushmark s ->f
	94	# f <$> const[PV "bar"] s ->g
724aa791	95	EOT_EOT
538f5756 RZ	96	# b <1> leavesub[1 ref] K/REFC,1 ->(end)
538f5756 RZ	97	# - <@> lineseq KP ->b
4e2ac264	98	# 1 <;> nextstate(main 666 optree_samples.t:72) v:>,<,% ->2
538f5756 RZ	99	# 4 <2> sassign vKS/2 ->5
	100	# 2 <0> shift s* ->3
	101	# 3 <0> padsv[$a:666,670] sRM*/LVINTRO ->4
4e2ac264	102	# 5 <;> nextstate(main 670 optree_samples.t:73) v:>,<,% ->6
724aa791	103	# - <1> null K/1 ->-
538f5756 RZ	104	# 7 <\|> cond_expr(other->8) K/1 ->c
538f5756 RZ	105	# 6 <0> padsv[$a:666,670] s ->7
724aa791	106	# - <@> scope K ->-
538f5756 RZ	107	# - <0> ex-nextstate v ->8
	108	# a <@> print sK ->b
	109	# 8 <0> pushmark s ->9
	110	# 9 <$> const(PV "foo") s ->a
	111	# h <@> leave KP ->b
	112	# c <0> enter ->d
4e2ac264	113	# d <;> nextstate(main 668 optree_samples.t:74) v:>,<,% ->e
538f5756 RZ	114	# g <@> print sK ->h
	115	# e <0> pushmark s ->f
	116	# f <$> const(PV "bar") s ->g
724aa791 JC	117	EONT_EONT
	118
	119	checkOptree ( name => '-exec sub {if shift print then,else}',
	120	bcopts => '-exec',
	121	code => sub { if (shift) { print "then" }
	122	else { print "else" }
	123	},
be2b1c74	124	strip_open_hints => 1,
724aa791	125	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
4e2ac264	126	# 1 <;> nextstate(main 674 optree_samples.t:125) v:>,<,%
538f5756 RZ	127	# 2 <0> shift s*
	128	# 3 <\|> cond_expr(other->4) K/1
	129	# 4 <0> pushmark s
	130	# 5 <$> const[PV "then"] s
	131	# 6 <@> print sK
	132	# goto 7
	133	# 8 <0> enter
4e2ac264	134	# 9 <;> nextstate(main 672 optree_samples.t:126) v:>,<,%
538f5756 RZ	135	# a <0> pushmark s
	136	# b <$> const[PV "else"] s
	137	# c <@> print sK
	138	# d <@> leave KP
	139	# 7 <1> leavesub[1 ref] K/REFC,1
724aa791	140	EOT_EOT
4e2ac264	141	# 1 <;> nextstate(main 674 optree_samples.t:129) v:>,<,%
538f5756 RZ	142	# 2 <0> shift s*
	143	# 3 <\|> cond_expr(other->4) K/1
	144	# 4 <0> pushmark s
	145	# 5 <$> const(PV "then") s
	146	# 6 <@> print sK
	147	# goto 7
	148	# 8 <0> enter
4e2ac264	149	# 9 <;> nextstate(main 672 optree_samples.t:130) v:>,<,%
538f5756 RZ	150	# a <0> pushmark s
	151	# b <$> const(PV "else") s
	152	# c <@> print sK
	153	# d <@> leave KP
	154	# 7 <1> leavesub[1 ref] K/REFC,1
724aa791 JC	155	EONT_EONT
	156
	157	checkOptree ( name => '-exec (see above, with my $a = shift)',
	158	bcopts => '-exec',
	159	code => sub { my $a = shift;
	160	if ($a) { print "foo" }
	161	else { print "bar" }
	162	},
be2b1c74	163	strip_open_hints => 1,
724aa791	164	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
4e2ac264	165	# 1 <;> nextstate(main 675 optree_samples.t:165) v:>,<,%
538f5756 RZ	166	# 2 <0> shift s*
	167	# 3 <0> padsv[$a:675,679] sRM*/LVINTRO
	168	# 4 <2> sassign vKS/2
4e2ac264	169	# 5 <;> nextstate(main 679 optree_samples.t:166) v:>,<,%
538f5756 RZ	170	# 6 <0> padsv[$a:675,679] s
	171	# 7 <\|> cond_expr(other->8) K/1
	172	# 8 <0> pushmark s
	173	# 9 <$> const[PV "foo"] s
	174	# a <@> print sK
	175	# goto b
	176	# c <0> enter
4e2ac264	177	# d <;> nextstate(main 677 optree_samples.t:167) v:>,<,%
538f5756 RZ	178	# e <0> pushmark s
	179	# f <$> const[PV "bar"] s
	180	# g <@> print sK
	181	# h <@> leave KP
	182	# b <1> leavesub[1 ref] K/REFC,1
724aa791	183	EOT_EOT
4e2ac264	184	# 1 <;> nextstate(main 675 optree_samples.t:171) v:>,<,%
538f5756 RZ	185	# 2 <0> shift s*
	186	# 3 <0> padsv[$a:675,679] sRM*/LVINTRO
	187	# 4 <2> sassign vKS/2
4e2ac264	188	# 5 <;> nextstate(main 679 optree_samples.t:172) v:>,<,%
538f5756 RZ	189	# 6 <0> padsv[$a:675,679] s
	190	# 7 <\|> cond_expr(other->8) K/1
	191	# 8 <0> pushmark s
	192	# 9 <$> const(PV "foo") s
	193	# a <@> print sK
	194	# goto b
	195	# c <0> enter
4e2ac264	196	# d <;> nextstate(main 677 optree_samples.t:173) v:>,<,%
538f5756 RZ	197	# e <0> pushmark s
	198	# f <$> const(PV "bar") s
	199	# g <@> print sK
	200	# h <@> leave KP
	201	# b <1> leavesub[1 ref] K/REFC,1
724aa791 JC	202	EONT_EONT
	203
	204	checkOptree ( name => '-exec sub { print (shift) ? "foo" : "bar" }',
	205	code => sub { print (shift) ? "foo" : "bar" },
	206	bcopts => '-exec',
be2b1c74	207	strip_open_hints => 1,
724aa791	208	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
4e2ac264	209	# 1 <;> nextstate(main 680 optree_samples.t:213) v:>,<,%
724aa791	210	# 2 <0> pushmark s
538f5756 RZ	211	# 3 <0> shift s*
	212	# 4 <@> print sK
	213	# 5 <\|> cond_expr(other->6) K/1
	214	# 6 <$> const[PV "foo"] s
	215	# goto 7
	216	# 8 <$> const[PV "bar"] s
	217	# 7 <1> leavesub[1 ref] K/REFC,1
724aa791	218	EOT_EOT
4e2ac264	219	# 1 <;> nextstate(main 680 optree_samples.t:221) v:>,<,%
724aa791	220	# 2 <0> pushmark s
538f5756 RZ	221	# 3 <0> shift s*
	222	# 4 <@> print sK
	223	# 5 <\|> cond_expr(other->6) K/1
	224	# 6 <$> const(PV "foo") s
	225	# goto 7
	226	# 8 <$> const(PV "bar") s
	227	# 7 <1> leavesub[1 ref] K/REFC,1
724aa791 JC	228	EONT_EONT
	229
	230	pass ("FOREACH");
	231
	232	checkOptree ( name => '-exec sub { foreach (1..10) {print "foo $_"} }',
	233	code => sub { foreach (1..10) {print "foo $_"} },
	234	bcopts => '-exec',
be2b1c74	235	strip_open_hints => 1,
724aa791	236	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
be2b1c74	237	# 1 <;> nextstate(main 443 optree.t:158) v:>,<,%
724aa791 JC	238	# 2 <0> pushmark s
	239	# 3 <$> const[IV 1] s
	240	# 4 <$> const[IV 10] s
	241	# 5 <#> gv[*_] s
0d863452	242	# 6 <{> enteriter(next->d last->g redo->7) lKS/8
724aa791 JC	243	# e <0> iter s
724aa791 JC	244	# f <\|> and(other->7) K/1
be2b1c74	245	# 7 <;> nextstate(main 442 optree.t:158) v:>,<,%
724aa791 JC	246	# 8 <0> pushmark s
	247	# 9 <$> const[PV "foo "] s
	248	# a <#> gvsv[*_] s
	249	# b <2> concat[t4] sK/2
	250	# c <@> print vK
	251	# d <0> unstack s
	252	# goto e
	253	# g <2> leaveloop K/2
	254	# h <1> leavesub[1 ref] K/REFC,1
724aa791	255	EOT_EOT
be2b1c74	256	# 1 <;> nextstate(main 444 optree_samples.t:182) v:>,<,%
724aa791 JC	257	# 2 <0> pushmark s
	258	# 3 <$> const(IV 1) s
	259	# 4 <$> const(IV 10) s
	260	# 5 <$> gv(*_) s
0d863452	261	# 6 <{> enteriter(next->d last->g redo->7) lKS/8
724aa791 JC	262	# e <0> iter s
724aa791 JC	263	# f <\|> and(other->7) K/1
be2b1c74	264	# 7 <;> nextstate(main 443 optree_samples.t:182) v:>,<,%
724aa791 JC	265	# 8 <0> pushmark s
	266	# 9 <$> const(PV "foo ") s
	267	# a <$> gvsv(*_) s
	268	# b <2> concat[t3] sK/2
	269	# c <@> print vK
	270	# d <0> unstack s
	271	# goto e
	272	# g <2> leaveloop K/2
	273	# h <1> leavesub[1 ref] K/REFC,1
	274	EONT_EONT
	275
	276	checkOptree ( name => '-basic sub { print "foo $_" foreach (1..10) }',
	277	code => sub { print "foo $_" foreach (1..10) },
	278	bcopts => '-basic',
be2b1c74	279	strip_open_hints => 1,
724aa791	280	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
ac56e7de NC	281	# g <1> leavesub[1 ref] K/REFC,1 ->(end)
ac56e7de NC	282	# - <@> lineseq KP ->g
be2b1c74	283	# 1 <;> nextstate(main 445 optree.t:167) v:>,<,% ->2
ac56e7de NC	284	# f <2> leaveloop K/2 ->g
	285	# 6 <{> enteriter(next->c last->f redo->7) lKS/8 ->d
	286	# - <0> ex-pushmark s ->2
	287	# - <1> ex-list lK ->5
	288	# 2 <0> pushmark s ->3
	289	# 3 <$> const[IV 1] s ->4
	290	# 4 <$> const[IV 10] s ->5
	291	# 5 <#> gv[*_] s ->6
	292	# - <1> null K/1 ->f
	293	# e <\|> and(other->7) K/1 ->f
	294	# d <0> iter s ->e
724aa791	295	# - <@> lineseq sK ->-
ac56e7de NC	296	# b <@> print vK ->c
	297	# 7 <0> pushmark s ->8
	298	# - <1> ex-stringify sK/1 ->b
	299	# - <0> ex-pushmark s ->8
	300	# a <2> concat[t2] sK/2 ->b
	301	# 8 <$> const[PV "foo "] s ->9
	302	# - <1> ex-rv2sv sK/1 ->a
	303	# 9 <#> gvsv[*_] s ->a
	304	# c <0> unstack s ->d
724aa791	305	EOT_EOT
ac56e7de NC	306	# g <1> leavesub[1 ref] K/REFC,1 ->(end)
ac56e7de NC	307	# - <@> lineseq KP ->g
be2b1c74	308	# 1 <;> nextstate(main 446 optree_samples.t:192) v:>,<,% ->2
ac56e7de NC	309	# f <2> leaveloop K/2 ->g
	310	# 6 <{> enteriter(next->c last->f redo->7) lKS/8 ->d
	311	# - <0> ex-pushmark s ->2
	312	# - <1> ex-list lK ->5
	313	# 2 <0> pushmark s ->3
	314	# 3 <$> const(IV 1) s ->4
	315	# 4 <$> const(IV 10) s ->5
	316	# 5 <$> gv(*_) s ->6
	317	# - <1> null K/1 ->f
	318	# e <\|> and(other->7) K/1 ->f
	319	# d <0> iter s ->e
724aa791	320	# - <@> lineseq sK ->-
ac56e7de NC	321	# b <@> print vK ->c
	322	# 7 <0> pushmark s ->8
	323	# - <1> ex-stringify sK/1 ->b
	324	# - <0> ex-pushmark s ->8
	325	# a <2> concat[t1] sK/2 ->b
	326	# 8 <$> const(PV "foo ") s ->9
	327	# - <1> ex-rv2sv sK/1 ->a
	328	# 9 <$> gvsv(*_) s ->a
	329	# c <0> unstack s ->d
724aa791 JC	330	EONT_EONT
724aa791 JC	331
498d59dd SH	332	checkOptree ( name => '-exec -e foreach (1..10) {print qq{foo $_}}',
498d59dd SH	333	prog => 'foreach (1..10) {print qq{foo $_}}',
724aa791	334	bcopts => '-exec',
be2b1c74	335	strip_open_hints => 1,
724aa791 JC	336	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
724aa791 JC	337	# 1 <0> enter
eae48c89	338	# 2 <;> nextstate(main 2 -e:1) v:>,<,%,{
724aa791 JC	339	# 3 <0> pushmark s
	340	# 4 <$> const[IV 1] s
	341	# 5 <$> const[IV 10] s
	342	# 6 <#> gv[*_] s
0d863452	343	# 7 <{> enteriter(next->e last->h redo->8) lKS/8
724aa791 JC	344	# f <0> iter s
724aa791 JC	345	# g <\|> and(other->8) vK/1
be2b1c74	346	# 8 <;> nextstate(main 1 -e:1) v:>,<,%
724aa791 JC	347	# 9 <0> pushmark s
	348	# a <$> const[PV "foo "] s
	349	# b <#> gvsv[*_] s
	350	# c <2> concat[t4] sK/2
	351	# d <@> print vK
	352	# e <0> unstack v
	353	# goto f
	354	# h <2> leaveloop vK/2
	355	# i <@> leave[1 ref] vKP/REFC
	356	EOT_EOT
	357	# 1 <0> enter
eae48c89	358	# 2 <;> nextstate(main 2 -e:1) v:>,<,%,{
724aa791 JC	359	# 3 <0> pushmark s
	360	# 4 <$> const(IV 1) s
	361	# 5 <$> const(IV 10) s
	362	# 6 <$> gv(*_) s
0d863452	363	# 7 <{> enteriter(next->e last->h redo->8) lKS/8
724aa791 JC	364	# f <0> iter s
724aa791 JC	365	# g <\|> and(other->8) vK/1
be2b1c74	366	# 8 <;> nextstate(main 1 -e:1) v:>,<,%
724aa791 JC	367	# 9 <0> pushmark s
	368	# a <$> const(PV "foo ") s
	369	# b <$> gvsv(*_) s
	370	# c <2> concat[t3] sK/2
	371	# d <@> print vK
	372	# e <0> unstack v
	373	# goto f
	374	# h <2> leaveloop vK/2
	375	# i <@> leave[1 ref] vKP/REFC
724aa791 JC	376	EONT_EONT
	377
	378	checkOptree ( name => '-exec sub { print "foo $_" foreach (1..10) }',
	379	code => sub { print "foo $_" foreach (1..10) },
	380	bcopts => '-exec',
be2b1c74	381	strip_open_hints => 1,
724aa791	382	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
be2b1c74	383	# 1 <;> nextstate(main 445 optree.t:167) v:>,<,%
ac56e7de NC	384	# 2 <0> pushmark s
	385	# 3 <$> const[IV 1] s
	386	# 4 <$> const[IV 10] s
	387	# 5 <#> gv[*_] s
	388	# 6 <{> enteriter(next->c last->f redo->7) lKS/8
	389	# d <0> iter s
	390	# e <\|> and(other->7) K/1
	391	# 7 <0> pushmark s
	392	# 8 <$> const[PV "foo "] s
	393	# 9 <#> gvsv[*_] s
	394	# a <2> concat[t2] sK/2
	395	# b <@> print vK
	396	# c <0> unstack s
	397	# goto d
	398	# f <2> leaveloop K/2
	399	# g <1> leavesub[1 ref] K/REFC,1
724aa791	400	EOT_EOT
be2b1c74	401	# 1 <;> nextstate(main 447 optree_samples.t:252) v:>,<,%
ac56e7de NC	402	# 2 <0> pushmark s
	403	# 3 <$> const(IV 1) s
	404	# 4 <$> const(IV 10) s
	405	# 5 <$> gv(*_) s
	406	# 6 <{> enteriter(next->c last->f redo->7) lKS/8
	407	# d <0> iter s
	408	# e <\|> and(other->7) K/1
	409	# 7 <0> pushmark s
	410	# 8 <$> const(PV "foo ") s
	411	# 9 <$> gvsv(*_) s
	412	# a <2> concat[t1] sK/2
	413	# b <@> print vK
	414	# c <0> unstack s
	415	# goto d
	416	# f <2> leaveloop K/2
	417	# g <1> leavesub[1 ref] K/REFC,1
724aa791 JC	418	EONT_EONT
724aa791 JC	419
cc02ea56 JC	420	pass("GREP: SAMPLES FROM PERLDOC -F GREP");
	421
	422	checkOptree ( name => '@foo = grep(!/^\#/, @bar)',
	423	code => '@foo = grep(!/^\#/, @bar)',
	424	bcopts => '-exec',
	425	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
d5ec2987	426	# 1 <;> nextstate(main 496 (eval 20):1) v:{
cc02ea56 JC	427	# 2 <0> pushmark s
	428	# 3 <0> pushmark s
	429	# 4 <#> gv[*bar] s
	430	# 5 <1> rv2av[t4] lKM/1
	431	# 6 <@> grepstart lK
	432	# 7 <\|> grepwhile(other->8)[t5] lK
	433	# 8 </> match(/"^#"/) s/RTIME
	434	# 9 <1> not sK/1
	435	# goto 7
	436	# a <0> pushmark s
	437	# b <#> gv[*foo] s
	438	# c <1> rv2av[t2] lKRM*/1
	439	# d <2> aassign[t6] KS/COMMON
	440	# e <1> leavesub[1 ref] K/REFC,1
	441	EOT_EOT
d5ec2987	442	# 1 <;> nextstate(main 496 (eval 20):1) v:{
cc02ea56 JC	443	# 2 <0> pushmark s
	444	# 3 <0> pushmark s
	445	# 4 <$> gv(*bar) s
	446	# 5 <1> rv2av[t2] lKM/1
	447	# 6 <@> grepstart lK
	448	# 7 <\|> grepwhile(other->8)[t3] lK
	449	# 8 </> match(/"^\\#"/) s/RTIME
	450	# 9 <1> not sK/1
	451	# goto 7
	452	# a <0> pushmark s
	453	# b <$> gv(*foo) s
	454	# c <1> rv2av[t1] lKRM*/1
	455	# d <2> aassign[t4] KS/COMMON
	456	# e <1> leavesub[1 ref] K/REFC,1
	457	EONT_EONT
	458
	459
	460	pass("MAP: SAMPLES FROM PERLDOC -F MAP");
	461
	462	checkOptree ( name => '%h = map { getkey($_) => $_ } @a',
	463	code => '%h = map { getkey($_) => $_ } @a',
	464	bcopts => '-exec',
	465	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
d5ec2987	466	# 1 <;> nextstate(main 501 (eval 22):1) v:{
cc02ea56 JC	467	# 2 <0> pushmark s
	468	# 3 <0> pushmark s
	469	# 4 <#> gv[*a] s
	470	# 5 <1> rv2av[t8] lKM/1
	471	# 6 <@> mapstart lK*
	472	# 7 <\|> mapwhile(other->8)[t9] lK
	473	# 8 <0> enter l
d5ec2987	474	# 9 <;> nextstate(main 500 (eval 22):1) v:{
cc02ea56 JC	475	# a <0> pushmark s
	476	# b <0> pushmark s
	477	# c <#> gvsv[*_] s
	478	# d <#> gv[*getkey] s/EARLYCV
	479	# e <1> entersub[t5] lKS/TARG,1
	480	# f <#> gvsv[*_] s
	481	# g <@> list lK
	482	# h <@> leave lKP
	483	# goto 7
	484	# i <0> pushmark s
	485	# j <#> gv[*h] s
	486	# k <1> rv2hv[t2] lKRM*/1
	487	# l <2> aassign[t10] KS/COMMON
	488	# m <1> leavesub[1 ref] K/REFC,1
	489	EOT_EOT
d5ec2987	490	# 1 <;> nextstate(main 501 (eval 22):1) v:{
cc02ea56 JC	491	# 2 <0> pushmark s
	492	# 3 <0> pushmark s
	493	# 4 <$> gv(*a) s
	494	# 5 <1> rv2av[t3] lKM/1
	495	# 6 <@> mapstart lK*
	496	# 7 <\|> mapwhile(other->8)[t4] lK
	497	# 8 <0> enter l
d5ec2987	498	# 9 <;> nextstate(main 500 (eval 22):1) v:{
cc02ea56 JC	499	# a <0> pushmark s
	500	# b <0> pushmark s
	501	# c <$> gvsv(*_) s
	502	# d <$> gv(*getkey) s/EARLYCV
	503	# e <1> entersub[t2] lKS/TARG,1
	504	# f <$> gvsv(*_) s
	505	# g <@> list lK
	506	# h <@> leave lKP
	507	# goto 7
	508	# i <0> pushmark s
	509	# j <$> gv(*h) s
	510	# k <1> rv2hv[t1] lKRM*/1
	511	# l <2> aassign[t5] KS/COMMON
	512	# m <1> leavesub[1 ref] K/REFC,1
	513	EONT_EONT
	514
	515	checkOptree ( name => '%h=(); for $_(@a){$h{getkey($_)} = $_}',
	516	code => '%h=(); for $_(@a){$h{getkey($_)} = $_}',
	517	bcopts => '-exec',
	518	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
	519	# 1 <;> nextstate(main 505 (eval 24):1) v
	520	# 2 <0> pushmark s
	521	# 3 <0> pushmark s
	522	# 4 <#> gv[*h] s
	523	# 5 <1> rv2hv[t2] lKRM*/1
	524	# 6 <2> aassign[t3] vKS
d5ec2987	525	# 7 <;> nextstate(main 506 (eval 24):1) v:{
cc02ea56 JC	526	# 8 <0> pushmark sM
	527	# 9 <#> gv[*a] s
	528	# a <1> rv2av[t6] sKRM/1
	529	# b <#> gv[*_] s
	530	# c <1> rv2gv sKRM/1
0d863452	531	# d <{> enteriter(next->o last->r redo->e) lKS/8
cc02ea56 JC	532	# p <0> iter s
cc02ea56 JC	533	# q <\|> and(other->e) K/1
d5ec2987	534	# e <;> nextstate(main 505 (eval 24):1) v:{
cc02ea56 JC	535	# f <#> gvsv[*_] s
	536	# g <#> gv[*h] s
	537	# h <1> rv2hv sKR/1
	538	# i <0> pushmark s
	539	# j <#> gvsv[*_] s
	540	# k <#> gv[*getkey] s/EARLYCV
	541	# l <1> entersub[t10] sKS/TARG,1
	542	# m <2> helem sKRM*/2
	543	# n <2> sassign vKS/2
	544	# o <0> unstack s
	545	# goto p
eae48c89	546	# r <2> leaveloop KP/2
cc02ea56 JC	547	# s <1> leavesub[1 ref] K/REFC,1
	548	EOT_EOT
	549	# 1 <;> nextstate(main 505 (eval 24):1) v
	550	# 2 <0> pushmark s
	551	# 3 <0> pushmark s
	552	# 4 <$> gv(*h) s
	553	# 5 <1> rv2hv[t1] lKRM*/1
	554	# 6 <2> aassign[t2] vKS
d5ec2987	555	# 7 <;> nextstate(main 506 (eval 24):1) v:{
cc02ea56 JC	556	# 8 <0> pushmark sM
	557	# 9 <$> gv(*a) s
	558	# a <1> rv2av[t3] sKRM/1
	559	# b <$> gv(*_) s
	560	# c <1> rv2gv sKRM/1
0d863452	561	# d <{> enteriter(next->o last->r redo->e) lKS/8
cc02ea56 JC	562	# p <0> iter s
cc02ea56 JC	563	# q <\|> and(other->e) K/1
d5ec2987	564	# e <;> nextstate(main 505 (eval 24):1) v:{
cc02ea56 JC	565	# f <$> gvsv(*_) s
	566	# g <$> gv(*h) s
	567	# h <1> rv2hv sKR/1
	568	# i <0> pushmark s
	569	# j <$> gvsv(*_) s
	570	# k <$> gv(*getkey) s/EARLYCV
	571	# l <1> entersub[t4] sKS/TARG,1
	572	# m <2> helem sKRM*/2
	573	# n <2> sassign vKS/2
	574	# o <0> unstack s
	575	# goto p
eae48c89	576	# r <2> leaveloop KP/2
cc02ea56 JC	577	# s <1> leavesub[1 ref] K/REFC,1
	578	EONT_EONT
	579
	580	checkOptree ( name => 'map $_+42, 10..20',
	581	code => 'map $_+42, 10..20',
	582	bcopts => '-exec',
	583	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
	584	# 1 <;> nextstate(main 497 (eval 20):1) v
	585	# 2 <0> pushmark s
	586	# 3 <$> const[AV ] s
	587	# 4 <1> rv2av lKPM/1
	588	# 5 <@> mapstart K
9ad9869c	589	# 6 <\|> mapwhile(other->7)[t5] K
cc02ea56 JC	590	# 7 <#> gvsv[*_] s
	591	# 8 <$> const[IV 42] s
	592	# 9 <2> add[t2] sK/2
	593	# goto 6
	594	# a <1> leavesub[1 ref] K/REFC,1
	595	EOT_EOT
	596	# 1 <;> nextstate(main 511 (eval 26):1) v
	597	# 2 <0> pushmark s
	598	# 3 <$> const(AV ) s
	599	# 4 <1> rv2av lKPM/1
	600	# 5 <@> mapstart K
	601	# 6 <\|> mapwhile(other->7)[t4] K
	602	# 7 <$> gvsv(*_) s
	603	# 8 <$> const(IV 42) s
	604	# 9 <2> add[t1] sK/2
	605	# goto 6
	606	# a <1> leavesub[1 ref] K/REFC,1
	607	EONT_EONT
	608
	609	pass("CONSTANTS");
	610
498d59dd SH	611	checkOptree ( name => '-e use constant j => qq{junk}; print j',
498d59dd SH	612	prog => 'use constant j => qq{junk}; print j',
724aa791	613	bcopts => '-exec',
be2b1c74	614	strip_open_hints => 1,
724aa791 JC	615	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
724aa791 JC	616	# 1 <0> enter
be2b1c74	617	# 2 <;> nextstate(main 71 -e:1) v:>,<,%,{
724aa791 JC	618	# 3 <0> pushmark s
	619	# 4 <$> const[PV "junk"] s
	620	# 5 <@> print vK
	621	# 6 <@> leave[1 ref] vKP/REFC
	622	EOT_EOT
	623	# 1 <0> enter
be2b1c74	624	# 2 <;> nextstate(main 71 -e:1) v:>,<,%,{
724aa791 JC	625	# 3 <0> pushmark s
	626	# 4 <$> const(PV "junk") s
	627	# 5 <@> print vK
	628	# 6 <@> leave[1 ref] vKP/REFC
	629	EONT_EONT
	630
2ce64696 JC	631	} # skip
2ce64696 JC	632
724aa791 JC	633	__END__
	634
	635	#######################################################################
	636
	637	checkOptree ( name => '-exec sub a { print (shift) ? "foo" : "bar" }',
	638	code => sub { print (shift) ? "foo" : "bar" },
	639	bcopts => '-exec',
	640	expect => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
	641	insert threaded reference here
	642	EOT_EOT
	643	insert non-threaded reference here
	644	EONT_EONT
	645