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