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