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