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