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