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