This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
[perl #77452] Deparse { ...; BEGIN{} } correctly
[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"
9     {
10                           parser->expect = XSTATE;
11                         ;}
12     break;
13
14   case 3:
15 #line 119 "perly.y"
16     {
17                           newPROG(block_end((ps[(3) - (4)].val.ival),(ps[(4) - (4)].val.opval)));
18                           PL_compiling.cop_seq = 0;
19                           (yyval.ival) = 0;
20                         ;}
21     break;
22
23   case 4:
24 #line 125 "perly.y"
25     {
26                           parser->expect = XTERM;
27                         ;}
28     break;
29
30   case 5:
31 #line 129 "perly.y"
32     {
33                           PL_eval_root = (ps[(3) - (3)].val.opval);
34                           (yyval.ival) = 0;
35                         ;}
36     break;
37
38   case 6:
39 #line 134 "perly.y"
40     {
41                           parser->expect = XBLOCK;
42                         ;}
43     break;
44
45   case 7:
46 #line 138 "perly.y"
47     {
48                           PL_pad_reset_pending = TRUE;
49                           PL_eval_root = (ps[(3) - (3)].val.opval);
50                           (yyval.ival) = 0;
51                           yyunlex();
52                           parser->yychar = YYEOF;
53                         ;}
54     break;
55
56   case 8:
57 #line 146 "perly.y"
58     {
59                           parser->expect = XSTATE;
60                         ;}
61     break;
62
63   case 9:
64 #line 150 "perly.y"
65     {
66                           PL_pad_reset_pending = TRUE;
67                           PL_eval_root = (ps[(3) - (3)].val.opval);
68                           (yyval.ival) = 0;
69                           yyunlex();
70                           parser->yychar = YYEOF;
71                         ;}
72     break;
73
74   case 10:
75 #line 158 "perly.y"
76     {
77                           parser->expect = XSTATE;
78                         ;}
79     break;
80
81   case 11:
82 #line 162 "perly.y"
83     {
84                           PL_pad_reset_pending = TRUE;
85                           PL_eval_root = (ps[(3) - (3)].val.opval);
86                           (yyval.ival) = 0;
87                           yyunlex();
88                           parser->yychar = YYEOF;
89                         ;}
90     break;
91
92   case 12:
93 #line 170 "perly.y"
94     {
95                           parser->expect = XSTATE;
96                         ;}
97     break;
98
99   case 13:
100 #line 174 "perly.y"
101     {
102                           PL_eval_root = (ps[(3) - (3)].val.opval);
103                           (yyval.ival) = 0;
104                         ;}
105     break;
106
107   case 14:
108 #line 182 "perly.y"
109     { if (parser->copline > (line_t)(ps[(1) - (4)].val.ival))
110                               parser->copline = (line_t)(ps[(1) - (4)].val.ival);
111                           (yyval.opval) = block_end((ps[(2) - (4)].val.ival), (ps[(3) - (4)].val.opval));
112                         ;}
113     break;
114
115   case 15:
116 #line 190 "perly.y"
117     { if (parser->copline > (line_t)(ps[(1) - (7)].val.ival))
118                               parser->copline = (line_t)(ps[(1) - (7)].val.ival);
119                           (yyval.opval) = block_end((ps[(2) - (7)].val.ival), (ps[(5) - (7)].val.opval));
120                         ;}
121     break;
122
123   case 16:
124 #line 197 "perly.y"
125     { (yyval.ival) = block_start(TRUE);
126                           parser->parsed_sub = 0; ;}
127     break;
128
129   case 17:
130 #line 202 "perly.y"
131     { if (parser->copline > (line_t)(ps[(1) - (4)].val.ival))
132                               parser->copline = (line_t)(ps[(1) - (4)].val.ival);
133                           (yyval.opval) = block_end((ps[(2) - (4)].val.ival), (ps[(3) - (4)].val.opval));
134                         ;}
135     break;
136
137   case 18:
138 #line 209 "perly.y"
139     { (yyval.ival) = block_start(FALSE);
140                           parser->parsed_sub = 0; ;}
141     break;
142
143   case 19:
144 #line 215 "perly.y"
145     { (yyval.opval) = (OP*)NULL; ;}
146     break;
147
148   case 20:
149 #line 217 "perly.y"
150     {   (yyval.opval) = op_append_list(OP_LINESEQ, (ps[(1) - (2)].val.opval), (ps[(2) - (2)].val.opval));
151                             PL_pad_reset_pending = TRUE;
152                             if ((ps[(1) - (2)].val.opval) && (ps[(2) - (2)].val.opval))
153                                 PL_hints |= HINT_BLOCK_SCOPE;
154                         ;}
155     break;
156
157   case 21:
158 #line 226 "perly.y"
159     { (yyval.opval) = (OP*)NULL; ;}
160     break;
161
162   case 22:
163 #line 228 "perly.y"
164     {   (yyval.opval) = op_append_list(OP_LINESEQ, (ps[(1) - (2)].val.opval), (ps[(2) - (2)].val.opval));
165                             PL_pad_reset_pending = TRUE;
166                             if ((ps[(1) - (2)].val.opval) && (ps[(2) - (2)].val.opval))
167                                 PL_hints |= HINT_BLOCK_SCOPE;
168                         ;}
169     break;
170
171   case 23:
172 #line 237 "perly.y"
173     {
174                           (yyval.opval) = (ps[(1) - (1)].val.opval) ? newSTATEOP(0, NULL, (ps[(1) - (1)].val.opval)) : NULL;
175                         ;}
176     break;
177
178   case 24:
179 #line 241 "perly.y"
180     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
181     break;
182
183   case 25:
184 #line 245 "perly.y"
185     {
186                           (yyval.opval) = newSTATEOP(SVf_UTF8 * (ps[(1) - (2)].val.pval)[strlen((ps[(1) - (2)].val.pval))+1], (ps[(1) - (2)].val.pval), (ps[(2) - (2)].val.opval));
187                         ;}
188     break;
189
190   case 26:
191 #line 249 "perly.y"
192     {
193                           (yyval.opval) = newSTATEOP(SVf_UTF8 * (ps[(1) - (2)].val.pval)[strlen((ps[(1) - (2)].val.pval))+1], (ps[(1) - (2)].val.pval), (ps[(2) - (2)].val.opval));
194                         ;}
195     break;
196
197   case 27:
198 #line 256 "perly.y"
199     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
200     break;
201
202   case 28:
203 #line 258 "perly.y"
204     {
205                           CV *fmtcv = PL_compcv;
206                           newFORM((ps[(2) - (4)].val.ival), (ps[(3) - (4)].val.opval), (ps[(4) - (4)].val.opval));
207                           (yyval.opval) = (OP*)NULL;
208                           if (CvOUTSIDE(fmtcv) && !CvEVAL(CvOUTSIDE(fmtcv))) {
209                               SvREFCNT_inc_simple_void(fmtcv);
210                               pad_add_anon(fmtcv, OP_NULL);
211                           }
212                         ;}
213     break;
214
215   case 29:
216 #line 268 "perly.y"
217     {
218                           if ((ps[(2) - (3)].val.opval)->op_type == OP_CONST) {
219                             const char *const name =
220                                 SvPV_nolen_const(((SVOP*)(ps[(2) - (3)].val.opval))->op_sv);
221                             if (strEQ(name, "BEGIN") || strEQ(name, "END")
222                               || strEQ(name, "INIT") || strEQ(name, "CHECK")
223                               || strEQ(name, "UNITCHECK"))
224                               CvSPECIAL_on(PL_compcv);
225                           }
226                           else
227                           /* State subs inside anonymous subs need to be
228                              clonable themselves. */
229                           if (CvANON(CvOUTSIDE(PL_compcv))
230                            || CvCLONE(CvOUTSIDE(PL_compcv))
231                            || !PadnameIsSTATE(PadlistNAMESARRAY(CvPADLIST(
232                                                 CvOUTSIDE(PL_compcv)
233                                              ))[(ps[(2) - (3)].val.opval)->op_targ]))
234                               CvCLONE_on(PL_compcv);
235                           parser->in_my = 0;
236                           parser->in_my_stash = NULL;
237                         ;}
238     break;
239
240   case 30:
241 #line 290 "perly.y"
242     {
243                           SvREFCNT_inc_simple_void(PL_compcv);
244                           (ps[(2) - (7)].val.opval)->op_type == OP_CONST
245                               ? newATTRSUB((ps[(3) - (7)].val.ival), (ps[(2) - (7)].val.opval), (ps[(5) - (7)].val.opval), (ps[(6) - (7)].val.opval), (ps[(7) - (7)].val.opval))
246                               : newMYSUB((ps[(3) - (7)].val.ival), (ps[(2) - (7)].val.opval), (ps[(5) - (7)].val.opval), (ps[(6) - (7)].val.opval), (ps[(7) - (7)].val.opval))
247                           ;
248                           (yyval.opval) = (OP*)NULL;
249                           intro_my();
250                           parser->parsed_sub = 1;
251                         ;}
252     break;
253
254   case 31:
255 #line 301 "perly.y"
256     {
257                           package((ps[(3) - (4)].val.opval));
258                           if ((ps[(2) - (4)].val.opval))
259                               package_version((ps[(2) - (4)].val.opval));
260                           (yyval.opval) = (OP*)NULL;
261                         ;}
262     break;
263
264   case 32:
265 #line 308 "perly.y"
266     { CvSPECIAL_on(PL_compcv); /* It's a BEGIN {} */ ;}
267     break;
268
269   case 33:
270 #line 310 "perly.y"
271     {
272                           SvREFCNT_inc_simple_void(PL_compcv);
273                           utilize((ps[(1) - (7)].val.ival), (ps[(2) - (7)].val.ival), (ps[(4) - (7)].val.opval), (ps[(5) - (7)].val.opval), (ps[(6) - (7)].val.opval));
274                           parser->parsed_sub = 1;
275                           (yyval.opval) = (OP*)NULL;
276                         ;}
277     break;
278
279   case 34:
280 #line 317 "perly.y"
281     {
282                           (yyval.opval) = block_end((ps[(3) - (7)].val.ival),
283                               newCONDOP(0, (ps[(4) - (7)].val.opval), op_scope((ps[(6) - (7)].val.opval)), (ps[(7) - (7)].val.opval)));
284                           parser->copline = (line_t)(ps[(1) - (7)].val.ival);
285                         ;}
286     break;
287
288   case 35:
289 #line 323 "perly.y"
290     {
291                           (yyval.opval) = block_end((ps[(3) - (7)].val.ival),
292                               newCONDOP(0, (ps[(4) - (7)].val.opval), op_scope((ps[(6) - (7)].val.opval)), (ps[(7) - (7)].val.opval)));
293                           parser->copline = (line_t)(ps[(1) - (7)].val.ival);
294                         ;}
295     break;
296
297   case 36:
298 #line 329 "perly.y"
299     {
300                           const PADOFFSET offset = pad_findmy_pvs("$_", 0);
301                           (yyval.opval) = block_end((ps[(3) - (6)].val.ival),
302                                   newGIVENOP((ps[(4) - (6)].val.opval), op_scope((ps[(6) - (6)].val.opval)),
303                                     offset == NOT_IN_PAD
304                                     || PAD_COMPNAME_FLAGS_isOUR(offset)
305                                       ? 0
306                                       : offset));
307                           parser->copline = (line_t)(ps[(1) - (6)].val.ival);
308                         ;}
309     break;
310
311   case 37:
312 #line 340 "perly.y"
313     { (yyval.opval) = block_end((ps[(3) - (6)].val.ival), newWHENOP((ps[(4) - (6)].val.opval), op_scope((ps[(6) - (6)].val.opval)))); ;}
314     break;
315
316   case 38:
317 #line 342 "perly.y"
318     { (yyval.opval) = newWHENOP(0, op_scope((ps[(2) - (2)].val.opval))); ;}
319     break;
320
321   case 39:
322 #line 344 "perly.y"
323     {
324                           (yyval.opval) = block_end((ps[(3) - (8)].val.ival),
325                                   newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
326                                       (ps[(4) - (8)].val.opval), (ps[(7) - (8)].val.opval), (ps[(8) - (8)].val.opval), (ps[(6) - (8)].val.ival)));
327                           parser->copline = (line_t)(ps[(1) - (8)].val.ival);
328                         ;}
329     break;
330
331   case 40:
332 #line 351 "perly.y"
333     {
334                           (yyval.opval) = block_end((ps[(3) - (8)].val.ival),
335                                   newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
336                                       (ps[(4) - (8)].val.opval), (ps[(7) - (8)].val.opval), (ps[(8) - (8)].val.opval), (ps[(6) - (8)].val.ival)));
337                           parser->copline = (line_t)(ps[(1) - (8)].val.ival);
338                         ;}
339     break;
340
341   case 41:
342 #line 358 "perly.y"
343     { parser->expect = XTERM; ;}
344     break;
345
346   case 42:
347 #line 360 "perly.y"
348     { parser->expect = XTERM; ;}
349     break;
350
351   case 43:
352 #line 363 "perly.y"
353     {
354                           OP *initop = (ps[(4) - (13)].val.opval);
355                           OP *forop = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
356                                       scalar((ps[(7) - (13)].val.opval)), (ps[(13) - (13)].val.opval), (ps[(11) - (13)].val.opval), (ps[(10) - (13)].val.ival));
357                           if (initop) {
358                               forop = op_prepend_elem(OP_LINESEQ, initop,
359                                   op_append_elem(OP_LINESEQ,
360                                       newOP(OP_UNSTACK, OPf_SPECIAL),
361                                       forop));
362                           }
363                           (yyval.opval) = block_end((ps[(3) - (13)].val.ival), forop);
364                           parser->copline = (line_t)(ps[(1) - (13)].val.ival);
365                         ;}
366     break;
367
368   case 44:
369 #line 377 "perly.y"
370     {
371                           (yyval.opval) = block_end((ps[(3) - (9)].val.ival), newFOROP(0, (ps[(4) - (9)].val.opval), (ps[(6) - (9)].val.opval), (ps[(8) - (9)].val.opval), (ps[(9) - (9)].val.opval)));
372                           parser->copline = (line_t)(ps[(1) - (9)].val.ival);
373                         ;}
374     break;
375
376   case 45:
377 #line 382 "perly.y"
378     {
379                           (yyval.opval) = block_end((ps[(4) - (8)].val.ival), newFOROP(0,
380                                       op_lvalue((ps[(2) - (8)].val.opval), OP_ENTERLOOP), (ps[(5) - (8)].val.opval), (ps[(7) - (8)].val.opval), (ps[(8) - (8)].val.opval)));
381                           parser->copline = (line_t)(ps[(1) - (8)].val.ival);
382                         ;}
383     break;
384
385   case 46:
386 #line 388 "perly.y"
387     { parser->in_my = 0; (yyval.opval) = my((ps[(5) - (5)].val.opval)); ;}
388     break;
389
390   case 47:
391 #line 390 "perly.y"
392     {
393                           (yyval.opval) = block_end(
394                                 (ps[(4) - (11)].val.ival),
395                                 newFOROP(0,
396                                          op_lvalue(
397                                             newUNOP(OP_REFGEN, 0,
398                                                     (ps[(6) - (11)].val.opval)),
399                                             OP_ENTERLOOP),
400                                          (ps[(8) - (11)].val.opval), (ps[(10) - (11)].val.opval), (ps[(11) - (11)].val.opval))
401                           );
402                           parser->copline = (line_t)(ps[(1) - (11)].val.ival);
403                         ;}
404     break;
405
406   case 48:
407 #line 403 "perly.y"
408     {
409                           (yyval.opval) = block_end((ps[(5) - (9)].val.ival), newFOROP(
410                                 0, op_lvalue(newUNOP(OP_REFGEN, 0,
411                                                      (ps[(3) - (9)].val.opval)),
412                                              OP_ENTERLOOP), (ps[(6) - (9)].val.opval), (ps[(8) - (9)].val.opval), (ps[(9) - (9)].val.opval)));
413                           parser->copline = (line_t)(ps[(1) - (9)].val.ival);
414                         ;}
415     break;
416
417   case 49:
418 #line 411 "perly.y"
419     {
420                           (yyval.opval) = block_end((ps[(3) - (7)].val.ival),
421                                   newFOROP(0, (OP*)NULL, (ps[(4) - (7)].val.opval), (ps[(6) - (7)].val.opval), (ps[(7) - (7)].val.opval)));
422                           parser->copline = (line_t)(ps[(1) - (7)].val.ival);
423                         ;}
424     break;
425
426   case 50:
427 #line 417 "perly.y"
428     {
429                           /* a block is a loop that happens once */
430                           (yyval.opval) = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
431                                   (OP*)NULL, (ps[(1) - (2)].val.opval), (ps[(2) - (2)].val.opval), 0);
432                         ;}
433     break;
434
435   case 51:
436 #line 423 "perly.y"
437     {
438                           package((ps[(3) - (5)].val.opval));
439                           if ((ps[(2) - (5)].val.opval)) {
440                               package_version((ps[(2) - (5)].val.opval));
441                           }
442                         ;}
443     break;
444
445   case 52:
446 #line 430 "perly.y"
447     {
448                           /* a block is a loop that happens once */
449                           (yyval.opval) = newWHILEOP(0, 1, (LOOP*)(OP*)NULL,
450                                   (OP*)NULL, block_end((ps[(5) - (8)].val.ival), (ps[(7) - (8)].val.opval)), (OP*)NULL, 0);
451                           if (parser->copline > (line_t)(ps[(4) - (8)].val.ival))
452                               parser->copline = (line_t)(ps[(4) - (8)].val.ival);
453                         ;}
454     break;
455
456   case 53:
457 #line 438 "perly.y"
458     {
459                           (yyval.opval) = (ps[(1) - (2)].val.opval);
460                         ;}
461     break;
462
463   case 54:
464 #line 442 "perly.y"
465     {
466                           (yyval.opval) = (OP*)NULL;
467                           parser->copline = NOLINE;
468                         ;}
469     break;
470
471   case 55:
472 #line 450 "perly.y"
473     { OP *list;
474                           if ((ps[(2) - (2)].val.opval)) {
475                               OP *term = (ps[(2) - (2)].val.opval);
476                               list = op_append_elem(OP_LIST, (ps[(1) - (2)].val.opval), term);
477                           }
478                           else {
479                               list = (ps[(1) - (2)].val.opval);
480                           }
481                           if (parser->copline == NOLINE)
482                                parser->copline = CopLINE(PL_curcop)-1;
483                           else parser->copline--;
484                           (yyval.opval) = newSTATEOP(0, NULL,
485                                           op_convert_list(OP_FORMLINE, 0, list));
486                         ;}
487     break;
488
489   case 56:
490 #line 467 "perly.y"
491     { (yyval.opval) = NULL; ;}
492     break;
493
494   case 57:
495 #line 469 "perly.y"
496     { (yyval.opval) = op_unscope((ps[(2) - (3)].val.opval)); ;}
497     break;
498
499   case 58:
500 #line 474 "perly.y"
501     { (yyval.opval) = (OP*)NULL; ;}
502     break;
503
504   case 59:
505 #line 476 "perly.y"
506     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
507     break;
508
509   case 60:
510 #line 478 "perly.y"
511     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval)); ;}
512     break;
513
514   case 61:
515 #line 480 "perly.y"
516     { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval)); ;}
517     break;
518
519   case 62:
520 #line 482 "perly.y"
521     { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, scalar((ps[(3) - (3)].val.opval)), (ps[(1) - (3)].val.opval)); ;}
522     break;
523
524   case 63:
525 #line 484 "perly.y"
526     { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval)); ;}
527     break;
528
529   case 64:
530 #line 486 "perly.y"
531     { (yyval.opval) = newFOROP(0, (OP*)NULL, (ps[(3) - (3)].val.opval), (ps[(1) - (3)].val.opval), (OP*)NULL);
532                           parser->copline = (line_t)(ps[(2) - (3)].val.ival); ;}
533     break;
534
535   case 65:
536 #line 489 "perly.y"
537     { (yyval.opval) = newWHENOP((ps[(3) - (3)].val.opval), op_scope((ps[(1) - (3)].val.opval))); ;}
538     break;
539
540   case 66:
541 #line 494 "perly.y"
542     { (yyval.opval) = (OP*)NULL; ;}
543     break;
544
545   case 67:
546 #line 496 "perly.y"
547     {
548                           ((ps[(2) - (2)].val.opval))->op_flags |= OPf_PARENS;
549                           (yyval.opval) = op_scope((ps[(2) - (2)].val.opval));
550                         ;}
551     break;
552
553   case 68:
554 #line 501 "perly.y"
555     { parser->copline = (line_t)(ps[(1) - (6)].val.ival);
556                             (yyval.opval) = newCONDOP(0,
557                                 newSTATEOP(OPf_SPECIAL,NULL,(ps[(3) - (6)].val.opval)),
558                                 op_scope((ps[(5) - (6)].val.opval)), (ps[(6) - (6)].val.opval));
559                           PL_hints |= HINT_BLOCK_SCOPE;
560                         ;}
561     break;
562
563   case 69:
564 #line 511 "perly.y"
565     { (yyval.opval) = (OP*)NULL; ;}
566     break;
567
568   case 70:
569 #line 513 "perly.y"
570     { (yyval.opval) = op_scope((ps[(2) - (2)].val.opval)); ;}
571     break;
572
573   case 71:
574 #line 518 "perly.y"
575     { (yyval.ival) = (PL_min_intro_pending &&
576                             PL_max_intro_pending >=  PL_min_intro_pending);
577                           intro_my(); ;}
578     break;
579
580   case 72:
581 #line 524 "perly.y"
582     { (yyval.opval) = (OP*)NULL; ;}
583     break;
584
585   case 74:
586 #line 530 "perly.y"
587     { YYSTYPE tmplval;
588                           (void)scan_num("1", &tmplval);
589                           (yyval.opval) = tmplval.opval; ;}
590     break;
591
592   case 76:
593 #line 538 "perly.y"
594     { (yyval.opval) = invert(scalar((ps[(1) - (1)].val.opval))); ;}
595     break;
596
597   case 77:
598 #line 543 "perly.y"
599     { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); ;}
600     break;
601
602   case 78:
603 #line 547 "perly.y"
604     { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); ;}
605     break;
606
607   case 79:
608 #line 551 "perly.y"
609     { (yyval.opval) = (ps[(1) - (1)].val.opval); intro_my(); ;}
610     break;
611
612   case 80:
613 #line 554 "perly.y"
614     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
615     break;
616
617   case 81:
618 #line 555 "perly.y"
619     { (yyval.opval) = (OP*)NULL; ;}
620     break;
621
622   case 82:
623 #line 559 "perly.y"
624     { (yyval.ival) = start_subparse(FALSE, 0);
625                             SAVEFREESV(PL_compcv); ;}
626     break;
627
628   case 83:
629 #line 565 "perly.y"
630     { (yyval.ival) = start_subparse(FALSE, CVf_ANON);
631                             SAVEFREESV(PL_compcv); ;}
632     break;
633
634   case 84:
635 #line 570 "perly.y"
636     { (yyval.ival) = start_subparse(TRUE, 0);
637                             SAVEFREESV(PL_compcv); ;}
638     break;
639
640   case 87:
641 #line 581 "perly.y"
642     { (yyval.opval) = (OP*)NULL; ;}
643     break;
644
645   case 89:
646 #line 587 "perly.y"
647     { (yyval.opval) = (OP*)NULL; ;}
648     break;
649
650   case 90:
651 #line 589 "perly.y"
652     { (yyval.opval) = (ps[(2) - (2)].val.opval); ;}
653     break;
654
655   case 91:
656 #line 591 "perly.y"
657     { (yyval.opval) = (OP*)NULL; ;}
658     break;
659
660   case 92:
661 #line 596 "perly.y"
662     { (yyval.opval) = (ps[(2) - (2)].val.opval); ;}
663     break;
664
665   case 93:
666 #line 598 "perly.y"
667     { (yyval.opval) = (OP*)NULL; ;}
668     break;
669
670   case 94:
671 #line 602 "perly.y"
672     { (yyval.opval) = (OP*)NULL; ;}
673     break;
674
675   case 95:
676 #line 604 "perly.y"
677     {
678                           if (!FEATURE_SIGNATURES_IS_ENABLED)
679                             Perl_croak(aTHX_ "Experimental "
680                                 "subroutine signatures not enabled");
681                           Perl_ck_warner_d(aTHX_
682                                 packWARN(WARN_EXPERIMENTAL__SIGNATURES),
683                                 "The signatures feature is experimental");
684                           (yyval.opval) = parse_subsignature();
685                         ;}
686     break;
687
688   case 96:
689 #line 614 "perly.y"
690     {
691                           (yyval.opval) = op_append_list(OP_LINESEQ, (ps[(2) - (3)].val.opval),
692                                 newSTATEOP(0, NULL, sawparens(newNULLLIST())));
693                           parser->expect = XBLOCK;
694                         ;}
695     break;
696
697   case 97:
698 #line 623 "perly.y"
699     {
700                           if (parser->copline > (line_t)(ps[(3) - (5)].val.ival))
701                               parser->copline = (line_t)(ps[(3) - (5)].val.ival);
702                           (yyval.opval) = block_end((ps[(1) - (5)].val.ival),
703                                 op_append_list(OP_LINESEQ, (ps[(2) - (5)].val.opval), (ps[(4) - (5)].val.opval)));
704                         ;}
705     break;
706
707   case 98:
708 #line 632 "perly.y"
709     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
710     break;
711
712   case 99:
713 #line 633 "perly.y"
714     { (yyval.opval) = (OP*)NULL; ;}
715     break;
716
717   case 100:
718 #line 638 "perly.y"
719     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
720     break;
721
722   case 101:
723 #line 640 "perly.y"
724     { (yyval.opval) = newLOGOP((ps[(2) - (3)].val.ival), 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
725     break;
726
727   case 102:
728 #line 642 "perly.y"
729     { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
730     break;
731
732   case 104:
733 #line 648 "perly.y"
734     { (yyval.opval) = (ps[(1) - (2)].val.opval); ;}
735     break;
736
737   case 105:
738 #line 650 "perly.y"
739     { 
740                           OP* term = (ps[(3) - (3)].val.opval);
741                           (yyval.opval) = op_append_elem(OP_LIST, (ps[(1) - (3)].val.opval), term);
742                         ;}
743     break;
744
745   case 107:
746 #line 659 "perly.y"
747     { (yyval.opval) = op_convert_list((ps[(1) - (3)].val.ival), OPf_STACKED,
748                                 op_prepend_elem(OP_LIST, newGVREF((ps[(1) - (3)].val.ival),(ps[(2) - (3)].val.opval)), (ps[(3) - (3)].val.opval)) );
749                         ;}
750     break;
751
752   case 108:
753 #line 663 "perly.y"
754     { (yyval.opval) = op_convert_list((ps[(1) - (5)].val.ival), OPf_STACKED,
755                                 op_prepend_elem(OP_LIST, newGVREF((ps[(1) - (5)].val.ival),(ps[(3) - (5)].val.opval)), (ps[(4) - (5)].val.opval)) );
756                         ;}
757     break;
758
759   case 109:
760 #line 667 "perly.y"
761     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
762                                 op_append_elem(OP_LIST,
763                                     op_prepend_elem(OP_LIST, scalar((ps[(1) - (6)].val.opval)), (ps[(5) - (6)].val.opval)),
764                                     newMETHOP(OP_METHOD, 0, (ps[(3) - (6)].val.opval))));
765                         ;}
766     break;
767
768   case 110:
769 #line 673 "perly.y"
770     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
771                                 op_append_elem(OP_LIST, scalar((ps[(1) - (3)].val.opval)),
772                                     newMETHOP(OP_METHOD, 0, (ps[(3) - (3)].val.opval))));
773                         ;}
774     break;
775
776   case 111:
777 #line 678 "perly.y"
778     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
779                                 op_append_elem(OP_LIST,
780                                     op_prepend_elem(OP_LIST, (ps[(2) - (3)].val.opval), (ps[(3) - (3)].val.opval)),
781                                     newMETHOP(OP_METHOD, 0, (ps[(1) - (3)].val.opval))));
782                         ;}
783     break;
784
785   case 112:
786 #line 684 "perly.y"
787     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
788                                 op_append_elem(OP_LIST,
789                                     op_prepend_elem(OP_LIST, (ps[(2) - (5)].val.opval), (ps[(4) - (5)].val.opval)),
790                                     newMETHOP(OP_METHOD, 0, (ps[(1) - (5)].val.opval))));
791                         ;}
792     break;
793
794   case 113:
795 #line 690 "perly.y"
796     { (yyval.opval) = op_convert_list((ps[(1) - (2)].val.ival), 0, (ps[(2) - (2)].val.opval)); ;}
797     break;
798
799   case 114:
800 #line 692 "perly.y"
801     { (yyval.opval) = op_convert_list((ps[(1) - (4)].val.ival), 0, (ps[(3) - (4)].val.opval)); ;}
802     break;
803
804   case 115:
805 #line 694 "perly.y"
806     { SvREFCNT_inc_simple_void(PL_compcv);
807                           (yyval.opval) = newANONATTRSUB((ps[(2) - (3)].val.ival), 0, (OP*)NULL, (ps[(3) - (3)].val.opval)); ;}
808     break;
809
810   case 116:
811 #line 697 "perly.y"
812     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
813                                  op_append_elem(OP_LIST,
814                                    op_prepend_elem(OP_LIST, (ps[(4) - (5)].val.opval), (ps[(5) - (5)].val.opval)), (ps[(1) - (5)].val.opval)));
815                         ;}
816     break;
817
818   case 119:
819 #line 712 "perly.y"
820     { (yyval.opval) = newBINOP(OP_GELEM, 0, (ps[(1) - (5)].val.opval), scalar((ps[(3) - (5)].val.opval))); ;}
821     break;
822
823   case 120:
824 #line 714 "perly.y"
825     { (yyval.opval) = newBINOP(OP_AELEM, 0, oopsAV((ps[(1) - (4)].val.opval)), scalar((ps[(3) - (4)].val.opval)));
826                         ;}
827     break;
828
829   case 121:
830 #line 717 "perly.y"
831     { (yyval.opval) = newBINOP(OP_AELEM, 0,
832                                         ref(newAVREF((ps[(1) - (5)].val.opval)),OP_RV2AV),
833                                         scalar((ps[(4) - (5)].val.opval)));
834                         ;}
835     break;
836
837   case 122:
838 #line 722 "perly.y"
839     { (yyval.opval) = newBINOP(OP_AELEM, 0,
840                                         ref(newAVREF((ps[(1) - (4)].val.opval)),OP_RV2AV),
841                                         scalar((ps[(3) - (4)].val.opval)));
842                         ;}
843     break;
844
845   case 123:
846 #line 727 "perly.y"
847     { (yyval.opval) = newBINOP(OP_HELEM, 0, oopsHV((ps[(1) - (5)].val.opval)), jmaybe((ps[(3) - (5)].val.opval)));
848                         ;}
849     break;
850
851   case 124:
852 #line 730 "perly.y"
853     { (yyval.opval) = newBINOP(OP_HELEM, 0,
854                                         ref(newHVREF((ps[(1) - (6)].val.opval)),OP_RV2HV),
855                                         jmaybe((ps[(4) - (6)].val.opval))); ;}
856     break;
857
858   case 125:
859 #line 734 "perly.y"
860     { (yyval.opval) = newBINOP(OP_HELEM, 0,
861                                         ref(newHVREF((ps[(1) - (5)].val.opval)),OP_RV2HV),
862                                         jmaybe((ps[(3) - (5)].val.opval))); ;}
863     break;
864
865   case 126:
866 #line 738 "perly.y"
867     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
868                                    newCVREF(0, scalar((ps[(1) - (4)].val.opval)))); ;}
869     break;
870
871   case 127:
872 #line 741 "perly.y"
873     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
874                                    op_append_elem(OP_LIST, (ps[(4) - (5)].val.opval),
875                                        newCVREF(0, scalar((ps[(1) - (5)].val.opval))))); ;}
876     break;
877
878   case 128:
879 #line 746 "perly.y"
880     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
881                                    op_append_elem(OP_LIST, (ps[(3) - (4)].val.opval),
882                                                newCVREF(0, scalar((ps[(1) - (4)].val.opval))))); ;}
883     break;
884
885   case 129:
886 #line 750 "perly.y"
887     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
888                                    newCVREF(0, scalar((ps[(1) - (3)].val.opval)))); ;}
889     break;
890
891   case 130:
892 #line 753 "perly.y"
893     { (yyval.opval) = newSLICEOP(0, (ps[(5) - (6)].val.opval), (ps[(2) - (6)].val.opval)); ;}
894     break;
895
896   case 131:
897 #line 755 "perly.y"
898     { (yyval.opval) = newSLICEOP(0, (ps[(3) - (4)].val.opval), (ps[(1) - (4)].val.opval)); ;}
899     break;
900
901   case 132:
902 #line 757 "perly.y"
903     { (yyval.opval) = newSLICEOP(0, (ps[(4) - (5)].val.opval), (OP*)NULL); ;}
904     break;
905
906   case 133:
907 #line 762 "perly.y"
908     { (yyval.opval) = newASSIGNOP(OPf_STACKED, (ps[(1) - (3)].val.opval), (ps[(2) - (3)].val.ival), (ps[(3) - (3)].val.opval)); ;}
909     break;
910
911   case 134:
912 #line 764 "perly.y"
913     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
914     break;
915
916   case 135:
917 #line 766 "perly.y"
918     {   if ((ps[(2) - (3)].val.ival) != OP_REPEAT)
919                                 scalar((ps[(1) - (3)].val.opval));
920                             (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, (ps[(1) - (3)].val.opval), scalar((ps[(3) - (3)].val.opval)));
921                         ;}
922     break;
923
924   case 136:
925 #line 771 "perly.y"
926     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
927     break;
928
929   case 137:
930 #line 773 "perly.y"
931     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
932     break;
933
934   case 138:
935 #line 775 "perly.y"
936     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
937     break;
938
939   case 139:
940 #line 777 "perly.y"
941     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
942     break;
943
944   case 140:
945 #line 779 "perly.y"
946     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
947     break;
948
949   case 141:
950 #line 781 "perly.y"
951     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
952     break;
953
954   case 142:
955 #line 783 "perly.y"
956     { (yyval.opval) = newRANGE((ps[(2) - (3)].val.ival), scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
957     break;
958
959   case 143:
960 #line 785 "perly.y"
961     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
962     break;
963
964   case 144:
965 #line 787 "perly.y"
966     { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
967     break;
968
969   case 145:
970 #line 789 "perly.y"
971     { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
972     break;
973
974   case 146:
975 #line 791 "perly.y"
976     { (yyval.opval) = bind_match((ps[(2) - (3)].val.ival), (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
977     break;
978
979   case 147:
980 #line 796 "perly.y"
981     { (yyval.opval) = newUNOP(OP_NEGATE, 0, scalar((ps[(2) - (2)].val.opval))); ;}
982     break;
983
984   case 148:
985 #line 798 "perly.y"
986     { (yyval.opval) = (ps[(2) - (2)].val.opval); ;}
987     break;
988
989   case 149:
990 #line 801 "perly.y"
991     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[(2) - (2)].val.opval))); ;}
992     break;
993
994   case 150:
995 #line 803 "perly.y"
996     { (yyval.opval) = newUNOP(OP_COMPLEMENT, 0, scalar((ps[(2) - (2)].val.opval))); ;}
997     break;
998
999   case 151:
1000 #line 805 "perly.y"
1001     { (yyval.opval) = newUNOP(OP_POSTINC, 0,
1002                                         op_lvalue(scalar((ps[(1) - (2)].val.opval)), OP_POSTINC)); ;}
1003     break;
1004
1005   case 152:
1006 #line 808 "perly.y"
1007     { (yyval.opval) = newUNOP(OP_POSTDEC, 0,
1008                                         op_lvalue(scalar((ps[(1) - (2)].val.opval)), OP_POSTDEC));;}
1009     break;
1010
1011   case 153:
1012 #line 811 "perly.y"
1013     { (yyval.opval) = op_convert_list(OP_JOIN, 0,
1014                                        op_append_elem(
1015                                         OP_LIST,
1016                                         newSVREF(scalar(
1017                                             newSVOP(OP_CONST,0,
1018                                                     newSVpvs("\""))
1019                                         )),
1020                                         (ps[(1) - (2)].val.opval)
1021                                        ));
1022                         ;}
1023     break;
1024
1025   case 154:
1026 #line 822 "perly.y"
1027     { (yyval.opval) = newUNOP(OP_PREINC, 0,
1028                                         op_lvalue(scalar((ps[(2) - (2)].val.opval)), OP_PREINC)); ;}
1029     break;
1030
1031   case 155:
1032 #line 825 "perly.y"
1033     { (yyval.opval) = newUNOP(OP_PREDEC, 0,
1034                                         op_lvalue(scalar((ps[(2) - (2)].val.opval)), OP_PREDEC)); ;}
1035     break;
1036
1037   case 156:
1038 #line 832 "perly.y"
1039     { (yyval.opval) = newANONLIST((ps[(2) - (3)].val.opval)); ;}
1040     break;
1041
1042   case 157:
1043 #line 834 "perly.y"
1044     { (yyval.opval) = newANONLIST((OP*)NULL);;}
1045     break;
1046
1047   case 158:
1048 #line 836 "perly.y"
1049     { (yyval.opval) = newANONHASH((ps[(2) - (4)].val.opval)); ;}
1050     break;
1051
1052   case 159:
1053 #line 838 "perly.y"
1054     { (yyval.opval) = newANONHASH((OP*)NULL); ;}
1055     break;
1056
1057   case 160:
1058 #line 840 "perly.y"
1059     { SvREFCNT_inc_simple_void(PL_compcv);
1060                           (yyval.opval) = newANONATTRSUB((ps[(2) - (5)].val.ival), (ps[(3) - (5)].val.opval), (ps[(4) - (5)].val.opval), (ps[(5) - (5)].val.opval)); ;}
1061     break;
1062
1063   case 161:
1064 #line 847 "perly.y"
1065     { (yyval.opval) = dofile((ps[(2) - (2)].val.opval), (ps[(1) - (2)].val.ival));;}
1066     break;
1067
1068   case 162:
1069 #line 849 "perly.y"
1070     { (yyval.opval) = newUNOP(OP_NULL, OPf_SPECIAL, op_scope((ps[(2) - (2)].val.opval)));;}
1071     break;
1072
1073   case 167:
1074 #line 857 "perly.y"
1075     { (yyval.opval) = newCONDOP(0, (ps[(1) - (5)].val.opval), (ps[(3) - (5)].val.opval), (ps[(5) - (5)].val.opval)); ;}
1076     break;
1077
1078   case 168:
1079 #line 859 "perly.y"
1080     { (yyval.opval) = newUNOP(OP_REFGEN, 0, op_lvalue((ps[(2) - (2)].val.opval),OP_REFGEN)); ;}
1081     break;
1082
1083   case 169:
1084 #line 861 "perly.y"
1085     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1086     break;
1087
1088   case 170:
1089 #line 863 "perly.y"
1090     { (yyval.opval) = localize((ps[(2) - (2)].val.opval),(ps[(1) - (2)].val.ival)); ;}
1091     break;
1092
1093   case 171:
1094 #line 865 "perly.y"
1095     { (yyval.opval) = sawparens((ps[(2) - (3)].val.opval)); ;}
1096     break;
1097
1098   case 172:
1099 #line 867 "perly.y"
1100     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1101     break;
1102
1103   case 173:
1104 #line 869 "perly.y"
1105     { (yyval.opval) = sawparens(newNULLLIST()); ;}
1106     break;
1107
1108   case 174:
1109 #line 871 "perly.y"
1110     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1111     break;
1112
1113   case 175:
1114 #line 873 "perly.y"
1115     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1116     break;
1117
1118   case 176:
1119 #line 875 "perly.y"
1120     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1121     break;
1122
1123   case 177:
1124 #line 877 "perly.y"
1125     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1126     break;
1127
1128   case 178:
1129 #line 879 "perly.y"
1130     { (yyval.opval) = newUNOP(OP_AV2ARYLEN, 0, ref((ps[(1) - (1)].val.opval), OP_AV2ARYLEN));;}
1131     break;
1132
1133   case 179:
1134 #line 881 "perly.y"
1135     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1136     break;
1137
1138   case 180:
1139 #line 883 "perly.y"
1140     { (yyval.opval) = op_prepend_elem(OP_ASLICE,
1141                                 newOP(OP_PUSHMARK, 0),
1142                                     newLISTOP(OP_ASLICE, 0,
1143                                         list((ps[(3) - (4)].val.opval)),
1144                                         ref((ps[(1) - (4)].val.opval), OP_ASLICE)));
1145                           if ((yyval.opval) && (ps[(1) - (4)].val.opval))
1146                               (yyval.opval)->op_private |=
1147                                   (ps[(1) - (4)].val.opval)->op_private & OPpSLICEWARNING;
1148                         ;}
1149     break;
1150
1151   case 181:
1152 #line 893 "perly.y"
1153     { (yyval.opval) = op_prepend_elem(OP_KVASLICE,
1154                                 newOP(OP_PUSHMARK, 0),
1155                                     newLISTOP(OP_KVASLICE, 0,
1156                                         list((ps[(3) - (4)].val.opval)),
1157                                         ref(oopsAV((ps[(1) - (4)].val.opval)), OP_KVASLICE)));
1158                           if ((yyval.opval) && (ps[(1) - (4)].val.opval))
1159                               (yyval.opval)->op_private |=
1160                                   (ps[(1) - (4)].val.opval)->op_private & OPpSLICEWARNING;
1161                         ;}
1162     break;
1163
1164   case 182:
1165 #line 903 "perly.y"
1166     { (yyval.opval) = op_prepend_elem(OP_HSLICE,
1167                                 newOP(OP_PUSHMARK, 0),
1168                                     newLISTOP(OP_HSLICE, 0,
1169                                         list((ps[(3) - (5)].val.opval)),
1170                                         ref(oopsHV((ps[(1) - (5)].val.opval)), OP_HSLICE)));
1171                           if ((yyval.opval) && (ps[(1) - (5)].val.opval))
1172                               (yyval.opval)->op_private |=
1173                                   (ps[(1) - (5)].val.opval)->op_private & OPpSLICEWARNING;
1174                         ;}
1175     break;
1176
1177   case 183:
1178 #line 913 "perly.y"
1179     { (yyval.opval) = op_prepend_elem(OP_KVHSLICE,
1180                                 newOP(OP_PUSHMARK, 0),
1181                                     newLISTOP(OP_KVHSLICE, 0,
1182                                         list((ps[(3) - (5)].val.opval)),
1183                                         ref((ps[(1) - (5)].val.opval), OP_KVHSLICE)));
1184                           if ((yyval.opval) && (ps[(1) - (5)].val.opval))
1185                               (yyval.opval)->op_private |=
1186                                   (ps[(1) - (5)].val.opval)->op_private & OPpSLICEWARNING;
1187                         ;}
1188     break;
1189
1190   case 184:
1191 #line 923 "perly.y"
1192     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1193     break;
1194
1195   case 185:
1196 #line 925 "perly.y"
1197     { (yyval.opval) = newUNOP(OP_ENTERSUB, 0, scalar((ps[(1) - (1)].val.opval))); ;}
1198     break;
1199
1200   case 186:
1201 #line 927 "perly.y"
1202     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (3)].val.opval)));
1203                         ;}
1204     break;
1205
1206   case 187:
1207 #line 930 "perly.y"
1208     {
1209                           (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1210                                 op_append_elem(OP_LIST, (ps[(3) - (4)].val.opval), scalar((ps[(1) - (4)].val.opval))));
1211                         ;}
1212     break;
1213
1214   case 188:
1215 #line 935 "perly.y"
1216     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1217                             op_append_elem(OP_LIST, (ps[(3) - (3)].val.opval), scalar((ps[(2) - (3)].val.opval))));
1218                         ;}
1219     break;
1220
1221   case 189:
1222 #line 939 "perly.y"
1223     { (yyval.opval) = newSVREF((ps[(1) - (4)].val.opval)); ;}
1224     break;
1225
1226   case 190:
1227 #line 941 "perly.y"
1228     { (yyval.opval) = newAVREF((ps[(1) - (4)].val.opval)); ;}
1229     break;
1230
1231   case 191:
1232 #line 943 "perly.y"
1233     { (yyval.opval) = newHVREF((ps[(1) - (4)].val.opval)); ;}
1234     break;
1235
1236   case 192:
1237 #line 945 "perly.y"
1238     { (yyval.opval) = newUNOP(OP_ENTERSUB, 0,
1239                                        scalar(newCVREF((ps[(3) - (4)].val.ival),(ps[(1) - (4)].val.opval)))); ;}
1240     break;
1241
1242   case 193:
1243 #line 948 "perly.y"
1244     { (yyval.opval) = newGVREF(0,(ps[(1) - (4)].val.opval)); ;}
1245     break;
1246
1247   case 194:
1248 #line 950 "perly.y"
1249     { (yyval.opval) = newOP((ps[(1) - (1)].val.ival), OPf_SPECIAL);
1250                             PL_hints |= HINT_BLOCK_SCOPE; ;}
1251     break;
1252
1253   case 195:
1254 #line 953 "perly.y"
1255     { (yyval.opval) = newLOOPEX((ps[(1) - (2)].val.ival),(ps[(2) - (2)].val.opval)); ;}
1256     break;
1257
1258   case 196:
1259 #line 955 "perly.y"
1260     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[(2) - (2)].val.opval))); ;}
1261     break;
1262
1263   case 197:
1264 #line 957 "perly.y"
1265     { (yyval.opval) = newOP((ps[(1) - (1)].val.ival), 0); ;}
1266     break;
1267
1268   case 198:
1269 #line 959 "perly.y"
1270     { (yyval.opval) = newUNOP((ps[(1) - (2)].val.ival), 0, (ps[(2) - (2)].val.opval)); ;}
1271     break;
1272
1273   case 199:
1274 #line 961 "perly.y"
1275     { (yyval.opval) = newUNOP((ps[(1) - (2)].val.ival), 0, (ps[(2) - (2)].val.opval)); ;}
1276     break;
1277
1278   case 200:
1279 #line 963 "perly.y"
1280     { (yyval.opval) = newOP(OP_REQUIRE, (ps[(1) - (1)].val.ival) ? OPf_SPECIAL : 0); ;}
1281     break;
1282
1283   case 201:
1284 #line 965 "perly.y"
1285     { (yyval.opval) = newUNOP(OP_REQUIRE, (ps[(1) - (2)].val.ival) ? OPf_SPECIAL : 0, (ps[(2) - (2)].val.opval)); ;}
1286     break;
1287
1288   case 202:
1289 #line 967 "perly.y"
1290     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (1)].val.opval))); ;}
1291     break;
1292
1293   case 203:
1294 #line 969 "perly.y"
1295     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1296                             op_append_elem(OP_LIST, (ps[(2) - (2)].val.opval), scalar((ps[(1) - (2)].val.opval)))); ;}
1297     break;
1298
1299   case 204:
1300 #line 972 "perly.y"
1301     { (yyval.opval) = newOP((ps[(1) - (1)].val.ival), 0); ;}
1302     break;
1303
1304   case 205:
1305 #line 974 "perly.y"
1306     { (yyval.opval) = newOP((ps[(1) - (3)].val.ival), 0);;}
1307     break;
1308
1309   case 206:
1310 #line 976 "perly.y"
1311     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1312     break;
1313
1314   case 207:
1315 #line 978 "perly.y"
1316     { (yyval.opval) = (ps[(1) - (3)].val.opval); ;}
1317     break;
1318
1319   case 208:
1320 #line 980 "perly.y"
1321     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (1)].val.opval))); ;}
1322     break;
1323
1324   case 209:
1325 #line 982 "perly.y"
1326     { (yyval.opval) = ((ps[(1) - (3)].val.ival) == OP_NOT)
1327                           ? newUNOP((ps[(1) - (3)].val.ival), 0, newSVOP(OP_CONST, 0, newSViv(0)))
1328                           : newOP((ps[(1) - (3)].val.ival), OPf_SPECIAL); ;}
1329     break;
1330
1331   case 210:
1332 #line 986 "perly.y"
1333     { (yyval.opval) = newUNOP((ps[(1) - (4)].val.ival), 0, (ps[(3) - (4)].val.opval)); ;}
1334     break;
1335
1336   case 211:
1337 #line 988 "perly.y"
1338     {
1339                             if (   (ps[(1) - (1)].val.opval)->op_type != OP_TRANS
1340                                 && (ps[(1) - (1)].val.opval)->op_type != OP_TRANSR
1341                                 && (((PMOP*)(ps[(1) - (1)].val.opval))->op_pmflags & PMf_HAS_CV))
1342                             {
1343                                 (yyval.ival) = start_subparse(FALSE, CVf_ANON);
1344                                 SAVEFREESV(PL_compcv);
1345                             } else
1346                                 (yyval.ival) = 0;
1347                         ;}
1348     break;
1349
1350   case 212:
1351 #line 999 "perly.y"
1352     { (yyval.opval) = pmruntime((ps[(1) - (5)].val.opval), (ps[(4) - (5)].val.opval), 1, (ps[(2) - (5)].val.ival)); ;}
1353     break;
1354
1355   case 215:
1356 #line 1003 "perly.y"
1357     {
1358                           (yyval.opval) = newLISTOP(OP_DIE, 0, newOP(OP_PUSHMARK, 0),
1359                                 newSVOP(OP_CONST, 0, newSVpvs("Unimplemented")));
1360                         ;}
1361     break;
1362
1363   case 217:
1364 #line 1012 "perly.y"
1365     { (yyval.opval) = my_attrs((ps[(2) - (3)].val.opval),(ps[(3) - (3)].val.opval)); ;}
1366     break;
1367
1368   case 218:
1369 #line 1014 "perly.y"
1370     { (yyval.opval) = localize((ps[(2) - (2)].val.opval),(ps[(1) - (2)].val.ival)); ;}
1371     break;
1372
1373   case 219:
1374 #line 1019 "perly.y"
1375     { (yyval.opval) = sawparens((ps[(2) - (3)].val.opval)); ;}
1376     break;
1377
1378   case 220:
1379 #line 1021 "perly.y"
1380     { (yyval.opval) = sawparens(newNULLLIST()); ;}
1381     break;
1382
1383   case 221:
1384 #line 1024 "perly.y"
1385     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1386     break;
1387
1388   case 222:
1389 #line 1026 "perly.y"
1390     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1391     break;
1392
1393   case 223:
1394 #line 1028 "perly.y"
1395     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1396     break;
1397
1398   case 224:
1399 #line 1033 "perly.y"
1400     { (yyval.opval) = (OP*)NULL; ;}
1401     break;
1402
1403   case 225:
1404 #line 1035 "perly.y"
1405     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1406     break;
1407
1408   case 226:
1409 #line 1039 "perly.y"
1410     { (yyval.opval) = (OP*)NULL; ;}
1411     break;
1412
1413   case 227:
1414 #line 1041 "perly.y"
1415     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1416     break;
1417
1418   case 228:
1419 #line 1047 "perly.y"
1420     { parser->in_my = 0; (yyval.opval) = my((ps[(1) - (1)].val.opval)); ;}
1421     break;
1422
1423   case 234:
1424 #line 1060 "perly.y"
1425     { (yyval.opval) = newCVREF((ps[(1) - (2)].val.ival),(ps[(2) - (2)].val.opval)); ;}
1426     break;
1427
1428   case 235:
1429 #line 1064 "perly.y"
1430     { (yyval.opval) = newSVREF((ps[(2) - (2)].val.opval)); ;}
1431     break;
1432
1433   case 236:
1434 #line 1068 "perly.y"
1435     { (yyval.opval) = newAVREF((ps[(2) - (2)].val.opval));
1436                           if ((yyval.opval)) (yyval.opval)->op_private |= (ps[(1) - (2)].val.ival);
1437                         ;}
1438     break;
1439
1440   case 237:
1441 #line 1074 "perly.y"
1442     { (yyval.opval) = newHVREF((ps[(2) - (2)].val.opval));
1443                           if ((yyval.opval)) (yyval.opval)->op_private |= (ps[(1) - (2)].val.ival);
1444                         ;}
1445     break;
1446
1447   case 238:
1448 #line 1080 "perly.y"
1449     { (yyval.opval) = newAVREF((ps[(2) - (2)].val.opval)); ;}
1450     break;
1451
1452   case 239:
1453 #line 1082 "perly.y"
1454     { (yyval.opval) = newAVREF((ps[(1) - (4)].val.opval)); ;}
1455     break;
1456
1457   case 240:
1458 #line 1086 "perly.y"
1459     { (yyval.opval) = newGVREF(0,(ps[(2) - (2)].val.opval)); ;}
1460     break;
1461
1462   case 242:
1463 #line 1091 "perly.y"
1464     { (yyval.opval) = newAVREF((ps[(1) - (3)].val.opval)); ;}
1465     break;
1466
1467   case 244:
1468 #line 1096 "perly.y"
1469     { (yyval.opval) = newHVREF((ps[(1) - (3)].val.opval)); ;}
1470     break;
1471
1472   case 246:
1473 #line 1101 "perly.y"
1474     { (yyval.opval) = newGVREF(0,(ps[(1) - (3)].val.opval)); ;}
1475     break;
1476
1477   case 247:
1478 #line 1106 "perly.y"
1479     { (yyval.opval) = scalar((ps[(1) - (1)].val.opval)); ;}
1480     break;
1481
1482   case 248:
1483 #line 1108 "perly.y"
1484     { (yyval.opval) = scalar((ps[(1) - (1)].val.opval)); ;}
1485     break;
1486
1487   case 249:
1488 #line 1110 "perly.y"
1489     { (yyval.opval) = op_scope((ps[(1) - (1)].val.opval)); ;}
1490     break;
1491
1492   case 250:
1493 #line 1113 "perly.y"
1494     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1495     break;
1496
1497
1498 /* Line 1267 of yacc.c.  */
1499
1500       default: break;
1501     
1502
1503 /* Generated from:
1504  * 20fd9dcde08a4a26833ba7bf337260d78986b6542a0f55c00d7a9245af45faf5 perly.y
1505  * d1d4df7b8e30ac9dede664af9179e6e5e7ddc7f2ad9c4eff9e2e5b32c9e16a6e regen_perly.pl
1506  * ex: set ro: */