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