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