This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
rename convert to op_convert_list and APIfy
[perl5.git] / perly.act
1 /* -*- buffer-read-only: t -*-
2    !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!!
3    This file is built by regen_perly.pl from perly.y.
4    Any changes made here will be lost!
5  */
6
7 case 2:
8 #line 115 "perly.y"
9     {
10                           parser->expect = XSTATE;
11                         }
12     break;
13
14   case 3:
15 #line 119 "perly.y"
16     {
17                           newPROG(block_end((ps[(3) - (4)].val.ival),(ps[(4) - (4)].val.opval)));
18                           (yyval.ival) = 0;
19                         }
20     break;
21
22   case 4:
23 #line 124 "perly.y"
24     {
25                           parser->expect = XTERM;
26                         }
27     break;
28
29   case 5:
30 #line 128 "perly.y"
31     {
32                           PL_eval_root = (ps[(3) - (3)].val.opval);
33                           (yyval.ival) = 0;
34                         }
35     break;
36
37   case 6:
38 #line 133 "perly.y"
39     {
40                           parser->expect = XBLOCK;
41                         }
42     break;
43
44   case 7:
45 #line 137 "perly.y"
46     {
47                           PL_pad_reset_pending = TRUE;
48                           PL_eval_root = (ps[(3) - (3)].val.opval);
49                           (yyval.ival) = 0;
50                           yyunlex();
51                           parser->yychar = YYEOF;
52                         }
53     break;
54
55   case 8:
56 #line 145 "perly.y"
57     {
58                           parser->expect = XSTATE;
59                         }
60     break;
61
62   case 9:
63 #line 149 "perly.y"
64     {
65                           PL_pad_reset_pending = TRUE;
66                           PL_eval_root = (ps[(3) - (3)].val.opval);
67                           (yyval.ival) = 0;
68                           yyunlex();
69                           parser->yychar = YYEOF;
70                         }
71     break;
72
73   case 10:
74 #line 157 "perly.y"
75     {
76                           parser->expect = XSTATE;
77                         }
78     break;
79
80   case 11:
81 #line 161 "perly.y"
82     {
83                           PL_pad_reset_pending = TRUE;
84                           PL_eval_root = (ps[(3) - (3)].val.opval);
85                           (yyval.ival) = 0;
86                           yyunlex();
87                           parser->yychar = YYEOF;
88                         }
89     break;
90
91   case 12:
92 #line 169 "perly.y"
93     {
94                           parser->expect = XSTATE;
95                         }
96     break;
97
98   case 13:
99 #line 173 "perly.y"
100     {
101                           PL_eval_root = (ps[(3) - (3)].val.opval);
102                           (yyval.ival) = 0;
103                         }
104     break;
105
106   case 14:
107 #line 181 "perly.y"
108     { if (parser->copline > (line_t)(ps[(1) - (4)].val.ival))
109                               parser->copline = (line_t)(ps[(1) - (4)].val.ival);
110                           (yyval.opval) = block_end((ps[(2) - (4)].val.ival), (ps[(3) - (4)].val.opval));
111                         }
112     break;
113
114   case 15:
115 #line 189 "perly.y"
116     { if (parser->copline > (line_t)(ps[(1) - (7)].val.ival))
117                               parser->copline = (line_t)(ps[(1) - (7)].val.ival);
118                           (yyval.opval) = block_end((ps[(2) - (7)].val.ival), (ps[(5) - (7)].val.opval));
119                         }
120     break;
121
122   case 16:
123 #line 196 "perly.y"
124     { (yyval.ival) = block_start(TRUE); }
125     break;
126
127   case 17:
128 #line 200 "perly.y"
129     { if (parser->copline > (line_t)(ps[(1) - (4)].val.ival))
130                               parser->copline = (line_t)(ps[(1) - (4)].val.ival);
131                           (yyval.opval) = block_end((ps[(2) - (4)].val.ival), (ps[(3) - (4)].val.opval));
132                         }
133     break;
134
135   case 18:
136 #line 207 "perly.y"
137     { (yyval.ival) = block_start(FALSE); }
138     break;
139
140   case 19:
141 #line 212 "perly.y"
142     { (yyval.opval) = (OP*)NULL; }
143     break;
144
145   case 20:
146 #line 214 "perly.y"
147     {   (yyval.opval) = op_append_list(OP_LINESEQ, (ps[(1) - (2)].val.opval), (ps[(2) - (2)].val.opval));
148                             PL_pad_reset_pending = TRUE;
149                             if ((ps[(1) - (2)].val.opval) && (ps[(2) - (2)].val.opval))
150                                 PL_hints |= HINT_BLOCK_SCOPE;
151                         }
152     break;
153
154   case 21:
155 #line 223 "perly.y"
156     { (yyval.opval) = (OP*)NULL; }
157     break;
158
159   case 22:
160 #line 225 "perly.y"
161     {   (yyval.opval) = op_append_list(OP_LINESEQ, (ps[(1) - (2)].val.opval), (ps[(2) - (2)].val.opval));
162                             PL_pad_reset_pending = TRUE;
163                             if ((ps[(1) - (2)].val.opval) && (ps[(2) - (2)].val.opval))
164                                 PL_hints |= HINT_BLOCK_SCOPE;
165                         }
166     break;
167
168   case 23:
169 #line 234 "perly.y"
170     {
171                           (yyval.opval) = (ps[(1) - (1)].val.opval) ? newSTATEOP(0, NULL, (ps[(1) - (1)].val.opval)) : NULL;
172                         }
173     break;
174
175   case 24:
176 #line 238 "perly.y"
177     { (yyval.opval) = (ps[(1) - (1)].val.opval); }
178     break;
179
180   case 25:
181 #line 242 "perly.y"
182     {
183                           (yyval.opval) = newSTATEOP(SVf_UTF8 * (ps[(1) - (2)].val.pval)[strlen((ps[(1) - (2)].val.pval))+1], (ps[(1) - (2)].val.pval), (ps[(2) - (2)].val.opval));
184                         }
185     break;
186
187   case 26:
188 #line 246 "perly.y"
189     {
190                           (yyval.opval) = newSTATEOP(SVf_UTF8 * (ps[(1) - (2)].val.pval)[strlen((ps[(1) - (2)].val.pval))+1], (ps[(1) - (2)].val.pval), (ps[(2) - (2)].val.opval));
191                         }
192     break;
193
194   case 27:
195 #line 253 "perly.y"
196     { (yyval.opval) = (ps[(1) - (1)].val.opval); }
197     break;
198
199   case 28:
200 #line 255 "perly.y"
201     {
202                           CV *fmtcv = PL_compcv;
203                           newFORM((ps[(2) - (4)].val.ival), (ps[(3) - (4)].val.opval), (ps[(4) - (4)].val.opval));
204                           (yyval.opval) = (OP*)NULL;
205                           if (CvOUTSIDE(fmtcv) && !CvEVAL(CvOUTSIDE(fmtcv))) {
206                               SvREFCNT_inc_simple_void(fmtcv);
207                               pad_add_anon(fmtcv, OP_NULL);
208                           }
209                         }
210     break;
211
212   case 29:
213 #line 265 "perly.y"
214     {
215                           if ((ps[(2) - (3)].val.opval)->op_type == OP_CONST) {
216                             const char *const name =
217                                 SvPV_nolen_const(((SVOP*)(ps[(2) - (3)].val.opval))->op_sv);
218                             if (strEQ(name, "BEGIN") || strEQ(name, "END")
219                               || strEQ(name, "INIT") || strEQ(name, "CHECK")
220                               || strEQ(name, "UNITCHECK"))
221                               CvSPECIAL_on(PL_compcv);
222                           }
223                           else
224                           /* State subs inside anonymous subs need to be
225                              clonable themselves. */
226                           if (CvANON(CvOUTSIDE(PL_compcv))
227                            || CvCLONE(CvOUTSIDE(PL_compcv))
228                            || !PadnameIsSTATE(PadlistNAMESARRAY(CvPADLIST(
229                                                 CvOUTSIDE(PL_compcv)
230                                              ))[(ps[(2) - (3)].val.opval)->op_targ]))
231                               CvCLONE_on(PL_compcv);
232                           parser->in_my = 0;
233                           parser->in_my_stash = NULL;
234                         }
235     break;
236
237   case 30:
238 #line 287 "perly.y"
239     {
240                           SvREFCNT_inc_simple_void(PL_compcv);
241                           (ps[(2) - (7)].val.opval)->op_type == OP_CONST
242                               ? newATTRSUB((ps[(3) - (7)].val.ival), (ps[(2) - (7)].val.opval), (ps[(5) - (7)].val.opval), (ps[(6) - (7)].val.opval), (ps[(7) - (7)].val.opval))
243                               : newMYSUB((ps[(3) - (7)].val.ival), (ps[(2) - (7)].val.opval), (ps[(5) - (7)].val.opval), (ps[(6) - (7)].val.opval), (ps[(7) - (7)].val.opval))
244                           ;
245                           (yyval.opval) = (OP*)NULL;
246                           intro_my();
247                         }
248     break;
249
250   case 31:
251 #line 297 "perly.y"
252     {
253                           package((ps[(3) - (4)].val.opval));
254                           if ((ps[(2) - (4)].val.opval))
255                               package_version((ps[(2) - (4)].val.opval));
256                           (yyval.opval) = (OP*)NULL;
257                         }
258     break;
259
260   case 32:
261 #line 304 "perly.y"
262     { CvSPECIAL_on(PL_compcv); /* It's a BEGIN {} */ }
263     break;
264
265   case 33:
266 #line 306 "perly.y"
267     {
268                           SvREFCNT_inc_simple_void(PL_compcv);
269                           utilize((ps[(1) - (7)].val.ival), (ps[(2) - (7)].val.ival), (ps[(4) - (7)].val.opval), (ps[(5) - (7)].val.opval), (ps[(6) - (7)].val.opval));
270                           (yyval.opval) = (OP*)NULL;
271                         }
272     break;
273
274   case 34:
275 #line 312 "perly.y"
276     {
277                           (yyval.opval) = block_end((ps[(3) - (7)].val.ival),
278                               newCONDOP(0, (ps[(4) - (7)].val.opval), op_scope((ps[(6) - (7)].val.opval)), (ps[(7) - (7)].val.opval)));
279                           parser->copline = (line_t)(ps[(1) - (7)].val.ival);
280                         }
281     break;
282
283   case 35:
284 #line 318 "perly.y"
285     {
286                           (yyval.opval) = block_end((ps[(3) - (7)].val.ival),
287                               newCONDOP(0, (ps[(4) - (7)].val.opval), op_scope((ps[(6) - (7)].val.opval)), (ps[(7) - (7)].val.opval)));
288                           parser->copline = (line_t)(ps[(1) - (7)].val.ival);
289                         }
290     break;
291
292   case 36:
293 #line 324 "perly.y"
294     {
295                           const PADOFFSET offset = pad_findmy_pvs("$_", 0);
296                           (yyval.opval) = block_end((ps[(3) - (6)].val.ival),
297                                   newGIVENOP((ps[(4) - (6)].val.opval), op_scope((ps[(6) - (6)].val.opval)),
298                                     offset == NOT_IN_PAD
299                                     || PAD_COMPNAME_FLAGS_isOUR(offset)
300                                       ? 0
301                                       : offset));
302                           parser->copline = (line_t)(ps[(1) - (6)].val.ival);
303                         }
304     break;
305
306   case 37:
307 #line 335 "perly.y"
308     { (yyval.opval) = block_end((ps[(3) - (6)].val.ival), newWHENOP((ps[(4) - (6)].val.opval), op_scope((ps[(6) - (6)].val.opval)))); }
309     break;
310
311   case 38:
312 #line 337 "perly.y"
313     { (yyval.opval) = newWHENOP(0, op_scope((ps[(2) - (2)].val.opval))); }
314     break;
315
316   case 39:
317 #line 339 "perly.y"
318     {
319                           (yyval.opval) = block_end((ps[(3) - (8)].val.ival),
320                                   newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
321                                       (ps[(4) - (8)].val.opval), (ps[(7) - (8)].val.opval), (ps[(8) - (8)].val.opval), (ps[(6) - (8)].val.ival)));
322                           parser->copline = (line_t)(ps[(1) - (8)].val.ival);
323                         }
324     break;
325
326   case 40:
327 #line 346 "perly.y"
328     {
329                           (yyval.opval) = block_end((ps[(3) - (8)].val.ival),
330                                   newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
331                                       (ps[(4) - (8)].val.opval), (ps[(7) - (8)].val.opval), (ps[(8) - (8)].val.opval), (ps[(6) - (8)].val.ival)));
332                           parser->copline = (line_t)(ps[(1) - (8)].val.ival);
333                         }
334     break;
335
336   case 41:
337 #line 353 "perly.y"
338     { parser->expect = XTERM; }
339     break;
340
341   case 42:
342 #line 355 "perly.y"
343     { parser->expect = XTERM; }
344     break;
345
346   case 43:
347 #line 358 "perly.y"
348     {
349                           OP *initop = (ps[(4) - (13)].val.opval);
350                           OP *forop = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
351                                       scalar((ps[(7) - (13)].val.opval)), (ps[(13) - (13)].val.opval), (ps[(11) - (13)].val.opval), (ps[(10) - (13)].val.ival));
352                           if (initop) {
353                               forop = op_prepend_elem(OP_LINESEQ, initop,
354                                   op_append_elem(OP_LINESEQ,
355                                       newOP(OP_UNSTACK, OPf_SPECIAL),
356                                       forop));
357                           }
358                           (yyval.opval) = block_end((ps[(3) - (13)].val.ival), forop);
359                           parser->copline = (line_t)(ps[(1) - (13)].val.ival);
360                         }
361     break;
362
363   case 44:
364 #line 372 "perly.y"
365     {
366                           (yyval.opval) = block_end((ps[(3) - (9)].val.ival), newFOROP(0, (ps[(4) - (9)].val.opval), (ps[(6) - (9)].val.opval), (ps[(8) - (9)].val.opval), (ps[(9) - (9)].val.opval)));
367                           parser->copline = (line_t)(ps[(1) - (9)].val.ival);
368                         }
369     break;
370
371   case 45:
372 #line 377 "perly.y"
373     {
374                           (yyval.opval) = block_end((ps[(4) - (8)].val.ival), newFOROP(0,
375                                       op_lvalue((ps[(2) - (8)].val.opval), OP_ENTERLOOP), (ps[(5) - (8)].val.opval), (ps[(7) - (8)].val.opval), (ps[(8) - (8)].val.opval)));
376                           parser->copline = (line_t)(ps[(1) - (8)].val.ival);
377                         }
378     break;
379
380   case 46:
381 #line 383 "perly.y"
382     { parser->in_my = 0; (yyval.opval) = my((ps[(5) - (5)].val.opval)); }
383     break;
384
385   case 47:
386 #line 385 "perly.y"
387     {
388                           (yyval.opval) = block_end(
389                                 (ps[(4) - (11)].val.ival),
390                                 newFOROP(0,
391                                          op_lvalue(
392                                             newUNOP(OP_REFGEN, 0,
393                                                     (ps[(6) - (11)].val.opval)),
394                                             OP_ENTERLOOP),
395                                          (ps[(8) - (11)].val.opval), (ps[(10) - (11)].val.opval), (ps[(11) - (11)].val.opval))
396                           );
397                           parser->copline = (line_t)(ps[(1) - (11)].val.ival);
398                         }
399     break;
400
401   case 48:
402 #line 398 "perly.y"
403     {
404                           (yyval.opval) = block_end((ps[(5) - (9)].val.ival), newFOROP(
405                                 0, op_lvalue(newUNOP(OP_REFGEN, 0,
406                                                      (ps[(3) - (9)].val.opval)),
407                                              OP_ENTERLOOP), (ps[(6) - (9)].val.opval), (ps[(8) - (9)].val.opval), (ps[(9) - (9)].val.opval)));
408                           parser->copline = (line_t)(ps[(1) - (9)].val.ival);
409                         }
410     break;
411
412   case 49:
413 #line 406 "perly.y"
414     {
415                           (yyval.opval) = block_end((ps[(3) - (7)].val.ival),
416                                   newFOROP(0, (OP*)NULL, (ps[(4) - (7)].val.opval), (ps[(6) - (7)].val.opval), (ps[(7) - (7)].val.opval)));
417                           parser->copline = (line_t)(ps[(1) - (7)].val.ival);
418                         }
419     break;
420
421   case 50:
422 #line 412 "perly.y"
423     {
424                           /* a block is a loop that happens once */
425                           (yyval.opval) = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
426                                   (OP*)NULL, (ps[(1) - (2)].val.opval), (ps[(2) - (2)].val.opval), 0);
427                         }
428     break;
429
430   case 51:
431 #line 418 "perly.y"
432     {
433                           package((ps[(3) - (5)].val.opval));
434                           if ((ps[(2) - (5)].val.opval)) {
435                               package_version((ps[(2) - (5)].val.opval));
436                           }
437                         }
438     break;
439
440   case 52:
441 #line 425 "perly.y"
442     {
443                           /* a block is a loop that happens once */
444                           (yyval.opval) = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
445                                   (OP*)NULL, block_end((ps[(5) - (8)].val.ival), (ps[(7) - (8)].val.opval)), (OP*)NULL, 0);
446                           if (parser->copline > (line_t)(ps[(4) - (8)].val.ival))
447                               parser->copline = (line_t)(ps[(4) - (8)].val.ival);
448                         }
449     break;
450
451   case 53:
452 #line 433 "perly.y"
453     {
454                           (yyval.opval) = (ps[(1) - (2)].val.opval);
455                         }
456     break;
457
458   case 54:
459 #line 437 "perly.y"
460     {
461                           (yyval.opval) = (OP*)NULL;
462                           parser->copline = NOLINE;
463                         }
464     break;
465
466   case 55:
467 #line 445 "perly.y"
468     { OP *list;
469                           if ((ps[(2) - (2)].val.opval)) {
470                               OP *term = (ps[(2) - (2)].val.opval);
471                               list = op_append_elem(OP_LIST, (ps[(1) - (2)].val.opval), term);
472                           }
473                           else {
474                               list = (ps[(1) - (2)].val.opval);
475                           }
476                           if (parser->copline == NOLINE)
477                                parser->copline = CopLINE(PL_curcop)-1;
478                           else parser->copline--;
479                           (yyval.opval) = newSTATEOP(0, NULL,
480                                           op_convert_list(OP_FORMLINE, 0, list));
481                         }
482     break;
483
484   case 56:
485 #line 462 "perly.y"
486     { (yyval.opval) = NULL; }
487     break;
488
489   case 57:
490 #line 464 "perly.y"
491     { (yyval.opval) = op_unscope((ps[(2) - (3)].val.opval)); }
492     break;
493
494   case 58:
495 #line 469 "perly.y"
496     { (yyval.opval) = (OP*)NULL; }
497     break;
498
499   case 59:
500 #line 471 "perly.y"
501     { (yyval.opval) = (ps[(1) - (1)].val.opval); }
502     break;
503
504   case 60:
505 #line 473 "perly.y"
506     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval)); }
507     break;
508
509   case 61:
510 #line 475 "perly.y"
511     { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval)); }
512     break;
513
514   case 62:
515 #line 477 "perly.y"
516     { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, scalar((ps[(3) - (3)].val.opval)), (ps[(1) - (3)].val.opval)); }
517     break;
518
519   case 63:
520 #line 479 "perly.y"
521     { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval)); }
522     break;
523
524   case 64:
525 #line 481 "perly.y"
526     { (yyval.opval) = newFOROP(0, (OP*)NULL, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval), (OP*)NULL);
527                           parser->copline = (line_t)(ps[(2) - (3)].val.ival); }
528     break;
529
530   case 65:
531 #line 484 "perly.y"
532     { (yyval.opval) = newWHENOP((ps[(3) - (3)].val.opval), op_scope((ps[(1) - (3)].val.opval))); }
533     break;
534
535   case 66:
536 #line 489 "perly.y"
537     { (yyval.opval) = (OP*)NULL; }
538     break;
539
540   case 67:
541 #line 491 "perly.y"
542     {
543                           ((ps[(2) - (2)].val.opval))->op_flags |= OPf_PARENS;
544                           (yyval.opval) = op_scope((ps[(2) - (2)].val.opval));
545                         }
546     break;
547
548   case 68:
549 #line 496 "perly.y"
550     { parser->copline = (line_t)(ps[(1) - (6)].val.ival);
551                             (yyval.opval) = newCONDOP(0,
552                                 newSTATEOP(OPf_SPECIAL,NULL,(ps[(3) - (6)].val.opval)),
553                                 op_scope((ps[(5) - (6)].val.opval)), (ps[(6) - (6)].val.opval));
554                           PL_hints |= HINT_BLOCK_SCOPE;
555                         }
556     break;
557
558   case 69:
559 #line 506 "perly.y"
560     { (yyval.opval) = (OP*)NULL; }
561     break;
562
563   case 70:
564 #line 508 "perly.y"
565     { (yyval.opval) = op_scope((ps[(2) - (2)].val.opval)); }
566     break;
567
568   case 71:
569 #line 513 "perly.y"
570     { (yyval.ival) = (PL_min_intro_pending &&
571                             PL_max_intro_pending >=  PL_min_intro_pending);
572                           intro_my(); }
573     break;
574
575   case 72:
576 #line 519 "perly.y"
577     { (yyval.opval) = (OP*)NULL; }
578     break;
579
580   case 74:
581 #line 525 "perly.y"
582     { YYSTYPE tmplval;
583                           (void)scan_num("1", &tmplval);
584                           (yyval.opval) = tmplval.opval; }
585     break;
586
587   case 76:
588 #line 533 "perly.y"
589     { (yyval.opval) = invert(scalar((ps[(1) - (1)].val.opval))); }
590     break;
591
592   case 77:
593 #line 538 "perly.y"
594     { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); }
595     break;
596
597   case 78:
598 #line 542 "perly.y"
599     { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); }
600     break;
601
602   case 79:
603 #line 546 "perly.y"
604     { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); }
605     break;
606
607   case 80:
608 #line 549 "perly.y"
609     { (yyval.opval) = (ps[(1) - (1)].val.opval); }
610     break;
611
612   case 81:
613 #line 550 "perly.y"
614     { (yyval.opval) = (OP*)NULL; }
615     break;
616
617   case 82:
618 #line 554 "perly.y"
619     { (yyval.ival) = start_subparse(FALSE, 0);
620                             SAVEFREESV(PL_compcv); }
621     break;
622
623   case 83:
624 #line 560 "perly.y"
625     { (yyval.ival) = start_subparse(FALSE, CVf_ANON);
626                             SAVEFREESV(PL_compcv); }
627     break;
628
629   case 84:
630 #line 565 "perly.y"
631     { (yyval.ival) = start_subparse(TRUE, 0);
632                             SAVEFREESV(PL_compcv); }
633     break;
634
635   case 87:
636 #line 576 "perly.y"
637     { (yyval.opval) = (OP*)NULL; }
638     break;
639
640   case 89:
641 #line 582 "perly.y"
642     { (yyval.opval) = (OP*)NULL; }
643     break;
644
645   case 90:
646 #line 584 "perly.y"
647     { (yyval.opval) = (ps[(2) - (2)].val.opval); }
648     break;
649
650   case 91:
651 #line 586 "perly.y"
652     { (yyval.opval) = (OP*)NULL; }
653     break;
654
655   case 92:
656 #line 591 "perly.y"
657     { (yyval.opval) = (ps[(2) - (2)].val.opval); }
658     break;
659
660   case 93:
661 #line 593 "perly.y"
662     { (yyval.opval) = (OP*)NULL; }
663     break;
664
665   case 94:
666 #line 597 "perly.y"
667     { (yyval.opval) = (OP*)NULL; }
668     break;
669
670   case 95:
671 #line 599 "perly.y"
672     {
673                           if (!FEATURE_SIGNATURES_IS_ENABLED)
674                             Perl_croak(aTHX_ "Experimental "
675                                 "subroutine signatures not enabled");
676                           Perl_ck_warner_d(aTHX_
677                                 packWARN(WARN_EXPERIMENTAL__SIGNATURES),
678                                 "The signatures feature is experimental");
679                           (yyval.opval) = parse_subsignature();
680                         }
681     break;
682
683   case 96:
684 #line 609 "perly.y"
685     {
686                           (yyval.opval) = op_append_list(OP_LINESEQ, (ps[(2) - (3)].val.opval),
687                                 newSTATEOP(0, NULL, sawparens(newNULLLIST())));
688                           parser->expect = XBLOCK;
689                         }
690     break;
691
692   case 97:
693 #line 618 "perly.y"
694     {
695                           if (parser->copline > (line_t)(ps[(3) - (5)].val.ival))
696                               parser->copline = (line_t)(ps[(3) - (5)].val.ival);
697                           (yyval.opval) = block_end((ps[(1) - (5)].val.ival),
698                                 op_append_list(OP_LINESEQ, (ps[(2) - (5)].val.opval), (ps[(4) - (5)].val.opval)));
699                         }
700     break;
701
702   case 98:
703 #line 627 "perly.y"
704     { (yyval.opval) = (ps[(1) - (1)].val.opval); }
705     break;
706
707   case 99:
708 #line 628 "perly.y"
709     { (yyval.opval) = (OP*)NULL; }
710     break;
711
712   case 100:
713 #line 633 "perly.y"
714     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); }
715     break;
716
717   case 101:
718 #line 635 "perly.y"
719     { (yyval.opval) = newLOGOP((ps[(2) - (3)].val.ival), 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); }
720     break;
721
722   case 102:
723 #line 637 "perly.y"
724     { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); }
725     break;
726
727   case 104:
728 #line 643 "perly.y"
729     { (yyval.opval) = (ps[(1) - (2)].val.opval); }
730     break;
731
732   case 105:
733 #line 645 "perly.y"
734     { 
735                           OP* term = (ps[(3) - (3)].val.opval);
736                           (yyval.opval) = op_append_elem(OP_LIST, (ps[(1) - (3)].val.opval), term);
737                         }
738     break;
739
740   case 107:
741 #line 654 "perly.y"
742     { (yyval.opval) = op_convert_list((ps[(1) - (3)].val.ival), OPf_STACKED,
743                                 op_prepend_elem(OP_LIST, newGVREF((ps[(1) - (3)].val.ival),(ps[(2) - (3)].val.opval)), (ps[(3) - (3)].val.opval)) );
744                         }
745     break;
746
747   case 108:
748 #line 658 "perly.y"
749     { (yyval.opval) = op_convert_list((ps[(1) - (5)].val.ival), OPf_STACKED,
750                                 op_prepend_elem(OP_LIST, newGVREF((ps[(1) - (5)].val.ival),(ps[(3) - (5)].val.opval)), (ps[(4) - (5)].val.opval)) );
751                         }
752     break;
753
754   case 109:
755 #line 662 "perly.y"
756     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
757                                 op_append_elem(OP_LIST,
758                                     op_prepend_elem(OP_LIST, scalar((ps[(1) - (6)].val.opval)), (ps[(5) - (6)].val.opval)),
759                                     newMETHOP(OP_METHOD, 0, (ps[(3) - (6)].val.opval))));
760                         }
761     break;
762
763   case 110:
764 #line 668 "perly.y"
765     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
766                                 op_append_elem(OP_LIST, scalar((ps[(1) - (3)].val.opval)),
767                                     newMETHOP(OP_METHOD, 0, (ps[(3) - (3)].val.opval))));
768                         }
769     break;
770
771   case 111:
772 #line 673 "perly.y"
773     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
774                                 op_append_elem(OP_LIST,
775                                     op_prepend_elem(OP_LIST, (ps[(2) - (3)].val.opval), (ps[(3) - (3)].val.opval)),
776                                     newMETHOP(OP_METHOD, 0, (ps[(1) - (3)].val.opval))));
777                         }
778     break;
779
780   case 112:
781 #line 679 "perly.y"
782     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
783                                 op_append_elem(OP_LIST,
784                                     op_prepend_elem(OP_LIST, (ps[(2) - (5)].val.opval), (ps[(4) - (5)].val.opval)),
785                                     newMETHOP(OP_METHOD, 0, (ps[(1) - (5)].val.opval))));
786                         }
787     break;
788
789   case 113:
790 #line 685 "perly.y"
791     { (yyval.opval) = op_convert_list((ps[(1) - (2)].val.ival), 0, (ps[(2) - (2)].val.opval)); }
792     break;
793
794   case 114:
795 #line 687 "perly.y"
796     { (yyval.opval) = op_convert_list((ps[(1) - (4)].val.ival), 0, (ps[(3) - (4)].val.opval)); }
797     break;
798
799   case 115:
800 #line 689 "perly.y"
801     { SvREFCNT_inc_simple_void(PL_compcv);
802                           (yyval.opval) = newANONATTRSUB((ps[(2) - (3)].val.ival), 0, (OP*)NULL, (ps[(3) - (3)].val.opval)); }
803     break;
804
805   case 116:
806 #line 692 "perly.y"
807     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
808                                  op_append_elem(OP_LIST,
809                                    op_prepend_elem(OP_LIST, (ps[(4) - (5)].val.opval), (ps[(5) - (5)].val.opval)), (ps[(1) - (5)].val.opval)));
810                         }
811     break;
812
813   case 119:
814 #line 707 "perly.y"
815     { (yyval.opval) = newBINOP(OP_GELEM, 0, (ps[(1) - (5)].val.opval), scalar((ps[(3) - (5)].val.opval))); }
816     break;
817
818   case 120:
819 #line 709 "perly.y"
820     { (yyval.opval) = newBINOP(OP_AELEM, 0, oopsAV((ps[(1) - (4)].val.opval)), scalar((ps[(3) - (4)].val.opval)));
821                         }
822     break;
823
824   case 121:
825 #line 712 "perly.y"
826     { (yyval.opval) = newBINOP(OP_AELEM, 0,
827                                         ref(newAVREF((ps[(1) - (5)].val.opval)),OP_RV2AV),
828                                         scalar((ps[(4) - (5)].val.opval)));
829                         }
830     break;
831
832   case 122:
833 #line 717 "perly.y"
834     { (yyval.opval) = newBINOP(OP_AELEM, 0,
835                                         ref(newAVREF((ps[(1) - (4)].val.opval)),OP_RV2AV),
836                                         scalar((ps[(3) - (4)].val.opval)));
837                         }
838     break;
839
840   case 123:
841 #line 722 "perly.y"
842     { (yyval.opval) = newBINOP(OP_HELEM, 0, oopsHV((ps[(1) - (5)].val.opval)), jmaybe((ps[(3) - (5)].val.opval)));
843                         }
844     break;
845
846   case 124:
847 #line 725 "perly.y"
848     { (yyval.opval) = newBINOP(OP_HELEM, 0,
849                                         ref(newHVREF((ps[(1) - (6)].val.opval)),OP_RV2HV),
850                                         jmaybe((ps[(4) - (6)].val.opval))); }
851     break;
852
853   case 125:
854 #line 729 "perly.y"
855     { (yyval.opval) = newBINOP(OP_HELEM, 0,
856                                         ref(newHVREF((ps[(1) - (5)].val.opval)),OP_RV2HV),
857                                         jmaybe((ps[(3) - (5)].val.opval))); }
858     break;
859
860   case 126:
861 #line 733 "perly.y"
862     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
863                                    newCVREF(0, scalar((ps[(1) - (4)].val.opval)))); }
864     break;
865
866   case 127:
867 #line 736 "perly.y"
868     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
869                                    op_append_elem(OP_LIST, (ps[(4) - (5)].val.opval),
870                                        newCVREF(0, scalar((ps[(1) - (5)].val.opval))))); }
871     break;
872
873   case 128:
874 #line 741 "perly.y"
875     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
876                                    op_append_elem(OP_LIST, (ps[(3) - (4)].val.opval),
877                                                newCVREF(0, scalar((ps[(1) - (4)].val.opval))))); }
878     break;
879
880   case 129:
881 #line 745 "perly.y"
882     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
883                                    newCVREF(0, scalar((ps[(1) - (3)].val.opval)))); }
884     break;
885
886   case 130:
887 #line 748 "perly.y"
888     { (yyval.opval) = newSLICEOP(0, (ps[(5) - (6)].val.opval), (ps[(2) - (6)].val.opval)); }
889     break;
890
891   case 131:
892 #line 750 "perly.y"
893     { (yyval.opval) = newSLICEOP(0, (ps[(3) - (4)].val.opval), (ps[(1) - (4)].val.opval)); }
894     break;
895
896   case 132:
897 #line 752 "perly.y"
898     { (yyval.opval) = newSLICEOP(0, (ps[(4) - (5)].val.opval), (OP*)NULL); }
899     break;
900
901   case 133:
902 #line 757 "perly.y"
903     { (yyval.opval) = newASSIGNOP(OPf_STACKED, (ps[(1) - (3)].val.opval), (ps[(2) - (3)].val.ival), (ps[(3) - (3)].val.opval)); }
904     break;
905
906   case 134:
907 #line 759 "perly.y"
908     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); }
909     break;
910
911   case 135:
912 #line 761 "perly.y"
913     {   if ((ps[(2) - (3)].val.ival) != OP_REPEAT)
914                                 scalar((ps[(1) - (3)].val.opval));
915                             (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, (ps[(1) - (3)].val.opval), scalar((ps[(3) - (3)].val.opval)));
916                         }
917     break;
918
919   case 136:
920 #line 766 "perly.y"
921     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); }
922     break;
923
924   case 137:
925 #line 768 "perly.y"
926     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); }
927     break;
928
929   case 138:
930 #line 770 "perly.y"
931     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); }
932     break;
933
934   case 139:
935 #line 772 "perly.y"
936     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); }
937     break;
938
939   case 140:
940 #line 774 "perly.y"
941     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); }
942     break;
943
944   case 141:
945 #line 776 "perly.y"
946     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); }
947     break;
948
949   case 142:
950 #line 778 "perly.y"
951     { (yyval.opval) = newRANGE((ps[(2) - (3)].val.ival), scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); }
952     break;
953
954   case 143:
955 #line 780 "perly.y"
956     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); }
957     break;
958
959   case 144:
960 #line 782 "perly.y"
961     { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); }
962     break;
963
964   case 145:
965 #line 784 "perly.y"
966     { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); }
967     break;
968
969   case 146:
970 #line 786 "perly.y"
971     { (yyval.opval) = bind_match((ps[(2) - (3)].val.ival), (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); }
972     break;
973
974   case 147:
975 #line 791 "perly.y"
976     { (yyval.opval) = newUNOP(OP_NEGATE, 0, scalar((ps[(2) - (2)].val.opval))); }
977     break;
978
979   case 148:
980 #line 793 "perly.y"
981     { (yyval.opval) = (ps[(2) - (2)].val.opval); }
982     break;
983
984   case 149:
985 #line 796 "perly.y"
986     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[(2) - (2)].val.opval))); }
987     break;
988
989   case 150:
990 #line 798 "perly.y"
991     { (yyval.opval) = newUNOP(OP_COMPLEMENT, 0, scalar((ps[(2) - (2)].val.opval))); }
992     break;
993
994   case 151:
995 #line 800 "perly.y"
996     { (yyval.opval) = newUNOP(OP_POSTINC, 0,
997                                         op_lvalue(scalar((ps[(1) - (2)].val.opval)), OP_POSTINC)); }
998     break;
999
1000   case 152:
1001 #line 803 "perly.y"
1002     { (yyval.opval) = newUNOP(OP_POSTDEC, 0,
1003                                         op_lvalue(scalar((ps[(1) - (2)].val.opval)), OP_POSTDEC));}
1004     break;
1005
1006   case 153:
1007 #line 806 "perly.y"
1008     { (yyval.opval) = op_convert_list(OP_JOIN, 0,
1009                                        op_append_elem(
1010                                         OP_LIST,
1011                                         newSVREF(scalar(
1012                                             newSVOP(OP_CONST,0,
1013                                                     newSVpvs("\""))
1014                                         )),
1015                                         (ps[(1) - (2)].val.opval)
1016                                        ));
1017                         }
1018     break;
1019
1020   case 154:
1021 #line 817 "perly.y"
1022     { (yyval.opval) = newUNOP(OP_PREINC, 0,
1023                                         op_lvalue(scalar((ps[(2) - (2)].val.opval)), OP_PREINC)); }
1024     break;
1025
1026   case 155:
1027 #line 820 "perly.y"
1028     { (yyval.opval) = newUNOP(OP_PREDEC, 0,
1029                                         op_lvalue(scalar((ps[(2) - (2)].val.opval)), OP_PREDEC)); }
1030     break;
1031
1032   case 156:
1033 #line 827 "perly.y"
1034     { (yyval.opval) = newANONLIST((ps[(2) - (3)].val.opval)); }
1035     break;
1036
1037   case 157:
1038 #line 829 "perly.y"
1039     { (yyval.opval) = newANONLIST((OP*)NULL);}
1040     break;
1041
1042   case 158:
1043 #line 831 "perly.y"
1044     { (yyval.opval) = newANONHASH((ps[(2) - (4)].val.opval)); }
1045     break;
1046
1047   case 159:
1048 #line 833 "perly.y"
1049     { (yyval.opval) = newANONHASH((OP*)NULL); }
1050     break;
1051
1052   case 160:
1053 #line 835 "perly.y"
1054     { SvREFCNT_inc_simple_void(PL_compcv);
1055                           (yyval.opval) = newANONATTRSUB((ps[(2) - (5)].val.ival), (ps[(3) - (5)].val.opval), (ps[(4) - (5)].val.opval), (ps[(5) - (5)].val.opval)); }
1056     break;
1057
1058   case 161:
1059 #line 842 "perly.y"
1060     { (yyval.opval) = dofile((ps[(2) - (2)].val.opval), (ps[(1) - (2)].val.ival));}
1061     break;
1062
1063   case 162:
1064 #line 844 "perly.y"
1065     { (yyval.opval) = newUNOP(OP_NULL, OPf_SPECIAL, op_scope((ps[(2) - (2)].val.opval)));}
1066     break;
1067
1068   case 167:
1069 #line 852 "perly.y"
1070     { (yyval.opval) = newCONDOP(0, (ps[(1) - (5)].val.opval), (ps[(3) - (5)].val.opval), (ps[(5) - (5)].val.opval)); }
1071     break;
1072
1073   case 168:
1074 #line 854 "perly.y"
1075     { (yyval.opval) = newUNOP(OP_REFGEN, 0, op_lvalue((ps[(2) - (2)].val.opval),OP_REFGEN)); }
1076     break;
1077
1078   case 169:
1079 #line 856 "perly.y"
1080     { (yyval.opval) = (ps[(1) - (1)].val.opval); }
1081     break;
1082
1083   case 170:
1084 #line 858 "perly.y"
1085     { (yyval.opval) = localize((ps[(2) - (2)].val.opval),(ps[(1) - (2)].val.ival)); }
1086     break;
1087
1088   case 171:
1089 #line 860 "perly.y"
1090     { (yyval.opval) = sawparens((ps[(2) - (3)].val.opval)); }
1091     break;
1092
1093   case 172:
1094 #line 862 "perly.y"
1095     { (yyval.opval) = (ps[(1) - (1)].val.opval); }
1096     break;
1097
1098   case 173:
1099 #line 864 "perly.y"
1100     { (yyval.opval) = sawparens(newNULLLIST()); }
1101     break;
1102
1103   case 174:
1104 #line 866 "perly.y"
1105     { (yyval.opval) = (ps[(1) - (1)].val.opval); }
1106     break;
1107
1108   case 175:
1109 #line 868 "perly.y"
1110     { (yyval.opval) = (ps[(1) - (1)].val.opval); }
1111     break;
1112
1113   case 176:
1114 #line 870 "perly.y"
1115     { (yyval.opval) = (ps[(1) - (1)].val.opval); }
1116     break;
1117
1118   case 177:
1119 #line 872 "perly.y"
1120     { (yyval.opval) = (ps[(1) - (1)].val.opval); }
1121     break;
1122
1123   case 178:
1124 #line 874 "perly.y"
1125     { (yyval.opval) = newUNOP(OP_AV2ARYLEN, 0, ref((ps[(1) - (1)].val.opval), OP_AV2ARYLEN));}
1126     break;
1127
1128   case 179:
1129 #line 876 "perly.y"
1130     { (yyval.opval) = (ps[(1) - (1)].val.opval); }
1131     break;
1132
1133   case 180:
1134 #line 878 "perly.y"
1135     { (yyval.opval) = op_prepend_elem(OP_ASLICE,
1136                                 newOP(OP_PUSHMARK, 0),
1137                                     newLISTOP(OP_ASLICE, 0,
1138                                         list((ps[(3) - (4)].val.opval)),
1139                                         ref((ps[(1) - (4)].val.opval), OP_ASLICE)));
1140                           if ((yyval.opval) && (ps[(1) - (4)].val.opval))
1141                               (yyval.opval)->op_private |=
1142                                   (ps[(1) - (4)].val.opval)->op_private & OPpSLICEWARNING;
1143                         }
1144     break;
1145
1146   case 181:
1147 #line 888 "perly.y"
1148     { (yyval.opval) = op_prepend_elem(OP_KVASLICE,
1149                                 newOP(OP_PUSHMARK, 0),
1150                                     newLISTOP(OP_KVASLICE, 0,
1151                                         list((ps[(3) - (4)].val.opval)),
1152                                         ref(oopsAV((ps[(1) - (4)].val.opval)), OP_KVASLICE)));
1153                           if ((yyval.opval) && (ps[(1) - (4)].val.opval))
1154                               (yyval.opval)->op_private |=
1155                                   (ps[(1) - (4)].val.opval)->op_private & OPpSLICEWARNING;
1156                         }
1157     break;
1158
1159   case 182:
1160 #line 898 "perly.y"
1161     { (yyval.opval) = op_prepend_elem(OP_HSLICE,
1162                                 newOP(OP_PUSHMARK, 0),
1163                                     newLISTOP(OP_HSLICE, 0,
1164                                         list((ps[(3) - (5)].val.opval)),
1165                                         ref(oopsHV((ps[(1) - (5)].val.opval)), OP_HSLICE)));
1166                           if ((yyval.opval) && (ps[(1) - (5)].val.opval))
1167                               (yyval.opval)->op_private |=
1168                                   (ps[(1) - (5)].val.opval)->op_private & OPpSLICEWARNING;
1169                         }
1170     break;
1171
1172   case 183:
1173 #line 908 "perly.y"
1174     { (yyval.opval) = op_prepend_elem(OP_KVHSLICE,
1175                                 newOP(OP_PUSHMARK, 0),
1176                                     newLISTOP(OP_KVHSLICE, 0,
1177                                         list((ps[(3) - (5)].val.opval)),
1178                                         ref((ps[(1) - (5)].val.opval), OP_KVHSLICE)));
1179                           if ((yyval.opval) && (ps[(1) - (5)].val.opval))
1180                               (yyval.opval)->op_private |=
1181                                   (ps[(1) - (5)].val.opval)->op_private & OPpSLICEWARNING;
1182                         }
1183     break;
1184
1185   case 184:
1186 #line 918 "perly.y"
1187     { (yyval.opval) = (ps[(1) - (1)].val.opval); }
1188     break;
1189
1190   case 185:
1191 #line 920 "perly.y"
1192     { (yyval.opval) = newUNOP(OP_ENTERSUB, 0, scalar((ps[(1) - (1)].val.opval))); }
1193     break;
1194
1195   case 186:
1196 #line 922 "perly.y"
1197     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (3)].val.opval)));
1198                         }
1199     break;
1200
1201   case 187:
1202 #line 925 "perly.y"
1203     {
1204                           (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1205                                 op_append_elem(OP_LIST, (ps[(3) - (4)].val.opval), scalar((ps[(1) - (4)].val.opval))));
1206                         }
1207     break;
1208
1209   case 188:
1210 #line 930 "perly.y"
1211     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1212                             op_append_elem(OP_LIST, (ps[(3) - (3)].val.opval), scalar((ps[(2) - (3)].val.opval))));
1213                         }
1214     break;
1215
1216   case 189:
1217 #line 934 "perly.y"
1218     { (yyval.opval) = newSVREF((ps[(1) - (4)].val.opval)); }
1219     break;
1220
1221   case 190:
1222 #line 936 "perly.y"
1223     { (yyval.opval) = newAVREF((ps[(1) - (4)].val.opval)); }
1224     break;
1225
1226   case 191:
1227 #line 938 "perly.y"
1228     { (yyval.opval) = newHVREF((ps[(1) - (4)].val.opval)); }
1229     break;
1230
1231   case 192:
1232 #line 940 "perly.y"
1233     { (yyval.opval) = newUNOP(OP_ENTERSUB, 0,
1234                                        scalar(newCVREF((ps[(3) - (4)].val.ival),(ps[(1) - (4)].val.opval)))); }
1235     break;
1236
1237   case 193:
1238 #line 943 "perly.y"
1239     { (yyval.opval) = newGVREF(0,(ps[(1) - (4)].val.opval)); }
1240     break;
1241
1242   case 194:
1243 #line 945 "perly.y"
1244     { (yyval.opval) = newOP((ps[(1) - (1)].val.ival), OPf_SPECIAL);
1245                             PL_hints |= HINT_BLOCK_SCOPE; }
1246     break;
1247
1248   case 195:
1249 #line 948 "perly.y"
1250     { (yyval.opval) = newLOOPEX((ps[(1) - (2)].val.ival),(ps[(2) - (2)].val.opval)); }
1251     break;
1252
1253   case 196:
1254 #line 950 "perly.y"
1255     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[(2) - (2)].val.opval))); }
1256     break;
1257
1258   case 197:
1259 #line 952 "perly.y"
1260     { (yyval.opval) = newOP((ps[(1) - (1)].val.ival), 0); }
1261     break;
1262
1263   case 198:
1264 #line 954 "perly.y"
1265     { (yyval.opval) = newUNOP((ps[(1) - (2)].val.ival), 0, (ps[(2) - (2)].val.opval)); }
1266     break;
1267
1268   case 199:
1269 #line 956 "perly.y"
1270     { (yyval.opval) = newUNOP((ps[(1) - (2)].val.ival), 0, (ps[(2) - (2)].val.opval)); }
1271     break;
1272
1273   case 200:
1274 #line 958 "perly.y"
1275     { (yyval.opval) = newOP(OP_REQUIRE, (ps[(1) - (1)].val.ival) ? OPf_SPECIAL : 0); }
1276     break;
1277
1278   case 201:
1279 #line 960 "perly.y"
1280     { (yyval.opval) = newUNOP(OP_REQUIRE, (ps[(1) - (2)].val.ival) ? OPf_SPECIAL : 0, (ps[(2) - (2)].val.opval)); }
1281     break;
1282
1283   case 202:
1284 #line 962 "perly.y"
1285     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (1)].val.opval))); }
1286     break;
1287
1288   case 203:
1289 #line 964 "perly.y"
1290     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1291                             op_append_elem(OP_LIST, (ps[(2) - (2)].val.opval), scalar((ps[(1) - (2)].val.opval)))); }
1292     break;
1293
1294   case 204:
1295 #line 967 "perly.y"
1296     { (yyval.opval) = newOP((ps[(1) - (1)].val.ival), 0); }
1297     break;
1298
1299   case 205:
1300 #line 969 "perly.y"
1301     { (yyval.opval) = newOP((ps[(1) - (3)].val.ival), 0);}
1302     break;
1303
1304   case 206:
1305 #line 971 "perly.y"
1306     { (yyval.opval) = (ps[(1) - (1)].val.opval); }
1307     break;
1308
1309   case 207:
1310 #line 973 "perly.y"
1311     { (yyval.opval) = (ps[(1) - (3)].val.opval); }
1312     break;
1313
1314   case 208:
1315 #line 975 "perly.y"
1316     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (1)].val.opval))); }
1317     break;
1318
1319   case 209:
1320 #line 977 "perly.y"
1321     { (yyval.opval) = ((ps[(1) - (3)].val.ival) == OP_NOT)
1322                           ? newUNOP((ps[(1) - (3)].val.ival), 0, newSVOP(OP_CONST, 0, newSViv(0)))
1323                           : newOP((ps[(1) - (3)].val.ival), OPf_SPECIAL); }
1324     break;
1325
1326   case 210:
1327 #line 981 "perly.y"
1328     { (yyval.opval) = newUNOP((ps[(1) - (4)].val.ival), 0, (ps[(3) - (4)].val.opval)); }
1329     break;
1330
1331   case 211:
1332 #line 983 "perly.y"
1333     {
1334                             if (   (ps[(1) - (1)].val.opval)->op_type != OP_TRANS
1335                                 && (ps[(1) - (1)].val.opval)->op_type != OP_TRANSR
1336                                 && (((PMOP*)(ps[(1) - (1)].val.opval))->op_pmflags & PMf_HAS_CV))
1337                             {
1338                                 (yyval.ival) = start_subparse(FALSE, CVf_ANON);
1339                                 SAVEFREESV(PL_compcv);
1340                             } else
1341                                 (yyval.ival) = 0;
1342                         }
1343     break;
1344
1345   case 212:
1346 #line 994 "perly.y"
1347     { (yyval.opval) = pmruntime((ps[(1) - (5)].val.opval), (ps[(4) - (5)].val.opval), 1, (ps[(2) - (5)].val.ival)); }
1348     break;
1349
1350   case 215:
1351 #line 998 "perly.y"
1352     {
1353                           (yyval.opval) = newLISTOP(OP_DIE, 0, newOP(OP_PUSHMARK, 0),
1354                                 newSVOP(OP_CONST, 0, newSVpvs("Unimplemented")));
1355                         }
1356     break;
1357
1358   case 217:
1359 #line 1007 "perly.y"
1360     { (yyval.opval) = my_attrs((ps[(2) - (3)].val.opval),(ps[(3) - (3)].val.opval)); }
1361     break;
1362
1363   case 218:
1364 #line 1009 "perly.y"
1365     { (yyval.opval) = localize((ps[(2) - (2)].val.opval),(ps[(1) - (2)].val.ival)); }
1366     break;
1367
1368   case 219:
1369 #line 1014 "perly.y"
1370     { (yyval.opval) = sawparens((ps[(2) - (3)].val.opval)); }
1371     break;
1372
1373   case 220:
1374 #line 1016 "perly.y"
1375     { (yyval.opval) = sawparens(newNULLLIST()); }
1376     break;
1377
1378   case 221:
1379 #line 1019 "perly.y"
1380     { (yyval.opval) = (ps[(1) - (1)].val.opval); }
1381     break;
1382
1383   case 222:
1384 #line 1021 "perly.y"
1385     { (yyval.opval) = (ps[(1) - (1)].val.opval); }
1386     break;
1387
1388   case 223:
1389 #line 1023 "perly.y"
1390     { (yyval.opval) = (ps[(1) - (1)].val.opval); }
1391     break;
1392
1393   case 224:
1394 #line 1028 "perly.y"
1395     { (yyval.opval) = (OP*)NULL; }
1396     break;
1397
1398   case 225:
1399 #line 1030 "perly.y"
1400     { (yyval.opval) = (ps[(1) - (1)].val.opval); }
1401     break;
1402
1403   case 226:
1404 #line 1034 "perly.y"
1405     { (yyval.opval) = (OP*)NULL; }
1406     break;
1407
1408   case 227:
1409 #line 1036 "perly.y"
1410     { (yyval.opval) = (ps[(1) - (1)].val.opval); }
1411     break;
1412
1413   case 228:
1414 #line 1042 "perly.y"
1415     { parser->in_my = 0; (yyval.opval) = my((ps[(1) - (1)].val.opval)); }
1416     break;
1417
1418   case 234:
1419 #line 1055 "perly.y"
1420     { (yyval.opval) = newCVREF((ps[(1) - (2)].val.ival),(ps[(2) - (2)].val.opval)); }
1421     break;
1422
1423   case 235:
1424 #line 1059 "perly.y"
1425     { (yyval.opval) = newSVREF((ps[(2) - (2)].val.opval)); }
1426     break;
1427
1428   case 236:
1429 #line 1063 "perly.y"
1430     { (yyval.opval) = newAVREF((ps[(2) - (2)].val.opval));
1431                           if ((yyval.opval)) (yyval.opval)->op_private |= (ps[(1) - (2)].val.ival);
1432                         }
1433     break;
1434
1435   case 237:
1436 #line 1069 "perly.y"
1437     { (yyval.opval) = newHVREF((ps[(2) - (2)].val.opval));
1438                           if ((yyval.opval)) (yyval.opval)->op_private |= (ps[(1) - (2)].val.ival);
1439                         }
1440     break;
1441
1442   case 238:
1443 #line 1075 "perly.y"
1444     { (yyval.opval) = newAVREF((ps[(2) - (2)].val.opval)); }
1445     break;
1446
1447   case 239:
1448 #line 1077 "perly.y"
1449     { (yyval.opval) = newAVREF((ps[(1) - (4)].val.opval)); }
1450     break;
1451
1452   case 240:
1453 #line 1081 "perly.y"
1454     { (yyval.opval) = newGVREF(0,(ps[(2) - (2)].val.opval)); }
1455     break;
1456
1457   case 242:
1458 #line 1086 "perly.y"
1459     { (yyval.opval) = newAVREF((ps[(1) - (3)].val.opval)); }
1460     break;
1461
1462   case 244:
1463 #line 1091 "perly.y"
1464     { (yyval.opval) = newHVREF((ps[(1) - (3)].val.opval)); }
1465     break;
1466
1467   case 246:
1468 #line 1096 "perly.y"
1469     { (yyval.opval) = newGVREF(0,(ps[(1) - (3)].val.opval)); }
1470     break;
1471
1472   case 247:
1473 #line 1101 "perly.y"
1474     { (yyval.opval) = scalar((ps[(1) - (1)].val.opval)); }
1475     break;
1476
1477   case 248:
1478 #line 1103 "perly.y"
1479     { (yyval.opval) = scalar((ps[(1) - (1)].val.opval)); }
1480     break;
1481
1482   case 249:
1483 #line 1105 "perly.y"
1484     { (yyval.opval) = op_scope((ps[(1) - (1)].val.opval)); }
1485     break;
1486
1487   case 250:
1488 #line 1108 "perly.y"
1489     { (yyval.opval) = (ps[(1) - (1)].val.opval); }
1490     break;
1491
1492       default: break;
1493     
1494
1495 /* Generated from:
1496  * acfba7616277d65c961140e70755bfce7328b5238b69030cd63c78d363a9736c perly.y
1497  * d1d4df7b8e30ac9dede664af9179e6e5e7ddc7f2ad9c4eff9e2e5b32c9e16a6e regen_perly.pl
1498  * ex: set ro: */