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