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