This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Set PL_expect less often when parsing semicolons
[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 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                           PL_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                           PL_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                           PL_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                           PL_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 (PL_parser->copline > (line_t)(ps[(4) - (8)].val.ival))
415                               PL_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                           PL_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 (PL_parser->copline == NOLINE)
445                                PL_parser->copline = CopLINE(PL_curcop)-1;
446                           else PL_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                           PL_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     { PL_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                           PL_parser->expect = XBLOCK;
657                         ;}
658     break;
659
660   case 94:
661 #line 594 "perly.y"
662     {
663                           if (PL_parser->copline > (line_t)(ps[(3) - (5)].val.ival))
664                               PL_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                             PL_parser->expect = XOPERATOR;
785                         ;}
786     break;
787
788   case 117:
789 #line 687 "perly.y"
790     { (yyval.opval) = newBINOP(OP_AELEM, 0, oopsAV((ps[(1) - (4)].val.opval)), scalar((ps[(3) - (4)].val.opval)));
791                         ;}
792     break;
793
794   case 118:
795 #line 690 "perly.y"
796     { (yyval.opval) = newBINOP(OP_AELEM, 0,
797                                         ref(newAVREF((ps[(1) - (5)].val.opval)),OP_RV2AV),
798                                         scalar((ps[(4) - (5)].val.opval)));
799                         ;}
800     break;
801
802   case 119:
803 #line 695 "perly.y"
804     { (yyval.opval) = newBINOP(OP_AELEM, 0,
805                                         ref(newAVREF((ps[(1) - (4)].val.opval)),OP_RV2AV),
806                                         scalar((ps[(3) - (4)].val.opval)));
807                         ;}
808     break;
809
810   case 120:
811 #line 700 "perly.y"
812     { (yyval.opval) = newBINOP(OP_HELEM, 0, oopsHV((ps[(1) - (5)].val.opval)), jmaybe((ps[(3) - (5)].val.opval)));
813                             PL_parser->expect = XOPERATOR;
814                         ;}
815     break;
816
817   case 121:
818 #line 704 "perly.y"
819     { (yyval.opval) = newBINOP(OP_HELEM, 0,
820                                         ref(newHVREF((ps[(1) - (6)].val.opval)),OP_RV2HV),
821                                         jmaybe((ps[(4) - (6)].val.opval)));
822                             PL_parser->expect = XOPERATOR;
823                         ;}
824     break;
825
826   case 122:
827 #line 710 "perly.y"
828     { (yyval.opval) = newBINOP(OP_HELEM, 0,
829                                         ref(newHVREF((ps[(1) - (5)].val.opval)),OP_RV2HV),
830                                         jmaybe((ps[(3) - (5)].val.opval)));
831                             PL_parser->expect = XOPERATOR;
832                         ;}
833     break;
834
835   case 123:
836 #line 716 "perly.y"
837     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
838                                    newCVREF(0, scalar((ps[(1) - (4)].val.opval)))); ;}
839     break;
840
841   case 124:
842 #line 719 "perly.y"
843     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
844                                    op_append_elem(OP_LIST, (ps[(4) - (5)].val.opval),
845                                        newCVREF(0, scalar((ps[(1) - (5)].val.opval))))); ;}
846     break;
847
848   case 125:
849 #line 724 "perly.y"
850     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
851                                    op_append_elem(OP_LIST, (ps[(3) - (4)].val.opval),
852                                                newCVREF(0, scalar((ps[(1) - (4)].val.opval))))); ;}
853     break;
854
855   case 126:
856 #line 728 "perly.y"
857     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
858                                    newCVREF(0, scalar((ps[(1) - (3)].val.opval)))); ;}
859     break;
860
861   case 127:
862 #line 731 "perly.y"
863     { (yyval.opval) = newSLICEOP(0, (ps[(5) - (6)].val.opval), (ps[(2) - (6)].val.opval)); ;}
864     break;
865
866   case 128:
867 #line 733 "perly.y"
868     { (yyval.opval) = newSLICEOP(0, (ps[(3) - (4)].val.opval), (ps[(1) - (4)].val.opval)); ;}
869     break;
870
871   case 129:
872 #line 735 "perly.y"
873     { (yyval.opval) = newSLICEOP(0, (ps[(4) - (5)].val.opval), (OP*)NULL); ;}
874     break;
875
876   case 130:
877 #line 740 "perly.y"
878     { (yyval.opval) = newASSIGNOP(OPf_STACKED, (ps[(1) - (3)].val.opval), (ps[(2) - (3)].val.ival), (ps[(3) - (3)].val.opval)); ;}
879     break;
880
881   case 131:
882 #line 742 "perly.y"
883     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
884     break;
885
886   case 132:
887 #line 744 "perly.y"
888     {   if ((ps[(2) - (3)].val.ival) != OP_REPEAT)
889                                 scalar((ps[(1) - (3)].val.opval));
890                             (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, (ps[(1) - (3)].val.opval), scalar((ps[(3) - (3)].val.opval)));
891                         ;}
892     break;
893
894   case 133:
895 #line 749 "perly.y"
896     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
897     break;
898
899   case 134:
900 #line 751 "perly.y"
901     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
902     break;
903
904   case 135:
905 #line 753 "perly.y"
906     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
907     break;
908
909   case 136:
910 #line 755 "perly.y"
911     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
912     break;
913
914   case 137:
915 #line 757 "perly.y"
916     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
917     break;
918
919   case 138:
920 #line 759 "perly.y"
921     { (yyval.opval) = newBINOP((ps[(2) - (3)].val.ival), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
922     break;
923
924   case 139:
925 #line 761 "perly.y"
926     { (yyval.opval) = newRANGE((ps[(2) - (3)].val.ival), scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval))); ;}
927     break;
928
929   case 140:
930 #line 763 "perly.y"
931     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
932     break;
933
934   case 141:
935 #line 765 "perly.y"
936     { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
937     break;
938
939   case 142:
940 #line 767 "perly.y"
941     { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
942     break;
943
944   case 143:
945 #line 769 "perly.y"
946     { (yyval.opval) = bind_match((ps[(2) - (3)].val.ival), (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval)); ;}
947     break;
948
949   case 144:
950 #line 774 "perly.y"
951     { (yyval.opval) = newUNOP(OP_NEGATE, 0, scalar((ps[(2) - (2)].val.opval))); ;}
952     break;
953
954   case 145:
955 #line 776 "perly.y"
956     { (yyval.opval) = (ps[(2) - (2)].val.opval); ;}
957     break;
958
959   case 146:
960 #line 779 "perly.y"
961     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[(2) - (2)].val.opval))); ;}
962     break;
963
964   case 147:
965 #line 781 "perly.y"
966     { (yyval.opval) = newUNOP(OP_COMPLEMENT, 0, scalar((ps[(2) - (2)].val.opval))); ;}
967     break;
968
969   case 148:
970 #line 783 "perly.y"
971     { (yyval.opval) = newUNOP(OP_POSTINC, 0,
972                                         op_lvalue(scalar((ps[(1) - (2)].val.opval)), OP_POSTINC)); ;}
973     break;
974
975   case 149:
976 #line 786 "perly.y"
977     { (yyval.opval) = newUNOP(OP_POSTDEC, 0,
978                                         op_lvalue(scalar((ps[(1) - (2)].val.opval)), OP_POSTDEC));;}
979     break;
980
981   case 150:
982 #line 789 "perly.y"
983     { (yyval.opval) = convert(OP_JOIN, 0,
984                                        op_append_elem(
985                                         OP_LIST,
986                                         newSVREF(scalar(
987                                             newSVOP(OP_CONST,0,
988                                                     newSVpvs("\""))
989                                         )),
990                                         (ps[(1) - (2)].val.opval)
991                                        ));
992                         ;}
993     break;
994
995   case 151:
996 #line 800 "perly.y"
997     { (yyval.opval) = newUNOP(OP_PREINC, 0,
998                                         op_lvalue(scalar((ps[(2) - (2)].val.opval)), OP_PREINC)); ;}
999     break;
1000
1001   case 152:
1002 #line 803 "perly.y"
1003     { (yyval.opval) = newUNOP(OP_PREDEC, 0,
1004                                         op_lvalue(scalar((ps[(2) - (2)].val.opval)), OP_PREDEC)); ;}
1005     break;
1006
1007   case 153:
1008 #line 810 "perly.y"
1009     { (yyval.opval) = newANONLIST((ps[(2) - (3)].val.opval)); ;}
1010     break;
1011
1012   case 154:
1013 #line 812 "perly.y"
1014     { (yyval.opval) = newANONLIST((OP*)NULL);;}
1015     break;
1016
1017   case 155:
1018 #line 814 "perly.y"
1019     { (yyval.opval) = newANONHASH((ps[(2) - (4)].val.opval)); ;}
1020     break;
1021
1022   case 156:
1023 #line 816 "perly.y"
1024     { (yyval.opval) = newANONHASH((OP*)NULL); ;}
1025     break;
1026
1027   case 157:
1028 #line 818 "perly.y"
1029     { SvREFCNT_inc_simple_void(PL_compcv);
1030                           (yyval.opval) = newANONATTRSUB((ps[(2) - (5)].val.ival), (ps[(3) - (5)].val.opval), (ps[(4) - (5)].val.opval), (ps[(5) - (5)].val.opval)); ;}
1031     break;
1032
1033   case 158:
1034 #line 825 "perly.y"
1035     { (yyval.opval) = dofile((ps[(2) - (2)].val.opval), (ps[(1) - (2)].val.ival));;}
1036     break;
1037
1038   case 159:
1039 #line 827 "perly.y"
1040     { (yyval.opval) = newUNOP(OP_NULL, OPf_SPECIAL, op_scope((ps[(2) - (2)].val.opval)));;}
1041     break;
1042
1043   case 164:
1044 #line 835 "perly.y"
1045     { (yyval.opval) = newCONDOP(0, (ps[(1) - (5)].val.opval), (ps[(3) - (5)].val.opval), (ps[(5) - (5)].val.opval)); ;}
1046     break;
1047
1048   case 165:
1049 #line 837 "perly.y"
1050     { (yyval.opval) = newUNOP(OP_REFGEN, 0, op_lvalue((ps[(2) - (2)].val.opval),OP_REFGEN)); ;}
1051     break;
1052
1053   case 166:
1054 #line 839 "perly.y"
1055     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1056     break;
1057
1058   case 167:
1059 #line 841 "perly.y"
1060     { (yyval.opval) = localize((ps[(2) - (2)].val.opval),(ps[(1) - (2)].val.ival)); ;}
1061     break;
1062
1063   case 168:
1064 #line 843 "perly.y"
1065     { (yyval.opval) = sawparens((ps[(2) - (3)].val.opval)); ;}
1066     break;
1067
1068   case 169:
1069 #line 845 "perly.y"
1070     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1071     break;
1072
1073   case 170:
1074 #line 847 "perly.y"
1075     { (yyval.opval) = sawparens(newNULLLIST()); ;}
1076     break;
1077
1078   case 171:
1079 #line 849 "perly.y"
1080     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1081     break;
1082
1083   case 172:
1084 #line 851 "perly.y"
1085     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1086     break;
1087
1088   case 173:
1089 #line 853 "perly.y"
1090     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1091     break;
1092
1093   case 174:
1094 #line 855 "perly.y"
1095     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1096     break;
1097
1098   case 175:
1099 #line 857 "perly.y"
1100     { (yyval.opval) = newUNOP(OP_AV2ARYLEN, 0, ref((ps[(1) - (1)].val.opval), OP_AV2ARYLEN));;}
1101     break;
1102
1103   case 176:
1104 #line 859 "perly.y"
1105     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1106     break;
1107
1108   case 177:
1109 #line 861 "perly.y"
1110     { (yyval.opval) = op_prepend_elem(OP_ASLICE,
1111                                 newOP(OP_PUSHMARK, 0),
1112                                     newLISTOP(OP_ASLICE, 0,
1113                                         list((ps[(3) - (4)].val.opval)),
1114                                         ref((ps[(1) - (4)].val.opval), OP_ASLICE)));
1115                           if ((yyval.opval) && (ps[(1) - (4)].val.opval))
1116                               (yyval.opval)->op_private |=
1117                                   (ps[(1) - (4)].val.opval)->op_private & OPpSLICEWARNING;
1118                         ;}
1119     break;
1120
1121   case 178:
1122 #line 871 "perly.y"
1123     { (yyval.opval) = op_prepend_elem(OP_KVASLICE,
1124                                 newOP(OP_PUSHMARK, 0),
1125                                     newLISTOP(OP_KVASLICE, 0,
1126                                         list((ps[(3) - (4)].val.opval)),
1127                                         ref(oopsAV((ps[(1) - (4)].val.opval)), OP_KVASLICE)));
1128                           if ((yyval.opval) && (ps[(1) - (4)].val.opval))
1129                               (yyval.opval)->op_private |=
1130                                   (ps[(1) - (4)].val.opval)->op_private & OPpSLICEWARNING;
1131                         ;}
1132     break;
1133
1134   case 179:
1135 #line 881 "perly.y"
1136     { (yyval.opval) = op_prepend_elem(OP_HSLICE,
1137                                 newOP(OP_PUSHMARK, 0),
1138                                     newLISTOP(OP_HSLICE, 0,
1139                                         list((ps[(3) - (5)].val.opval)),
1140                                         ref(oopsHV((ps[(1) - (5)].val.opval)), OP_HSLICE)));
1141                           if ((yyval.opval) && (ps[(1) - (5)].val.opval))
1142                               (yyval.opval)->op_private |=
1143                                   (ps[(1) - (5)].val.opval)->op_private & OPpSLICEWARNING;
1144                             PL_parser->expect = XOPERATOR;
1145                         ;}
1146     break;
1147
1148   case 180:
1149 #line 892 "perly.y"
1150     { (yyval.opval) = op_prepend_elem(OP_KVHSLICE,
1151                                 newOP(OP_PUSHMARK, 0),
1152                                     newLISTOP(OP_KVHSLICE, 0,
1153                                         list((ps[(3) - (5)].val.opval)),
1154                                         ref((ps[(1) - (5)].val.opval), OP_KVHSLICE)));
1155                           if ((yyval.opval) && (ps[(1) - (5)].val.opval))
1156                               (yyval.opval)->op_private |=
1157                                   (ps[(1) - (5)].val.opval)->op_private & OPpSLICEWARNING;
1158                             PL_parser->expect = XOPERATOR;
1159                         ;}
1160     break;
1161
1162   case 181:
1163 #line 903 "perly.y"
1164     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1165     break;
1166
1167   case 182:
1168 #line 905 "perly.y"
1169     { (yyval.opval) = newUNOP(OP_ENTERSUB, 0, scalar((ps[(1) - (1)].val.opval))); ;}
1170     break;
1171
1172   case 183:
1173 #line 907 "perly.y"
1174     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (3)].val.opval)));
1175                         ;}
1176     break;
1177
1178   case 184:
1179 #line 910 "perly.y"
1180     {
1181                           (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1182                                 op_append_elem(OP_LIST, (ps[(3) - (4)].val.opval), scalar((ps[(1) - (4)].val.opval))));
1183                         ;}
1184     break;
1185
1186   case 185:
1187 #line 915 "perly.y"
1188     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1189                             op_append_elem(OP_LIST, (ps[(3) - (3)].val.opval), scalar((ps[(2) - (3)].val.opval))));
1190                         ;}
1191     break;
1192
1193   case 186:
1194 #line 919 "perly.y"
1195     { (yyval.opval) = newSVREF((ps[(1) - (4)].val.opval)); ;}
1196     break;
1197
1198   case 187:
1199 #line 921 "perly.y"
1200     { (yyval.opval) = newAVREF((ps[(1) - (4)].val.opval)); ;}
1201     break;
1202
1203   case 188:
1204 #line 923 "perly.y"
1205     { (yyval.opval) = newHVREF((ps[(1) - (4)].val.opval)); ;}
1206     break;
1207
1208   case 189:
1209 #line 925 "perly.y"
1210     { (yyval.opval) = newUNOP(OP_ENTERSUB, 0,
1211                                        scalar(newCVREF((ps[(3) - (4)].val.ival),(ps[(1) - (4)].val.opval)))); ;}
1212     break;
1213
1214   case 190:
1215 #line 928 "perly.y"
1216     { (yyval.opval) = newGVREF(0,(ps[(1) - (4)].val.opval)); ;}
1217     break;
1218
1219   case 191:
1220 #line 930 "perly.y"
1221     { (yyval.opval) = newOP((ps[(1) - (1)].val.ival), OPf_SPECIAL);
1222                             PL_hints |= HINT_BLOCK_SCOPE; ;}
1223     break;
1224
1225   case 192:
1226 #line 933 "perly.y"
1227     { (yyval.opval) = newLOOPEX((ps[(1) - (2)].val.ival),(ps[(2) - (2)].val.opval)); ;}
1228     break;
1229
1230   case 193:
1231 #line 935 "perly.y"
1232     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[(2) - (2)].val.opval))); ;}
1233     break;
1234
1235   case 194:
1236 #line 937 "perly.y"
1237     { (yyval.opval) = newOP((ps[(1) - (1)].val.ival), 0); ;}
1238     break;
1239
1240   case 195:
1241 #line 939 "perly.y"
1242     { (yyval.opval) = newUNOP((ps[(1) - (2)].val.ival), 0, (ps[(2) - (2)].val.opval)); ;}
1243     break;
1244
1245   case 196:
1246 #line 941 "perly.y"
1247     { (yyval.opval) = newUNOP((ps[(1) - (2)].val.ival), 0, (ps[(2) - (2)].val.opval)); ;}
1248     break;
1249
1250   case 197:
1251 #line 943 "perly.y"
1252     { (yyval.opval) = newOP(OP_REQUIRE, (ps[(1) - (1)].val.ival) ? OPf_SPECIAL : 0); ;}
1253     break;
1254
1255   case 198:
1256 #line 945 "perly.y"
1257     { (yyval.opval) = newUNOP(OP_REQUIRE, (ps[(1) - (2)].val.ival) ? OPf_SPECIAL : 0, (ps[(2) - (2)].val.opval)); ;}
1258     break;
1259
1260   case 199:
1261 #line 947 "perly.y"
1262     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (1)].val.opval))); ;}
1263     break;
1264
1265   case 200:
1266 #line 949 "perly.y"
1267     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1268                             op_append_elem(OP_LIST, (ps[(2) - (2)].val.opval), scalar((ps[(1) - (2)].val.opval)))); ;}
1269     break;
1270
1271   case 201:
1272 #line 952 "perly.y"
1273     { (yyval.opval) = newOP((ps[(1) - (1)].val.ival), 0); ;}
1274     break;
1275
1276   case 202:
1277 #line 954 "perly.y"
1278     { (yyval.opval) = newOP((ps[(1) - (3)].val.ival), 0);;}
1279     break;
1280
1281   case 203:
1282 #line 956 "perly.y"
1283     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1284     break;
1285
1286   case 204:
1287 #line 958 "perly.y"
1288     { (yyval.opval) = (ps[(1) - (3)].val.opval); ;}
1289     break;
1290
1291   case 205:
1292 #line 960 "perly.y"
1293     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (1)].val.opval))); ;}
1294     break;
1295
1296   case 206:
1297 #line 962 "perly.y"
1298     { (yyval.opval) = ((ps[(1) - (3)].val.ival) == OP_NOT)
1299                           ? newUNOP((ps[(1) - (3)].val.ival), 0, newSVOP(OP_CONST, 0, newSViv(0)))
1300                           : newOP((ps[(1) - (3)].val.ival), OPf_SPECIAL); ;}
1301     break;
1302
1303   case 207:
1304 #line 966 "perly.y"
1305     { (yyval.opval) = newUNOP((ps[(1) - (4)].val.ival), 0, (ps[(3) - (4)].val.opval)); ;}
1306     break;
1307
1308   case 208:
1309 #line 968 "perly.y"
1310     {
1311                             if (   (ps[(1) - (1)].val.opval)->op_type != OP_TRANS
1312                                 && (ps[(1) - (1)].val.opval)->op_type != OP_TRANSR
1313                                 && (((PMOP*)(ps[(1) - (1)].val.opval))->op_pmflags & PMf_HAS_CV))
1314                             {
1315                                 (yyval.ival) = start_subparse(FALSE, CVf_ANON);
1316                                 SAVEFREESV(PL_compcv);
1317                             } else
1318                                 (yyval.ival) = 0;
1319                         ;}
1320     break;
1321
1322   case 209:
1323 #line 979 "perly.y"
1324     { (yyval.opval) = pmruntime((ps[(1) - (5)].val.opval), (ps[(4) - (5)].val.opval), 1, (ps[(2) - (5)].val.ival)); ;}
1325     break;
1326
1327   case 212:
1328 #line 983 "perly.y"
1329     {
1330                           (yyval.opval) = newLISTOP(OP_DIE, 0, newOP(OP_PUSHMARK, 0),
1331                                 newSVOP(OP_CONST, 0, newSVpvs("Unimplemented")));
1332                         ;}
1333     break;
1334
1335   case 214:
1336 #line 992 "perly.y"
1337     { (yyval.opval) = my_attrs((ps[(2) - (3)].val.opval),(ps[(3) - (3)].val.opval)); ;}
1338     break;
1339
1340   case 215:
1341 #line 994 "perly.y"
1342     { (yyval.opval) = localize((ps[(2) - (2)].val.opval),(ps[(1) - (2)].val.ival)); ;}
1343     break;
1344
1345   case 216:
1346 #line 999 "perly.y"
1347     { (yyval.opval) = sawparens((ps[(2) - (3)].val.opval)); ;}
1348     break;
1349
1350   case 217:
1351 #line 1001 "perly.y"
1352     { (yyval.opval) = sawparens(newNULLLIST()); ;}
1353     break;
1354
1355   case 218:
1356 #line 1004 "perly.y"
1357     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1358     break;
1359
1360   case 219:
1361 #line 1006 "perly.y"
1362     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1363     break;
1364
1365   case 220:
1366 #line 1008 "perly.y"
1367     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1368     break;
1369
1370   case 221:
1371 #line 1013 "perly.y"
1372     { (yyval.opval) = (OP*)NULL; ;}
1373     break;
1374
1375   case 222:
1376 #line 1015 "perly.y"
1377     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1378     break;
1379
1380   case 223:
1381 #line 1019 "perly.y"
1382     { (yyval.opval) = (OP*)NULL; ;}
1383     break;
1384
1385   case 224:
1386 #line 1021 "perly.y"
1387     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1388     break;
1389
1390   case 225:
1391 #line 1027 "perly.y"
1392     { PL_parser->in_my = 0; (yyval.opval) = my((ps[(1) - (1)].val.opval)); ;}
1393     break;
1394
1395   case 226:
1396 #line 1031 "perly.y"
1397     { (yyval.opval) = newCVREF((ps[(1) - (2)].val.ival),(ps[(2) - (2)].val.opval)); ;}
1398     break;
1399
1400   case 227:
1401 #line 1035 "perly.y"
1402     { (yyval.opval) = newSVREF((ps[(2) - (2)].val.opval)); ;}
1403     break;
1404
1405   case 228:
1406 #line 1039 "perly.y"
1407     { (yyval.opval) = newAVREF((ps[(2) - (2)].val.opval));
1408                           if ((yyval.opval)) (yyval.opval)->op_private |= (ps[(1) - (2)].val.ival);
1409                         ;}
1410     break;
1411
1412   case 229:
1413 #line 1045 "perly.y"
1414     { (yyval.opval) = newHVREF((ps[(2) - (2)].val.opval));
1415                           if ((yyval.opval)) (yyval.opval)->op_private |= (ps[(1) - (2)].val.ival);
1416                         ;}
1417     break;
1418
1419   case 230:
1420 #line 1051 "perly.y"
1421     { (yyval.opval) = newAVREF((ps[(2) - (2)].val.opval)); ;}
1422     break;
1423
1424   case 231:
1425 #line 1053 "perly.y"
1426     { (yyval.opval) = newAVREF((ps[(1) - (4)].val.opval)); ;}
1427     break;
1428
1429   case 232:
1430 #line 1057 "perly.y"
1431     { (yyval.opval) = newGVREF(0,(ps[(2) - (2)].val.opval)); ;}
1432     break;
1433
1434   case 234:
1435 #line 1062 "perly.y"
1436     { (yyval.opval) = newAVREF((ps[(1) - (3)].val.opval)); ;}
1437     break;
1438
1439   case 236:
1440 #line 1067 "perly.y"
1441     { (yyval.opval) = newHVREF((ps[(1) - (3)].val.opval)); ;}
1442     break;
1443
1444   case 238:
1445 #line 1072 "perly.y"
1446     { (yyval.opval) = newGVREF(0,(ps[(1) - (3)].val.opval)); ;}
1447     break;
1448
1449   case 239:
1450 #line 1077 "perly.y"
1451     { (yyval.opval) = scalar((ps[(1) - (1)].val.opval)); ;}
1452     break;
1453
1454   case 240:
1455 #line 1079 "perly.y"
1456     { (yyval.opval) = scalar((ps[(1) - (1)].val.opval)); ;}
1457     break;
1458
1459   case 241:
1460 #line 1081 "perly.y"
1461     { (yyval.opval) = op_scope((ps[(1) - (1)].val.opval)); ;}
1462     break;
1463
1464   case 242:
1465 #line 1084 "perly.y"
1466     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1467     break;
1468
1469
1470 /* Line 1267 of yacc.c.  */
1471
1472       default: break;
1473     
1474
1475 /* Generated from:
1476  * e89acf986fa79bb74d827a4fd4823d07ff25bd99c2087cf4e7a7e6ae41d7a246 perly.y
1477  * d1d4df7b8e30ac9dede664af9179e6e5e7ddc7f2ad9c4eff9e2e5b32c9e16a6e regen_perly.pl
1478  * ex: set ro: */