This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
OP_ARGCHECK: use custom aux struct
[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 120 "perly.y" /* yacc.c:1648  */
9     {
10                           parser->expect = XSTATE;
11                           (yyval.ival) = 0;
12                         }
13
14     break;
15
16   case 3:
17 #line 125 "perly.y" /* yacc.c:1648  */
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 131 "perly.y" /* yacc.c:1648  */
28     {
29                           parser->expect = XTERM;
30                           (yyval.ival) = 0;
31                         }
32
33     break;
34
35   case 5:
36 #line 136 "perly.y" /* yacc.c:1648  */
37     {
38                           PL_eval_root = (ps[0].val.opval);
39                           (yyval.ival) = 0;
40                         }
41
42     break;
43
44   case 6:
45 #line 141 "perly.y" /* yacc.c:1648  */
46     {
47                           parser->expect = XBLOCK;
48                           (yyval.ival) = 0;
49                         }
50
51     break;
52
53   case 7:
54 #line 146 "perly.y" /* yacc.c:1648  */
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 154 "perly.y" /* yacc.c:1648  */
67     {
68                           parser->expect = XSTATE;
69                           (yyval.ival) = 0;
70                         }
71
72     break;
73
74   case 9:
75 #line 159 "perly.y" /* yacc.c:1648  */
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 167 "perly.y" /* yacc.c:1648  */
88     {
89                           parser->expect = XSTATE;
90                           (yyval.ival) = 0;
91                         }
92
93     break;
94
95   case 11:
96 #line 172 "perly.y" /* yacc.c:1648  */
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 180 "perly.y" /* yacc.c:1648  */
109     {
110                           parser->expect = XSTATE;
111                           (yyval.ival) = 0;
112                         }
113
114     break;
115
116   case 13:
117 #line 185 "perly.y" /* yacc.c:1648  */
118     {
119                           PL_eval_root = (ps[0].val.opval);
120                           (yyval.ival) = 0;
121                         }
122
123     break;
124
125   case 14:
126 #line 190 "perly.y" /* yacc.c:1648  */
127     {
128                           parser->expect = XSTATE;
129                           (yyval.ival) = 0;
130                         }
131
132     break;
133
134   case 15:
135 #line 195 "perly.y" /* yacc.c:1648  */
136     {
137                           PL_eval_root = (ps[0].val.opval);
138                           (yyval.ival) = 0;
139                         }
140
141     break;
142
143   case 16:
144 #line 203 "perly.y" /* yacc.c:1648  */
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 211 "perly.y" /* yacc.c:1648  */
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 218 "perly.y" /* yacc.c:1648  */
163     { (yyval.ival) = block_start(TRUE);
164                           parser->parsed_sub = 0; }
165
166     break;
167
168   case 19:
169 #line 223 "perly.y" /* yacc.c:1648  */
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 230 "perly.y" /* yacc.c:1648  */
179     { (yyval.ival) = block_start(FALSE);
180                           parser->parsed_sub = 0; }
181
182     break;
183
184   case 21:
185 #line 236 "perly.y" /* yacc.c:1648  */
186     { (yyval.opval) = NULL; }
187
188     break;
189
190   case 22:
191 #line 238 "perly.y" /* yacc.c:1648  */
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 247 "perly.y" /* yacc.c:1648  */
202     { (yyval.opval) = NULL; }
203
204     break;
205
206   case 24:
207 #line 249 "perly.y" /* yacc.c:1648  */
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 258 "perly.y" /* yacc.c:1648  */
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 262 "perly.y" /* yacc.c:1648  */
226     { (yyval.opval) = (ps[0].val.opval); }
227
228     break;
229
230   case 27:
231 #line 266 "perly.y" /* yacc.c:1648  */
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 273 "perly.y" /* yacc.c:1648  */
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 283 "perly.y" /* yacc.c:1648  */
254     { (yyval.opval) = (ps[0].val.opval); }
255
256     break;
257
258   case 30:
259 #line 285 "perly.y" /* yacc.c:1648  */
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 297 "perly.y" /* yacc.c:1648  */
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 303 "perly.y" /* yacc.c:1648  */
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 318 "perly.y" /* yacc.c:1648  */
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 324 "perly.y" /* yacc.c:1648  */
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 335 "perly.y" /* yacc.c:1648  */
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 342 "perly.y" /* yacc.c:1648  */
335     { CvSPECIAL_on(PL_compcv); /* It's a BEGIN {} */ }
336
337     break;
338
339   case 37:
340 #line 344 "perly.y" /* yacc.c:1648  */
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 351 "perly.y" /* yacc.c:1648  */
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 357 "perly.y" /* yacc.c:1648  */
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 363 "perly.y" /* yacc.c:1648  */
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 368 "perly.y" /* yacc.c:1648  */
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 370 "perly.y" /* yacc.c:1648  */
387     { (yyval.opval) = newWHENOP(0, op_scope((ps[0].val.opval))); }
388
389     break;
390
391   case 43:
392 #line 372 "perly.y" /* yacc.c:1648  */
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 379 "perly.y" /* yacc.c:1648  */
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 386 "perly.y" /* yacc.c:1648  */
415     { parser->expect = XTERM; }
416
417     break;
418
419   case 46:
420 #line 388 "perly.y" /* yacc.c:1648  */
421     { parser->expect = XTERM; }
422
423     break;
424
425   case 47:
426 #line 391 "perly.y" /* yacc.c:1648  */
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 406 "perly.y" /* yacc.c:1648  */
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 411 "perly.y" /* yacc.c:1648  */
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 417 "perly.y" /* yacc.c:1648  */
465     { parser->in_my = 0; (yyval.opval) = my((ps[0].val.opval)); }
466
467     break;
468
469   case 51:
470 #line 419 "perly.y" /* yacc.c:1648  */
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 432 "perly.y" /* yacc.c:1648  */
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 440 "perly.y" /* yacc.c:1648  */
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 446 "perly.y" /* yacc.c:1648  */
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 452 "perly.y" /* yacc.c:1648  */
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 459 "perly.y" /* yacc.c:1648  */
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 467 "perly.y" /* yacc.c:1648  */
543     {
544                           (yyval.opval) = (ps[-1].val.opval);
545                         }
546
547     break;
548
549   case 58:
550 #line 471 "perly.y" /* yacc.c:1648  */
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 476 "perly.y" /* yacc.c:1648  */
560     {
561                           (yyval.opval) = NULL;
562                           parser->copline = NOLINE;
563                         }
564
565     break;
566
567   case 60:
568 #line 484 "perly.y" /* yacc.c:1648  */
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 501 "perly.y" /* yacc.c:1648  */
588     { (yyval.opval) = NULL; }
589
590     break;
591
592   case 62:
593 #line 503 "perly.y" /* yacc.c:1648  */
594     { (yyval.opval) = op_unscope((ps[-1].val.opval)); }
595
596     break;
597
598   case 63:
599 #line 508 "perly.y" /* yacc.c:1648  */
600     { (yyval.opval) = NULL; }
601
602     break;
603
604   case 64:
605 #line 510 "perly.y" /* yacc.c:1648  */
606     { (yyval.opval) = (ps[0].val.opval); }
607
608     break;
609
610   case 65:
611 #line 512 "perly.y" /* yacc.c:1648  */
612     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[0].val.opval), (ps[-2].val.opval)); }
613
614     break;
615
616   case 66:
617 #line 514 "perly.y" /* yacc.c:1648  */
618     { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[0].val.opval), (ps[-2].val.opval)); }
619
620     break;
621
622   case 67:
623 #line 516 "perly.y" /* yacc.c:1648  */
624     { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, scalar((ps[0].val.opval)), (ps[-2].val.opval)); }
625
626     break;
627
628   case 68:
629 #line 518 "perly.y" /* yacc.c:1648  */
630     { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, (ps[0].val.opval), (ps[-2].val.opval)); }
631
632     break;
633
634   case 69:
635 #line 520 "perly.y" /* yacc.c:1648  */
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 70:
642 #line 523 "perly.y" /* yacc.c:1648  */
643     { (yyval.opval) = newWHENOP((ps[0].val.opval), op_scope((ps[-2].val.opval))); }
644
645     break;
646
647   case 71:
648 #line 528 "perly.y" /* yacc.c:1648  */
649     { (yyval.opval) = NULL; }
650
651     break;
652
653   case 72:
654 #line 530 "perly.y" /* yacc.c:1648  */
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 73:
663 #line 535 "perly.y" /* yacc.c:1648  */
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 74:
674 #line 545 "perly.y" /* yacc.c:1648  */
675     { (yyval.opval) = NULL; }
676
677     break;
678
679   case 75:
680 #line 547 "perly.y" /* yacc.c:1648  */
681     { (yyval.opval) = op_scope((ps[0].val.opval)); }
682
683     break;
684
685   case 76:
686 #line 552 "perly.y" /* yacc.c:1648  */
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 77:
694 #line 558 "perly.y" /* yacc.c:1648  */
695     { (yyval.opval) = NULL; }
696
697     break;
698
699   case 79:
700 #line 564 "perly.y" /* yacc.c:1648  */
701     { YYSTYPE tmplval;
702                           (void)scan_num("1", &tmplval);
703                           (yyval.opval) = tmplval.opval; }
704
705     break;
706
707   case 81:
708 #line 572 "perly.y" /* yacc.c:1648  */
709     { (yyval.opval) = invert(scalar((ps[0].val.opval))); }
710
711     break;
712
713   case 82:
714 #line 577 "perly.y" /* yacc.c:1648  */
715     { (yyval.opval) = (ps[0].val.opval); intro_my(); }
716
717     break;
718
719   case 83:
720 #line 581 "perly.y" /* yacc.c:1648  */
721     { (yyval.opval) = (ps[0].val.opval); intro_my(); }
722
723     break;
724
725   case 84:
726 #line 584 "perly.y" /* yacc.c:1648  */
727     { (yyval.opval) = (ps[0].val.opval); }
728
729     break;
730
731   case 85:
732 #line 585 "perly.y" /* yacc.c:1648  */
733     { (yyval.opval) = NULL; }
734
735     break;
736
737   case 86:
738 #line 589 "perly.y" /* yacc.c:1648  */
739     { (yyval.ival) = start_subparse(FALSE, 0);
740                             SAVEFREESV(PL_compcv); }
741
742     break;
743
744   case 87:
745 #line 595 "perly.y" /* yacc.c:1648  */
746     { (yyval.ival) = start_subparse(FALSE, CVf_ANON);
747                             SAVEFREESV(PL_compcv); }
748
749     break;
750
751   case 88:
752 #line 600 "perly.y" /* yacc.c:1648  */
753     { (yyval.ival) = start_subparse(TRUE, 0);
754                             SAVEFREESV(PL_compcv); }
755
756     break;
757
758   case 91:
759 #line 611 "perly.y" /* yacc.c:1648  */
760     { (yyval.opval) = NULL; }
761
762     break;
763
764   case 93:
765 #line 617 "perly.y" /* yacc.c:1648  */
766     { (yyval.opval) = NULL; }
767
768     break;
769
770   case 94:
771 #line 619 "perly.y" /* yacc.c:1648  */
772     { (yyval.opval) = (ps[0].val.opval); }
773
774     break;
775
776   case 95:
777 #line 621 "perly.y" /* yacc.c:1648  */
778     { (yyval.opval) = NULL; }
779
780     break;
781
782   case 96:
783 #line 626 "perly.y" /* yacc.c:1648  */
784     { (yyval.opval) = (ps[0].val.opval); }
785
786     break;
787
788   case 97:
789 #line 628 "perly.y" /* yacc.c:1648  */
790     { (yyval.opval) = NULL; }
791
792     break;
793
794   case 98:
795 #line 639 "perly.y" /* yacc.c:1648  */
796     { parser->in_my = 0; (yyval.opval) = NULL; }
797
798     break;
799
800   case 99:
801 #line 641 "perly.y" /* yacc.c:1648  */
802     { parser->in_my = 0; (yyval.opval) = (ps[0].val.opval); }
803
804     break;
805
806   case 100:
807 #line 646 "perly.y" /* yacc.c:1648  */
808     { (yyval.ival) = '@'; }
809
810     break;
811
812   case 101:
813 #line 648 "perly.y" /* yacc.c:1648  */
814     { (yyval.ival) = '%'; }
815
816     break;
817
818   case 102:
819 #line 652 "perly.y" /* yacc.c:1648  */
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 103:
839 #line 671 "perly.y" /* yacc.c:1648  */
840     { (yyval.opval) = NULL; }
841
842     break;
843
844   case 104:
845 #line 673 "perly.y" /* yacc.c:1648  */
846     { (yyval.opval) = newOP(OP_NULL, 0); }
847
848     break;
849
850   case 105:
851 #line 675 "perly.y" /* yacc.c:1648  */
852     { (yyval.opval) = (ps[0].val.opval); }
853
854     break;
855
856   case 106:
857 #line 681 "perly.y" /* yacc.c:1648  */
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 107:
922 #line 746 "perly.y" /* yacc.c:1648  */
923     { parser->in_my = KEY_sigvar; (yyval.opval) = (ps[0].val.opval); }
924
925     break;
926
927   case 108:
928 #line 748 "perly.y" /* yacc.c:1648  */
929     { parser->in_my = KEY_sigvar; (yyval.opval) = (ps[0].val.opval); }
930
931     break;
932
933   case 109:
934 #line 754 "perly.y" /* yacc.c:1648  */
935     { (yyval.opval) = (ps[-1].val.opval); }
936
937     break;
938
939   case 110:
940 #line 756 "perly.y" /* yacc.c:1648  */
941     {
942                           (yyval.opval) = op_append_list(OP_LINESEQ, (ps[-2].val.opval), (ps[0].val.opval));
943                         }
944
945     break;
946
947   case 111:
948 #line 760 "perly.y" /* yacc.c:1648  */
949     { (yyval.opval) = (ps[0].val.opval); }
950
951     break;
952
953   case 112:
954 #line 765 "perly.y" /* yacc.c:1648  */
955     { (yyval.opval) = NULL; }
956
957     break;
958
959   case 113:
960 #line 767 "perly.y" /* yacc.c:1648  */
961     { (yyval.opval) = (ps[0].val.opval); }
962
963     break;
964
965   case 114:
966 #line 771 "perly.y" /* yacc.c:1648  */
967     { (yyval.opval) = NULL; }
968
969     break;
970
971   case 115:
972 #line 773 "perly.y" /* yacc.c:1648  */
973     { (yyval.opval) = (ps[0].val.opval); }
974
975     break;
976
977   case 116:
978 #line 777 "perly.y" /* yacc.c:1648  */
979     { (yyval.opval) = (ps[-1].val.opval); }
980
981     break;
982
983   case 117:
984 #line 780 "perly.y" /* yacc.c:1648  */
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 118:
999 #line 791 "perly.y" /* yacc.c:1648  */
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                             (yyval.opval) = op_append_elem(OP_LINESEQ,
1029                                                 sigops,
1030                                                 newSTATEOP(0, NULL, NULL));
1031
1032                             parser->in_my = 0;
1033                             /* tell the toker that attrributes can follow
1034                              * this sig, but only so that the toker
1035                              * can skip through any (illegal) trailing
1036                              * attribute text then give a useful error
1037                              * message about "attributes before sig",
1038                              * rather than falling over ina mess at
1039                              * unrecognised syntax.
1040                              */
1041                             parser->expect = XATTRBLOCK;
1042                             parser->sig_seen = TRUE;
1043                             LEAVE;
1044                         }
1045
1046     break;
1047
1048   case 119:
1049 #line 839 "perly.y" /* yacc.c:1648  */
1050     { (yyval.opval) = (ps[0].val.opval); }
1051
1052     break;
1053
1054   case 120:
1055 #line 840 "perly.y" /* yacc.c:1648  */
1056     { (yyval.opval) = NULL; }
1057
1058     break;
1059
1060   case 121:
1061 #line 846 "perly.y" /* yacc.c:1648  */
1062     {
1063                           if (parser->copline > (line_t)(ps[-2].val.ival))
1064                               parser->copline = (line_t)(ps[-2].val.ival);
1065                           (yyval.opval) = block_end((ps[-3].val.ival), (ps[-1].val.opval));
1066                         }
1067
1068     break;
1069
1070   case 122:
1071 #line 856 "perly.y" /* yacc.c:1648  */
1072     { (yyval.opval) = (ps[0].val.opval); }
1073
1074     break;
1075
1076   case 123:
1077 #line 857 "perly.y" /* yacc.c:1648  */
1078     { (yyval.opval) = NULL; }
1079
1080     break;
1081
1082   case 124:
1083 #line 861 "perly.y" /* yacc.c:1648  */
1084     {
1085                           if (parser->copline > (line_t)(ps[-2].val.ival))
1086                               parser->copline = (line_t)(ps[-2].val.ival);
1087                           (yyval.opval) = block_end((ps[-4].val.ival),
1088                                 op_append_list(OP_LINESEQ, (ps[-3].val.opval), (ps[-1].val.opval)));
1089                         }
1090
1091     break;
1092
1093   case 125:
1094 #line 872 "perly.y" /* yacc.c:1648  */
1095     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1096
1097     break;
1098
1099   case 126:
1100 #line 874 "perly.y" /* yacc.c:1648  */
1101     { (yyval.opval) = newLOGOP((ps[-1].val.ival), 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1102
1103     break;
1104
1105   case 127:
1106 #line 876 "perly.y" /* yacc.c:1648  */
1107     { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1108
1109     break;
1110
1111   case 129:
1112 #line 882 "perly.y" /* yacc.c:1648  */
1113     { (yyval.opval) = (ps[-1].val.opval); }
1114
1115     break;
1116
1117   case 130:
1118 #line 884 "perly.y" /* yacc.c:1648  */
1119     {
1120                           OP* term = (ps[0].val.opval);
1121                           (yyval.opval) = op_append_elem(OP_LIST, (ps[-2].val.opval), term);
1122                         }
1123
1124     break;
1125
1126   case 132:
1127 #line 893 "perly.y" /* yacc.c:1648  */
1128     { (yyval.opval) = op_convert_list((ps[-2].val.ival), OPf_STACKED,
1129                                 op_prepend_elem(OP_LIST, newGVREF((ps[-2].val.ival),(ps[-1].val.opval)), (ps[0].val.opval)) );
1130                         }
1131
1132     break;
1133
1134   case 133:
1135 #line 897 "perly.y" /* yacc.c:1648  */
1136     { (yyval.opval) = op_convert_list((ps[-4].val.ival), OPf_STACKED,
1137                                 op_prepend_elem(OP_LIST, newGVREF((ps[-4].val.ival),(ps[-2].val.opval)), (ps[-1].val.opval)) );
1138                         }
1139
1140     break;
1141
1142   case 134:
1143 #line 901 "perly.y" /* yacc.c:1648  */
1144     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
1145                                 op_append_elem(OP_LIST,
1146                                     op_prepend_elem(OP_LIST, scalar((ps[-5].val.opval)), (ps[-1].val.opval)),
1147                                     newMETHOP(OP_METHOD, 0, (ps[-3].val.opval))));
1148                         }
1149
1150     break;
1151
1152   case 135:
1153 #line 907 "perly.y" /* yacc.c:1648  */
1154     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
1155                                 op_append_elem(OP_LIST, scalar((ps[-2].val.opval)),
1156                                     newMETHOP(OP_METHOD, 0, (ps[0].val.opval))));
1157                         }
1158
1159     break;
1160
1161   case 136:
1162 #line 912 "perly.y" /* yacc.c:1648  */
1163     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
1164                                 op_append_elem(OP_LIST,
1165                                     op_prepend_elem(OP_LIST, (ps[-1].val.opval), (ps[0].val.opval)),
1166                                     newMETHOP(OP_METHOD, 0, (ps[-2].val.opval))));
1167                         }
1168
1169     break;
1170
1171   case 137:
1172 #line 918 "perly.y" /* yacc.c:1648  */
1173     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
1174                                 op_append_elem(OP_LIST,
1175                                     op_prepend_elem(OP_LIST, (ps[-3].val.opval), (ps[-1].val.opval)),
1176                                     newMETHOP(OP_METHOD, 0, (ps[-4].val.opval))));
1177                         }
1178
1179     break;
1180
1181   case 138:
1182 #line 924 "perly.y" /* yacc.c:1648  */
1183     { (yyval.opval) = op_convert_list((ps[-1].val.ival), 0, (ps[0].val.opval)); }
1184
1185     break;
1186
1187   case 139:
1188 #line 926 "perly.y" /* yacc.c:1648  */
1189     { (yyval.opval) = op_convert_list((ps[-3].val.ival), 0, (ps[-1].val.opval)); }
1190
1191     break;
1192
1193   case 140:
1194 #line 928 "perly.y" /* yacc.c:1648  */
1195     { (yyval.opval) = op_convert_list((ps[-3].val.ival), 0, (ps[-1].val.opval)); }
1196
1197     break;
1198
1199   case 141:
1200 #line 930 "perly.y" /* yacc.c:1648  */
1201     { SvREFCNT_inc_simple_void(PL_compcv);
1202                           (yyval.opval) = newANONATTRSUB((ps[-1].val.ival), 0, NULL, (ps[0].val.opval)); }
1203
1204     break;
1205
1206   case 142:
1207 #line 933 "perly.y" /* yacc.c:1648  */
1208     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1209                                  op_append_elem(OP_LIST,
1210                                    op_prepend_elem(OP_LIST, (ps[-1].val.opval), (ps[0].val.opval)), (ps[-4].val.opval)));
1211                         }
1212
1213     break;
1214
1215   case 145:
1216 #line 948 "perly.y" /* yacc.c:1648  */
1217     { (yyval.opval) = newBINOP(OP_GELEM, 0, (ps[-4].val.opval), scalar((ps[-2].val.opval))); }
1218
1219     break;
1220
1221   case 146:
1222 #line 950 "perly.y" /* yacc.c:1648  */
1223     { (yyval.opval) = newBINOP(OP_AELEM, 0, oopsAV((ps[-3].val.opval)), scalar((ps[-1].val.opval)));
1224                         }
1225
1226     break;
1227
1228   case 147:
1229 #line 953 "perly.y" /* yacc.c:1648  */
1230     { (yyval.opval) = newBINOP(OP_AELEM, 0,
1231                                         ref(newAVREF((ps[-4].val.opval)),OP_RV2AV),
1232                                         scalar((ps[-1].val.opval)));
1233                         }
1234
1235     break;
1236
1237   case 148:
1238 #line 958 "perly.y" /* yacc.c:1648  */
1239     { (yyval.opval) = newBINOP(OP_AELEM, 0,
1240                                         ref(newAVREF((ps[-3].val.opval)),OP_RV2AV),
1241                                         scalar((ps[-1].val.opval)));
1242                         }
1243
1244     break;
1245
1246   case 149:
1247 #line 963 "perly.y" /* yacc.c:1648  */
1248     { (yyval.opval) = newBINOP(OP_HELEM, 0, oopsHV((ps[-4].val.opval)), jmaybe((ps[-2].val.opval)));
1249                         }
1250
1251     break;
1252
1253   case 150:
1254 #line 966 "perly.y" /* yacc.c:1648  */
1255     { (yyval.opval) = newBINOP(OP_HELEM, 0,
1256                                         ref(newHVREF((ps[-5].val.opval)),OP_RV2HV),
1257                                         jmaybe((ps[-2].val.opval))); }
1258
1259     break;
1260
1261   case 151:
1262 #line 970 "perly.y" /* yacc.c:1648  */
1263     { (yyval.opval) = newBINOP(OP_HELEM, 0,
1264                                         ref(newHVREF((ps[-4].val.opval)),OP_RV2HV),
1265                                         jmaybe((ps[-2].val.opval))); }
1266
1267     break;
1268
1269   case 152:
1270 #line 974 "perly.y" /* yacc.c:1648  */
1271     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1272                                    newCVREF(0, scalar((ps[-3].val.opval))));
1273                           if (parser->expect == XBLOCK)
1274                               parser->expect = XOPERATOR;
1275                         }
1276
1277     break;
1278
1279   case 153:
1280 #line 980 "perly.y" /* yacc.c:1648  */
1281     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1282                                    op_append_elem(OP_LIST, (ps[-1].val.opval),
1283                                        newCVREF(0, scalar((ps[-4].val.opval)))));
1284                           if (parser->expect == XBLOCK)
1285                               parser->expect = XOPERATOR;
1286                         }
1287
1288     break;
1289
1290   case 154:
1291 #line 988 "perly.y" /* yacc.c:1648  */
1292     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1293                                    op_append_elem(OP_LIST, (ps[-1].val.opval),
1294                                                newCVREF(0, scalar((ps[-3].val.opval)))));
1295                           if (parser->expect == XBLOCK)
1296                               parser->expect = XOPERATOR;
1297                         }
1298
1299     break;
1300
1301   case 155:
1302 #line 995 "perly.y" /* yacc.c:1648  */
1303     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1304                                    newCVREF(0, scalar((ps[-2].val.opval))));
1305                           if (parser->expect == XBLOCK)
1306                               parser->expect = XOPERATOR;
1307                         }
1308
1309     break;
1310
1311   case 156:
1312 #line 1001 "perly.y" /* yacc.c:1648  */
1313     { (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), (ps[-4].val.opval)); }
1314
1315     break;
1316
1317   case 157:
1318 #line 1003 "perly.y" /* yacc.c:1648  */
1319     { (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), (ps[-3].val.opval)); }
1320
1321     break;
1322
1323   case 158:
1324 #line 1005 "perly.y" /* yacc.c:1648  */
1325     { (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), NULL); }
1326
1327     break;
1328
1329   case 159:
1330 #line 1010 "perly.y" /* yacc.c:1648  */
1331     { (yyval.opval) = newASSIGNOP(OPf_STACKED, (ps[-2].val.opval), (ps[-1].val.ival), (ps[0].val.opval)); }
1332
1333     break;
1334
1335   case 160:
1336 #line 1012 "perly.y" /* yacc.c:1648  */
1337     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1338
1339     break;
1340
1341   case 161:
1342 #line 1014 "perly.y" /* yacc.c:1648  */
1343     {   if ((ps[-1].val.ival) != OP_REPEAT)
1344                                 scalar((ps[-2].val.opval));
1345                             (yyval.opval) = newBINOP((ps[-1].val.ival), 0, (ps[-2].val.opval), scalar((ps[0].val.opval)));
1346                         }
1347
1348     break;
1349
1350   case 162:
1351 #line 1019 "perly.y" /* yacc.c:1648  */
1352     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1353
1354     break;
1355
1356   case 163:
1357 #line 1021 "perly.y" /* yacc.c:1648  */
1358     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1359
1360     break;
1361
1362   case 164:
1363 #line 1023 "perly.y" /* yacc.c:1648  */
1364     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1365
1366     break;
1367
1368   case 165:
1369 #line 1025 "perly.y" /* yacc.c:1648  */
1370     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1371
1372     break;
1373
1374   case 166:
1375 #line 1027 "perly.y" /* yacc.c:1648  */
1376     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1377
1378     break;
1379
1380   case 167:
1381 #line 1029 "perly.y" /* yacc.c:1648  */
1382     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1383
1384     break;
1385
1386   case 168:
1387 #line 1031 "perly.y" /* yacc.c:1648  */
1388     { (yyval.opval) = newRANGE((ps[-1].val.ival), scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1389
1390     break;
1391
1392   case 169:
1393 #line 1033 "perly.y" /* yacc.c:1648  */
1394     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1395
1396     break;
1397
1398   case 170:
1399 #line 1035 "perly.y" /* yacc.c:1648  */
1400     { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1401
1402     break;
1403
1404   case 171:
1405 #line 1037 "perly.y" /* yacc.c:1648  */
1406     { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1407
1408     break;
1409
1410   case 172:
1411 #line 1039 "perly.y" /* yacc.c:1648  */
1412     { (yyval.opval) = bind_match((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); }
1413
1414     break;
1415
1416   case 173:
1417 #line 1044 "perly.y" /* yacc.c:1648  */
1418     { (yyval.opval) = newUNOP(OP_NEGATE, 0, scalar((ps[0].val.opval))); }
1419
1420     break;
1421
1422   case 174:
1423 #line 1046 "perly.y" /* yacc.c:1648  */
1424     { (yyval.opval) = (ps[0].val.opval); }
1425
1426     break;
1427
1428   case 175:
1429 #line 1049 "perly.y" /* yacc.c:1648  */
1430     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[0].val.opval))); }
1431
1432     break;
1433
1434   case 176:
1435 #line 1051 "perly.y" /* yacc.c:1648  */
1436     { (yyval.opval) = newUNOP((ps[-1].val.ival), 0, scalar((ps[0].val.opval))); }
1437
1438     break;
1439
1440   case 177:
1441 #line 1053 "perly.y" /* yacc.c:1648  */
1442     { (yyval.opval) = newUNOP(OP_POSTINC, 0,
1443                                         op_lvalue(scalar((ps[-1].val.opval)), OP_POSTINC)); }
1444
1445     break;
1446
1447   case 178:
1448 #line 1056 "perly.y" /* yacc.c:1648  */
1449     { (yyval.opval) = newUNOP(OP_POSTDEC, 0,
1450                                         op_lvalue(scalar((ps[-1].val.opval)), OP_POSTDEC));}
1451
1452     break;
1453
1454   case 179:
1455 #line 1059 "perly.y" /* yacc.c:1648  */
1456     { (yyval.opval) = op_convert_list(OP_JOIN, 0,
1457                                        op_append_elem(
1458                                         OP_LIST,
1459                                         newSVREF(scalar(
1460                                             newSVOP(OP_CONST,0,
1461                                                     newSVpvs("\""))
1462                                         )),
1463                                         (ps[-1].val.opval)
1464                                        ));
1465                         }
1466
1467     break;
1468
1469   case 180:
1470 #line 1070 "perly.y" /* yacc.c:1648  */
1471     { (yyval.opval) = newUNOP(OP_PREINC, 0,
1472                                         op_lvalue(scalar((ps[0].val.opval)), OP_PREINC)); }
1473
1474     break;
1475
1476   case 181:
1477 #line 1073 "perly.y" /* yacc.c:1648  */
1478     { (yyval.opval) = newUNOP(OP_PREDEC, 0,
1479                                         op_lvalue(scalar((ps[0].val.opval)), OP_PREDEC)); }
1480
1481     break;
1482
1483   case 182:
1484 #line 1080 "perly.y" /* yacc.c:1648  */
1485     { (yyval.opval) = newANONLIST((ps[-1].val.opval)); }
1486
1487     break;
1488
1489   case 183:
1490 #line 1082 "perly.y" /* yacc.c:1648  */
1491     { (yyval.opval) = newANONLIST(NULL);}
1492
1493     break;
1494
1495   case 184:
1496 #line 1084 "perly.y" /* yacc.c:1648  */
1497     { (yyval.opval) = newANONHASH((ps[-2].val.opval)); }
1498
1499     break;
1500
1501   case 185:
1502 #line 1086 "perly.y" /* yacc.c:1648  */
1503     { (yyval.opval) = newANONHASH(NULL); }
1504
1505     break;
1506
1507   case 186:
1508 #line 1088 "perly.y" /* yacc.c:1648  */
1509     { SvREFCNT_inc_simple_void(PL_compcv);
1510                           (yyval.opval) = newANONATTRSUB((ps[-3].val.ival), (ps[-2].val.opval), (ps[-1].val.opval), (ps[0].val.opval)); }
1511
1512     break;
1513
1514   case 187:
1515 #line 1091 "perly.y" /* yacc.c:1648  */
1516     { SvREFCNT_inc_simple_void(PL_compcv);
1517                           (yyval.opval) = newANONATTRSUB((ps[-2].val.ival), NULL, (ps[-1].val.opval), (ps[0].val.opval)); }
1518
1519     break;
1520
1521   case 188:
1522 #line 1097 "perly.y" /* yacc.c:1648  */
1523     { (yyval.opval) = dofile((ps[0].val.opval), (ps[-1].val.ival));}
1524
1525     break;
1526
1527   case 189:
1528 #line 1099 "perly.y" /* yacc.c:1648  */
1529     { (yyval.opval) = newUNOP(OP_NULL, OPf_SPECIAL, op_scope((ps[0].val.opval)));}
1530
1531     break;
1532
1533   case 194:
1534 #line 1107 "perly.y" /* yacc.c:1648  */
1535     { (yyval.opval) = newCONDOP(0, (ps[-4].val.opval), (ps[-2].val.opval), (ps[0].val.opval)); }
1536
1537     break;
1538
1539   case 195:
1540 #line 1109 "perly.y" /* yacc.c:1648  */
1541     { (yyval.opval) = newUNOP(OP_REFGEN, 0, (ps[0].val.opval)); }
1542
1543     break;
1544
1545   case 196:
1546 #line 1111 "perly.y" /* yacc.c:1648  */
1547     { (yyval.opval) = newUNOP(OP_REFGEN, 0, localize((ps[0].val.opval),1)); }
1548
1549     break;
1550
1551   case 197:
1552 #line 1113 "perly.y" /* yacc.c:1648  */
1553     { (yyval.opval) = (ps[0].val.opval); }
1554
1555     break;
1556
1557   case 198:
1558 #line 1115 "perly.y" /* yacc.c:1648  */
1559     { (yyval.opval) = localize((ps[0].val.opval),0); }
1560
1561     break;
1562
1563   case 199:
1564 #line 1117 "perly.y" /* yacc.c:1648  */
1565     { (yyval.opval) = sawparens((ps[-1].val.opval)); }
1566
1567     break;
1568
1569   case 200:
1570 #line 1119 "perly.y" /* yacc.c:1648  */
1571     { (yyval.opval) = (ps[0].val.opval); }
1572
1573     break;
1574
1575   case 201:
1576 #line 1121 "perly.y" /* yacc.c:1648  */
1577     { (yyval.opval) = sawparens(newNULLLIST()); }
1578
1579     break;
1580
1581   case 202:
1582 #line 1123 "perly.y" /* yacc.c:1648  */
1583     { (yyval.opval) = (ps[0].val.opval); }
1584
1585     break;
1586
1587   case 203:
1588 #line 1125 "perly.y" /* yacc.c:1648  */
1589     { (yyval.opval) = (ps[0].val.opval); }
1590
1591     break;
1592
1593   case 204:
1594 #line 1127 "perly.y" /* yacc.c:1648  */
1595     { (yyval.opval) = (ps[0].val.opval); }
1596
1597     break;
1598
1599   case 205:
1600 #line 1129 "perly.y" /* yacc.c:1648  */
1601     { (yyval.opval) = (ps[0].val.opval); }
1602
1603     break;
1604
1605   case 206:
1606 #line 1131 "perly.y" /* yacc.c:1648  */
1607     { (yyval.opval) = newUNOP(OP_AV2ARYLEN, 0, ref((ps[0].val.opval), OP_AV2ARYLEN));}
1608
1609     break;
1610
1611   case 207:
1612 #line 1133 "perly.y" /* yacc.c:1648  */
1613     { (yyval.opval) = (ps[0].val.opval); }
1614
1615     break;
1616
1617   case 208:
1618 #line 1135 "perly.y" /* yacc.c:1648  */
1619     { (yyval.opval) = op_prepend_elem(OP_ASLICE,
1620                                 newOP(OP_PUSHMARK, 0),
1621                                     newLISTOP(OP_ASLICE, 0,
1622                                         list((ps[-1].val.opval)),
1623                                         ref((ps[-3].val.opval), OP_ASLICE)));
1624                           if ((yyval.opval) && (ps[-3].val.opval))
1625                               (yyval.opval)->op_private |=
1626                                   (ps[-3].val.opval)->op_private & OPpSLICEWARNING;
1627                         }
1628
1629     break;
1630
1631   case 209:
1632 #line 1145 "perly.y" /* yacc.c:1648  */
1633     { (yyval.opval) = op_prepend_elem(OP_KVASLICE,
1634                                 newOP(OP_PUSHMARK, 0),
1635                                     newLISTOP(OP_KVASLICE, 0,
1636                                         list((ps[-1].val.opval)),
1637                                         ref(oopsAV((ps[-3].val.opval)), OP_KVASLICE)));
1638                           if ((yyval.opval) && (ps[-3].val.opval))
1639                               (yyval.opval)->op_private |=
1640                                   (ps[-3].val.opval)->op_private & OPpSLICEWARNING;
1641                         }
1642
1643     break;
1644
1645   case 210:
1646 #line 1155 "perly.y" /* yacc.c:1648  */
1647     { (yyval.opval) = op_prepend_elem(OP_HSLICE,
1648                                 newOP(OP_PUSHMARK, 0),
1649                                     newLISTOP(OP_HSLICE, 0,
1650                                         list((ps[-2].val.opval)),
1651                                         ref(oopsHV((ps[-4].val.opval)), OP_HSLICE)));
1652                           if ((yyval.opval) && (ps[-4].val.opval))
1653                               (yyval.opval)->op_private |=
1654                                   (ps[-4].val.opval)->op_private & OPpSLICEWARNING;
1655                         }
1656
1657     break;
1658
1659   case 211:
1660 #line 1165 "perly.y" /* yacc.c:1648  */
1661     { (yyval.opval) = op_prepend_elem(OP_KVHSLICE,
1662                                 newOP(OP_PUSHMARK, 0),
1663                                     newLISTOP(OP_KVHSLICE, 0,
1664                                         list((ps[-2].val.opval)),
1665                                         ref((ps[-4].val.opval), OP_KVHSLICE)));
1666                           if ((yyval.opval) && (ps[-4].val.opval))
1667                               (yyval.opval)->op_private |=
1668                                   (ps[-4].val.opval)->op_private & OPpSLICEWARNING;
1669                         }
1670
1671     break;
1672
1673   case 212:
1674 #line 1175 "perly.y" /* yacc.c:1648  */
1675     { (yyval.opval) = (ps[0].val.opval); }
1676
1677     break;
1678
1679   case 213:
1680 #line 1177 "perly.y" /* yacc.c:1648  */
1681     { (yyval.opval) = newUNOP(OP_ENTERSUB, 0, scalar((ps[0].val.opval))); }
1682
1683     break;
1684
1685   case 214:
1686 #line 1179 "perly.y" /* yacc.c:1648  */
1687     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[-2].val.opval)));
1688                         }
1689
1690     break;
1691
1692   case 215:
1693 #line 1182 "perly.y" /* yacc.c:1648  */
1694     {
1695                           (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1696                                 op_append_elem(OP_LIST, (ps[-1].val.opval), scalar((ps[-3].val.opval))));
1697                         }
1698
1699     break;
1700
1701   case 216:
1702 #line 1187 "perly.y" /* yacc.c:1648  */
1703     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1704                             op_append_elem(OP_LIST, (ps[0].val.opval), scalar((ps[-1].val.opval))));
1705                         }
1706
1707     break;
1708
1709   case 217:
1710 #line 1191 "perly.y" /* yacc.c:1648  */
1711     { (yyval.opval) = newSVREF((ps[-3].val.opval)); }
1712
1713     break;
1714
1715   case 218:
1716 #line 1193 "perly.y" /* yacc.c:1648  */
1717     { (yyval.opval) = newAVREF((ps[-3].val.opval)); }
1718
1719     break;
1720
1721   case 219:
1722 #line 1195 "perly.y" /* yacc.c:1648  */
1723     { (yyval.opval) = newHVREF((ps[-3].val.opval)); }
1724
1725     break;
1726
1727   case 220:
1728 #line 1197 "perly.y" /* yacc.c:1648  */
1729     { (yyval.opval) = newUNOP(OP_ENTERSUB, 0,
1730                                        scalar(newCVREF((ps[-1].val.ival),(ps[-3].val.opval)))); }
1731
1732     break;
1733
1734   case 221:
1735 #line 1200 "perly.y" /* yacc.c:1648  */
1736     { (yyval.opval) = newGVREF(0,(ps[-3].val.opval)); }
1737
1738     break;
1739
1740   case 222:
1741 #line 1202 "perly.y" /* yacc.c:1648  */
1742     { (yyval.opval) = newOP((ps[0].val.ival), OPf_SPECIAL);
1743                             PL_hints |= HINT_BLOCK_SCOPE; }
1744
1745     break;
1746
1747   case 223:
1748 #line 1205 "perly.y" /* yacc.c:1648  */
1749     { (yyval.opval) = newLOOPEX((ps[-1].val.ival),(ps[0].val.opval)); }
1750
1751     break;
1752
1753   case 224:
1754 #line 1207 "perly.y" /* yacc.c:1648  */
1755     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[0].val.opval))); }
1756
1757     break;
1758
1759   case 225:
1760 #line 1209 "perly.y" /* yacc.c:1648  */
1761     { (yyval.opval) = newOP((ps[0].val.ival), 0); }
1762
1763     break;
1764
1765   case 226:
1766 #line 1211 "perly.y" /* yacc.c:1648  */
1767     { (yyval.opval) = newUNOP((ps[-1].val.ival), 0, (ps[0].val.opval)); }
1768
1769     break;
1770
1771   case 227:
1772 #line 1213 "perly.y" /* yacc.c:1648  */
1773     { (yyval.opval) = newUNOP((ps[-1].val.ival), 0, (ps[0].val.opval)); }
1774
1775     break;
1776
1777   case 228:
1778 #line 1215 "perly.y" /* yacc.c:1648  */
1779     { (yyval.opval) = newOP(OP_REQUIRE, (ps[0].val.ival) ? OPf_SPECIAL : 0); }
1780
1781     break;
1782
1783   case 229:
1784 #line 1217 "perly.y" /* yacc.c:1648  */
1785     { (yyval.opval) = newUNOP(OP_REQUIRE, (ps[-1].val.ival) ? OPf_SPECIAL : 0, (ps[0].val.opval)); }
1786
1787     break;
1788
1789   case 230:
1790 #line 1219 "perly.y" /* yacc.c:1648  */
1791     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[0].val.opval))); }
1792
1793     break;
1794
1795   case 231:
1796 #line 1221 "perly.y" /* yacc.c:1648  */
1797     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1798                             op_append_elem(OP_LIST, (ps[0].val.opval), scalar((ps[-1].val.opval)))); }
1799
1800     break;
1801
1802   case 232:
1803 #line 1224 "perly.y" /* yacc.c:1648  */
1804     { (yyval.opval) = newOP((ps[0].val.ival), 0); }
1805
1806     break;
1807
1808   case 233:
1809 #line 1226 "perly.y" /* yacc.c:1648  */
1810     { (yyval.opval) = newOP((ps[-2].val.ival), 0);}
1811
1812     break;
1813
1814   case 234:
1815 #line 1228 "perly.y" /* yacc.c:1648  */
1816     { (yyval.opval) = (ps[0].val.opval); }
1817
1818     break;
1819
1820   case 235:
1821 #line 1230 "perly.y" /* yacc.c:1648  */
1822     { (yyval.opval) = (ps[-2].val.opval); }
1823
1824     break;
1825
1826   case 236:
1827 #line 1232 "perly.y" /* yacc.c:1648  */
1828     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[0].val.opval))); }
1829
1830     break;
1831
1832   case 237:
1833 #line 1234 "perly.y" /* yacc.c:1648  */
1834     { (yyval.opval) = ((ps[-2].val.ival) == OP_NOT)
1835                           ? newUNOP((ps[-2].val.ival), 0, newSVOP(OP_CONST, 0, newSViv(0)))
1836                           : newOP((ps[-2].val.ival), OPf_SPECIAL); }
1837
1838     break;
1839
1840   case 238:
1841 #line 1238 "perly.y" /* yacc.c:1648  */
1842     { (yyval.opval) = newUNOP((ps[-3].val.ival), 0, (ps[-1].val.opval)); }
1843
1844     break;
1845
1846   case 239:
1847 #line 1240 "perly.y" /* yacc.c:1648  */
1848     {
1849                             if (   (ps[0].val.opval)->op_type != OP_TRANS
1850                                 && (ps[0].val.opval)->op_type != OP_TRANSR
1851                                 && (((PMOP*)(ps[0].val.opval))->op_pmflags & PMf_HAS_CV))
1852                             {
1853                                 (yyval.ival) = start_subparse(FALSE, CVf_ANON);
1854                                 SAVEFREESV(PL_compcv);
1855                             } else
1856                                 (yyval.ival) = 0;
1857                         }
1858
1859     break;
1860
1861   case 240:
1862 #line 1251 "perly.y" /* yacc.c:1648  */
1863     { (yyval.opval) = pmruntime((ps[-5].val.opval), (ps[-2].val.opval), (ps[-1].val.opval), 1, (ps[-4].val.ival)); }
1864
1865     break;
1866
1867   case 244:
1868 #line 1259 "perly.y" /* yacc.c:1648  */
1869     { (yyval.opval) = my_attrs((ps[-1].val.opval),(ps[0].val.opval)); }
1870
1871     break;
1872
1873   case 245:
1874 #line 1261 "perly.y" /* yacc.c:1648  */
1875     { (yyval.opval) = localize((ps[0].val.opval),1); }
1876
1877     break;
1878
1879   case 246:
1880 #line 1263 "perly.y" /* yacc.c:1648  */
1881     { (yyval.opval) = newUNOP(OP_REFGEN, 0, my_attrs((ps[-1].val.opval),(ps[0].val.opval))); }
1882
1883     break;
1884
1885   case 247:
1886 #line 1268 "perly.y" /* yacc.c:1648  */
1887     { (yyval.opval) = sawparens((ps[-1].val.opval)); }
1888
1889     break;
1890
1891   case 248:
1892 #line 1270 "perly.y" /* yacc.c:1648  */
1893     { (yyval.opval) = sawparens(newNULLLIST()); }
1894
1895     break;
1896
1897   case 249:
1898 #line 1273 "perly.y" /* yacc.c:1648  */
1899     { (yyval.opval) = (ps[0].val.opval); }
1900
1901     break;
1902
1903   case 250:
1904 #line 1275 "perly.y" /* yacc.c:1648  */
1905     { (yyval.opval) = (ps[0].val.opval); }
1906
1907     break;
1908
1909   case 251:
1910 #line 1277 "perly.y" /* yacc.c:1648  */
1911     { (yyval.opval) = (ps[0].val.opval); }
1912
1913     break;
1914
1915   case 252:
1916 #line 1282 "perly.y" /* yacc.c:1648  */
1917     { (yyval.opval) = NULL; }
1918
1919     break;
1920
1921   case 253:
1922 #line 1284 "perly.y" /* yacc.c:1648  */
1923     { (yyval.opval) = (ps[0].val.opval); }
1924
1925     break;
1926
1927   case 254:
1928 #line 1288 "perly.y" /* yacc.c:1648  */
1929     { (yyval.opval) = NULL; }
1930
1931     break;
1932
1933   case 255:
1934 #line 1290 "perly.y" /* yacc.c:1648  */
1935     { (yyval.opval) = (ps[0].val.opval); }
1936
1937     break;
1938
1939   case 256:
1940 #line 1294 "perly.y" /* yacc.c:1648  */
1941     { (yyval.opval) = NULL; }
1942
1943     break;
1944
1945   case 257:
1946 #line 1296 "perly.y" /* yacc.c:1648  */
1947     { (yyval.opval) = (ps[0].val.opval); }
1948
1949     break;
1950
1951   case 258:
1952 #line 1302 "perly.y" /* yacc.c:1648  */
1953     { parser->in_my = 0; (yyval.opval) = my((ps[0].val.opval)); }
1954
1955     break;
1956
1957   case 266:
1958 #line 1319 "perly.y" /* yacc.c:1648  */
1959     { (yyval.opval) = newCVREF((ps[-1].val.ival),(ps[0].val.opval)); }
1960
1961     break;
1962
1963   case 267:
1964 #line 1323 "perly.y" /* yacc.c:1648  */
1965     { (yyval.opval) = newSVREF((ps[0].val.opval)); }
1966
1967     break;
1968
1969   case 268:
1970 #line 1327 "perly.y" /* yacc.c:1648  */
1971     { (yyval.opval) = newAVREF((ps[0].val.opval));
1972                           if ((yyval.opval)) (yyval.opval)->op_private |= (ps[-1].val.ival);
1973                         }
1974
1975     break;
1976
1977   case 269:
1978 #line 1333 "perly.y" /* yacc.c:1648  */
1979     { (yyval.opval) = newHVREF((ps[0].val.opval));
1980                           if ((yyval.opval)) (yyval.opval)->op_private |= (ps[-1].val.ival);
1981                         }
1982
1983     break;
1984
1985   case 270:
1986 #line 1339 "perly.y" /* yacc.c:1648  */
1987     { (yyval.opval) = newAVREF((ps[0].val.opval)); }
1988
1989     break;
1990
1991   case 271:
1992 #line 1341 "perly.y" /* yacc.c:1648  */
1993     { (yyval.opval) = newAVREF((ps[-3].val.opval)); }
1994
1995     break;
1996
1997   case 272:
1998 #line 1345 "perly.y" /* yacc.c:1648  */
1999     { (yyval.opval) = newGVREF(0,(ps[0].val.opval)); }
2000
2001     break;
2002
2003   case 274:
2004 #line 1350 "perly.y" /* yacc.c:1648  */
2005     { (yyval.opval) = newAVREF((ps[-2].val.opval)); }
2006
2007     break;
2008
2009   case 276:
2010 #line 1355 "perly.y" /* yacc.c:1648  */
2011     { (yyval.opval) = newHVREF((ps[-2].val.opval)); }
2012
2013     break;
2014
2015   case 278:
2016 #line 1360 "perly.y" /* yacc.c:1648  */
2017     { (yyval.opval) = newGVREF(0,(ps[-2].val.opval)); }
2018
2019     break;
2020
2021   case 279:
2022 #line 1365 "perly.y" /* yacc.c:1648  */
2023     { (yyval.opval) = scalar((ps[0].val.opval)); }
2024
2025     break;
2026
2027   case 280:
2028 #line 1367 "perly.y" /* yacc.c:1648  */
2029     { (yyval.opval) = scalar((ps[0].val.opval)); }
2030
2031     break;
2032
2033   case 281:
2034 #line 1369 "perly.y" /* yacc.c:1648  */
2035     { (yyval.opval) = op_scope((ps[0].val.opval)); }
2036
2037     break;
2038
2039   case 282:
2040 #line 1372 "perly.y" /* yacc.c:1648  */
2041     { (yyval.opval) = (ps[0].val.opval); }
2042
2043     break;
2044
2045
2046
2047       default: break;
2048     
2049
2050 /* Generated from:
2051  * 2c3a1b30e52b1e872156c881cc6e702a9c0d1be569bfa579632b5eec73ffa9ef perly.y
2052  * 0947213b55d0ed11693554bea04987e886cf285f5c14cf9075fa1e7acc3f4061 regen_perly.pl
2053  * ex: set ro: */