This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
rename "WORD" lexical token to "BAREWORD"
[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 115 "perly.y" /* yacc.c:1646  */
9     {
10                           parser->expect = XSTATE;
11                         }
12
13     break;
14
15   case 3:
16 #line 119 "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 125 "perly.y" /* yacc.c:1646  */
27     {
28                           parser->expect = XTERM;
29                         }
30
31     break;
32
33   case 5:
34 #line 129 "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 134 "perly.y" /* yacc.c:1646  */
44     {
45                           parser->expect = XBLOCK;
46                         }
47
48     break;
49
50   case 7:
51 #line 138 "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 146 "perly.y" /* yacc.c:1646  */
64     {
65                           parser->expect = XSTATE;
66                         }
67
68     break;
69
70   case 9:
71 #line 150 "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 158 "perly.y" /* yacc.c:1646  */
84     {
85                           parser->expect = XSTATE;
86                         }
87
88     break;
89
90   case 11:
91 #line 162 "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 170 "perly.y" /* yacc.c:1646  */
104     {
105                           parser->expect = XSTATE;
106                         }
107
108     break;
109
110   case 13:
111 #line 174 "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 182 "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 190 "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 197 "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 202 "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 209 "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 215 "perly.y" /* yacc.c:1646  */
162     { (yyval.opval) = (OP*)NULL; }
163
164     break;
165
166   case 20:
167 #line 217 "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 226 "perly.y" /* yacc.c:1646  */
178     { (yyval.opval) = (OP*)NULL; }
179
180     break;
181
182   case 22:
183 #line 228 "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 237 "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 241 "perly.y" /* yacc.c:1646  */
202     { (yyval.opval) = (ps[0].val.opval); }
203
204     break;
205
206   case 25:
207 #line 245 "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 249 "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 256 "perly.y" /* yacc.c:1646  */
224     { (yyval.opval) = (ps[0].val.opval); }
225
226     break;
227
228   case 28:
229 #line 258 "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 268 "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 290 "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 301 "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 323 "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 340 "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 347 "perly.y" /* yacc.c:1646  */
343     { CvSPECIAL_on(PL_compcv); /* It's a BEGIN {} */ }
344
345     break;
346
347   case 35:
348 #line 349 "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 356 "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 362 "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 368 "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 373 "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 375 "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 377 "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 384 "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 391 "perly.y" /* yacc.c:1646  */
423     { parser->expect = XTERM; }
424
425     break;
426
427   case 44:
428 #line 393 "perly.y" /* yacc.c:1646  */
429     { parser->expect = XTERM; }
430
431     break;
432
433   case 45:
434 #line 396 "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 411 "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 416 "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 422 "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 424 "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 437 "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 445 "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 451 "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 457 "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 464 "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 472 "perly.y" /* yacc.c:1646  */
551     {
552                           (yyval.opval) = (ps[-1].val.opval);
553                         }
554
555     break;
556
557   case 56:
558 #line 476 "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 484 "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 501 "perly.y" /* yacc.c:1646  */
587     { (yyval.opval) = NULL; }
588
589     break;
590
591   case 59:
592 #line 503 "perly.y" /* yacc.c:1646  */
593     { (yyval.opval) = op_unscope((ps[-1].val.opval)); }
594
595     break;
596
597   case 60:
598 #line 508 "perly.y" /* yacc.c:1646  */
599     { (yyval.opval) = (OP*)NULL; }
600
601     break;
602
603   case 61:
604 #line 510 "perly.y" /* yacc.c:1646  */
605     { (yyval.opval) = (ps[0].val.opval); }
606
607     break;
608
609   case 62:
610 #line 512 "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 514 "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 516 "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 518 "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 520 "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 523 "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 528 "perly.y" /* yacc.c:1646  */
648     { (yyval.opval) = (OP*)NULL; }
649
650     break;
651
652   case 69:
653 #line 530 "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 535 "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 545 "perly.y" /* yacc.c:1646  */
674     { (yyval.opval) = (OP*)NULL; }
675
676     break;
677
678   case 72:
679 #line 547 "perly.y" /* yacc.c:1646  */
680     { (yyval.opval) = op_scope((ps[0].val.opval)); }
681
682     break;
683
684   case 73:
685 #line 552 "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 558 "perly.y" /* yacc.c:1646  */
694     { (yyval.opval) = (OP*)NULL; }
695
696     break;
697
698   case 76:
699 #line 564 "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 572 "perly.y" /* yacc.c:1646  */
708     { (yyval.opval) = invert(scalar((ps[0].val.opval))); }
709
710     break;
711
712   case 79:
713 #line 577 "perly.y" /* yacc.c:1646  */
714     { (yyval.opval) = (ps[0].val.opval); intro_my(); }
715
716     break;
717
718   case 80:
719 #line 581 "perly.y" /* yacc.c:1646  */
720     { (yyval.opval) = (ps[0].val.opval); intro_my(); }
721
722     break;
723
724   case 81:
725 #line 584 "perly.y" /* yacc.c:1646  */
726     { (yyval.opval) = (ps[0].val.opval); }
727
728     break;
729
730   case 82:
731 #line 585 "perly.y" /* yacc.c:1646  */
732     { (yyval.opval) = (OP*)NULL; }
733
734     break;
735
736   case 83:
737 #line 589 "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 595 "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 600 "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 611 "perly.y" /* yacc.c:1646  */
759     { (yyval.opval) = (OP*)NULL; }
760
761     break;
762
763   case 90:
764 #line 617 "perly.y" /* yacc.c:1646  */
765     { (yyval.opval) = (OP*)NULL; }
766
767     break;
768
769   case 91:
770 #line 619 "perly.y" /* yacc.c:1646  */
771     { (yyval.opval) = (ps[0].val.opval); }
772
773     break;
774
775   case 92:
776 #line 621 "perly.y" /* yacc.c:1646  */
777     { (yyval.opval) = (OP*)NULL; }
778
779     break;
780
781   case 93:
782 #line 626 "perly.y" /* yacc.c:1646  */
783     { (yyval.opval) = (ps[0].val.opval); }
784
785     break;
786
787   case 94:
788 #line 628 "perly.y" /* yacc.c:1646  */
789     { (yyval.opval) = (OP*)NULL; }
790
791     break;
792
793   case 95:
794 #line 633 "perly.y" /* yacc.c:1646  */
795     {
796                           /* We shouldn't get here otherwise */
797                           assert(FEATURE_SIGNATURES_IS_ENABLED);
798
799                           Perl_ck_warner_d(aTHX_
800                                 packWARN(WARN_EXPERIMENTAL__SIGNATURES),
801                                 "The signatures feature is experimental");
802                           (yyval.opval) = parse_subsignature();
803                         }
804
805     break;
806
807   case 96:
808 #line 643 "perly.y" /* yacc.c:1646  */
809     {
810                           (yyval.opval) = op_append_list(OP_LINESEQ, (ps[-1].val.opval),
811                                 newSTATEOP(0, NULL, sawparens(newNULLLIST())));
812                           parser->expect = XATTRBLOCK;
813                         }
814
815     break;
816
817   case 98:
818 #line 652 "perly.y" /* yacc.c:1646  */
819     { (yyval.opval) = (OP*)NULL; }
820
821     break;
822
823   case 99:
824 #line 657 "perly.y" /* yacc.c:1646  */
825     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
826
827     break;
828
829   case 100:
830 #line 659 "perly.y" /* yacc.c:1646  */
831     { (yyval.opval) = newLOGOP((ps[-1].val.ival), 0, (ps[-2].val.opval), (ps[0].val.opval)); }
832
833     break;
834
835   case 101:
836 #line 661 "perly.y" /* yacc.c:1646  */
837     { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
838
839     break;
840
841   case 103:
842 #line 667 "perly.y" /* yacc.c:1646  */
843     { (yyval.opval) = (ps[-1].val.opval); }
844
845     break;
846
847   case 104:
848 #line 669 "perly.y" /* yacc.c:1646  */
849     {
850                           OP* term = (ps[0].val.opval);
851                           (yyval.opval) = op_append_elem(OP_LIST, (ps[-2].val.opval), term);
852                         }
853
854     break;
855
856   case 106:
857 #line 678 "perly.y" /* yacc.c:1646  */
858     { (yyval.opval) = op_convert_list((ps[-2].val.ival), OPf_STACKED,
859                                 op_prepend_elem(OP_LIST, newGVREF((ps[-2].val.ival),(ps[-1].val.opval)), (ps[0].val.opval)) );
860                         }
861
862     break;
863
864   case 107:
865 #line 682 "perly.y" /* yacc.c:1646  */
866     { (yyval.opval) = op_convert_list((ps[-4].val.ival), OPf_STACKED,
867                                 op_prepend_elem(OP_LIST, newGVREF((ps[-4].val.ival),(ps[-2].val.opval)), (ps[-1].val.opval)) );
868                         }
869
870     break;
871
872   case 108:
873 #line 686 "perly.y" /* yacc.c:1646  */
874     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
875                                 op_append_elem(OP_LIST,
876                                     op_prepend_elem(OP_LIST, scalar((ps[-5].val.opval)), (ps[-1].val.opval)),
877                                     newMETHOP(OP_METHOD, 0, (ps[-3].val.opval))));
878                         }
879
880     break;
881
882   case 109:
883 #line 692 "perly.y" /* yacc.c:1646  */
884     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
885                                 op_append_elem(OP_LIST, scalar((ps[-2].val.opval)),
886                                     newMETHOP(OP_METHOD, 0, (ps[0].val.opval))));
887                         }
888
889     break;
890
891   case 110:
892 #line 697 "perly.y" /* yacc.c:1646  */
893     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
894                                 op_append_elem(OP_LIST,
895                                     op_prepend_elem(OP_LIST, (ps[-1].val.opval), (ps[0].val.opval)),
896                                     newMETHOP(OP_METHOD, 0, (ps[-2].val.opval))));
897                         }
898
899     break;
900
901   case 111:
902 #line 703 "perly.y" /* yacc.c:1646  */
903     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
904                                 op_append_elem(OP_LIST,
905                                     op_prepend_elem(OP_LIST, (ps[-3].val.opval), (ps[-1].val.opval)),
906                                     newMETHOP(OP_METHOD, 0, (ps[-4].val.opval))));
907                         }
908
909     break;
910
911   case 112:
912 #line 709 "perly.y" /* yacc.c:1646  */
913     { (yyval.opval) = op_convert_list((ps[-1].val.ival), 0, (ps[0].val.opval)); }
914
915     break;
916
917   case 113:
918 #line 711 "perly.y" /* yacc.c:1646  */
919     { (yyval.opval) = op_convert_list((ps[-3].val.ival), 0, (ps[-1].val.opval)); }
920
921     break;
922
923   case 114:
924 #line 713 "perly.y" /* yacc.c:1646  */
925     { SvREFCNT_inc_simple_void(PL_compcv);
926                           (yyval.opval) = newANONATTRSUB((ps[-1].val.ival), 0, (OP*)NULL, (ps[0].val.opval)); }
927
928     break;
929
930   case 115:
931 #line 716 "perly.y" /* yacc.c:1646  */
932     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
933                                  op_append_elem(OP_LIST,
934                                    op_prepend_elem(OP_LIST, (ps[-1].val.opval), (ps[0].val.opval)), (ps[-4].val.opval)));
935                         }
936
937     break;
938
939   case 118:
940 #line 731 "perly.y" /* yacc.c:1646  */
941     { (yyval.opval) = newBINOP(OP_GELEM, 0, (ps[-4].val.opval), scalar((ps[-2].val.opval))); }
942
943     break;
944
945   case 119:
946 #line 733 "perly.y" /* yacc.c:1646  */
947     { (yyval.opval) = newBINOP(OP_AELEM, 0, oopsAV((ps[-3].val.opval)), scalar((ps[-1].val.opval)));
948                         }
949
950     break;
951
952   case 120:
953 #line 736 "perly.y" /* yacc.c:1646  */
954     { (yyval.opval) = newBINOP(OP_AELEM, 0,
955                                         ref(newAVREF((ps[-4].val.opval)),OP_RV2AV),
956                                         scalar((ps[-1].val.opval)));
957                         }
958
959     break;
960
961   case 121:
962 #line 741 "perly.y" /* yacc.c:1646  */
963     { (yyval.opval) = newBINOP(OP_AELEM, 0,
964                                         ref(newAVREF((ps[-3].val.opval)),OP_RV2AV),
965                                         scalar((ps[-1].val.opval)));
966                         }
967
968     break;
969
970   case 122:
971 #line 746 "perly.y" /* yacc.c:1646  */
972     { (yyval.opval) = newBINOP(OP_HELEM, 0, oopsHV((ps[-4].val.opval)), jmaybe((ps[-2].val.opval)));
973                         }
974
975     break;
976
977   case 123:
978 #line 749 "perly.y" /* yacc.c:1646  */
979     { (yyval.opval) = newBINOP(OP_HELEM, 0,
980                                         ref(newHVREF((ps[-5].val.opval)),OP_RV2HV),
981                                         jmaybe((ps[-2].val.opval))); }
982
983     break;
984
985   case 124:
986 #line 753 "perly.y" /* yacc.c:1646  */
987     { (yyval.opval) = newBINOP(OP_HELEM, 0,
988                                         ref(newHVREF((ps[-4].val.opval)),OP_RV2HV),
989                                         jmaybe((ps[-2].val.opval))); }
990
991     break;
992
993   case 125:
994 #line 757 "perly.y" /* yacc.c:1646  */
995     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
996                                    newCVREF(0, scalar((ps[-3].val.opval)))); }
997
998     break;
999
1000   case 126:
1001 #line 760 "perly.y" /* yacc.c:1646  */
1002     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1003                                    op_append_elem(OP_LIST, (ps[-1].val.opval),
1004                                        newCVREF(0, scalar((ps[-4].val.opval))))); }
1005
1006     break;
1007
1008   case 127:
1009 #line 765 "perly.y" /* yacc.c:1646  */
1010     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1011                                    op_append_elem(OP_LIST, (ps[-1].val.opval),
1012                                                newCVREF(0, scalar((ps[-3].val.opval))))); }
1013
1014     break;
1015
1016   case 128:
1017 #line 769 "perly.y" /* yacc.c:1646  */
1018     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1019                                    newCVREF(0, scalar((ps[-2].val.opval)))); }
1020
1021     break;
1022
1023   case 129:
1024 #line 772 "perly.y" /* yacc.c:1646  */
1025     { (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), (ps[-4].val.opval)); }
1026
1027     break;
1028
1029   case 130:
1030 #line 774 "perly.y" /* yacc.c:1646  */
1031     { (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), (ps[-3].val.opval)); }
1032
1033     break;
1034
1035   case 131:
1036 #line 776 "perly.y" /* yacc.c:1646  */
1037     { (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), (OP*)NULL); }
1038
1039     break;
1040
1041   case 132:
1042 #line 781 "perly.y" /* yacc.c:1646  */
1043     { (yyval.opval) = newASSIGNOP(OPf_STACKED, (ps[-2].val.opval), (ps[-1].val.ival), (ps[0].val.opval)); }
1044
1045     break;
1046
1047   case 133:
1048 #line 783 "perly.y" /* yacc.c:1646  */
1049     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1050
1051     break;
1052
1053   case 134:
1054 #line 785 "perly.y" /* yacc.c:1646  */
1055     {   if ((ps[-1].val.ival) != OP_REPEAT)
1056                                 scalar((ps[-2].val.opval));
1057                             (yyval.opval) = newBINOP((ps[-1].val.ival), 0, (ps[-2].val.opval), scalar((ps[0].val.opval)));
1058                         }
1059
1060     break;
1061
1062   case 135:
1063 #line 790 "perly.y" /* yacc.c:1646  */
1064     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1065
1066     break;
1067
1068   case 136:
1069 #line 792 "perly.y" /* yacc.c:1646  */
1070     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1071
1072     break;
1073
1074   case 137:
1075 #line 794 "perly.y" /* yacc.c:1646  */
1076     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1077
1078     break;
1079
1080   case 138:
1081 #line 796 "perly.y" /* yacc.c:1646  */
1082     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1083
1084     break;
1085
1086   case 139:
1087 #line 798 "perly.y" /* yacc.c:1646  */
1088     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1089
1090     break;
1091
1092   case 140:
1093 #line 800 "perly.y" /* yacc.c:1646  */
1094     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1095
1096     break;
1097
1098   case 141:
1099 #line 802 "perly.y" /* yacc.c:1646  */
1100     { (yyval.opval) = newRANGE((ps[-1].val.ival), scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1101
1102     break;
1103
1104   case 142:
1105 #line 804 "perly.y" /* yacc.c:1646  */
1106     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1107
1108     break;
1109
1110   case 143:
1111 #line 806 "perly.y" /* yacc.c:1646  */
1112     { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1113
1114     break;
1115
1116   case 144:
1117 #line 808 "perly.y" /* yacc.c:1646  */
1118     { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1119
1120     break;
1121
1122   case 145:
1123 #line 810 "perly.y" /* yacc.c:1646  */
1124     { (yyval.opval) = bind_match((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); }
1125
1126     break;
1127
1128   case 146:
1129 #line 815 "perly.y" /* yacc.c:1646  */
1130     { (yyval.opval) = newUNOP(OP_NEGATE, 0, scalar((ps[0].val.opval))); }
1131
1132     break;
1133
1134   case 147:
1135 #line 817 "perly.y" /* yacc.c:1646  */
1136     { (yyval.opval) = (ps[0].val.opval); }
1137
1138     break;
1139
1140   case 148:
1141 #line 820 "perly.y" /* yacc.c:1646  */
1142     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[0].val.opval))); }
1143
1144     break;
1145
1146   case 149:
1147 #line 822 "perly.y" /* yacc.c:1646  */
1148     { (yyval.opval) = newUNOP((ps[-1].val.ival), 0, scalar((ps[0].val.opval))); }
1149
1150     break;
1151
1152   case 150:
1153 #line 824 "perly.y" /* yacc.c:1646  */
1154     { (yyval.opval) = newUNOP(OP_POSTINC, 0,
1155                                         op_lvalue(scalar((ps[-1].val.opval)), OP_POSTINC)); }
1156
1157     break;
1158
1159   case 151:
1160 #line 827 "perly.y" /* yacc.c:1646  */
1161     { (yyval.opval) = newUNOP(OP_POSTDEC, 0,
1162                                         op_lvalue(scalar((ps[-1].val.opval)), OP_POSTDEC));}
1163
1164     break;
1165
1166   case 152:
1167 #line 830 "perly.y" /* yacc.c:1646  */
1168     { (yyval.opval) = op_convert_list(OP_JOIN, 0,
1169                                        op_append_elem(
1170                                         OP_LIST,
1171                                         newSVREF(scalar(
1172                                             newSVOP(OP_CONST,0,
1173                                                     newSVpvs("\""))
1174                                         )),
1175                                         (ps[-1].val.opval)
1176                                        ));
1177                         }
1178
1179     break;
1180
1181   case 153:
1182 #line 841 "perly.y" /* yacc.c:1646  */
1183     { (yyval.opval) = newUNOP(OP_PREINC, 0,
1184                                         op_lvalue(scalar((ps[0].val.opval)), OP_PREINC)); }
1185
1186     break;
1187
1188   case 154:
1189 #line 844 "perly.y" /* yacc.c:1646  */
1190     { (yyval.opval) = newUNOP(OP_PREDEC, 0,
1191                                         op_lvalue(scalar((ps[0].val.opval)), OP_PREDEC)); }
1192
1193     break;
1194
1195   case 155:
1196 #line 851 "perly.y" /* yacc.c:1646  */
1197     { (yyval.opval) = newANONLIST((ps[-1].val.opval)); }
1198
1199     break;
1200
1201   case 156:
1202 #line 853 "perly.y" /* yacc.c:1646  */
1203     { (yyval.opval) = newANONLIST((OP*)NULL);}
1204
1205     break;
1206
1207   case 157:
1208 #line 855 "perly.y" /* yacc.c:1646  */
1209     { (yyval.opval) = newANONHASH((ps[-2].val.opval)); }
1210
1211     break;
1212
1213   case 158:
1214 #line 857 "perly.y" /* yacc.c:1646  */
1215     { (yyval.opval) = newANONHASH((OP*)NULL); }
1216
1217     break;
1218
1219   case 159:
1220 #line 859 "perly.y" /* yacc.c:1646  */
1221     { SvREFCNT_inc_simple_void(PL_compcv);
1222                           (yyval.opval) = newANONATTRSUB((ps[-3].val.ival), (ps[-2].val.opval), (ps[-1].val.opval), (ps[0].val.opval)); }
1223
1224     break;
1225
1226   case 160:
1227 #line 862 "perly.y" /* yacc.c:1646  */
1228     {
1229                           OP *body;
1230                           if (parser->copline > (line_t)(ps[-2].val.ival))
1231                               parser->copline = (line_t)(ps[-2].val.ival);
1232                           body = block_end((ps[-5].val.ival),
1233                                 op_append_list(OP_LINESEQ, (ps[-4].val.opval), (ps[-1].val.opval)));
1234                           SvREFCNT_inc_simple_void(PL_compcv);
1235                           (yyval.opval) = newANONATTRSUB((ps[-6].val.ival), NULL, (ps[-3].val.opval), body);
1236                         }
1237
1238     break;
1239
1240   case 161:
1241 #line 876 "perly.y" /* yacc.c:1646  */
1242     { (yyval.opval) = dofile((ps[0].val.opval), (ps[-1].val.ival));}
1243
1244     break;
1245
1246   case 162:
1247 #line 878 "perly.y" /* yacc.c:1646  */
1248     { (yyval.opval) = newUNOP(OP_NULL, OPf_SPECIAL, op_scope((ps[0].val.opval)));}
1249
1250     break;
1251
1252   case 167:
1253 #line 886 "perly.y" /* yacc.c:1646  */
1254     { (yyval.opval) = newCONDOP(0, (ps[-4].val.opval), (ps[-2].val.opval), (ps[0].val.opval)); }
1255
1256     break;
1257
1258   case 168:
1259 #line 888 "perly.y" /* yacc.c:1646  */
1260     { (yyval.opval) = newUNOP(OP_REFGEN, 0, (ps[0].val.opval)); }
1261
1262     break;
1263
1264   case 169:
1265 #line 890 "perly.y" /* yacc.c:1646  */
1266     { (yyval.opval) = newUNOP(OP_REFGEN, 0, localize((ps[0].val.opval),1)); }
1267
1268     break;
1269
1270   case 170:
1271 #line 892 "perly.y" /* yacc.c:1646  */
1272     { (yyval.opval) = (ps[0].val.opval); }
1273
1274     break;
1275
1276   case 171:
1277 #line 894 "perly.y" /* yacc.c:1646  */
1278     { (yyval.opval) = localize((ps[0].val.opval),0); }
1279
1280     break;
1281
1282   case 172:
1283 #line 896 "perly.y" /* yacc.c:1646  */
1284     { (yyval.opval) = sawparens((ps[-1].val.opval)); }
1285
1286     break;
1287
1288   case 173:
1289 #line 898 "perly.y" /* yacc.c:1646  */
1290     { (yyval.opval) = (ps[0].val.opval); }
1291
1292     break;
1293
1294   case 174:
1295 #line 900 "perly.y" /* yacc.c:1646  */
1296     { (yyval.opval) = sawparens(newNULLLIST()); }
1297
1298     break;
1299
1300   case 175:
1301 #line 902 "perly.y" /* yacc.c:1646  */
1302     { (yyval.opval) = (ps[0].val.opval); }
1303
1304     break;
1305
1306   case 176:
1307 #line 904 "perly.y" /* yacc.c:1646  */
1308     { (yyval.opval) = (ps[0].val.opval); }
1309
1310     break;
1311
1312   case 177:
1313 #line 906 "perly.y" /* yacc.c:1646  */
1314     { (yyval.opval) = (ps[0].val.opval); }
1315
1316     break;
1317
1318   case 178:
1319 #line 908 "perly.y" /* yacc.c:1646  */
1320     { (yyval.opval) = (ps[0].val.opval); }
1321
1322     break;
1323
1324   case 179:
1325 #line 910 "perly.y" /* yacc.c:1646  */
1326     { (yyval.opval) = newUNOP(OP_AV2ARYLEN, 0, ref((ps[0].val.opval), OP_AV2ARYLEN));}
1327
1328     break;
1329
1330   case 180:
1331 #line 912 "perly.y" /* yacc.c:1646  */
1332     { (yyval.opval) = (ps[0].val.opval); }
1333
1334     break;
1335
1336   case 181:
1337 #line 914 "perly.y" /* yacc.c:1646  */
1338     { (yyval.opval) = op_prepend_elem(OP_ASLICE,
1339                                 newOP(OP_PUSHMARK, 0),
1340                                     newLISTOP(OP_ASLICE, 0,
1341                                         list((ps[-1].val.opval)),
1342                                         ref((ps[-3].val.opval), OP_ASLICE)));
1343                           if ((yyval.opval) && (ps[-3].val.opval))
1344                               (yyval.opval)->op_private |=
1345                                   (ps[-3].val.opval)->op_private & OPpSLICEWARNING;
1346                         }
1347
1348     break;
1349
1350   case 182:
1351 #line 924 "perly.y" /* yacc.c:1646  */
1352     { (yyval.opval) = op_prepend_elem(OP_KVASLICE,
1353                                 newOP(OP_PUSHMARK, 0),
1354                                     newLISTOP(OP_KVASLICE, 0,
1355                                         list((ps[-1].val.opval)),
1356                                         ref(oopsAV((ps[-3].val.opval)), OP_KVASLICE)));
1357                           if ((yyval.opval) && (ps[-3].val.opval))
1358                               (yyval.opval)->op_private |=
1359                                   (ps[-3].val.opval)->op_private & OPpSLICEWARNING;
1360                         }
1361
1362     break;
1363
1364   case 183:
1365 #line 934 "perly.y" /* yacc.c:1646  */
1366     { (yyval.opval) = op_prepend_elem(OP_HSLICE,
1367                                 newOP(OP_PUSHMARK, 0),
1368                                     newLISTOP(OP_HSLICE, 0,
1369                                         list((ps[-2].val.opval)),
1370                                         ref(oopsHV((ps[-4].val.opval)), OP_HSLICE)));
1371                           if ((yyval.opval) && (ps[-4].val.opval))
1372                               (yyval.opval)->op_private |=
1373                                   (ps[-4].val.opval)->op_private & OPpSLICEWARNING;
1374                         }
1375
1376     break;
1377
1378   case 184:
1379 #line 944 "perly.y" /* yacc.c:1646  */
1380     { (yyval.opval) = op_prepend_elem(OP_KVHSLICE,
1381                                 newOP(OP_PUSHMARK, 0),
1382                                     newLISTOP(OP_KVHSLICE, 0,
1383                                         list((ps[-2].val.opval)),
1384                                         ref((ps[-4].val.opval), OP_KVHSLICE)));
1385                           if ((yyval.opval) && (ps[-4].val.opval))
1386                               (yyval.opval)->op_private |=
1387                                   (ps[-4].val.opval)->op_private & OPpSLICEWARNING;
1388                         }
1389
1390     break;
1391
1392   case 185:
1393 #line 954 "perly.y" /* yacc.c:1646  */
1394     { (yyval.opval) = (ps[0].val.opval); }
1395
1396     break;
1397
1398   case 186:
1399 #line 956 "perly.y" /* yacc.c:1646  */
1400     { (yyval.opval) = newUNOP(OP_ENTERSUB, 0, scalar((ps[0].val.opval))); }
1401
1402     break;
1403
1404   case 187:
1405 #line 958 "perly.y" /* yacc.c:1646  */
1406     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[-2].val.opval)));
1407                         }
1408
1409     break;
1410
1411   case 188:
1412 #line 961 "perly.y" /* yacc.c:1646  */
1413     {
1414                           (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1415                                 op_append_elem(OP_LIST, (ps[-1].val.opval), scalar((ps[-3].val.opval))));
1416                         }
1417
1418     break;
1419
1420   case 189:
1421 #line 966 "perly.y" /* yacc.c:1646  */
1422     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1423                             op_append_elem(OP_LIST, (ps[0].val.opval), scalar((ps[-1].val.opval))));
1424                         }
1425
1426     break;
1427
1428   case 190:
1429 #line 970 "perly.y" /* yacc.c:1646  */
1430     { (yyval.opval) = newSVREF((ps[-3].val.opval)); }
1431
1432     break;
1433
1434   case 191:
1435 #line 972 "perly.y" /* yacc.c:1646  */
1436     { (yyval.opval) = newAVREF((ps[-3].val.opval)); }
1437
1438     break;
1439
1440   case 192:
1441 #line 974 "perly.y" /* yacc.c:1646  */
1442     { (yyval.opval) = newHVREF((ps[-3].val.opval)); }
1443
1444     break;
1445
1446   case 193:
1447 #line 976 "perly.y" /* yacc.c:1646  */
1448     { (yyval.opval) = newUNOP(OP_ENTERSUB, 0,
1449                                        scalar(newCVREF((ps[-1].val.ival),(ps[-3].val.opval)))); }
1450
1451     break;
1452
1453   case 194:
1454 #line 979 "perly.y" /* yacc.c:1646  */
1455     { (yyval.opval) = newGVREF(0,(ps[-3].val.opval)); }
1456
1457     break;
1458
1459   case 195:
1460 #line 981 "perly.y" /* yacc.c:1646  */
1461     { (yyval.opval) = newOP((ps[0].val.ival), OPf_SPECIAL);
1462                             PL_hints |= HINT_BLOCK_SCOPE; }
1463
1464     break;
1465
1466   case 196:
1467 #line 984 "perly.y" /* yacc.c:1646  */
1468     { (yyval.opval) = newLOOPEX((ps[-1].val.ival),(ps[0].val.opval)); }
1469
1470     break;
1471
1472   case 197:
1473 #line 986 "perly.y" /* yacc.c:1646  */
1474     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[0].val.opval))); }
1475
1476     break;
1477
1478   case 198:
1479 #line 988 "perly.y" /* yacc.c:1646  */
1480     { (yyval.opval) = newOP((ps[0].val.ival), 0); }
1481
1482     break;
1483
1484   case 199:
1485 #line 990 "perly.y" /* yacc.c:1646  */
1486     { (yyval.opval) = newUNOP((ps[-1].val.ival), 0, (ps[0].val.opval)); }
1487
1488     break;
1489
1490   case 200:
1491 #line 992 "perly.y" /* yacc.c:1646  */
1492     { (yyval.opval) = newUNOP((ps[-1].val.ival), 0, (ps[0].val.opval)); }
1493
1494     break;
1495
1496   case 201:
1497 #line 994 "perly.y" /* yacc.c:1646  */
1498     { (yyval.opval) = newOP(OP_REQUIRE, (ps[0].val.ival) ? OPf_SPECIAL : 0); }
1499
1500     break;
1501
1502   case 202:
1503 #line 996 "perly.y" /* yacc.c:1646  */
1504     { (yyval.opval) = newUNOP(OP_REQUIRE, (ps[-1].val.ival) ? OPf_SPECIAL : 0, (ps[0].val.opval)); }
1505
1506     break;
1507
1508   case 203:
1509 #line 998 "perly.y" /* yacc.c:1646  */
1510     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[0].val.opval))); }
1511
1512     break;
1513
1514   case 204:
1515 #line 1000 "perly.y" /* yacc.c:1646  */
1516     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1517                             op_append_elem(OP_LIST, (ps[0].val.opval), scalar((ps[-1].val.opval)))); }
1518
1519     break;
1520
1521   case 205:
1522 #line 1003 "perly.y" /* yacc.c:1646  */
1523     { (yyval.opval) = newOP((ps[0].val.ival), 0); }
1524
1525     break;
1526
1527   case 206:
1528 #line 1005 "perly.y" /* yacc.c:1646  */
1529     { (yyval.opval) = newOP((ps[-2].val.ival), 0);}
1530
1531     break;
1532
1533   case 207:
1534 #line 1007 "perly.y" /* yacc.c:1646  */
1535     { (yyval.opval) = (ps[0].val.opval); }
1536
1537     break;
1538
1539   case 208:
1540 #line 1009 "perly.y" /* yacc.c:1646  */
1541     { (yyval.opval) = (ps[-2].val.opval); }
1542
1543     break;
1544
1545   case 209:
1546 #line 1011 "perly.y" /* yacc.c:1646  */
1547     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[0].val.opval))); }
1548
1549     break;
1550
1551   case 210:
1552 #line 1013 "perly.y" /* yacc.c:1646  */
1553     { (yyval.opval) = ((ps[-2].val.ival) == OP_NOT)
1554                           ? newUNOP((ps[-2].val.ival), 0, newSVOP(OP_CONST, 0, newSViv(0)))
1555                           : newOP((ps[-2].val.ival), OPf_SPECIAL); }
1556
1557     break;
1558
1559   case 211:
1560 #line 1017 "perly.y" /* yacc.c:1646  */
1561     { (yyval.opval) = newUNOP((ps[-3].val.ival), 0, (ps[-1].val.opval)); }
1562
1563     break;
1564
1565   case 212:
1566 #line 1019 "perly.y" /* yacc.c:1646  */
1567     {
1568                             if (   (ps[0].val.opval)->op_type != OP_TRANS
1569                                 && (ps[0].val.opval)->op_type != OP_TRANSR
1570                                 && (((PMOP*)(ps[0].val.opval))->op_pmflags & PMf_HAS_CV))
1571                             {
1572                                 (yyval.ival) = start_subparse(FALSE, CVf_ANON);
1573                                 SAVEFREESV(PL_compcv);
1574                             } else
1575                                 (yyval.ival) = 0;
1576                         }
1577
1578     break;
1579
1580   case 213:
1581 #line 1030 "perly.y" /* yacc.c:1646  */
1582     { (yyval.opval) = pmruntime((ps[-5].val.opval), (ps[-2].val.opval), (ps[-1].val.opval), 1, (ps[-4].val.ival)); }
1583
1584     break;
1585
1586   case 216:
1587 #line 1034 "perly.y" /* yacc.c:1646  */
1588     {
1589                           (yyval.opval) = newLISTOP(OP_DIE, 0, newOP(OP_PUSHMARK, 0),
1590                                 newSVOP(OP_CONST, 0, newSVpvs("Unimplemented")));
1591                         }
1592
1593     break;
1594
1595   case 218:
1596 #line 1043 "perly.y" /* yacc.c:1646  */
1597     { (yyval.opval) = my_attrs((ps[-1].val.opval),(ps[0].val.opval)); }
1598
1599     break;
1600
1601   case 219:
1602 #line 1045 "perly.y" /* yacc.c:1646  */
1603     { (yyval.opval) = localize((ps[0].val.opval),1); }
1604
1605     break;
1606
1607   case 220:
1608 #line 1047 "perly.y" /* yacc.c:1646  */
1609     { (yyval.opval) = newUNOP(OP_REFGEN, 0, my_attrs((ps[-1].val.opval),(ps[0].val.opval))); }
1610
1611     break;
1612
1613   case 221:
1614 #line 1052 "perly.y" /* yacc.c:1646  */
1615     { (yyval.opval) = sawparens((ps[-1].val.opval)); }
1616
1617     break;
1618
1619   case 222:
1620 #line 1054 "perly.y" /* yacc.c:1646  */
1621     { (yyval.opval) = sawparens(newNULLLIST()); }
1622
1623     break;
1624
1625   case 223:
1626 #line 1057 "perly.y" /* yacc.c:1646  */
1627     { (yyval.opval) = (ps[0].val.opval); }
1628
1629     break;
1630
1631   case 224:
1632 #line 1059 "perly.y" /* yacc.c:1646  */
1633     { (yyval.opval) = (ps[0].val.opval); }
1634
1635     break;
1636
1637   case 225:
1638 #line 1061 "perly.y" /* yacc.c:1646  */
1639     { (yyval.opval) = (ps[0].val.opval); }
1640
1641     break;
1642
1643   case 226:
1644 #line 1066 "perly.y" /* yacc.c:1646  */
1645     { (yyval.opval) = (OP*)NULL; }
1646
1647     break;
1648
1649   case 227:
1650 #line 1068 "perly.y" /* yacc.c:1646  */
1651     { (yyval.opval) = (ps[0].val.opval); }
1652
1653     break;
1654
1655   case 228:
1656 #line 1072 "perly.y" /* yacc.c:1646  */
1657     { (yyval.opval) = (OP*)NULL; }
1658
1659     break;
1660
1661   case 229:
1662 #line 1074 "perly.y" /* yacc.c:1646  */
1663     { (yyval.opval) = (ps[0].val.opval); }
1664
1665     break;
1666
1667   case 230:
1668 #line 1078 "perly.y" /* yacc.c:1646  */
1669     { (yyval.opval) = (OP*)NULL; }
1670
1671     break;
1672
1673   case 231:
1674 #line 1080 "perly.y" /* yacc.c:1646  */
1675     { (yyval.opval) = (ps[0].val.opval); }
1676
1677     break;
1678
1679   case 232:
1680 #line 1086 "perly.y" /* yacc.c:1646  */
1681     { parser->in_my = 0; (yyval.opval) = my((ps[0].val.opval)); }
1682
1683     break;
1684
1685   case 240:
1686 #line 1103 "perly.y" /* yacc.c:1646  */
1687     { (yyval.opval) = newCVREF((ps[-1].val.ival),(ps[0].val.opval)); }
1688
1689     break;
1690
1691   case 241:
1692 #line 1107 "perly.y" /* yacc.c:1646  */
1693     { (yyval.opval) = newSVREF((ps[0].val.opval)); }
1694
1695     break;
1696
1697   case 242:
1698 #line 1111 "perly.y" /* yacc.c:1646  */
1699     { (yyval.opval) = newAVREF((ps[0].val.opval));
1700                           if ((yyval.opval)) (yyval.opval)->op_private |= (ps[-1].val.ival);
1701                         }
1702
1703     break;
1704
1705   case 243:
1706 #line 1117 "perly.y" /* yacc.c:1646  */
1707     { (yyval.opval) = newHVREF((ps[0].val.opval));
1708                           if ((yyval.opval)) (yyval.opval)->op_private |= (ps[-1].val.ival);
1709                         }
1710
1711     break;
1712
1713   case 244:
1714 #line 1123 "perly.y" /* yacc.c:1646  */
1715     { (yyval.opval) = newAVREF((ps[0].val.opval)); }
1716
1717     break;
1718
1719   case 245:
1720 #line 1125 "perly.y" /* yacc.c:1646  */
1721     { (yyval.opval) = newAVREF((ps[-3].val.opval)); }
1722
1723     break;
1724
1725   case 246:
1726 #line 1129 "perly.y" /* yacc.c:1646  */
1727     { (yyval.opval) = newGVREF(0,(ps[0].val.opval)); }
1728
1729     break;
1730
1731   case 248:
1732 #line 1134 "perly.y" /* yacc.c:1646  */
1733     { (yyval.opval) = newAVREF((ps[-2].val.opval)); }
1734
1735     break;
1736
1737   case 250:
1738 #line 1139 "perly.y" /* yacc.c:1646  */
1739     { (yyval.opval) = newHVREF((ps[-2].val.opval)); }
1740
1741     break;
1742
1743   case 252:
1744 #line 1144 "perly.y" /* yacc.c:1646  */
1745     { (yyval.opval) = newGVREF(0,(ps[-2].val.opval)); }
1746
1747     break;
1748
1749   case 253:
1750 #line 1149 "perly.y" /* yacc.c:1646  */
1751     { (yyval.opval) = scalar((ps[0].val.opval)); }
1752
1753     break;
1754
1755   case 254:
1756 #line 1151 "perly.y" /* yacc.c:1646  */
1757     { (yyval.opval) = scalar((ps[0].val.opval)); }
1758
1759     break;
1760
1761   case 255:
1762 #line 1153 "perly.y" /* yacc.c:1646  */
1763     { (yyval.opval) = op_scope((ps[0].val.opval)); }
1764
1765     break;
1766
1767   case 256:
1768 #line 1156 "perly.y" /* yacc.c:1646  */
1769     { (yyval.opval) = (ps[0].val.opval); }
1770
1771     break;
1772
1773
1774
1775       default: break;
1776     
1777
1778 /* Generated from:
1779  * fba24dfc68a3a84c9ae95cb9e14cc156ac487e6f3228cdf84c166d3cd820e59a perly.y
1780  * 3e1dff60f26df8933d7aed0c0e87177a0f022c14800c0707eb62a7db4196ac98 regen_perly.pl
1781  * ex: set ro: */