This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Use explicit %empty
[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 137 "perly.y"
9                         {
10                           parser->expect = XSTATE;
11                           (yyval.ival) = 0;
12                         }
13
14     break;
15
16   case 3:
17 #line 142 "perly.y"
18                         {
19                           newPROG(block_end((ps[-1].val.ival),(ps[0].val.opval)));
20                           PL_compiling.cop_seq = 0;
21                           (yyval.ival) = 0;
22                         }
23
24     break;
25
26   case 4:
27 #line 148 "perly.y"
28                         {
29                           parser->expect = XTERM;
30                           (yyval.ival) = 0;
31                         }
32
33     break;
34
35   case 5:
36 #line 153 "perly.y"
37                         {
38                           PL_eval_root = (ps[0].val.opval);
39                           (yyval.ival) = 0;
40                         }
41
42     break;
43
44   case 6:
45 #line 158 "perly.y"
46                         {
47                           parser->expect = XBLOCK;
48                           (yyval.ival) = 0;
49                         }
50
51     break;
52
53   case 7:
54 #line 163 "perly.y"
55                         {
56                           PL_pad_reset_pending = TRUE;
57                           PL_eval_root = (ps[0].val.opval);
58                           (yyval.ival) = 0;
59                           yyunlex();
60                           parser->yychar = yytoken = YYEOF;
61                         }
62
63     break;
64
65   case 8:
66 #line 171 "perly.y"
67                         {
68                           parser->expect = XSTATE;
69                           (yyval.ival) = 0;
70                         }
71
72     break;
73
74   case 9:
75 #line 176 "perly.y"
76                         {
77                           PL_pad_reset_pending = TRUE;
78                           PL_eval_root = (ps[0].val.opval);
79                           (yyval.ival) = 0;
80                           yyunlex();
81                           parser->yychar = yytoken = YYEOF;
82                         }
83
84     break;
85
86   case 10:
87 #line 184 "perly.y"
88                         {
89                           parser->expect = XSTATE;
90                           (yyval.ival) = 0;
91                         }
92
93     break;
94
95   case 11:
96 #line 189 "perly.y"
97                         {
98                           PL_pad_reset_pending = TRUE;
99                           PL_eval_root = (ps[0].val.opval);
100                           (yyval.ival) = 0;
101                           yyunlex();
102                           parser->yychar = yytoken = YYEOF;
103                         }
104
105     break;
106
107   case 12:
108 #line 197 "perly.y"
109                         {
110                           parser->expect = XSTATE;
111                           (yyval.ival) = 0;
112                         }
113
114     break;
115
116   case 13:
117 #line 202 "perly.y"
118                         {
119                           PL_eval_root = (ps[0].val.opval);
120                           (yyval.ival) = 0;
121                         }
122
123     break;
124
125   case 14:
126 #line 207 "perly.y"
127                         {
128                           parser->expect = XSTATE;
129                           (yyval.ival) = 0;
130                         }
131
132     break;
133
134   case 15:
135 #line 212 "perly.y"
136                         {
137                           PL_eval_root = (ps[0].val.opval);
138                           (yyval.ival) = 0;
139                         }
140
141     break;
142
143   case 16:
144 #line 220 "perly.y"
145                         { if (parser->copline > (line_t)(ps[-3].val.ival))
146                               parser->copline = (line_t)(ps[-3].val.ival);
147                           (yyval.opval) = block_end((ps[-2].val.ival), (ps[-1].val.opval));
148                         }
149
150     break;
151
152   case 17:
153 #line 228 "perly.y"
154                         { if (parser->copline > (line_t)(ps[-6].val.ival))
155                               parser->copline = (line_t)(ps[-6].val.ival);
156                           (yyval.opval) = block_end((ps[-5].val.ival), (ps[-2].val.opval));
157                         }
158
159     break;
160
161   case 18:
162 #line 235 "perly.y"
163                         { (yyval.ival) = block_start(TRUE);
164                           parser->parsed_sub = 0; }
165
166     break;
167
168   case 19:
169 #line 240 "perly.y"
170                         { if (parser->copline > (line_t)(ps[-3].val.ival))
171                               parser->copline = (line_t)(ps[-3].val.ival);
172                           (yyval.opval) = block_end((ps[-2].val.ival), (ps[-1].val.opval));
173                         }
174
175     break;
176
177   case 20:
178 #line 247 "perly.y"
179                         { (yyval.ival) = block_start(FALSE);
180                           parser->parsed_sub = 0; }
181
182     break;
183
184   case 21:
185 #line 253 "perly.y"
186                         { (yyval.opval) = NULL; }
187
188     break;
189
190   case 22:
191 #line 255 "perly.y"
192                         {   (yyval.opval) = op_append_list(OP_LINESEQ, (ps[-1].val.opval), (ps[0].val.opval));
193                             PL_pad_reset_pending = TRUE;
194                             if ((ps[-1].val.opval) && (ps[0].val.opval))
195                                 PL_hints |= HINT_BLOCK_SCOPE;
196                         }
197
198     break;
199
200   case 23:
201 #line 264 "perly.y"
202                         { (yyval.opval) = NULL; }
203
204     break;
205
206   case 24:
207 #line 266 "perly.y"
208                         {   (yyval.opval) = op_append_list(OP_LINESEQ, (ps[-1].val.opval), (ps[0].val.opval));
209                             PL_pad_reset_pending = TRUE;
210                             if ((ps[-1].val.opval) && (ps[0].val.opval))
211                                 PL_hints |= HINT_BLOCK_SCOPE;
212                         }
213
214     break;
215
216   case 25:
217 #line 275 "perly.y"
218                         {
219                           (yyval.opval) = (ps[0].val.opval) ? newSTATEOP(0, NULL, (ps[0].val.opval)) : NULL;
220                         }
221
222     break;
223
224   case 26:
225 #line 279 "perly.y"
226                         { (yyval.opval) = (ps[0].val.opval); }
227
228     break;
229
230   case 27:
231 #line 283 "perly.y"
232                         {
233                           SV *label = cSVOPx_sv((ps[-1].val.opval));
234                           (yyval.opval) = newSTATEOP(SvFLAGS(label) & SVf_UTF8,
235                                             savepv(SvPVX_const(label)), (ps[0].val.opval));
236                           op_free((ps[-1].val.opval));
237                         }
238
239     break;
240
241   case 28:
242 #line 290 "perly.y"
243                         {
244                           SV *label = cSVOPx_sv((ps[-1].val.opval));
245                           (yyval.opval) = newSTATEOP(SvFLAGS(label) & SVf_UTF8,
246                                             savepv(SvPVX_const(label)), (ps[0].val.opval));
247                           op_free((ps[-1].val.opval));
248                         }
249
250     break;
251
252   case 29:
253 #line 300 "perly.y"
254                         { (yyval.opval) = (ps[0].val.opval); }
255
256     break;
257
258   case 30:
259 #line 302 "perly.y"
260                         {
261                           CV *fmtcv = PL_compcv;
262                           newFORM((ps[-2].val.ival), (ps[-1].val.opval), (ps[0].val.opval));
263                           (yyval.opval) = NULL;
264                           if (CvOUTSIDE(fmtcv) && !CvEVAL(CvOUTSIDE(fmtcv))) {
265                               pad_add_weakref(fmtcv);
266                           }
267                           parser->parsed_sub = 1;
268                         }
269
270     break;
271
272   case 31:
273 #line 314 "perly.y"
274                         {
275                           init_named_cv(PL_compcv, (ps[-1].val.opval));
276                           parser->in_my = 0;
277                           parser->in_my_stash = NULL;
278                         }
279
280     break;
281
282   case 32:
283 #line 320 "perly.y"
284                         {
285                           SvREFCNT_inc_simple_void(PL_compcv);
286                           (ps[-5].val.opval)->op_type == OP_CONST
287                               ? newATTRSUB((ps[-4].val.ival), (ps[-5].val.opval), (ps[-2].val.opval), (ps[-1].val.opval), (ps[0].val.opval))
288                               : newMYSUB((ps[-4].val.ival), (ps[-5].val.opval), (ps[-2].val.opval), (ps[-1].val.opval), (ps[0].val.opval))
289                           ;
290                           (yyval.opval) = NULL;
291                           intro_my();
292                           parser->parsed_sub = 1;
293                         }
294
295     break;
296
297   case 33:
298 #line 335 "perly.y"
299                         {
300                           init_named_cv(PL_compcv, (ps[-1].val.opval));
301                           parser->in_my = 0;
302                           parser->in_my_stash = NULL;
303                         }
304
305     break;
306
307   case 34:
308 #line 341 "perly.y"
309                         {
310                           SvREFCNT_inc_simple_void(PL_compcv);
311                           (ps[-4].val.opval)->op_type == OP_CONST
312                               ? newATTRSUB((ps[-3].val.ival), (ps[-4].val.opval), NULL, (ps[-1].val.opval), (ps[0].val.opval))
313                               : newMYSUB(  (ps[-3].val.ival), (ps[-4].val.opval), NULL, (ps[-1].val.opval), (ps[0].val.opval))
314                           ;
315                           (yyval.opval) = NULL;
316                           intro_my();
317                           parser->parsed_sub = 1;
318                         }
319
320     break;
321
322   case 35:
323 #line 352 "perly.y"
324                         {
325                           package((ps[-1].val.opval));
326                           if ((ps[-2].val.opval))
327                               package_version((ps[-2].val.opval));
328                           (yyval.opval) = NULL;
329                         }
330
331     break;
332
333   case 36:
334 #line 359 "perly.y"
335                         { CvSPECIAL_on(PL_compcv); /* It's a BEGIN {} */ }
336
337     break;
338
339   case 37:
340 #line 361 "perly.y"
341                         {
342                           SvREFCNT_inc_simple_void(PL_compcv);
343                           utilize((ps[-6].val.ival), (ps[-5].val.ival), (ps[-3].val.opval), (ps[-2].val.opval), (ps[-1].val.opval));
344                           parser->parsed_sub = 1;
345                           (yyval.opval) = NULL;
346                         }
347
348     break;
349
350   case 38:
351 #line 368 "perly.y"
352                         {
353                           (yyval.opval) = block_end((ps[-4].val.ival),
354                               newCONDOP(0, (ps[-3].val.opval), op_scope((ps[-1].val.opval)), (ps[0].val.opval)));
355                           parser->copline = (line_t)(ps[-6].val.ival);
356                         }
357
358     break;
359
360   case 39:
361 #line 374 "perly.y"
362                         {
363                           (yyval.opval) = block_end((ps[-4].val.ival),
364                               newCONDOP(0, (ps[-3].val.opval), (ps[0].val.opval), op_scope((ps[-1].val.opval))));
365                           parser->copline = (line_t)(ps[-6].val.ival);
366                         }
367
368     break;
369
370   case 40:
371 #line 380 "perly.y"
372                         {
373                           (yyval.opval) = block_end((ps[-3].val.ival), newGIVENOP((ps[-2].val.opval), op_scope((ps[0].val.opval)), 0));
374                           parser->copline = (line_t)(ps[-5].val.ival);
375                         }
376
377     break;
378
379   case 41:
380 #line 385 "perly.y"
381                         { (yyval.opval) = block_end((ps[-3].val.ival), newWHENOP((ps[-2].val.opval), op_scope((ps[0].val.opval)))); }
382
383     break;
384
385   case 42:
386 #line 387 "perly.y"
387                         { (yyval.opval) = newWHENOP(0, op_scope((ps[0].val.opval))); }
388
389     break;
390
391   case 43:
392 #line 389 "perly.y"
393                         {
394                           (yyval.opval) = block_end((ps[-5].val.ival),
395                                   newWHILEOP(0, 1, NULL,
396                                       (ps[-4].val.opval), (ps[-1].val.opval), (ps[0].val.opval), (ps[-2].val.ival)));
397                           parser->copline = (line_t)(ps[-7].val.ival);
398                         }
399
400     break;
401
402   case 44:
403 #line 396 "perly.y"
404                         {
405                           (yyval.opval) = block_end((ps[-5].val.ival),
406                                   newWHILEOP(0, 1, NULL,
407                                       (ps[-4].val.opval), (ps[-1].val.opval), (ps[0].val.opval), (ps[-2].val.ival)));
408                           parser->copline = (line_t)(ps[-7].val.ival);
409                         }
410
411     break;
412
413   case 45:
414 #line 403 "perly.y"
415                         { parser->expect = XTERM; }
416
417     break;
418
419   case 46:
420 #line 405 "perly.y"
421                         { parser->expect = XTERM; }
422
423     break;
424
425   case 47:
426 #line 408 "perly.y"
427                         {
428                           OP *initop = (ps[-9].val.opval);
429                           OP *forop = newWHILEOP(0, 1, NULL,
430                                       scalar((ps[-6].val.opval)), (ps[0].val.opval), (ps[-2].val.opval), (ps[-3].val.ival));
431                           if (initop) {
432                               forop = op_prepend_elem(OP_LINESEQ, initop,
433                                   op_append_elem(OP_LINESEQ,
434                                       newOP(OP_UNSTACK, OPf_SPECIAL),
435                                       forop));
436                           }
437                           PL_hints |= HINT_BLOCK_SCOPE;
438                           (yyval.opval) = block_end((ps[-10].val.ival), forop);
439                           parser->copline = (line_t)(ps[-12].val.ival);
440                         }
441
442     break;
443
444   case 48:
445 #line 423 "perly.y"
446                         {
447                           (yyval.opval) = block_end((ps[-6].val.ival), newFOROP(0, (ps[-5].val.opval), (ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval)));
448                           parser->copline = (line_t)(ps[-8].val.ival);
449                         }
450
451     break;
452
453   case 49:
454 #line 428 "perly.y"
455                         {
456                           (yyval.opval) = block_end((ps[-4].val.ival), newFOROP(0,
457                                       op_lvalue((ps[-6].val.opval), OP_ENTERLOOP), (ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval)));
458                           parser->copline = (line_t)(ps[-7].val.ival);
459                         }
460
461     break;
462
463   case 50:
464 #line 434 "perly.y"
465                         { parser->in_my = 0; (yyval.opval) = my((ps[0].val.opval)); }
466
467     break;
468
469   case 51:
470 #line 436 "perly.y"
471                         {
472                           (yyval.opval) = block_end(
473                                 (ps[-7].val.ival),
474                                 newFOROP(0,
475                                          op_lvalue(
476                                             newUNOP(OP_REFGEN, 0,
477                                                     (ps[-5].val.opval)),
478                                             OP_ENTERLOOP),
479                                          (ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval))
480                           );
481                           parser->copline = (line_t)(ps[-9].val.ival);
482                         }
483
484     break;
485
486   case 52:
487 #line 449 "perly.y"
488                         {
489                           (yyval.opval) = block_end((ps[-4].val.ival), newFOROP(
490                                 0, op_lvalue(newUNOP(OP_REFGEN, 0,
491                                                      (ps[-6].val.opval)),
492                                              OP_ENTERLOOP), (ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval)));
493                           parser->copline = (line_t)(ps[-8].val.ival);
494                         }
495
496     break;
497
498   case 53:
499 #line 457 "perly.y"
500                         {
501                           (yyval.opval) = block_end((ps[-4].val.ival),
502                                   newFOROP(0, NULL, (ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval)));
503                           parser->copline = (line_t)(ps[-6].val.ival);
504                         }
505
506     break;
507
508   case 54:
509 #line 463 "perly.y"
510                         {
511                           /* a block is a loop that happens once */
512                           (yyval.opval) = newWHILEOP(0, 1, NULL,
513                                   NULL, (ps[-1].val.opval), (ps[0].val.opval), 0);
514                         }
515
516     break;
517
518   case 55:
519 #line 469 "perly.y"
520                         {
521                           package((ps[-2].val.opval));
522                           if ((ps[-3].val.opval)) {
523                               package_version((ps[-3].val.opval));
524                           }
525                         }
526
527     break;
528
529   case 56:
530 #line 476 "perly.y"
531                         {
532                           /* a block is a loop that happens once */
533                           (yyval.opval) = newWHILEOP(0, 1, NULL,
534                                   NULL, block_end((ps[-3].val.ival), (ps[-1].val.opval)), NULL, 0);
535                           if (parser->copline > (line_t)(ps[-4].val.ival))
536                               parser->copline = (line_t)(ps[-4].val.ival);
537                         }
538
539     break;
540
541   case 57:
542 #line 484 "perly.y"
543                         {
544                           (yyval.opval) = (ps[-1].val.opval);
545                         }
546
547     break;
548
549   case 58:
550 #line 488 "perly.y"
551                         {
552                           (yyval.opval) = newLISTOP(OP_DIE, 0, newOP(OP_PUSHMARK, 0),
553                                 newSVOP(OP_CONST, 0, newSVpvs("Unimplemented")));
554                         }
555
556     break;
557
558   case 59:
559 #line 493 "perly.y"
560                         {
561                           (yyval.opval) = NULL;
562                           parser->copline = NOLINE;
563                         }
564
565     break;
566
567   case 60:
568 #line 501 "perly.y"
569                         { OP *list;
570                           if ((ps[0].val.opval)) {
571                               OP *term = (ps[0].val.opval);
572                               list = op_append_elem(OP_LIST, (ps[-1].val.opval), term);
573                           }
574                           else {
575                               list = (ps[-1].val.opval);
576                           }
577                           if (parser->copline == NOLINE)
578                                parser->copline = CopLINE(PL_curcop)-1;
579                           else parser->copline--;
580                           (yyval.opval) = newSTATEOP(0, NULL,
581                                           op_convert_list(OP_FORMLINE, 0, list));
582                         }
583
584     break;
585
586   case 61:
587 #line 518 "perly.y"
588                         { (yyval.opval) = NULL; }
589
590     break;
591
592   case 62:
593 #line 520 "perly.y"
594                         { (yyval.opval) = op_unscope((ps[-1].val.opval)); }
595
596     break;
597
598   case 64:
599 #line 528 "perly.y"
600                         { (yyval.opval) = NULL; }
601
602     break;
603
604   case 65:
605 #line 530 "perly.y"
606                         { (yyval.opval) = (ps[0].val.opval); }
607
608     break;
609
610   case 66:
611 #line 532 "perly.y"
612                         { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[0].val.opval), (ps[-2].val.opval)); }
613
614     break;
615
616   case 67:
617 #line 534 "perly.y"
618                         { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[0].val.opval), (ps[-2].val.opval)); }
619
620     break;
621
622   case 68:
623 #line 536 "perly.y"
624                         { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, scalar((ps[0].val.opval)), (ps[-2].val.opval)); }
625
626     break;
627
628   case 69:
629 #line 538 "perly.y"
630                         { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, (ps[0].val.opval), (ps[-2].val.opval)); }
631
632     break;
633
634   case 70:
635 #line 540 "perly.y"
636                         { (yyval.opval) = newFOROP(0, NULL, (ps[0].val.opval), (ps[-2].val.opval), NULL);
637                           parser->copline = (line_t)(ps[-1].val.ival); }
638
639     break;
640
641   case 71:
642 #line 543 "perly.y"
643                         { (yyval.opval) = newWHENOP((ps[0].val.opval), op_scope((ps[-2].val.opval))); }
644
645     break;
646
647   case 72:
648 #line 548 "perly.y"
649                         { (yyval.opval) = NULL; }
650
651     break;
652
653   case 73:
654 #line 550 "perly.y"
655                         {
656                           ((ps[0].val.opval))->op_flags |= OPf_PARENS;
657                           (yyval.opval) = op_scope((ps[0].val.opval));
658                         }
659
660     break;
661
662   case 74:
663 #line 555 "perly.y"
664                         { parser->copline = (line_t)(ps[-5].val.ival);
665                             (yyval.opval) = newCONDOP(0,
666                                 newSTATEOP(OPf_SPECIAL,NULL,(ps[-3].val.opval)),
667                                 op_scope((ps[-1].val.opval)), (ps[0].val.opval));
668                           PL_hints |= HINT_BLOCK_SCOPE;
669                         }
670
671     break;
672
673   case 75:
674 #line 565 "perly.y"
675                         { (yyval.opval) = NULL; }
676
677     break;
678
679   case 76:
680 #line 567 "perly.y"
681                         { (yyval.opval) = op_scope((ps[0].val.opval)); }
682
683     break;
684
685   case 77:
686 #line 572 "perly.y"
687                         { (yyval.ival) = (PL_min_intro_pending &&
688                             PL_max_intro_pending >=  PL_min_intro_pending);
689                           intro_my(); }
690
691     break;
692
693   case 78:
694 #line 578 "perly.y"
695                         { (yyval.opval) = NULL; }
696
697     break;
698
699   case 80:
700 #line 584 "perly.y"
701                         { YYSTYPE tmplval;
702                           (void)scan_num("1", &tmplval);
703                           (yyval.opval) = tmplval.opval; }
704
705     break;
706
707   case 82:
708 #line 592 "perly.y"
709                         { (yyval.opval) = invert(scalar((ps[0].val.opval))); }
710
711     break;
712
713   case 83:
714 #line 597 "perly.y"
715                         { (yyval.opval) = (ps[0].val.opval); intro_my(); }
716
717     break;
718
719   case 84:
720 #line 601 "perly.y"
721                         { (yyval.opval) = (ps[0].val.opval); intro_my(); }
722
723     break;
724
725   case 85:
726 #line 604 "perly.y"
727                                 { (yyval.opval) = (ps[0].val.opval); }
728
729     break;
730
731   case 86:
732 #line 605 "perly.y"
733                         { (yyval.opval) = NULL; }
734
735     break;
736
737   case 87:
738 #line 609 "perly.y"
739                         { (yyval.ival) = start_subparse(FALSE, 0);
740                             SAVEFREESV(PL_compcv); }
741
742     break;
743
744   case 88:
745 #line 615 "perly.y"
746                         { (yyval.ival) = start_subparse(FALSE, CVf_ANON);
747                             SAVEFREESV(PL_compcv); }
748
749     break;
750
751   case 89:
752 #line 620 "perly.y"
753                         { (yyval.ival) = start_subparse(TRUE, 0);
754                             SAVEFREESV(PL_compcv); }
755
756     break;
757
758   case 92:
759 #line 631 "perly.y"
760                         { (yyval.opval) = NULL; }
761
762     break;
763
764   case 94:
765 #line 637 "perly.y"
766                         { (yyval.opval) = NULL; }
767
768     break;
769
770   case 95:
771 #line 639 "perly.y"
772                         { (yyval.opval) = (ps[0].val.opval); }
773
774     break;
775
776   case 96:
777 #line 641 "perly.y"
778                         { (yyval.opval) = NULL; }
779
780     break;
781
782   case 97:
783 #line 646 "perly.y"
784                         { (yyval.opval) = (ps[0].val.opval); }
785
786     break;
787
788   case 98:
789 #line 648 "perly.y"
790                         { (yyval.opval) = NULL; }
791
792     break;
793
794   case 99:
795 #line 659 "perly.y"
796                         { parser->in_my = 0; (yyval.opval) = NULL; }
797
798     break;
799
800   case 100:
801 #line 661 "perly.y"
802                         { parser->in_my = 0; (yyval.opval) = (ps[0].val.opval); }
803
804     break;
805
806   case 101:
807 #line 666 "perly.y"
808                         { (yyval.ival) = '@'; }
809
810     break;
811
812   case 102:
813 #line 668 "perly.y"
814                         { (yyval.ival) = '%'; }
815
816     break;
817
818   case 103:
819 #line 672 "perly.y"
820                         {
821                             I32 sigil   = (ps[-2].val.ival);
822                             OP *var     = (ps[-1].val.opval);
823                             OP *defexpr = (ps[0].val.opval);
824
825                             if (parser->sig_slurpy)
826                                 yyerror("Multiple slurpy parameters not allowed");
827                             parser->sig_slurpy = (char)sigil;
828
829                             if (defexpr)
830                                 yyerror("A slurpy parameter may not have "
831                                         "a default value");
832
833                             (yyval.opval) = var ? newSTATEOP(0, NULL, var) : NULL;
834                         }
835
836     break;
837
838   case 104:
839 #line 691 "perly.y"
840                         { (yyval.opval) = NULL; }
841
842     break;
843
844   case 105:
845 #line 693 "perly.y"
846                         { (yyval.opval) = newOP(OP_NULL, 0); }
847
848     break;
849
850   case 106:
851 #line 695 "perly.y"
852                         { (yyval.opval) = (ps[0].val.opval); }
853
854     break;
855
856   case 107:
857 #line 701 "perly.y"
858                         {
859                             OP *var     = (ps[-1].val.opval);
860                             OP *defexpr = (ps[0].val.opval);
861
862                             if (parser->sig_slurpy)
863                                 yyerror("Slurpy parameter not last");
864
865                             parser->sig_elems++;
866
867                             if (defexpr) {
868                                 parser->sig_optelems++;
869
870                                 if (   defexpr->op_type == OP_NULL
871                                     && !(defexpr->op_flags & OPf_KIDS))
872                                 {
873                                     /* handle '$=' special case */
874                                     if (var)
875                                         yyerror("Optional parameter "
876                                                     "lacks default expression");
877                                     op_free(defexpr);
878                                 }
879                                 else { 
880                                     /* a normal '=default' expression */ 
881                                     OP *defop = (OP*)alloc_LOGOP(OP_ARGDEFELEM,
882                                                         defexpr,
883                                                         LINKLIST(defexpr));
884                                     /* re-purpose op_targ to hold @_ index */
885                                     defop->op_targ =
886                                         (PADOFFSET)(parser->sig_elems - 1);
887
888                                     if (var) {
889                                         var->op_flags |= OPf_STACKED;
890                                         (void)op_sibling_splice(var,
891                                                         NULL, 0, defop);
892                                         scalar(defop);
893                                     }
894                                     else
895                                         var = newUNOP(OP_NULL, 0, defop);
896
897                                     LINKLIST(var);
898                                     /* NB: normally the first child of a
899                                      * logop is executed before the logop,
900                                      * and it pushes a boolean result
901                                      * ready for the logop. For ARGDEFELEM,
902                                      * the op itself does the boolean
903                                      * calculation, so set the first op to
904                                      * it instead.
905                                      */
906                                     var->op_next = defop;
907                                     defexpr->op_next = var;
908                                 }
909                             }
910                             else {
911                                 if (parser->sig_optelems)
912                                     yyerror("Mandatory parameter "
913                                             "follows optional parameter");
914                             }
915
916                             (yyval.opval) = var ? newSTATEOP(0, NULL, var) : NULL;
917                         }
918
919     break;
920
921   case 108:
922 #line 766 "perly.y"
923                         { parser->in_my = KEY_sigvar; (yyval.opval) = (ps[0].val.opval); }
924
925     break;
926
927   case 109:
928 #line 768 "perly.y"
929                         { parser->in_my = KEY_sigvar; (yyval.opval) = (ps[0].val.opval); }
930
931     break;
932
933   case 110:
934 #line 774 "perly.y"
935                         { (yyval.opval) = (ps[-1].val.opval); }
936
937     break;
938
939   case 111:
940 #line 776 "perly.y"
941                         {
942                           (yyval.opval) = op_append_list(OP_LINESEQ, (ps[-2].val.opval), (ps[0].val.opval));
943                         }
944
945     break;
946
947   case 112:
948 #line 780 "perly.y"
949                         { (yyval.opval) = (ps[0].val.opval); }
950
951     break;
952
953   case 113:
954 #line 785 "perly.y"
955                         { (yyval.opval) = NULL; }
956
957     break;
958
959   case 114:
960 #line 787 "perly.y"
961                         { (yyval.opval) = (ps[0].val.opval); }
962
963     break;
964
965   case 115:
966 #line 791 "perly.y"
967                         { (yyval.opval) = NULL; }
968
969     break;
970
971   case 116:
972 #line 793 "perly.y"
973                         { (yyval.opval) = (ps[0].val.opval); }
974
975     break;
976
977   case 117:
978 #line 797 "perly.y"
979                         { (yyval.opval) = (ps[-1].val.opval); }
980
981     break;
982
983   case 118:
984 #line 800 "perly.y"
985                         {
986                             ENTER;
987                             SAVEIV(parser->sig_elems);
988                             SAVEIV(parser->sig_optelems);
989                             SAVEI8(parser->sig_slurpy);
990                             parser->sig_elems    = 0;
991                             parser->sig_optelems = 0;
992                             parser->sig_slurpy   = 0;
993                             parser->in_my        = KEY_sigvar;
994                         }
995
996     break;
997
998   case 119:
999 #line 811 "perly.y"
1000                         {
1001                             OP            *sigops = (ps[0].val.opval);
1002                             struct op_argcheck_aux *aux;
1003                             OP            *check;
1004
1005                             if (!FEATURE_SIGNATURES_IS_ENABLED)
1006                                 Perl_croak(aTHX_ "Experimental "
1007                                     "subroutine signatures not enabled");
1008
1009                             /* We shouldn't get here otherwise */
1010                             Perl_ck_warner_d(aTHX_
1011                                 packWARN(WARN_EXPERIMENTAL__SIGNATURES),
1012                                 "The signatures feature is experimental");
1013
1014                             aux = (struct op_argcheck_aux*)
1015                                     PerlMemShared_malloc(
1016                                         sizeof(struct op_argcheck_aux));
1017                             aux->params     = parser->sig_elems;
1018                             aux->opt_params = parser->sig_optelems;
1019                             aux->slurpy     = parser->sig_slurpy;
1020                             check = newUNOP_AUX(OP_ARGCHECK, 0, NULL,
1021                                             (UNOP_AUX_item *)aux);
1022                             sigops = op_prepend_elem(OP_LINESEQ, check, sigops);
1023                             sigops = op_prepend_elem(OP_LINESEQ,
1024                                                 newSTATEOP(0, NULL, NULL),
1025                                                 sigops);
1026                             /* a nextstate at the end handles context
1027                              * correctly for an empty sub body */
1028                             sigops = op_append_elem(OP_LINESEQ,
1029                                                 sigops,
1030                                                 newSTATEOP(0, NULL, NULL));
1031                             /* wrap the list of arg ops in a NULL aux op.
1032                               This serves two purposes. First, it makes
1033                               the arg list a separate subtree from the
1034                               body of the sub, and secondly the null op
1035                               may in future be upgraded to an OP_SIGNATURE
1036                               when implemented. For now leave it as
1037                               ex-argcheck */
1038                             (yyval.opval) = newUNOP_AUX(OP_ARGCHECK, 0, sigops, NULL);
1039                             op_null((yyval.opval));
1040
1041                             parser->in_my = 0;
1042                             /* tell the toker that attrributes can follow
1043                              * this sig, but only so that the toker
1044                              * can skip through any (illegal) trailing
1045                              * attribute text then give a useful error
1046                              * message about "attributes before sig",
1047                              * rather than falling over ina mess at
1048                              * unrecognised syntax.
1049                              */
1050                             parser->expect = XATTRBLOCK;
1051                             parser->sig_seen = TRUE;
1052                             LEAVE;
1053                         }
1054
1055     break;
1056
1057   case 120:
1058 #line 868 "perly.y"
1059                         { (yyval.opval) = (ps[0].val.opval); }
1060
1061     break;
1062
1063   case 121:
1064 #line 869 "perly.y"
1065                                 { (yyval.opval) = NULL; }
1066
1067     break;
1068
1069   case 122:
1070 #line 875 "perly.y"
1071                         {
1072                           if (parser->copline > (line_t)(ps[-2].val.ival))
1073                               parser->copline = (line_t)(ps[-2].val.ival);
1074                           (yyval.opval) = block_end((ps[-3].val.ival), (ps[-1].val.opval));
1075                         }
1076
1077     break;
1078
1079   case 123:
1080 #line 885 "perly.y"
1081                            { (yyval.opval) = (ps[0].val.opval); }
1082
1083     break;
1084
1085   case 124:
1086 #line 886 "perly.y"
1087                                    { (yyval.opval) = NULL; }
1088
1089     break;
1090
1091   case 125:
1092 #line 890 "perly.y"
1093                         {
1094                           if (parser->copline > (line_t)(ps[-2].val.ival))
1095                               parser->copline = (line_t)(ps[-2].val.ival);
1096                           (yyval.opval) = block_end((ps[-4].val.ival),
1097                                 op_append_list(OP_LINESEQ, (ps[-3].val.opval), (ps[-1].val.opval)));
1098                         }
1099
1100     break;
1101
1102   case 126:
1103 #line 901 "perly.y"
1104                         { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1105
1106     break;
1107
1108   case 127:
1109 #line 903 "perly.y"
1110                         { (yyval.opval) = newLOGOP((ps[-1].val.ival), 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1111
1112     break;
1113
1114   case 129:
1115 #line 909 "perly.y"
1116                         { (yyval.opval) = (ps[-1].val.opval); }
1117
1118     break;
1119
1120   case 130:
1121 #line 911 "perly.y"
1122                         {
1123                           OP* term = (ps[0].val.opval);
1124                           (yyval.opval) = op_append_elem(OP_LIST, (ps[-2].val.opval), term);
1125                         }
1126
1127     break;
1128
1129   case 132:
1130 #line 920 "perly.y"
1131                         { (yyval.opval) = op_convert_list((ps[-2].val.ival), OPf_STACKED,
1132                                 op_prepend_elem(OP_LIST, newGVREF((ps[-2].val.ival),(ps[-1].val.opval)), (ps[0].val.opval)) );
1133                         }
1134
1135     break;
1136
1137   case 133:
1138 #line 924 "perly.y"
1139                         { (yyval.opval) = op_convert_list((ps[-4].val.ival), OPf_STACKED,
1140                                 op_prepend_elem(OP_LIST, newGVREF((ps[-4].val.ival),(ps[-2].val.opval)), (ps[-1].val.opval)) );
1141                         }
1142
1143     break;
1144
1145   case 134:
1146 #line 928 "perly.y"
1147                         { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
1148                                 op_append_elem(OP_LIST,
1149                                     op_prepend_elem(OP_LIST, scalar((ps[-5].val.opval)), (ps[-1].val.opval)),
1150                                     newMETHOP(OP_METHOD, 0, (ps[-3].val.opval))));
1151                         }
1152
1153     break;
1154
1155   case 135:
1156 #line 934 "perly.y"
1157                         { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
1158                                 op_append_elem(OP_LIST, scalar((ps[-2].val.opval)),
1159                                     newMETHOP(OP_METHOD, 0, (ps[0].val.opval))));
1160                         }
1161
1162     break;
1163
1164   case 136:
1165 #line 939 "perly.y"
1166                         { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
1167                                 op_append_elem(OP_LIST,
1168                                     op_prepend_elem(OP_LIST, (ps[-1].val.opval), (ps[0].val.opval)),
1169                                     newMETHOP(OP_METHOD, 0, (ps[-2].val.opval))));
1170                         }
1171
1172     break;
1173
1174   case 137:
1175 #line 945 "perly.y"
1176                         { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
1177                                 op_append_elem(OP_LIST,
1178                                     op_prepend_elem(OP_LIST, (ps[-3].val.opval), (ps[-1].val.opval)),
1179                                     newMETHOP(OP_METHOD, 0, (ps[-4].val.opval))));
1180                         }
1181
1182     break;
1183
1184   case 138:
1185 #line 951 "perly.y"
1186                         { (yyval.opval) = op_convert_list((ps[-1].val.ival), 0, (ps[0].val.opval)); }
1187
1188     break;
1189
1190   case 139:
1191 #line 953 "perly.y"
1192                         { (yyval.opval) = op_convert_list((ps[-3].val.ival), 0, (ps[-1].val.opval)); }
1193
1194     break;
1195
1196   case 140:
1197 #line 955 "perly.y"
1198                         { (yyval.opval) = op_convert_list((ps[-3].val.ival), 0, (ps[-1].val.opval)); }
1199
1200     break;
1201
1202   case 141:
1203 #line 957 "perly.y"
1204                         { SvREFCNT_inc_simple_void(PL_compcv);
1205                           (yyval.opval) = newANONATTRSUB((ps[-1].val.ival), 0, NULL, (ps[0].val.opval)); }
1206
1207     break;
1208
1209   case 142:
1210 #line 960 "perly.y"
1211                         { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1212                                  op_append_elem(OP_LIST,
1213                                    op_prepend_elem(OP_LIST, (ps[-1].val.opval), (ps[0].val.opval)), (ps[-4].val.opval)));
1214                         }
1215
1216     break;
1217
1218   case 145:
1219 #line 975 "perly.y"
1220                         { (yyval.opval) = newBINOP(OP_GELEM, 0, (ps[-4].val.opval), scalar((ps[-2].val.opval))); }
1221
1222     break;
1223
1224   case 146:
1225 #line 977 "perly.y"
1226                         { (yyval.opval) = newBINOP(OP_AELEM, 0, oopsAV((ps[-3].val.opval)), scalar((ps[-1].val.opval)));
1227                         }
1228
1229     break;
1230
1231   case 147:
1232 #line 980 "perly.y"
1233                         { (yyval.opval) = newBINOP(OP_AELEM, 0,
1234                                         ref(newAVREF((ps[-4].val.opval)),OP_RV2AV),
1235                                         scalar((ps[-1].val.opval)));
1236                         }
1237
1238     break;
1239
1240   case 148:
1241 #line 985 "perly.y"
1242                         { (yyval.opval) = newBINOP(OP_AELEM, 0,
1243                                         ref(newAVREF((ps[-3].val.opval)),OP_RV2AV),
1244                                         scalar((ps[-1].val.opval)));
1245                         }
1246
1247     break;
1248
1249   case 149:
1250 #line 990 "perly.y"
1251                         { (yyval.opval) = newBINOP(OP_HELEM, 0, oopsHV((ps[-4].val.opval)), jmaybe((ps[-2].val.opval)));
1252                         }
1253
1254     break;
1255
1256   case 150:
1257 #line 993 "perly.y"
1258                         { (yyval.opval) = newBINOP(OP_HELEM, 0,
1259                                         ref(newHVREF((ps[-5].val.opval)),OP_RV2HV),
1260                                         jmaybe((ps[-2].val.opval))); }
1261
1262     break;
1263
1264   case 151:
1265 #line 997 "perly.y"
1266                         { (yyval.opval) = newBINOP(OP_HELEM, 0,
1267                                         ref(newHVREF((ps[-4].val.opval)),OP_RV2HV),
1268                                         jmaybe((ps[-2].val.opval))); }
1269
1270     break;
1271
1272   case 152:
1273 #line 1001 "perly.y"
1274                         { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1275                                    newCVREF(0, scalar((ps[-3].val.opval))));
1276                           if (parser->expect == XBLOCK)
1277                               parser->expect = XOPERATOR;
1278                         }
1279
1280     break;
1281
1282   case 153:
1283 #line 1007 "perly.y"
1284                         { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1285                                    op_append_elem(OP_LIST, (ps[-1].val.opval),
1286                                        newCVREF(0, scalar((ps[-4].val.opval)))));
1287                           if (parser->expect == XBLOCK)
1288                               parser->expect = XOPERATOR;
1289                         }
1290
1291     break;
1292
1293   case 154:
1294 #line 1015 "perly.y"
1295                         { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1296                                    op_append_elem(OP_LIST, (ps[-1].val.opval),
1297                                                newCVREF(0, scalar((ps[-3].val.opval)))));
1298                           if (parser->expect == XBLOCK)
1299                               parser->expect = XOPERATOR;
1300                         }
1301
1302     break;
1303
1304   case 155:
1305 #line 1022 "perly.y"
1306                         { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1307                                    newCVREF(0, scalar((ps[-2].val.opval))));
1308                           if (parser->expect == XBLOCK)
1309                               parser->expect = XOPERATOR;
1310                         }
1311
1312     break;
1313
1314   case 156:
1315 #line 1028 "perly.y"
1316                         { (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), (ps[-4].val.opval)); }
1317
1318     break;
1319
1320   case 157:
1321 #line 1030 "perly.y"
1322                         { (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), (ps[-3].val.opval)); }
1323
1324     break;
1325
1326   case 158:
1327 #line 1032 "perly.y"
1328                         { (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), NULL); }
1329
1330     break;
1331
1332   case 159:
1333 #line 1037 "perly.y"
1334                         { (yyval.opval) = newASSIGNOP(OPf_STACKED, (ps[-2].val.opval), (ps[-1].val.ival), (ps[0].val.opval)); }
1335
1336     break;
1337
1338   case 160:
1339 #line 1039 "perly.y"
1340                         { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1341
1342     break;
1343
1344   case 161:
1345 #line 1041 "perly.y"
1346                         {   if ((ps[-1].val.ival) != OP_REPEAT)
1347                                 scalar((ps[-2].val.opval));
1348                             (yyval.opval) = newBINOP((ps[-1].val.ival), 0, (ps[-2].val.opval), scalar((ps[0].val.opval)));
1349                         }
1350
1351     break;
1352
1353   case 162:
1354 #line 1046 "perly.y"
1355                         { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1356
1357     break;
1358
1359   case 163:
1360 #line 1048 "perly.y"
1361                         { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1362
1363     break;
1364
1365   case 164:
1366 #line 1050 "perly.y"
1367                         { (yyval.opval) = (ps[0].val.opval); }
1368
1369     break;
1370
1371   case 165:
1372 #line 1052 "perly.y"
1373                         { (yyval.opval) = (ps[0].val.opval); }
1374
1375     break;
1376
1377   case 166:
1378 #line 1054 "perly.y"
1379                         { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1380
1381     break;
1382
1383   case 167:
1384 #line 1056 "perly.y"
1385                         { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1386
1387     break;
1388
1389   case 168:
1390 #line 1058 "perly.y"
1391                         { (yyval.opval) = newRANGE((ps[-1].val.ival), scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1392
1393     break;
1394
1395   case 169:
1396 #line 1060 "perly.y"
1397                         { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1398
1399     break;
1400
1401   case 170:
1402 #line 1062 "perly.y"
1403                         { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1404
1405     break;
1406
1407   case 171:
1408 #line 1064 "perly.y"
1409                         { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1410
1411     break;
1412
1413   case 172:
1414 #line 1066 "perly.y"
1415                         { (yyval.opval) = bind_match((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); }
1416
1417     break;
1418
1419   case 173:
1420 #line 1070 "perly.y"
1421                         { (yyval.opval) = cmpchain_finish((ps[0].val.opval)); }
1422
1423     break;
1424
1425   case 174:
1426 #line 1072 "perly.y"
1427                         { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1428
1429     break;
1430
1431   case 175:
1432 #line 1074 "perly.y"
1433                         { yyerror("syntax error"); YYERROR; }
1434
1435     break;
1436
1437   case 176:
1438 #line 1076 "perly.y"
1439                         { yyerror("syntax error"); YYERROR; }
1440
1441     break;
1442
1443   case 177:
1444 #line 1080 "perly.y"
1445                         { (yyval.opval) = cmpchain_start((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); }
1446
1447     break;
1448
1449   case 178:
1450 #line 1082 "perly.y"
1451                         { (yyval.opval) = cmpchain_extend((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); }
1452
1453     break;
1454
1455   case 179:
1456 #line 1086 "perly.y"
1457                         { (yyval.opval) = cmpchain_finish((ps[0].val.opval)); }
1458
1459     break;
1460
1461   case 180:
1462 #line 1088 "perly.y"
1463                         { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1464
1465     break;
1466
1467   case 181:
1468 #line 1090 "perly.y"
1469                         { yyerror("syntax error"); YYERROR; }
1470
1471     break;
1472
1473   case 182:
1474 #line 1092 "perly.y"
1475                         { yyerror("syntax error"); YYERROR; }
1476
1477     break;
1478
1479   case 183:
1480 #line 1096 "perly.y"
1481                         { (yyval.opval) = cmpchain_start((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); }
1482
1483     break;
1484
1485   case 184:
1486 #line 1098 "perly.y"
1487                         { (yyval.opval) = cmpchain_extend((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); }
1488
1489     break;
1490
1491   case 185:
1492 #line 1103 "perly.y"
1493                         { (yyval.opval) = newUNOP(OP_NEGATE, 0, scalar((ps[0].val.opval))); }
1494
1495     break;
1496
1497   case 186:
1498 #line 1105 "perly.y"
1499                         { (yyval.opval) = (ps[0].val.opval); }
1500
1501     break;
1502
1503   case 187:
1504 #line 1108 "perly.y"
1505                         { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[0].val.opval))); }
1506
1507     break;
1508
1509   case 188:
1510 #line 1110 "perly.y"
1511                         { (yyval.opval) = newUNOP((ps[-1].val.ival), 0, scalar((ps[0].val.opval))); }
1512
1513     break;
1514
1515   case 189:
1516 #line 1112 "perly.y"
1517                         { (yyval.opval) = newUNOP(OP_POSTINC, 0,
1518                                         op_lvalue(scalar((ps[-1].val.opval)), OP_POSTINC)); }
1519
1520     break;
1521
1522   case 190:
1523 #line 1115 "perly.y"
1524                         { (yyval.opval) = newUNOP(OP_POSTDEC, 0,
1525                                         op_lvalue(scalar((ps[-1].val.opval)), OP_POSTDEC));}
1526
1527     break;
1528
1529   case 191:
1530 #line 1118 "perly.y"
1531                         { (yyval.opval) = op_convert_list(OP_JOIN, 0,
1532                                        op_append_elem(
1533                                         OP_LIST,
1534                                         newSVREF(scalar(
1535                                             newSVOP(OP_CONST,0,
1536                                                     newSVpvs("\""))
1537                                         )),
1538                                         (ps[-1].val.opval)
1539                                        ));
1540                         }
1541
1542     break;
1543
1544   case 192:
1545 #line 1129 "perly.y"
1546                         { (yyval.opval) = newUNOP(OP_PREINC, 0,
1547                                         op_lvalue(scalar((ps[0].val.opval)), OP_PREINC)); }
1548
1549     break;
1550
1551   case 193:
1552 #line 1132 "perly.y"
1553                         { (yyval.opval) = newUNOP(OP_PREDEC, 0,
1554                                         op_lvalue(scalar((ps[0].val.opval)), OP_PREDEC)); }
1555
1556     break;
1557
1558   case 194:
1559 #line 1139 "perly.y"
1560                         { (yyval.opval) = newANONLIST((ps[-1].val.opval)); }
1561
1562     break;
1563
1564   case 195:
1565 #line 1141 "perly.y"
1566                         { (yyval.opval) = newANONLIST(NULL);}
1567
1568     break;
1569
1570   case 196:
1571 #line 1143 "perly.y"
1572                         { (yyval.opval) = newANONHASH((ps[-2].val.opval)); }
1573
1574     break;
1575
1576   case 197:
1577 #line 1145 "perly.y"
1578                         { (yyval.opval) = newANONHASH(NULL); }
1579
1580     break;
1581
1582   case 198:
1583 #line 1147 "perly.y"
1584                         { SvREFCNT_inc_simple_void(PL_compcv);
1585                           (yyval.opval) = newANONATTRSUB((ps[-3].val.ival), (ps[-2].val.opval), (ps[-1].val.opval), (ps[0].val.opval)); }
1586
1587     break;
1588
1589   case 199:
1590 #line 1150 "perly.y"
1591                         { SvREFCNT_inc_simple_void(PL_compcv);
1592                           (yyval.opval) = newANONATTRSUB((ps[-2].val.ival), NULL, (ps[-1].val.opval), (ps[0].val.opval)); }
1593
1594     break;
1595
1596   case 200:
1597 #line 1156 "perly.y"
1598                         { (yyval.opval) = dofile((ps[0].val.opval), (ps[-1].val.ival));}
1599
1600     break;
1601
1602   case 201:
1603 #line 1158 "perly.y"
1604                         { (yyval.opval) = newUNOP(OP_NULL, OPf_SPECIAL, op_scope((ps[0].val.opval)));}
1605
1606     break;
1607
1608   case 206:
1609 #line 1166 "perly.y"
1610                         { (yyval.opval) = newCONDOP(0, (ps[-4].val.opval), (ps[-2].val.opval), (ps[0].val.opval)); }
1611
1612     break;
1613
1614   case 207:
1615 #line 1168 "perly.y"
1616                         { (yyval.opval) = newUNOP(OP_REFGEN, 0, (ps[0].val.opval)); }
1617
1618     break;
1619
1620   case 208:
1621 #line 1170 "perly.y"
1622                         { (yyval.opval) = newUNOP(OP_REFGEN, 0, localize((ps[0].val.opval),1)); }
1623
1624     break;
1625
1626   case 209:
1627 #line 1172 "perly.y"
1628                         { (yyval.opval) = (ps[0].val.opval); }
1629
1630     break;
1631
1632   case 210:
1633 #line 1174 "perly.y"
1634                         { (yyval.opval) = localize((ps[0].val.opval),0); }
1635
1636     break;
1637
1638   case 211:
1639 #line 1176 "perly.y"
1640                         { (yyval.opval) = sawparens((ps[-1].val.opval)); }
1641
1642     break;
1643
1644   case 212:
1645 #line 1178 "perly.y"
1646                         { (yyval.opval) = (ps[0].val.opval); }
1647
1648     break;
1649
1650   case 213:
1651 #line 1180 "perly.y"
1652                         { (yyval.opval) = sawparens(newNULLLIST()); }
1653
1654     break;
1655
1656   case 214:
1657 #line 1182 "perly.y"
1658                         { (yyval.opval) = (ps[0].val.opval); }
1659
1660     break;
1661
1662   case 215:
1663 #line 1184 "perly.y"
1664                         { (yyval.opval) = (ps[0].val.opval); }
1665
1666     break;
1667
1668   case 216:
1669 #line 1186 "perly.y"
1670                         { (yyval.opval) = (ps[0].val.opval); }
1671
1672     break;
1673
1674   case 217:
1675 #line 1188 "perly.y"
1676                         { (yyval.opval) = (ps[0].val.opval); }
1677
1678     break;
1679
1680   case 218:
1681 #line 1190 "perly.y"
1682                         { (yyval.opval) = newUNOP(OP_AV2ARYLEN, 0, ref((ps[0].val.opval), OP_AV2ARYLEN));}
1683
1684     break;
1685
1686   case 219:
1687 #line 1192 "perly.y"
1688                         { (yyval.opval) = (ps[0].val.opval); }
1689
1690     break;
1691
1692   case 220:
1693 #line 1194 "perly.y"
1694                         { (yyval.opval) = op_prepend_elem(OP_ASLICE,
1695                                 newOP(OP_PUSHMARK, 0),
1696                                     newLISTOP(OP_ASLICE, 0,
1697                                         list((ps[-1].val.opval)),
1698                                         ref((ps[-3].val.opval), OP_ASLICE)));
1699                           if ((yyval.opval) && (ps[-3].val.opval))
1700                               (yyval.opval)->op_private |=
1701                                   (ps[-3].val.opval)->op_private & OPpSLICEWARNING;
1702                         }
1703
1704     break;
1705
1706   case 221:
1707 #line 1204 "perly.y"
1708                         { (yyval.opval) = op_prepend_elem(OP_KVASLICE,
1709                                 newOP(OP_PUSHMARK, 0),
1710                                     newLISTOP(OP_KVASLICE, 0,
1711                                         list((ps[-1].val.opval)),
1712                                         ref(oopsAV((ps[-3].val.opval)), OP_KVASLICE)));
1713                           if ((yyval.opval) && (ps[-3].val.opval))
1714                               (yyval.opval)->op_private |=
1715                                   (ps[-3].val.opval)->op_private & OPpSLICEWARNING;
1716                         }
1717
1718     break;
1719
1720   case 222:
1721 #line 1214 "perly.y"
1722                         { (yyval.opval) = op_prepend_elem(OP_HSLICE,
1723                                 newOP(OP_PUSHMARK, 0),
1724                                     newLISTOP(OP_HSLICE, 0,
1725                                         list((ps[-2].val.opval)),
1726                                         ref(oopsHV((ps[-4].val.opval)), OP_HSLICE)));
1727                           if ((yyval.opval) && (ps[-4].val.opval))
1728                               (yyval.opval)->op_private |=
1729                                   (ps[-4].val.opval)->op_private & OPpSLICEWARNING;
1730                         }
1731
1732     break;
1733
1734   case 223:
1735 #line 1224 "perly.y"
1736                         { (yyval.opval) = op_prepend_elem(OP_KVHSLICE,
1737                                 newOP(OP_PUSHMARK, 0),
1738                                     newLISTOP(OP_KVHSLICE, 0,
1739                                         list((ps[-2].val.opval)),
1740                                         ref((ps[-4].val.opval), OP_KVHSLICE)));
1741                           if ((yyval.opval) && (ps[-4].val.opval))
1742                               (yyval.opval)->op_private |=
1743                                   (ps[-4].val.opval)->op_private & OPpSLICEWARNING;
1744                         }
1745
1746     break;
1747
1748   case 224:
1749 #line 1234 "perly.y"
1750                         { (yyval.opval) = (ps[0].val.opval); }
1751
1752     break;
1753
1754   case 225:
1755 #line 1236 "perly.y"
1756                         { (yyval.opval) = newUNOP(OP_ENTERSUB, 0, scalar((ps[0].val.opval))); }
1757
1758     break;
1759
1760   case 226:
1761 #line 1238 "perly.y"
1762                         { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[-2].val.opval)));
1763                         }
1764
1765     break;
1766
1767   case 227:
1768 #line 1241 "perly.y"
1769                         {
1770                           (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1771                                 op_append_elem(OP_LIST, (ps[-1].val.opval), scalar((ps[-3].val.opval))));
1772                         }
1773
1774     break;
1775
1776   case 228:
1777 #line 1246 "perly.y"
1778                         { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1779                             op_append_elem(OP_LIST, (ps[0].val.opval), scalar((ps[-1].val.opval))));
1780                         }
1781
1782     break;
1783
1784   case 229:
1785 #line 1250 "perly.y"
1786                         { (yyval.opval) = newSVREF((ps[-3].val.opval)); }
1787
1788     break;
1789
1790   case 230:
1791 #line 1252 "perly.y"
1792                         { (yyval.opval) = newAVREF((ps[-3].val.opval)); }
1793
1794     break;
1795
1796   case 231:
1797 #line 1254 "perly.y"
1798                         { (yyval.opval) = newHVREF((ps[-3].val.opval)); }
1799
1800     break;
1801
1802   case 232:
1803 #line 1256 "perly.y"
1804                         { (yyval.opval) = newUNOP(OP_ENTERSUB, 0,
1805                                        scalar(newCVREF((ps[-1].val.ival),(ps[-3].val.opval)))); }
1806
1807     break;
1808
1809   case 233:
1810 #line 1259 "perly.y"
1811                         { (yyval.opval) = newGVREF(0,(ps[-3].val.opval)); }
1812
1813     break;
1814
1815   case 234:
1816 #line 1261 "perly.y"
1817                         { (yyval.opval) = newOP((ps[0].val.ival), OPf_SPECIAL);
1818                             PL_hints |= HINT_BLOCK_SCOPE; }
1819
1820     break;
1821
1822   case 235:
1823 #line 1264 "perly.y"
1824                         { (yyval.opval) = newLOOPEX((ps[-1].val.ival),(ps[0].val.opval)); }
1825
1826     break;
1827
1828   case 236:
1829 #line 1266 "perly.y"
1830                         { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[0].val.opval))); }
1831
1832     break;
1833
1834   case 237:
1835 #line 1268 "perly.y"
1836                         { (yyval.opval) = newOP((ps[0].val.ival), 0); }
1837
1838     break;
1839
1840   case 238:
1841 #line 1270 "perly.y"
1842                         { (yyval.opval) = newUNOP((ps[-1].val.ival), 0, (ps[0].val.opval)); }
1843
1844     break;
1845
1846   case 239:
1847 #line 1272 "perly.y"
1848                         { (yyval.opval) = newUNOP((ps[-1].val.ival), 0, (ps[0].val.opval)); }
1849
1850     break;
1851
1852   case 240:
1853 #line 1274 "perly.y"
1854                         { (yyval.opval) = newOP(OP_REQUIRE, (ps[0].val.ival) ? OPf_SPECIAL : 0); }
1855
1856     break;
1857
1858   case 241:
1859 #line 1276 "perly.y"
1860                         { (yyval.opval) = newUNOP(OP_REQUIRE, (ps[-1].val.ival) ? OPf_SPECIAL : 0, (ps[0].val.opval)); }
1861
1862     break;
1863
1864   case 242:
1865 #line 1278 "perly.y"
1866                         { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[0].val.opval))); }
1867
1868     break;
1869
1870   case 243:
1871 #line 1280 "perly.y"
1872                         { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1873                             op_append_elem(OP_LIST, (ps[0].val.opval), scalar((ps[-1].val.opval)))); }
1874
1875     break;
1876
1877   case 244:
1878 #line 1283 "perly.y"
1879                         { (yyval.opval) = newOP((ps[0].val.ival), 0); }
1880
1881     break;
1882
1883   case 245:
1884 #line 1285 "perly.y"
1885                         { (yyval.opval) = newOP((ps[-2].val.ival), 0);}
1886
1887     break;
1888
1889   case 246:
1890 #line 1287 "perly.y"
1891                         { (yyval.opval) = (ps[0].val.opval); }
1892
1893     break;
1894
1895   case 247:
1896 #line 1289 "perly.y"
1897                         { (yyval.opval) = (ps[-2].val.opval); }
1898
1899     break;
1900
1901   case 248:
1902 #line 1291 "perly.y"
1903                         { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[0].val.opval))); }
1904
1905     break;
1906
1907   case 249:
1908 #line 1293 "perly.y"
1909                         { (yyval.opval) = ((ps[-2].val.ival) == OP_NOT)
1910                           ? newUNOP((ps[-2].val.ival), 0, newSVOP(OP_CONST, 0, newSViv(0)))
1911                           : newOP((ps[-2].val.ival), OPf_SPECIAL); }
1912
1913     break;
1914
1915   case 250:
1916 #line 1297 "perly.y"
1917                         { (yyval.opval) = newUNOP((ps[-3].val.ival), 0, (ps[-1].val.opval)); }
1918
1919     break;
1920
1921   case 251:
1922 #line 1299 "perly.y"
1923                         {
1924                             if (   (ps[0].val.opval)->op_type != OP_TRANS
1925                                 && (ps[0].val.opval)->op_type != OP_TRANSR
1926                                 && (((PMOP*)(ps[0].val.opval))->op_pmflags & PMf_HAS_CV))
1927                             {
1928                                 (yyval.ival) = start_subparse(FALSE, CVf_ANON);
1929                                 SAVEFREESV(PL_compcv);
1930                             } else
1931                                 (yyval.ival) = 0;
1932                         }
1933
1934     break;
1935
1936   case 252:
1937 #line 1310 "perly.y"
1938                         { (yyval.opval) = pmruntime((ps[-5].val.opval), (ps[-2].val.opval), (ps[-1].val.opval), 1, (ps[-4].val.ival)); }
1939
1940     break;
1941
1942   case 256:
1943 #line 1318 "perly.y"
1944                         { (yyval.opval) = my_attrs((ps[-1].val.opval),(ps[0].val.opval)); }
1945
1946     break;
1947
1948   case 257:
1949 #line 1320 "perly.y"
1950                         { (yyval.opval) = localize((ps[0].val.opval),1); }
1951
1952     break;
1953
1954   case 258:
1955 #line 1322 "perly.y"
1956                         { (yyval.opval) = newUNOP(OP_REFGEN, 0, my_attrs((ps[-1].val.opval),(ps[0].val.opval))); }
1957
1958     break;
1959
1960   case 259:
1961 #line 1327 "perly.y"
1962                         { (yyval.opval) = sawparens((ps[-1].val.opval)); }
1963
1964     break;
1965
1966   case 260:
1967 #line 1329 "perly.y"
1968                         { (yyval.opval) = sawparens(newNULLLIST()); }
1969
1970     break;
1971
1972   case 261:
1973 #line 1332 "perly.y"
1974                         { (yyval.opval) = (ps[0].val.opval); }
1975
1976     break;
1977
1978   case 262:
1979 #line 1334 "perly.y"
1980                         { (yyval.opval) = (ps[0].val.opval); }
1981
1982     break;
1983
1984   case 263:
1985 #line 1336 "perly.y"
1986                         { (yyval.opval) = (ps[0].val.opval); }
1987
1988     break;
1989
1990   case 264:
1991 #line 1341 "perly.y"
1992                         { (yyval.opval) = NULL; }
1993
1994     break;
1995
1996   case 265:
1997 #line 1343 "perly.y"
1998                         { (yyval.opval) = (ps[0].val.opval); }
1999
2000     break;
2001
2002   case 266:
2003 #line 1347 "perly.y"
2004                         { (yyval.opval) = NULL; }
2005
2006     break;
2007
2008   case 267:
2009 #line 1349 "perly.y"
2010                         { (yyval.opval) = (ps[0].val.opval); }
2011
2012     break;
2013
2014   case 268:
2015 #line 1353 "perly.y"
2016                         { (yyval.opval) = NULL; }
2017
2018     break;
2019
2020   case 269:
2021 #line 1355 "perly.y"
2022                         { (yyval.opval) = (ps[0].val.opval); }
2023
2024     break;
2025
2026   case 270:
2027 #line 1361 "perly.y"
2028                         { parser->in_my = 0; (yyval.opval) = my((ps[0].val.opval)); }
2029
2030     break;
2031
2032   case 278:
2033 #line 1378 "perly.y"
2034                         { (yyval.opval) = newCVREF((ps[-1].val.ival),(ps[0].val.opval)); }
2035
2036     break;
2037
2038   case 279:
2039 #line 1382 "perly.y"
2040                         { (yyval.opval) = newSVREF((ps[0].val.opval)); }
2041
2042     break;
2043
2044   case 280:
2045 #line 1386 "perly.y"
2046                         { (yyval.opval) = newAVREF((ps[0].val.opval));
2047                           if ((yyval.opval)) (yyval.opval)->op_private |= (ps[-1].val.ival);
2048                         }
2049
2050     break;
2051
2052   case 281:
2053 #line 1392 "perly.y"
2054                         { (yyval.opval) = newHVREF((ps[0].val.opval));
2055                           if ((yyval.opval)) (yyval.opval)->op_private |= (ps[-1].val.ival);
2056                         }
2057
2058     break;
2059
2060   case 282:
2061 #line 1398 "perly.y"
2062                         { (yyval.opval) = newAVREF((ps[0].val.opval)); }
2063
2064     break;
2065
2066   case 283:
2067 #line 1400 "perly.y"
2068                         { (yyval.opval) = newAVREF((ps[-3].val.opval)); }
2069
2070     break;
2071
2072   case 284:
2073 #line 1404 "perly.y"
2074                         { (yyval.opval) = newGVREF(0,(ps[0].val.opval)); }
2075
2076     break;
2077
2078   case 286:
2079 #line 1409 "perly.y"
2080                         { (yyval.opval) = newAVREF((ps[-2].val.opval)); }
2081
2082     break;
2083
2084   case 288:
2085 #line 1414 "perly.y"
2086                         { (yyval.opval) = newHVREF((ps[-2].val.opval)); }
2087
2088     break;
2089
2090   case 290:
2091 #line 1419 "perly.y"
2092                         { (yyval.opval) = newGVREF(0,(ps[-2].val.opval)); }
2093
2094     break;
2095
2096   case 291:
2097 #line 1424 "perly.y"
2098                         { (yyval.opval) = scalar((ps[0].val.opval)); }
2099
2100     break;
2101
2102   case 292:
2103 #line 1426 "perly.y"
2104                         { (yyval.opval) = scalar((ps[0].val.opval)); }
2105
2106     break;
2107
2108   case 293:
2109 #line 1428 "perly.y"
2110                         { (yyval.opval) = op_scope((ps[0].val.opval)); }
2111
2112     break;
2113
2114   case 294:
2115 #line 1431 "perly.y"
2116                         { (yyval.opval) = (ps[0].val.opval); }
2117
2118     break;
2119
2120
2121
2122
2123       default: break;
2124     
2125
2126 /* Generated from:
2127  * 9a5909b0af5f61f96907e330008f3cdc9dadcab1417c5bcb188cb3b9f6593c01 perly.y
2128  * acf1cbfd2545faeaaa58b1cf0cf9d7f98b5be0752eb7a54528ef904a9e2e1ca7 regen_perly.pl
2129  * ex: set ro: */