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