This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
ucfirst() new signature diagnostic messages
[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     { (yyval.opval) = (ps[0].val.opval); }
802
803     break;
804
805   case 97:
806 #line 649 "perly.y" /* yacc.c:1646  */
807     { (yyval.ival) = '@'; }
808
809     break;
810
811   case 98:
812 #line 651 "perly.y" /* yacc.c:1646  */
813     { (yyval.ival) = '%'; }
814
815     break;
816
817   case 99:
818 #line 655 "perly.y" /* yacc.c:1646  */
819     {
820                             I32 sigil   = (ps[-2].val.ival);
821                             OP *var     = (ps[-1].val.opval);
822                             OP *defexpr = (ps[0].val.opval);
823
824                             if (PL_parser->sig_slurpy)
825                                 yyerror("Multiple slurpy parameters not allowed");
826                             PL_parser->sig_slurpy = sigil;
827
828                             if (defexpr)
829                                 yyerror("A slurpy parameter may not have "
830                                         "a default value");
831
832                             (yyval.opval) = var ? newSTATEOP(0, NULL, var) : (OP*)NULL;
833                         }
834
835     break;
836
837   case 100:
838 #line 674 "perly.y" /* yacc.c:1646  */
839     { (yyval.opval) = (OP*)NULL; }
840
841     break;
842
843   case 101:
844 #line 676 "perly.y" /* yacc.c:1646  */
845     { (yyval.opval) = newOP(OP_NULL, 0); }
846
847     break;
848
849   case 102:
850 #line 678 "perly.y" /* yacc.c:1646  */
851     { (yyval.opval) = (ps[0].val.opval); }
852
853     break;
854
855   case 103:
856 #line 684 "perly.y" /* yacc.c:1646  */
857     {
858                             OP *var     = (ps[-1].val.opval);
859                             OP *defexpr = (ps[0].val.opval);
860
861                             if (PL_parser->sig_slurpy)
862                                 yyerror("Slurpy parameter not last");
863
864                             PL_parser->sig_elems++;
865
866                             if (defexpr) {
867                                 PL_parser->sig_optelems++;
868
869                                 if (   defexpr->op_type == OP_NULL
870                                     && !(defexpr->op_flags & OPf_KIDS))
871                                 {
872                                     /* handle '$=' special case */
873                                     if (var)
874                                         yyerror("Optional parameter "
875                                                     "lacks default expression");
876                                     op_free(defexpr);
877                                 }
878                                 else { 
879                                     /* a normal '=default' expression */ 
880                                     OP *defop = (OP*)alloc_LOGOP(OP_ARGDEFELEM,
881                                                         defexpr,
882                                                         LINKLIST(defexpr));
883                                     /* re-purpose op_targ to hold @_ index */
884                                     defop->op_targ = PL_parser->sig_elems - 1;
885
886                                     if (var) {
887                                         var->op_flags |= OPf_STACKED;
888                                         (void)op_sibling_splice(var,
889                                                         NULL, 0, defop);
890                                         scalar(defop);
891                                     }
892                                     else
893                                         var = newUNOP(OP_NULL, 0, defop);
894
895                                     LINKLIST(var);
896                                     /* NB: normally the first child of a
897                                      * logop is executed before the logop,
898                                      * and it pushes a boolean result
899                                      * ready for the logop. For ARGDEFELEM,
900                                      * the op itself does the boolean
901                                      * calculation, so set the first op to
902                                      * it instead.
903                                      */
904                                     var->op_next = defop;
905                                     defexpr->op_next = var;
906                                 }
907                             }
908                             else {
909                                 if (PL_parser->sig_optelems)
910                                     yyerror("Mandatory parameter "
911                                             "follows optional parameter");
912                             }
913
914                             (yyval.opval) = var ? newSTATEOP(0, NULL, var) : (OP*)NULL;
915                         }
916
917     break;
918
919   case 104:
920 #line 748 "perly.y" /* yacc.c:1646  */
921     { parser->expect = XSIGVAR; (yyval.opval) = (ps[0].val.opval); }
922
923     break;
924
925   case 105:
926 #line 750 "perly.y" /* yacc.c:1646  */
927     { parser->expect = XSIGVAR; (yyval.opval) = (ps[0].val.opval); }
928
929     break;
930
931   case 106:
932 #line 756 "perly.y" /* yacc.c:1646  */
933     { (yyval.opval) = (ps[-1].val.opval); }
934
935     break;
936
937   case 107:
938 #line 758 "perly.y" /* yacc.c:1646  */
939     {
940                           (yyval.opval) = op_append_list(OP_LINESEQ, (ps[-2].val.opval), (ps[0].val.opval));
941                         }
942
943     break;
944
945   case 108:
946 #line 762 "perly.y" /* yacc.c:1646  */
947     { (yyval.opval) = (ps[0].val.opval); }
948
949     break;
950
951   case 109:
952 #line 767 "perly.y" /* yacc.c:1646  */
953     { (yyval.opval) = (OP*)NULL; }
954
955     break;
956
957   case 110:
958 #line 769 "perly.y" /* yacc.c:1646  */
959     { (yyval.opval) = (ps[0].val.opval); }
960
961     break;
962
963   case 111:
964 #line 773 "perly.y" /* yacc.c:1646  */
965     {
966                             ENTER;
967                             SAVEINT(PL_parser->sig_elems);
968                             SAVEINT(PL_parser->sig_optelems);
969                             SAVEI8(PL_parser->sig_slurpy);
970                             PL_parser->sig_elems    = 0;
971                             PL_parser->sig_optelems = 0;
972                             PL_parser->sig_slurpy   = 0;
973                             parser->expect = XSIGVAR;
974                         }
975
976     break;
977
978   case 112:
979 #line 785 "perly.y" /* yacc.c:1646  */
980     {
981                             OP            *sigops = (ps[-1].val.opval);
982                             UNOP_AUX_item *aux;
983                             OP            *check;
984
985                             assert(FEATURE_SIGNATURES_IS_ENABLED);
986
987                             /* We shouldn't get here otherwise */
988                             Perl_ck_warner_d(aTHX_
989                                 packWARN(WARN_EXPERIMENTAL__SIGNATURES),
990                                 "The signatures feature is experimental");
991
992                             aux = (UNOP_AUX_item*)PerlMemShared_malloc(
993                                 sizeof(UNOP_AUX_item) * 3);
994                             aux[0].uv = PL_parser->sig_elems;
995                             aux[1].uv = PL_parser->sig_optelems;
996                             aux[2].iv = PL_parser->sig_slurpy;
997                             check = newUNOP_AUX(OP_ARGCHECK, 0, NULL, aux);
998                             sigops = op_prepend_elem(OP_LINESEQ, check, sigops);
999                             sigops = op_prepend_elem(OP_LINESEQ,
1000                                                 newSTATEOP(0, NULL, NULL),
1001                                                 sigops);
1002                             /* a nextstate at the end handles context
1003                              * correctly for an empty sub body */
1004                             (yyval.opval) = op_append_elem(OP_LINESEQ,
1005                                                 sigops,
1006                                                 newSTATEOP(0, NULL, NULL));
1007
1008                             parser->expect = XATTRBLOCK;
1009                             LEAVE;
1010                         }
1011
1012     break;
1013
1014   case 114:
1015 #line 822 "perly.y" /* yacc.c:1646  */
1016     { (yyval.opval) = (OP*)NULL; }
1017
1018     break;
1019
1020   case 115:
1021 #line 827 "perly.y" /* yacc.c:1646  */
1022     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1023
1024     break;
1025
1026   case 116:
1027 #line 829 "perly.y" /* yacc.c:1646  */
1028     { (yyval.opval) = newLOGOP((ps[-1].val.ival), 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1029
1030     break;
1031
1032   case 117:
1033 #line 831 "perly.y" /* yacc.c:1646  */
1034     { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1035
1036     break;
1037
1038   case 119:
1039 #line 837 "perly.y" /* yacc.c:1646  */
1040     { (yyval.opval) = (ps[-1].val.opval); }
1041
1042     break;
1043
1044   case 120:
1045 #line 839 "perly.y" /* yacc.c:1646  */
1046     {
1047                           OP* term = (ps[0].val.opval);
1048                           (yyval.opval) = op_append_elem(OP_LIST, (ps[-2].val.opval), term);
1049                         }
1050
1051     break;
1052
1053   case 122:
1054 #line 848 "perly.y" /* yacc.c:1646  */
1055     { (yyval.opval) = op_convert_list((ps[-2].val.ival), OPf_STACKED,
1056                                 op_prepend_elem(OP_LIST, newGVREF((ps[-2].val.ival),(ps[-1].val.opval)), (ps[0].val.opval)) );
1057                         }
1058
1059     break;
1060
1061   case 123:
1062 #line 852 "perly.y" /* yacc.c:1646  */
1063     { (yyval.opval) = op_convert_list((ps[-4].val.ival), OPf_STACKED,
1064                                 op_prepend_elem(OP_LIST, newGVREF((ps[-4].val.ival),(ps[-2].val.opval)), (ps[-1].val.opval)) );
1065                         }
1066
1067     break;
1068
1069   case 124:
1070 #line 856 "perly.y" /* yacc.c:1646  */
1071     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
1072                                 op_append_elem(OP_LIST,
1073                                     op_prepend_elem(OP_LIST, scalar((ps[-5].val.opval)), (ps[-1].val.opval)),
1074                                     newMETHOP(OP_METHOD, 0, (ps[-3].val.opval))));
1075                         }
1076
1077     break;
1078
1079   case 125:
1080 #line 862 "perly.y" /* yacc.c:1646  */
1081     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
1082                                 op_append_elem(OP_LIST, scalar((ps[-2].val.opval)),
1083                                     newMETHOP(OP_METHOD, 0, (ps[0].val.opval))));
1084                         }
1085
1086     break;
1087
1088   case 126:
1089 #line 867 "perly.y" /* yacc.c:1646  */
1090     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
1091                                 op_append_elem(OP_LIST,
1092                                     op_prepend_elem(OP_LIST, (ps[-1].val.opval), (ps[0].val.opval)),
1093                                     newMETHOP(OP_METHOD, 0, (ps[-2].val.opval))));
1094                         }
1095
1096     break;
1097
1098   case 127:
1099 #line 873 "perly.y" /* yacc.c:1646  */
1100     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
1101                                 op_append_elem(OP_LIST,
1102                                     op_prepend_elem(OP_LIST, (ps[-3].val.opval), (ps[-1].val.opval)),
1103                                     newMETHOP(OP_METHOD, 0, (ps[-4].val.opval))));
1104                         }
1105
1106     break;
1107
1108   case 128:
1109 #line 879 "perly.y" /* yacc.c:1646  */
1110     { (yyval.opval) = op_convert_list((ps[-1].val.ival), 0, (ps[0].val.opval)); }
1111
1112     break;
1113
1114   case 129:
1115 #line 881 "perly.y" /* yacc.c:1646  */
1116     { (yyval.opval) = op_convert_list((ps[-3].val.ival), 0, (ps[-1].val.opval)); }
1117
1118     break;
1119
1120   case 130:
1121 #line 883 "perly.y" /* yacc.c:1646  */
1122     { SvREFCNT_inc_simple_void(PL_compcv);
1123                           (yyval.opval) = newANONATTRSUB((ps[-1].val.ival), 0, (OP*)NULL, (ps[0].val.opval)); }
1124
1125     break;
1126
1127   case 131:
1128 #line 886 "perly.y" /* yacc.c:1646  */
1129     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1130                                  op_append_elem(OP_LIST,
1131                                    op_prepend_elem(OP_LIST, (ps[-1].val.opval), (ps[0].val.opval)), (ps[-4].val.opval)));
1132                         }
1133
1134     break;
1135
1136   case 134:
1137 #line 901 "perly.y" /* yacc.c:1646  */
1138     { (yyval.opval) = newBINOP(OP_GELEM, 0, (ps[-4].val.opval), scalar((ps[-2].val.opval))); }
1139
1140     break;
1141
1142   case 135:
1143 #line 903 "perly.y" /* yacc.c:1646  */
1144     { (yyval.opval) = newBINOP(OP_AELEM, 0, oopsAV((ps[-3].val.opval)), scalar((ps[-1].val.opval)));
1145                         }
1146
1147     break;
1148
1149   case 136:
1150 #line 906 "perly.y" /* yacc.c:1646  */
1151     { (yyval.opval) = newBINOP(OP_AELEM, 0,
1152                                         ref(newAVREF((ps[-4].val.opval)),OP_RV2AV),
1153                                         scalar((ps[-1].val.opval)));
1154                         }
1155
1156     break;
1157
1158   case 137:
1159 #line 911 "perly.y" /* yacc.c:1646  */
1160     { (yyval.opval) = newBINOP(OP_AELEM, 0,
1161                                         ref(newAVREF((ps[-3].val.opval)),OP_RV2AV),
1162                                         scalar((ps[-1].val.opval)));
1163                         }
1164
1165     break;
1166
1167   case 138:
1168 #line 916 "perly.y" /* yacc.c:1646  */
1169     { (yyval.opval) = newBINOP(OP_HELEM, 0, oopsHV((ps[-4].val.opval)), jmaybe((ps[-2].val.opval)));
1170                         }
1171
1172     break;
1173
1174   case 139:
1175 #line 919 "perly.y" /* yacc.c:1646  */
1176     { (yyval.opval) = newBINOP(OP_HELEM, 0,
1177                                         ref(newHVREF((ps[-5].val.opval)),OP_RV2HV),
1178                                         jmaybe((ps[-2].val.opval))); }
1179
1180     break;
1181
1182   case 140:
1183 #line 923 "perly.y" /* yacc.c:1646  */
1184     { (yyval.opval) = newBINOP(OP_HELEM, 0,
1185                                         ref(newHVREF((ps[-4].val.opval)),OP_RV2HV),
1186                                         jmaybe((ps[-2].val.opval))); }
1187
1188     break;
1189
1190   case 141:
1191 #line 927 "perly.y" /* yacc.c:1646  */
1192     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1193                                    newCVREF(0, scalar((ps[-3].val.opval)))); }
1194
1195     break;
1196
1197   case 142:
1198 #line 930 "perly.y" /* yacc.c:1646  */
1199     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1200                                    op_append_elem(OP_LIST, (ps[-1].val.opval),
1201                                        newCVREF(0, scalar((ps[-4].val.opval))))); }
1202
1203     break;
1204
1205   case 143:
1206 #line 935 "perly.y" /* yacc.c:1646  */
1207     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1208                                    op_append_elem(OP_LIST, (ps[-1].val.opval),
1209                                                newCVREF(0, scalar((ps[-3].val.opval))))); }
1210
1211     break;
1212
1213   case 144:
1214 #line 939 "perly.y" /* yacc.c:1646  */
1215     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1216                                    newCVREF(0, scalar((ps[-2].val.opval)))); }
1217
1218     break;
1219
1220   case 145:
1221 #line 942 "perly.y" /* yacc.c:1646  */
1222     { (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), (ps[-4].val.opval)); }
1223
1224     break;
1225
1226   case 146:
1227 #line 944 "perly.y" /* yacc.c:1646  */
1228     { (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), (ps[-3].val.opval)); }
1229
1230     break;
1231
1232   case 147:
1233 #line 946 "perly.y" /* yacc.c:1646  */
1234     { (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), (OP*)NULL); }
1235
1236     break;
1237
1238   case 148:
1239 #line 951 "perly.y" /* yacc.c:1646  */
1240     { (yyval.opval) = newASSIGNOP(OPf_STACKED, (ps[-2].val.opval), (ps[-1].val.ival), (ps[0].val.opval)); }
1241
1242     break;
1243
1244   case 149:
1245 #line 953 "perly.y" /* yacc.c:1646  */
1246     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1247
1248     break;
1249
1250   case 150:
1251 #line 955 "perly.y" /* yacc.c:1646  */
1252     {   if ((ps[-1].val.ival) != OP_REPEAT)
1253                                 scalar((ps[-2].val.opval));
1254                             (yyval.opval) = newBINOP((ps[-1].val.ival), 0, (ps[-2].val.opval), scalar((ps[0].val.opval)));
1255                         }
1256
1257     break;
1258
1259   case 151:
1260 #line 960 "perly.y" /* yacc.c:1646  */
1261     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1262
1263     break;
1264
1265   case 152:
1266 #line 962 "perly.y" /* yacc.c:1646  */
1267     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1268
1269     break;
1270
1271   case 153:
1272 #line 964 "perly.y" /* yacc.c:1646  */
1273     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1274
1275     break;
1276
1277   case 154:
1278 #line 966 "perly.y" /* yacc.c:1646  */
1279     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1280
1281     break;
1282
1283   case 155:
1284 #line 968 "perly.y" /* yacc.c:1646  */
1285     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1286
1287     break;
1288
1289   case 156:
1290 #line 970 "perly.y" /* yacc.c:1646  */
1291     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1292
1293     break;
1294
1295   case 157:
1296 #line 972 "perly.y" /* yacc.c:1646  */
1297     { (yyval.opval) = newRANGE((ps[-1].val.ival), scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1298
1299     break;
1300
1301   case 158:
1302 #line 974 "perly.y" /* yacc.c:1646  */
1303     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1304
1305     break;
1306
1307   case 159:
1308 #line 976 "perly.y" /* yacc.c:1646  */
1309     { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1310
1311     break;
1312
1313   case 160:
1314 #line 978 "perly.y" /* yacc.c:1646  */
1315     { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1316
1317     break;
1318
1319   case 161:
1320 #line 980 "perly.y" /* yacc.c:1646  */
1321     { (yyval.opval) = bind_match((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); }
1322
1323     break;
1324
1325   case 162:
1326 #line 985 "perly.y" /* yacc.c:1646  */
1327     { (yyval.opval) = newUNOP(OP_NEGATE, 0, scalar((ps[0].val.opval))); }
1328
1329     break;
1330
1331   case 163:
1332 #line 987 "perly.y" /* yacc.c:1646  */
1333     { (yyval.opval) = (ps[0].val.opval); }
1334
1335     break;
1336
1337   case 164:
1338 #line 990 "perly.y" /* yacc.c:1646  */
1339     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[0].val.opval))); }
1340
1341     break;
1342
1343   case 165:
1344 #line 992 "perly.y" /* yacc.c:1646  */
1345     { (yyval.opval) = newUNOP((ps[-1].val.ival), 0, scalar((ps[0].val.opval))); }
1346
1347     break;
1348
1349   case 166:
1350 #line 994 "perly.y" /* yacc.c:1646  */
1351     { (yyval.opval) = newUNOP(OP_POSTINC, 0,
1352                                         op_lvalue(scalar((ps[-1].val.opval)), OP_POSTINC)); }
1353
1354     break;
1355
1356   case 167:
1357 #line 997 "perly.y" /* yacc.c:1646  */
1358     { (yyval.opval) = newUNOP(OP_POSTDEC, 0,
1359                                         op_lvalue(scalar((ps[-1].val.opval)), OP_POSTDEC));}
1360
1361     break;
1362
1363   case 168:
1364 #line 1000 "perly.y" /* yacc.c:1646  */
1365     { (yyval.opval) = op_convert_list(OP_JOIN, 0,
1366                                        op_append_elem(
1367                                         OP_LIST,
1368                                         newSVREF(scalar(
1369                                             newSVOP(OP_CONST,0,
1370                                                     newSVpvs("\""))
1371                                         )),
1372                                         (ps[-1].val.opval)
1373                                        ));
1374                         }
1375
1376     break;
1377
1378   case 169:
1379 #line 1011 "perly.y" /* yacc.c:1646  */
1380     { (yyval.opval) = newUNOP(OP_PREINC, 0,
1381                                         op_lvalue(scalar((ps[0].val.opval)), OP_PREINC)); }
1382
1383     break;
1384
1385   case 170:
1386 #line 1014 "perly.y" /* yacc.c:1646  */
1387     { (yyval.opval) = newUNOP(OP_PREDEC, 0,
1388                                         op_lvalue(scalar((ps[0].val.opval)), OP_PREDEC)); }
1389
1390     break;
1391
1392   case 171:
1393 #line 1021 "perly.y" /* yacc.c:1646  */
1394     { (yyval.opval) = newANONLIST((ps[-1].val.opval)); }
1395
1396     break;
1397
1398   case 172:
1399 #line 1023 "perly.y" /* yacc.c:1646  */
1400     { (yyval.opval) = newANONLIST((OP*)NULL);}
1401
1402     break;
1403
1404   case 173:
1405 #line 1025 "perly.y" /* yacc.c:1646  */
1406     { (yyval.opval) = newANONHASH((ps[-2].val.opval)); }
1407
1408     break;
1409
1410   case 174:
1411 #line 1027 "perly.y" /* yacc.c:1646  */
1412     { (yyval.opval) = newANONHASH((OP*)NULL); }
1413
1414     break;
1415
1416   case 175:
1417 #line 1029 "perly.y" /* yacc.c:1646  */
1418     { SvREFCNT_inc_simple_void(PL_compcv);
1419                           (yyval.opval) = newANONATTRSUB((ps[-3].val.ival), (ps[-2].val.opval), (ps[-1].val.opval), (ps[0].val.opval)); }
1420
1421     break;
1422
1423   case 176:
1424 #line 1032 "perly.y" /* yacc.c:1646  */
1425     {
1426                           OP *body;
1427                           if (parser->copline > (line_t)(ps[-2].val.ival))
1428                               parser->copline = (line_t)(ps[-2].val.ival);
1429                           body = block_end((ps[-5].val.ival),
1430                                 op_append_list(OP_LINESEQ, (ps[-4].val.opval), (ps[-1].val.opval)));
1431                           SvREFCNT_inc_simple_void(PL_compcv);
1432                           (yyval.opval) = newANONATTRSUB((ps[-6].val.ival), NULL, (ps[-3].val.opval), body);
1433                         }
1434
1435     break;
1436
1437   case 177:
1438 #line 1046 "perly.y" /* yacc.c:1646  */
1439     { (yyval.opval) = dofile((ps[0].val.opval), (ps[-1].val.ival));}
1440
1441     break;
1442
1443   case 178:
1444 #line 1048 "perly.y" /* yacc.c:1646  */
1445     { (yyval.opval) = newUNOP(OP_NULL, OPf_SPECIAL, op_scope((ps[0].val.opval)));}
1446
1447     break;
1448
1449   case 183:
1450 #line 1056 "perly.y" /* yacc.c:1646  */
1451     { (yyval.opval) = newCONDOP(0, (ps[-4].val.opval), (ps[-2].val.opval), (ps[0].val.opval)); }
1452
1453     break;
1454
1455   case 184:
1456 #line 1058 "perly.y" /* yacc.c:1646  */
1457     { (yyval.opval) = newUNOP(OP_REFGEN, 0, (ps[0].val.opval)); }
1458
1459     break;
1460
1461   case 185:
1462 #line 1060 "perly.y" /* yacc.c:1646  */
1463     { (yyval.opval) = newUNOP(OP_REFGEN, 0, localize((ps[0].val.opval),1)); }
1464
1465     break;
1466
1467   case 186:
1468 #line 1062 "perly.y" /* yacc.c:1646  */
1469     { (yyval.opval) = (ps[0].val.opval); }
1470
1471     break;
1472
1473   case 187:
1474 #line 1064 "perly.y" /* yacc.c:1646  */
1475     { (yyval.opval) = localize((ps[0].val.opval),0); }
1476
1477     break;
1478
1479   case 188:
1480 #line 1066 "perly.y" /* yacc.c:1646  */
1481     { (yyval.opval) = sawparens((ps[-1].val.opval)); }
1482
1483     break;
1484
1485   case 189:
1486 #line 1068 "perly.y" /* yacc.c:1646  */
1487     { (yyval.opval) = (ps[0].val.opval); }
1488
1489     break;
1490
1491   case 190:
1492 #line 1070 "perly.y" /* yacc.c:1646  */
1493     { (yyval.opval) = sawparens(newNULLLIST()); }
1494
1495     break;
1496
1497   case 191:
1498 #line 1072 "perly.y" /* yacc.c:1646  */
1499     { (yyval.opval) = (ps[0].val.opval); }
1500
1501     break;
1502
1503   case 192:
1504 #line 1074 "perly.y" /* yacc.c:1646  */
1505     { (yyval.opval) = (ps[0].val.opval); }
1506
1507     break;
1508
1509   case 193:
1510 #line 1076 "perly.y" /* yacc.c:1646  */
1511     { (yyval.opval) = (ps[0].val.opval); }
1512
1513     break;
1514
1515   case 194:
1516 #line 1078 "perly.y" /* yacc.c:1646  */
1517     { (yyval.opval) = (ps[0].val.opval); }
1518
1519     break;
1520
1521   case 195:
1522 #line 1080 "perly.y" /* yacc.c:1646  */
1523     { (yyval.opval) = newUNOP(OP_AV2ARYLEN, 0, ref((ps[0].val.opval), OP_AV2ARYLEN));}
1524
1525     break;
1526
1527   case 196:
1528 #line 1082 "perly.y" /* yacc.c:1646  */
1529     { (yyval.opval) = (ps[0].val.opval); }
1530
1531     break;
1532
1533   case 197:
1534 #line 1084 "perly.y" /* yacc.c:1646  */
1535     { (yyval.opval) = op_prepend_elem(OP_ASLICE,
1536                                 newOP(OP_PUSHMARK, 0),
1537                                     newLISTOP(OP_ASLICE, 0,
1538                                         list((ps[-1].val.opval)),
1539                                         ref((ps[-3].val.opval), OP_ASLICE)));
1540                           if ((yyval.opval) && (ps[-3].val.opval))
1541                               (yyval.opval)->op_private |=
1542                                   (ps[-3].val.opval)->op_private & OPpSLICEWARNING;
1543                         }
1544
1545     break;
1546
1547   case 198:
1548 #line 1094 "perly.y" /* yacc.c:1646  */
1549     { (yyval.opval) = op_prepend_elem(OP_KVASLICE,
1550                                 newOP(OP_PUSHMARK, 0),
1551                                     newLISTOP(OP_KVASLICE, 0,
1552                                         list((ps[-1].val.opval)),
1553                                         ref(oopsAV((ps[-3].val.opval)), OP_KVASLICE)));
1554                           if ((yyval.opval) && (ps[-3].val.opval))
1555                               (yyval.opval)->op_private |=
1556                                   (ps[-3].val.opval)->op_private & OPpSLICEWARNING;
1557                         }
1558
1559     break;
1560
1561   case 199:
1562 #line 1104 "perly.y" /* yacc.c:1646  */
1563     { (yyval.opval) = op_prepend_elem(OP_HSLICE,
1564                                 newOP(OP_PUSHMARK, 0),
1565                                     newLISTOP(OP_HSLICE, 0,
1566                                         list((ps[-2].val.opval)),
1567                                         ref(oopsHV((ps[-4].val.opval)), OP_HSLICE)));
1568                           if ((yyval.opval) && (ps[-4].val.opval))
1569                               (yyval.opval)->op_private |=
1570                                   (ps[-4].val.opval)->op_private & OPpSLICEWARNING;
1571                         }
1572
1573     break;
1574
1575   case 200:
1576 #line 1114 "perly.y" /* yacc.c:1646  */
1577     { (yyval.opval) = op_prepend_elem(OP_KVHSLICE,
1578                                 newOP(OP_PUSHMARK, 0),
1579                                     newLISTOP(OP_KVHSLICE, 0,
1580                                         list((ps[-2].val.opval)),
1581                                         ref((ps[-4].val.opval), OP_KVHSLICE)));
1582                           if ((yyval.opval) && (ps[-4].val.opval))
1583                               (yyval.opval)->op_private |=
1584                                   (ps[-4].val.opval)->op_private & OPpSLICEWARNING;
1585                         }
1586
1587     break;
1588
1589   case 201:
1590 #line 1124 "perly.y" /* yacc.c:1646  */
1591     { (yyval.opval) = (ps[0].val.opval); }
1592
1593     break;
1594
1595   case 202:
1596 #line 1126 "perly.y" /* yacc.c:1646  */
1597     { (yyval.opval) = newUNOP(OP_ENTERSUB, 0, scalar((ps[0].val.opval))); }
1598
1599     break;
1600
1601   case 203:
1602 #line 1128 "perly.y" /* yacc.c:1646  */
1603     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[-2].val.opval)));
1604                         }
1605
1606     break;
1607
1608   case 204:
1609 #line 1131 "perly.y" /* yacc.c:1646  */
1610     {
1611                           (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1612                                 op_append_elem(OP_LIST, (ps[-1].val.opval), scalar((ps[-3].val.opval))));
1613                         }
1614
1615     break;
1616
1617   case 205:
1618 #line 1136 "perly.y" /* yacc.c:1646  */
1619     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1620                             op_append_elem(OP_LIST, (ps[0].val.opval), scalar((ps[-1].val.opval))));
1621                         }
1622
1623     break;
1624
1625   case 206:
1626 #line 1140 "perly.y" /* yacc.c:1646  */
1627     { (yyval.opval) = newSVREF((ps[-3].val.opval)); }
1628
1629     break;
1630
1631   case 207:
1632 #line 1142 "perly.y" /* yacc.c:1646  */
1633     { (yyval.opval) = newAVREF((ps[-3].val.opval)); }
1634
1635     break;
1636
1637   case 208:
1638 #line 1144 "perly.y" /* yacc.c:1646  */
1639     { (yyval.opval) = newHVREF((ps[-3].val.opval)); }
1640
1641     break;
1642
1643   case 209:
1644 #line 1146 "perly.y" /* yacc.c:1646  */
1645     { (yyval.opval) = newUNOP(OP_ENTERSUB, 0,
1646                                        scalar(newCVREF((ps[-1].val.ival),(ps[-3].val.opval)))); }
1647
1648     break;
1649
1650   case 210:
1651 #line 1149 "perly.y" /* yacc.c:1646  */
1652     { (yyval.opval) = newGVREF(0,(ps[-3].val.opval)); }
1653
1654     break;
1655
1656   case 211:
1657 #line 1151 "perly.y" /* yacc.c:1646  */
1658     { (yyval.opval) = newOP((ps[0].val.ival), OPf_SPECIAL);
1659                             PL_hints |= HINT_BLOCK_SCOPE; }
1660
1661     break;
1662
1663   case 212:
1664 #line 1154 "perly.y" /* yacc.c:1646  */
1665     { (yyval.opval) = newLOOPEX((ps[-1].val.ival),(ps[0].val.opval)); }
1666
1667     break;
1668
1669   case 213:
1670 #line 1156 "perly.y" /* yacc.c:1646  */
1671     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[0].val.opval))); }
1672
1673     break;
1674
1675   case 214:
1676 #line 1158 "perly.y" /* yacc.c:1646  */
1677     { (yyval.opval) = newOP((ps[0].val.ival), 0); }
1678
1679     break;
1680
1681   case 215:
1682 #line 1160 "perly.y" /* yacc.c:1646  */
1683     { (yyval.opval) = newUNOP((ps[-1].val.ival), 0, (ps[0].val.opval)); }
1684
1685     break;
1686
1687   case 216:
1688 #line 1162 "perly.y" /* yacc.c:1646  */
1689     { (yyval.opval) = newUNOP((ps[-1].val.ival), 0, (ps[0].val.opval)); }
1690
1691     break;
1692
1693   case 217:
1694 #line 1164 "perly.y" /* yacc.c:1646  */
1695     { (yyval.opval) = newOP(OP_REQUIRE, (ps[0].val.ival) ? OPf_SPECIAL : 0); }
1696
1697     break;
1698
1699   case 218:
1700 #line 1166 "perly.y" /* yacc.c:1646  */
1701     { (yyval.opval) = newUNOP(OP_REQUIRE, (ps[-1].val.ival) ? OPf_SPECIAL : 0, (ps[0].val.opval)); }
1702
1703     break;
1704
1705   case 219:
1706 #line 1168 "perly.y" /* yacc.c:1646  */
1707     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[0].val.opval))); }
1708
1709     break;
1710
1711   case 220:
1712 #line 1170 "perly.y" /* yacc.c:1646  */
1713     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1714                             op_append_elem(OP_LIST, (ps[0].val.opval), scalar((ps[-1].val.opval)))); }
1715
1716     break;
1717
1718   case 221:
1719 #line 1173 "perly.y" /* yacc.c:1646  */
1720     { (yyval.opval) = newOP((ps[0].val.ival), 0); }
1721
1722     break;
1723
1724   case 222:
1725 #line 1175 "perly.y" /* yacc.c:1646  */
1726     { (yyval.opval) = newOP((ps[-2].val.ival), 0);}
1727
1728     break;
1729
1730   case 223:
1731 #line 1177 "perly.y" /* yacc.c:1646  */
1732     { (yyval.opval) = (ps[0].val.opval); }
1733
1734     break;
1735
1736   case 224:
1737 #line 1179 "perly.y" /* yacc.c:1646  */
1738     { (yyval.opval) = (ps[-2].val.opval); }
1739
1740     break;
1741
1742   case 225:
1743 #line 1181 "perly.y" /* yacc.c:1646  */
1744     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[0].val.opval))); }
1745
1746     break;
1747
1748   case 226:
1749 #line 1183 "perly.y" /* yacc.c:1646  */
1750     { (yyval.opval) = ((ps[-2].val.ival) == OP_NOT)
1751                           ? newUNOP((ps[-2].val.ival), 0, newSVOP(OP_CONST, 0, newSViv(0)))
1752                           : newOP((ps[-2].val.ival), OPf_SPECIAL); }
1753
1754     break;
1755
1756   case 227:
1757 #line 1187 "perly.y" /* yacc.c:1646  */
1758     { (yyval.opval) = newUNOP((ps[-3].val.ival), 0, (ps[-1].val.opval)); }
1759
1760     break;
1761
1762   case 228:
1763 #line 1189 "perly.y" /* yacc.c:1646  */
1764     {
1765                             if (   (ps[0].val.opval)->op_type != OP_TRANS
1766                                 && (ps[0].val.opval)->op_type != OP_TRANSR
1767                                 && (((PMOP*)(ps[0].val.opval))->op_pmflags & PMf_HAS_CV))
1768                             {
1769                                 (yyval.ival) = start_subparse(FALSE, CVf_ANON);
1770                                 SAVEFREESV(PL_compcv);
1771                             } else
1772                                 (yyval.ival) = 0;
1773                         }
1774
1775     break;
1776
1777   case 229:
1778 #line 1200 "perly.y" /* yacc.c:1646  */
1779     { (yyval.opval) = pmruntime((ps[-5].val.opval), (ps[-2].val.opval), (ps[-1].val.opval), 1, (ps[-4].val.ival)); }
1780
1781     break;
1782
1783   case 232:
1784 #line 1204 "perly.y" /* yacc.c:1646  */
1785     {
1786                           (yyval.opval) = newLISTOP(OP_DIE, 0, newOP(OP_PUSHMARK, 0),
1787                                 newSVOP(OP_CONST, 0, newSVpvs("Unimplemented")));
1788                         }
1789
1790     break;
1791
1792   case 234:
1793 #line 1213 "perly.y" /* yacc.c:1646  */
1794     { (yyval.opval) = my_attrs((ps[-1].val.opval),(ps[0].val.opval)); }
1795
1796     break;
1797
1798   case 235:
1799 #line 1215 "perly.y" /* yacc.c:1646  */
1800     { (yyval.opval) = localize((ps[0].val.opval),1); }
1801
1802     break;
1803
1804   case 236:
1805 #line 1217 "perly.y" /* yacc.c:1646  */
1806     { (yyval.opval) = newUNOP(OP_REFGEN, 0, my_attrs((ps[-1].val.opval),(ps[0].val.opval))); }
1807
1808     break;
1809
1810   case 237:
1811 #line 1222 "perly.y" /* yacc.c:1646  */
1812     { (yyval.opval) = sawparens((ps[-1].val.opval)); }
1813
1814     break;
1815
1816   case 238:
1817 #line 1224 "perly.y" /* yacc.c:1646  */
1818     { (yyval.opval) = sawparens(newNULLLIST()); }
1819
1820     break;
1821
1822   case 239:
1823 #line 1227 "perly.y" /* yacc.c:1646  */
1824     { (yyval.opval) = (ps[0].val.opval); }
1825
1826     break;
1827
1828   case 240:
1829 #line 1229 "perly.y" /* yacc.c:1646  */
1830     { (yyval.opval) = (ps[0].val.opval); }
1831
1832     break;
1833
1834   case 241:
1835 #line 1231 "perly.y" /* yacc.c:1646  */
1836     { (yyval.opval) = (ps[0].val.opval); }
1837
1838     break;
1839
1840   case 242:
1841 #line 1236 "perly.y" /* yacc.c:1646  */
1842     { (yyval.opval) = (OP*)NULL; }
1843
1844     break;
1845
1846   case 243:
1847 #line 1238 "perly.y" /* yacc.c:1646  */
1848     { (yyval.opval) = (ps[0].val.opval); }
1849
1850     break;
1851
1852   case 244:
1853 #line 1242 "perly.y" /* yacc.c:1646  */
1854     { (yyval.opval) = (OP*)NULL; }
1855
1856     break;
1857
1858   case 245:
1859 #line 1244 "perly.y" /* yacc.c:1646  */
1860     { (yyval.opval) = (ps[0].val.opval); }
1861
1862     break;
1863
1864   case 246:
1865 #line 1248 "perly.y" /* yacc.c:1646  */
1866     { (yyval.opval) = (OP*)NULL; }
1867
1868     break;
1869
1870   case 247:
1871 #line 1250 "perly.y" /* yacc.c:1646  */
1872     { (yyval.opval) = (ps[0].val.opval); }
1873
1874     break;
1875
1876   case 248:
1877 #line 1256 "perly.y" /* yacc.c:1646  */
1878     { parser->in_my = 0; (yyval.opval) = my((ps[0].val.opval)); }
1879
1880     break;
1881
1882   case 256:
1883 #line 1273 "perly.y" /* yacc.c:1646  */
1884     { (yyval.opval) = newCVREF((ps[-1].val.ival),(ps[0].val.opval)); }
1885
1886     break;
1887
1888   case 257:
1889 #line 1277 "perly.y" /* yacc.c:1646  */
1890     { (yyval.opval) = newSVREF((ps[0].val.opval)); }
1891
1892     break;
1893
1894   case 258:
1895 #line 1281 "perly.y" /* yacc.c:1646  */
1896     { (yyval.opval) = newAVREF((ps[0].val.opval));
1897                           if ((yyval.opval)) (yyval.opval)->op_private |= (ps[-1].val.ival);
1898                         }
1899
1900     break;
1901
1902   case 259:
1903 #line 1287 "perly.y" /* yacc.c:1646  */
1904     { (yyval.opval) = newHVREF((ps[0].val.opval));
1905                           if ((yyval.opval)) (yyval.opval)->op_private |= (ps[-1].val.ival);
1906                         }
1907
1908     break;
1909
1910   case 260:
1911 #line 1293 "perly.y" /* yacc.c:1646  */
1912     { (yyval.opval) = newAVREF((ps[0].val.opval)); }
1913
1914     break;
1915
1916   case 261:
1917 #line 1295 "perly.y" /* yacc.c:1646  */
1918     { (yyval.opval) = newAVREF((ps[-3].val.opval)); }
1919
1920     break;
1921
1922   case 262:
1923 #line 1299 "perly.y" /* yacc.c:1646  */
1924     { (yyval.opval) = newGVREF(0,(ps[0].val.opval)); }
1925
1926     break;
1927
1928   case 264:
1929 #line 1304 "perly.y" /* yacc.c:1646  */
1930     { (yyval.opval) = newAVREF((ps[-2].val.opval)); }
1931
1932     break;
1933
1934   case 266:
1935 #line 1309 "perly.y" /* yacc.c:1646  */
1936     { (yyval.opval) = newHVREF((ps[-2].val.opval)); }
1937
1938     break;
1939
1940   case 268:
1941 #line 1314 "perly.y" /* yacc.c:1646  */
1942     { (yyval.opval) = newGVREF(0,(ps[-2].val.opval)); }
1943
1944     break;
1945
1946   case 269:
1947 #line 1319 "perly.y" /* yacc.c:1646  */
1948     { (yyval.opval) = scalar((ps[0].val.opval)); }
1949
1950     break;
1951
1952   case 270:
1953 #line 1321 "perly.y" /* yacc.c:1646  */
1954     { (yyval.opval) = scalar((ps[0].val.opval)); }
1955
1956     break;
1957
1958   case 271:
1959 #line 1323 "perly.y" /* yacc.c:1646  */
1960     { (yyval.opval) = op_scope((ps[0].val.opval)); }
1961
1962     break;
1963
1964   case 272:
1965 #line 1326 "perly.y" /* yacc.c:1646  */
1966     { (yyval.opval) = (ps[0].val.opval); }
1967
1968     break;
1969
1970
1971
1972       default: break;
1973     
1974
1975 /* Generated from:
1976  * f197986843aaef0ab285344b7144e3bf7b35fea3ed9aa46884a25d31c7485700 perly.y
1977  * 3e1dff60f26df8933d7aed0c0e87177a0f022c14800c0707eb62a7db4196ac98 regen_perly.pl
1978  * ex: set ro: */