utf8.c: Generalize static fcn return for indeterminate result
[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 118 "perly.y" /* yacc.c:1646  */
9     {
10                           parser->expect = XSTATE;
11                           (yyval.ival) = 0;
12                         }
13
14     break;
15
16   case 3:
17 #line 123 "perly.y" /* yacc.c:1646  */
18     {
19                           newPROG(block_end((ps[-1].val.ival),(ps[0].val.opval)));
20                           PL_compiling.cop_seq = 0;
21                           (yyval.ival) = 0;
22                         }
23
24     break;
25
26   case 4:
27 #line 129 "perly.y" /* yacc.c:1646  */
28     {
29                           parser->expect = XTERM;
30                           (yyval.ival) = 0;
31                         }
32
33     break;
34
35   case 5:
36 #line 134 "perly.y" /* yacc.c:1646  */
37     {
38                           PL_eval_root = (ps[0].val.opval);
39                           (yyval.ival) = 0;
40                         }
41
42     break;
43
44   case 6:
45 #line 139 "perly.y" /* yacc.c:1646  */
46     {
47                           parser->expect = XBLOCK;
48                           (yyval.ival) = 0;
49                         }
50
51     break;
52
53   case 7:
54 #line 144 "perly.y" /* yacc.c:1646  */
55     {
56                           PL_pad_reset_pending = TRUE;
57                           PL_eval_root = (ps[0].val.opval);
58                           (yyval.ival) = 0;
59                           yyunlex();
60                           parser->yychar = yytoken = YYEOF;
61                         }
62
63     break;
64
65   case 8:
66 #line 152 "perly.y" /* yacc.c:1646  */
67     {
68                           parser->expect = XSTATE;
69                           (yyval.ival) = 0;
70                         }
71
72     break;
73
74   case 9:
75 #line 157 "perly.y" /* yacc.c:1646  */
76     {
77                           PL_pad_reset_pending = TRUE;
78                           PL_eval_root = (ps[0].val.opval);
79                           (yyval.ival) = 0;
80                           yyunlex();
81                           parser->yychar = yytoken = YYEOF;
82                         }
83
84     break;
85
86   case 10:
87 #line 165 "perly.y" /* yacc.c:1646  */
88     {
89                           parser->expect = XSTATE;
90                           (yyval.ival) = 0;
91                         }
92
93     break;
94
95   case 11:
96 #line 170 "perly.y" /* yacc.c:1646  */
97     {
98                           PL_pad_reset_pending = TRUE;
99                           PL_eval_root = (ps[0].val.opval);
100                           (yyval.ival) = 0;
101                           yyunlex();
102                           parser->yychar = yytoken = YYEOF;
103                         }
104
105     break;
106
107   case 12:
108 #line 178 "perly.y" /* yacc.c:1646  */
109     {
110                           parser->expect = XSTATE;
111                           (yyval.ival) = 0;
112                         }
113
114     break;
115
116   case 13:
117 #line 183 "perly.y" /* yacc.c:1646  */
118     {
119                           PL_eval_root = (ps[0].val.opval);
120                           (yyval.ival) = 0;
121                         }
122
123     break;
124
125   case 14:
126 #line 191 "perly.y" /* yacc.c:1646  */
127     { if (parser->copline > (line_t)(ps[-3].val.ival))
128                               parser->copline = (line_t)(ps[-3].val.ival);
129                           (yyval.opval) = block_end((ps[-2].val.ival), (ps[-1].val.opval));
130                         }
131
132     break;
133
134   case 15:
135 #line 199 "perly.y" /* yacc.c:1646  */
136     { if (parser->copline > (line_t)(ps[-6].val.ival))
137                               parser->copline = (line_t)(ps[-6].val.ival);
138                           (yyval.opval) = block_end((ps[-5].val.ival), (ps[-2].val.opval));
139                         }
140
141     break;
142
143   case 16:
144 #line 206 "perly.y" /* yacc.c:1646  */
145     { (yyval.ival) = block_start(TRUE);
146                           parser->parsed_sub = 0; }
147
148     break;
149
150   case 17:
151 #line 211 "perly.y" /* yacc.c:1646  */
152     { if (parser->copline > (line_t)(ps[-3].val.ival))
153                               parser->copline = (line_t)(ps[-3].val.ival);
154                           (yyval.opval) = block_end((ps[-2].val.ival), (ps[-1].val.opval));
155                         }
156
157     break;
158
159   case 18:
160 #line 218 "perly.y" /* yacc.c:1646  */
161     { (yyval.ival) = block_start(FALSE);
162                           parser->parsed_sub = 0; }
163
164     break;
165
166   case 19:
167 #line 224 "perly.y" /* yacc.c:1646  */
168     { (yyval.opval) = NULL; }
169
170     break;
171
172   case 20:
173 #line 226 "perly.y" /* yacc.c:1646  */
174     {   (yyval.opval) = op_append_list(OP_LINESEQ, (ps[-1].val.opval), (ps[0].val.opval));
175                             PL_pad_reset_pending = TRUE;
176                             if ((ps[-1].val.opval) && (ps[0].val.opval))
177                                 PL_hints |= HINT_BLOCK_SCOPE;
178                         }
179
180     break;
181
182   case 21:
183 #line 235 "perly.y" /* yacc.c:1646  */
184     { (yyval.opval) = NULL; }
185
186     break;
187
188   case 22:
189 #line 237 "perly.y" /* yacc.c:1646  */
190     {   (yyval.opval) = op_append_list(OP_LINESEQ, (ps[-1].val.opval), (ps[0].val.opval));
191                             PL_pad_reset_pending = TRUE;
192                             if ((ps[-1].val.opval) && (ps[0].val.opval))
193                                 PL_hints |= HINT_BLOCK_SCOPE;
194                         }
195
196     break;
197
198   case 23:
199 #line 246 "perly.y" /* yacc.c:1646  */
200     {
201                           (yyval.opval) = (ps[0].val.opval) ? newSTATEOP(0, NULL, (ps[0].val.opval)) : NULL;
202                         }
203
204     break;
205
206   case 24:
207 #line 250 "perly.y" /* yacc.c:1646  */
208     { (yyval.opval) = (ps[0].val.opval); }
209
210     break;
211
212   case 25:
213 #line 254 "perly.y" /* yacc.c:1646  */
214     {
215                           (yyval.opval) = newSTATEOP(SVf_UTF8 * (ps[-1].val.pval)[strlen((ps[-1].val.pval))+1], (ps[-1].val.pval), (ps[0].val.opval));
216                         }
217
218     break;
219
220   case 26:
221 #line 258 "perly.y" /* yacc.c:1646  */
222     {
223                           (yyval.opval) = newSTATEOP(SVf_UTF8 * (ps[-1].val.pval)[strlen((ps[-1].val.pval))+1], (ps[-1].val.pval), (ps[0].val.opval));
224                         }
225
226     break;
227
228   case 27:
229 #line 265 "perly.y" /* yacc.c:1646  */
230     { (yyval.opval) = (ps[0].val.opval); }
231
232     break;
233
234   case 28:
235 #line 267 "perly.y" /* yacc.c:1646  */
236     {
237                           CV *fmtcv = PL_compcv;
238                           newFORM((ps[-2].val.ival), (ps[-1].val.opval), (ps[0].val.opval));
239                           (yyval.opval) = NULL;
240                           if (CvOUTSIDE(fmtcv) && !CvEVAL(CvOUTSIDE(fmtcv))) {
241                               pad_add_weakref(fmtcv);
242                           }
243                           parser->parsed_sub = 1;
244                         }
245
246     break;
247
248   case 29:
249 #line 277 "perly.y" /* yacc.c:1646  */
250     {
251                           if ((ps[-1].val.opval)->op_type == OP_CONST) {
252                             const char *const name =
253                                 SvPV_nolen_const(((SVOP*)(ps[-1].val.opval))->op_sv);
254                             if (strEQ(name, "BEGIN") || strEQ(name, "END")
255                               || strEQ(name, "INIT") || strEQ(name, "CHECK")
256                               || strEQ(name, "UNITCHECK"))
257                               CvSPECIAL_on(PL_compcv);
258                           }
259                           else
260                           /* State subs inside anonymous subs need to be
261                              clonable themselves. */
262                           if (CvANON(CvOUTSIDE(PL_compcv))
263                            || CvCLONE(CvOUTSIDE(PL_compcv))
264                            || !PadnameIsSTATE(PadlistNAMESARRAY(CvPADLIST(
265                                                 CvOUTSIDE(PL_compcv)
266                                              ))[(ps[-1].val.opval)->op_targ]))
267                               CvCLONE_on(PL_compcv);
268                           parser->in_my = 0;
269                           parser->in_my_stash = NULL;
270                         }
271
272     break;
273
274   case 30:
275 #line 299 "perly.y" /* yacc.c:1646  */
276     {
277                           SvREFCNT_inc_simple_void(PL_compcv);
278                           (ps[-5].val.opval)->op_type == OP_CONST
279                               ? newATTRSUB((ps[-4].val.ival), (ps[-5].val.opval), (ps[-2].val.opval), (ps[-1].val.opval), (ps[0].val.opval))
280                               : newMYSUB((ps[-4].val.ival), (ps[-5].val.opval), (ps[-2].val.opval), (ps[-1].val.opval), (ps[0].val.opval))
281                           ;
282                           (yyval.opval) = NULL;
283                           intro_my();
284                           parser->parsed_sub = 1;
285                         }
286
287     break;
288
289   case 31:
290 #line 310 "perly.y" /* yacc.c:1646  */
291     {
292                           if ((ps[-1].val.opval)->op_type == OP_CONST) {
293                             const char *const name =
294                                 SvPV_nolen_const(((SVOP*)(ps[-1].val.opval))->op_sv);
295                             if (strEQ(name, "BEGIN") || strEQ(name, "END")
296                               || strEQ(name, "INIT") || strEQ(name, "CHECK")
297                               || strEQ(name, "UNITCHECK"))
298                               CvSPECIAL_on(PL_compcv);
299                           }
300                           else
301                           /* State subs inside anonymous subs need to be
302                              clonable themselves. */
303                           if (CvANON(CvOUTSIDE(PL_compcv))
304                            || CvCLONE(CvOUTSIDE(PL_compcv))
305                            || !PadnameIsSTATE(PadlistNAMESARRAY(CvPADLIST(
306                                                 CvOUTSIDE(PL_compcv)
307                                              ))[(ps[-1].val.opval)->op_targ]))
308                               CvCLONE_on(PL_compcv);
309                           parser->in_my = 0;
310                           parser->in_my_stash = NULL;
311                         }
312
313     break;
314
315   case 32:
316 #line 332 "perly.y" /* yacc.c:1646  */
317     {
318                           OP *body;
319                           if (parser->copline > (line_t)(ps[-2].val.ival))
320                               parser->copline = (line_t)(ps[-2].val.ival);
321                           body = block_end((ps[-5].val.ival),
322                                 op_append_list(OP_LINESEQ, (ps[-4].val.opval), (ps[-1].val.opval)));
323
324                           SvREFCNT_inc_simple_void(PL_compcv);
325                           (ps[-8].val.opval)->op_type == OP_CONST
326                               ? newATTRSUB((ps[-7].val.ival), (ps[-8].val.opval), NULL, (ps[-3].val.opval), body)
327                               : newMYSUB((ps[-7].val.ival), (ps[-8].val.opval), NULL, (ps[-3].val.opval), body)
328                           ;
329                           (yyval.opval) = NULL;
330                           intro_my();
331                           parser->parsed_sub = 1;
332                         }
333
334     break;
335
336   case 33:
337 #line 349 "perly.y" /* yacc.c:1646  */
338     {
339                           package((ps[-1].val.opval));
340                           if ((ps[-2].val.opval))
341                               package_version((ps[-2].val.opval));
342                           (yyval.opval) = NULL;
343                         }
344
345     break;
346
347   case 34:
348 #line 356 "perly.y" /* yacc.c:1646  */
349     { CvSPECIAL_on(PL_compcv); /* It's a BEGIN {} */ }
350
351     break;
352
353   case 35:
354 #line 358 "perly.y" /* yacc.c:1646  */
355     {
356                           SvREFCNT_inc_simple_void(PL_compcv);
357                           utilize((ps[-6].val.ival), (ps[-5].val.ival), (ps[-3].val.opval), (ps[-2].val.opval), (ps[-1].val.opval));
358                           parser->parsed_sub = 1;
359                           (yyval.opval) = NULL;
360                         }
361
362     break;
363
364   case 36:
365 #line 365 "perly.y" /* yacc.c:1646  */
366     {
367                           (yyval.opval) = block_end((ps[-4].val.ival),
368                               newCONDOP(0, (ps[-3].val.opval), op_scope((ps[-1].val.opval)), (ps[0].val.opval)));
369                           parser->copline = (line_t)(ps[-6].val.ival);
370                         }
371
372     break;
373
374   case 37:
375 #line 371 "perly.y" /* yacc.c:1646  */
376     {
377                           (yyval.opval) = block_end((ps[-4].val.ival),
378                               newCONDOP(0, (ps[-3].val.opval), (ps[0].val.opval), op_scope((ps[-1].val.opval))));
379                           parser->copline = (line_t)(ps[-6].val.ival);
380                         }
381
382     break;
383
384   case 38:
385 #line 377 "perly.y" /* yacc.c:1646  */
386     {
387                           (yyval.opval) = block_end((ps[-3].val.ival), newGIVENOP((ps[-2].val.opval), op_scope((ps[0].val.opval)), 0));
388                           parser->copline = (line_t)(ps[-5].val.ival);
389                         }
390
391     break;
392
393   case 39:
394 #line 382 "perly.y" /* yacc.c:1646  */
395     { (yyval.opval) = block_end((ps[-3].val.ival), newWHENOP((ps[-2].val.opval), op_scope((ps[0].val.opval)))); }
396
397     break;
398
399   case 40:
400 #line 384 "perly.y" /* yacc.c:1646  */
401     { (yyval.opval) = newWHENOP(0, op_scope((ps[0].val.opval))); }
402
403     break;
404
405   case 41:
406 #line 386 "perly.y" /* yacc.c:1646  */
407     {
408                           (yyval.opval) = block_end((ps[-5].val.ival),
409                                   newWHILEOP(0, 1, NULL,
410                                       (ps[-4].val.opval), (ps[-1].val.opval), (ps[0].val.opval), (ps[-2].val.ival)));
411                           parser->copline = (line_t)(ps[-7].val.ival);
412                         }
413
414     break;
415
416   case 42:
417 #line 393 "perly.y" /* yacc.c:1646  */
418     {
419                           (yyval.opval) = block_end((ps[-5].val.ival),
420                                   newWHILEOP(0, 1, NULL,
421                                       (ps[-4].val.opval), (ps[-1].val.opval), (ps[0].val.opval), (ps[-2].val.ival)));
422                           parser->copline = (line_t)(ps[-7].val.ival);
423                         }
424
425     break;
426
427   case 43:
428 #line 400 "perly.y" /* yacc.c:1646  */
429     { parser->expect = XTERM; }
430
431     break;
432
433   case 44:
434 #line 402 "perly.y" /* yacc.c:1646  */
435     { parser->expect = XTERM; }
436
437     break;
438
439   case 45:
440 #line 405 "perly.y" /* yacc.c:1646  */
441     {
442                           OP *initop = (ps[-9].val.opval);
443                           OP *forop = newWHILEOP(0, 1, NULL,
444                                       scalar((ps[-6].val.opval)), (ps[0].val.opval), (ps[-2].val.opval), (ps[-3].val.ival));
445                           if (initop) {
446                               forop = op_prepend_elem(OP_LINESEQ, initop,
447                                   op_append_elem(OP_LINESEQ,
448                                       newOP(OP_UNSTACK, OPf_SPECIAL),
449                                       forop));
450                           }
451                           PL_hints |= HINT_BLOCK_SCOPE;
452                           (yyval.opval) = block_end((ps[-10].val.ival), forop);
453                           parser->copline = (line_t)(ps[-12].val.ival);
454                         }
455
456     break;
457
458   case 46:
459 #line 420 "perly.y" /* yacc.c:1646  */
460     {
461                           (yyval.opval) = block_end((ps[-6].val.ival), newFOROP(0, (ps[-5].val.opval), (ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval)));
462                           parser->copline = (line_t)(ps[-8].val.ival);
463                         }
464
465     break;
466
467   case 47:
468 #line 425 "perly.y" /* yacc.c:1646  */
469     {
470                           (yyval.opval) = block_end((ps[-4].val.ival), newFOROP(0,
471                                       op_lvalue((ps[-6].val.opval), OP_ENTERLOOP), (ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval)));
472                           parser->copline = (line_t)(ps[-7].val.ival);
473                         }
474
475     break;
476
477   case 48:
478 #line 431 "perly.y" /* yacc.c:1646  */
479     { parser->in_my = 0; (yyval.opval) = my((ps[0].val.opval)); }
480
481     break;
482
483   case 49:
484 #line 433 "perly.y" /* yacc.c:1646  */
485     {
486                           (yyval.opval) = block_end(
487                                 (ps[-7].val.ival),
488                                 newFOROP(0,
489                                          op_lvalue(
490                                             newUNOP(OP_REFGEN, 0,
491                                                     (ps[-5].val.opval)),
492                                             OP_ENTERLOOP),
493                                          (ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval))
494                           );
495                           parser->copline = (line_t)(ps[-9].val.ival);
496                         }
497
498     break;
499
500   case 50:
501 #line 446 "perly.y" /* yacc.c:1646  */
502     {
503                           (yyval.opval) = block_end((ps[-4].val.ival), newFOROP(
504                                 0, op_lvalue(newUNOP(OP_REFGEN, 0,
505                                                      (ps[-6].val.opval)),
506                                              OP_ENTERLOOP), (ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval)));
507                           parser->copline = (line_t)(ps[-8].val.ival);
508                         }
509
510     break;
511
512   case 51:
513 #line 454 "perly.y" /* yacc.c:1646  */
514     {
515                           (yyval.opval) = block_end((ps[-4].val.ival),
516                                   newFOROP(0, NULL, (ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval)));
517                           parser->copline = (line_t)(ps[-6].val.ival);
518                         }
519
520     break;
521
522   case 52:
523 #line 460 "perly.y" /* yacc.c:1646  */
524     {
525                           /* a block is a loop that happens once */
526                           (yyval.opval) = newWHILEOP(0, 1, NULL,
527                                   NULL, (ps[-1].val.opval), (ps[0].val.opval), 0);
528                         }
529
530     break;
531
532   case 53:
533 #line 466 "perly.y" /* yacc.c:1646  */
534     {
535                           package((ps[-2].val.opval));
536                           if ((ps[-3].val.opval)) {
537                               package_version((ps[-3].val.opval));
538                           }
539                         }
540
541     break;
542
543   case 54:
544 #line 473 "perly.y" /* yacc.c:1646  */
545     {
546                           /* a block is a loop that happens once */
547                           (yyval.opval) = newWHILEOP(0, 1, NULL,
548                                   NULL, block_end((ps[-3].val.ival), (ps[-1].val.opval)), NULL, 0);
549                           if (parser->copline > (line_t)(ps[-4].val.ival))
550                               parser->copline = (line_t)(ps[-4].val.ival);
551                         }
552
553     break;
554
555   case 55:
556 #line 481 "perly.y" /* yacc.c:1646  */
557     {
558                           (yyval.opval) = (ps[-1].val.opval);
559                         }
560
561     break;
562
563   case 56:
564 #line 485 "perly.y" /* yacc.c:1646  */
565     {
566                           (yyval.opval) = NULL;
567                           parser->copline = NOLINE;
568                         }
569
570     break;
571
572   case 57:
573 #line 493 "perly.y" /* yacc.c:1646  */
574     { OP *list;
575                           if ((ps[0].val.opval)) {
576                               OP *term = (ps[0].val.opval);
577                               list = op_append_elem(OP_LIST, (ps[-1].val.opval), term);
578                           }
579                           else {
580                               list = (ps[-1].val.opval);
581                           }
582                           if (parser->copline == NOLINE)
583                                parser->copline = CopLINE(PL_curcop)-1;
584                           else parser->copline--;
585                           (yyval.opval) = newSTATEOP(0, NULL,
586                                           op_convert_list(OP_FORMLINE, 0, list));
587                         }
588
589     break;
590
591   case 58:
592 #line 510 "perly.y" /* yacc.c:1646  */
593     { (yyval.opval) = NULL; }
594
595     break;
596
597   case 59:
598 #line 512 "perly.y" /* yacc.c:1646  */
599     { (yyval.opval) = op_unscope((ps[-1].val.opval)); }
600
601     break;
602
603   case 60:
604 #line 517 "perly.y" /* yacc.c:1646  */
605     { (yyval.opval) = NULL; }
606
607     break;
608
609   case 61:
610 #line 519 "perly.y" /* yacc.c:1646  */
611     { (yyval.opval) = (ps[0].val.opval); }
612
613     break;
614
615   case 62:
616 #line 521 "perly.y" /* yacc.c:1646  */
617     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[0].val.opval), (ps[-2].val.opval)); }
618
619     break;
620
621   case 63:
622 #line 523 "perly.y" /* yacc.c:1646  */
623     { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[0].val.opval), (ps[-2].val.opval)); }
624
625     break;
626
627   case 64:
628 #line 525 "perly.y" /* yacc.c:1646  */
629     { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, scalar((ps[0].val.opval)), (ps[-2].val.opval)); }
630
631     break;
632
633   case 65:
634 #line 527 "perly.y" /* yacc.c:1646  */
635     { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, (ps[0].val.opval), (ps[-2].val.opval)); }
636
637     break;
638
639   case 66:
640 #line 529 "perly.y" /* yacc.c:1646  */
641     { (yyval.opval) = newFOROP(0, NULL, (ps[0].val.opval), (ps[-2].val.opval), NULL);
642                           parser->copline = (line_t)(ps[-1].val.ival); }
643
644     break;
645
646   case 67:
647 #line 532 "perly.y" /* yacc.c:1646  */
648     { (yyval.opval) = newWHENOP((ps[0].val.opval), op_scope((ps[-2].val.opval))); }
649
650     break;
651
652   case 68:
653 #line 537 "perly.y" /* yacc.c:1646  */
654     { (yyval.opval) = NULL; }
655
656     break;
657
658   case 69:
659 #line 539 "perly.y" /* yacc.c:1646  */
660     {
661                           ((ps[0].val.opval))->op_flags |= OPf_PARENS;
662                           (yyval.opval) = op_scope((ps[0].val.opval));
663                         }
664
665     break;
666
667   case 70:
668 #line 544 "perly.y" /* yacc.c:1646  */
669     { parser->copline = (line_t)(ps[-5].val.ival);
670                             (yyval.opval) = newCONDOP(0,
671                                 newSTATEOP(OPf_SPECIAL,NULL,(ps[-3].val.opval)),
672                                 op_scope((ps[-1].val.opval)), (ps[0].val.opval));
673                           PL_hints |= HINT_BLOCK_SCOPE;
674                         }
675
676     break;
677
678   case 71:
679 #line 554 "perly.y" /* yacc.c:1646  */
680     { (yyval.opval) = NULL; }
681
682     break;
683
684   case 72:
685 #line 556 "perly.y" /* yacc.c:1646  */
686     { (yyval.opval) = op_scope((ps[0].val.opval)); }
687
688     break;
689
690   case 73:
691 #line 561 "perly.y" /* yacc.c:1646  */
692     { (yyval.ival) = (PL_min_intro_pending &&
693                             PL_max_intro_pending >=  PL_min_intro_pending);
694                           intro_my(); }
695
696     break;
697
698   case 74:
699 #line 567 "perly.y" /* yacc.c:1646  */
700     { (yyval.opval) = NULL; }
701
702     break;
703
704   case 76:
705 #line 573 "perly.y" /* yacc.c:1646  */
706     { YYSTYPE tmplval;
707                           (void)scan_num("1", &tmplval);
708                           (yyval.opval) = tmplval.opval; }
709
710     break;
711
712   case 78:
713 #line 581 "perly.y" /* yacc.c:1646  */
714     { (yyval.opval) = invert(scalar((ps[0].val.opval))); }
715
716     break;
717
718   case 79:
719 #line 586 "perly.y" /* yacc.c:1646  */
720     { (yyval.opval) = (ps[0].val.opval); intro_my(); }
721
722     break;
723
724   case 80:
725 #line 590 "perly.y" /* yacc.c:1646  */
726     { (yyval.opval) = (ps[0].val.opval); intro_my(); }
727
728     break;
729
730   case 81:
731 #line 593 "perly.y" /* yacc.c:1646  */
732     { (yyval.opval) = (ps[0].val.opval); }
733
734     break;
735
736   case 82:
737 #line 594 "perly.y" /* yacc.c:1646  */
738     { (yyval.opval) = NULL; }
739
740     break;
741
742   case 83:
743 #line 598 "perly.y" /* yacc.c:1646  */
744     { (yyval.ival) = start_subparse(FALSE, 0);
745                             SAVEFREESV(PL_compcv); }
746
747     break;
748
749   case 84:
750 #line 604 "perly.y" /* yacc.c:1646  */
751     { (yyval.ival) = start_subparse(FALSE, CVf_ANON);
752                             SAVEFREESV(PL_compcv); }
753
754     break;
755
756   case 85:
757 #line 609 "perly.y" /* yacc.c:1646  */
758     { (yyval.ival) = start_subparse(TRUE, 0);
759                             SAVEFREESV(PL_compcv); }
760
761     break;
762
763   case 88:
764 #line 620 "perly.y" /* yacc.c:1646  */
765     { (yyval.opval) = NULL; }
766
767     break;
768
769   case 90:
770 #line 626 "perly.y" /* yacc.c:1646  */
771     { (yyval.opval) = NULL; }
772
773     break;
774
775   case 91:
776 #line 628 "perly.y" /* yacc.c:1646  */
777     { (yyval.opval) = (ps[0].val.opval); }
778
779     break;
780
781   case 92:
782 #line 630 "perly.y" /* yacc.c:1646  */
783     { (yyval.opval) = NULL; }
784
785     break;
786
787   case 93:
788 #line 635 "perly.y" /* yacc.c:1646  */
789     { (yyval.opval) = (ps[0].val.opval); }
790
791     break;
792
793   case 94:
794 #line 637 "perly.y" /* yacc.c:1646  */
795     { (yyval.opval) = NULL; }
796
797     break;
798
799   case 95:
800 #line 648 "perly.y" /* yacc.c:1646  */
801     { parser->in_my = 0; (yyval.opval) = NULL; }
802
803     break;
804
805   case 96:
806 #line 650 "perly.y" /* yacc.c:1646  */
807     { parser->in_my = 0; (yyval.opval) = (ps[0].val.opval); }
808
809     break;
810
811   case 97:
812 #line 655 "perly.y" /* yacc.c:1646  */
813     { (yyval.ival) = '@'; }
814
815     break;
816
817   case 98:
818 #line 657 "perly.y" /* yacc.c:1646  */
819     { (yyval.ival) = '%'; }
820
821     break;
822
823   case 99:
824 #line 661 "perly.y" /* yacc.c:1646  */
825     {
826                             I32 sigil   = (ps[-2].val.ival);
827                             OP *var     = (ps[-1].val.opval);
828                             OP *defexpr = (ps[0].val.opval);
829
830                             if (parser->sig_slurpy)
831                                 yyerror("Multiple slurpy parameters not allowed");
832                             parser->sig_slurpy = (char)sigil;
833
834                             if (defexpr)
835                                 yyerror("A slurpy parameter may not have "
836                                         "a default value");
837
838                             (yyval.opval) = var ? newSTATEOP(0, NULL, var) : NULL;
839                         }
840
841     break;
842
843   case 100:
844 #line 680 "perly.y" /* yacc.c:1646  */
845     { (yyval.opval) = NULL; }
846
847     break;
848
849   case 101:
850 #line 682 "perly.y" /* yacc.c:1646  */
851     { (yyval.opval) = newOP(OP_NULL, 0); }
852
853     break;
854
855   case 102:
856 #line 684 "perly.y" /* yacc.c:1646  */
857     { (yyval.opval) = (ps[0].val.opval); }
858
859     break;
860
861   case 103:
862 #line 690 "perly.y" /* yacc.c:1646  */
863     {
864                             OP *var     = (ps[-1].val.opval);
865                             OP *defexpr = (ps[0].val.opval);
866
867                             if (parser->sig_slurpy)
868                                 yyerror("Slurpy parameter not last");
869
870                             parser->sig_elems++;
871
872                             if (defexpr) {
873                                 parser->sig_optelems++;
874
875                                 if (   defexpr->op_type == OP_NULL
876                                     && !(defexpr->op_flags & OPf_KIDS))
877                                 {
878                                     /* handle '$=' special case */
879                                     if (var)
880                                         yyerror("Optional parameter "
881                                                     "lacks default expression");
882                                     op_free(defexpr);
883                                 }
884                                 else { 
885                                     /* a normal '=default' expression */ 
886                                     OP *defop = (OP*)alloc_LOGOP(OP_ARGDEFELEM,
887                                                         defexpr,
888                                                         LINKLIST(defexpr));
889                                     /* re-purpose op_targ to hold @_ index */
890                                     defop->op_targ =
891                                         (PADOFFSET)(parser->sig_elems - 1);
892
893                                     if (var) {
894                                         var->op_flags |= OPf_STACKED;
895                                         (void)op_sibling_splice(var,
896                                                         NULL, 0, defop);
897                                         scalar(defop);
898                                     }
899                                     else
900                                         var = newUNOP(OP_NULL, 0, defop);
901
902                                     LINKLIST(var);
903                                     /* NB: normally the first child of a
904                                      * logop is executed before the logop,
905                                      * and it pushes a boolean result
906                                      * ready for the logop. For ARGDEFELEM,
907                                      * the op itself does the boolean
908                                      * calculation, so set the first op to
909                                      * it instead.
910                                      */
911                                     var->op_next = defop;
912                                     defexpr->op_next = var;
913                                 }
914                             }
915                             else {
916                                 if (parser->sig_optelems)
917                                     yyerror("Mandatory parameter "
918                                             "follows optional parameter");
919                             }
920
921                             (yyval.opval) = var ? newSTATEOP(0, NULL, var) : NULL;
922                         }
923
924     break;
925
926   case 104:
927 #line 755 "perly.y" /* yacc.c:1646  */
928     { parser->in_my = KEY_sigvar; (yyval.opval) = (ps[0].val.opval); }
929
930     break;
931
932   case 105:
933 #line 757 "perly.y" /* yacc.c:1646  */
934     { parser->in_my = KEY_sigvar; (yyval.opval) = (ps[0].val.opval); }
935
936     break;
937
938   case 106:
939 #line 763 "perly.y" /* yacc.c:1646  */
940     { (yyval.opval) = (ps[-1].val.opval); }
941
942     break;
943
944   case 107:
945 #line 765 "perly.y" /* yacc.c:1646  */
946     {
947                           (yyval.opval) = op_append_list(OP_LINESEQ, (ps[-2].val.opval), (ps[0].val.opval));
948                         }
949
950     break;
951
952   case 108:
953 #line 769 "perly.y" /* yacc.c:1646  */
954     { (yyval.opval) = (ps[0].val.opval); }
955
956     break;
957
958   case 109:
959 #line 774 "perly.y" /* yacc.c:1646  */
960     { (yyval.opval) = NULL; }
961
962     break;
963
964   case 110:
965 #line 776 "perly.y" /* yacc.c:1646  */
966     { (yyval.opval) = (ps[0].val.opval); }
967
968     break;
969
970   case 111:
971 #line 780 "perly.y" /* yacc.c:1646  */
972     {
973                             ENTER;
974                             SAVEIV(parser->sig_elems);
975                             SAVEIV(parser->sig_optelems);
976                             SAVEI8(parser->sig_slurpy);
977                             parser->sig_elems    = 0;
978                             parser->sig_optelems = 0;
979                             parser->sig_slurpy   = 0;
980                             parser->in_my        = KEY_sigvar;
981                         }
982
983     break;
984
985   case 112:
986 #line 792 "perly.y" /* yacc.c:1646  */
987     {
988                             OP            *sigops = (ps[-1].val.opval);
989                             UNOP_AUX_item *aux;
990                             OP            *check;
991
992                             if (!parser->error_count) {
993                                 assert(FEATURE_SIGNATURES_IS_ENABLED);
994                             }
995
996                             /* We shouldn't get here otherwise */
997                             Perl_ck_warner_d(aTHX_
998                                 packWARN(WARN_EXPERIMENTAL__SIGNATURES),
999                                 "The signatures feature is experimental");
1000
1001                             aux = (UNOP_AUX_item*)PerlMemShared_malloc(
1002                                 sizeof(UNOP_AUX_item) * 3);
1003                             aux[0].iv = parser->sig_elems;
1004                             aux[1].iv = parser->sig_optelems;
1005                             aux[2].iv = parser->sig_slurpy;
1006                             check = newUNOP_AUX(OP_ARGCHECK, 0, NULL, aux);
1007                             sigops = op_prepend_elem(OP_LINESEQ, check, sigops);
1008                             sigops = op_prepend_elem(OP_LINESEQ,
1009                                                 newSTATEOP(0, NULL, NULL),
1010                                                 sigops);
1011                             /* a nextstate at the end handles context
1012                              * correctly for an empty sub body */
1013                             (yyval.opval) = op_append_elem(OP_LINESEQ,
1014                                                 sigops,
1015                                                 newSTATEOP(0, NULL, NULL));
1016
1017                             parser->in_my = 0;
1018                             parser->expect = XATTRBLOCK;
1019                             LEAVE;
1020                         }
1021
1022     break;
1023
1024   case 114:
1025 #line 832 "perly.y" /* yacc.c:1646  */
1026     { (yyval.opval) = NULL; }
1027
1028     break;
1029
1030   case 115:
1031 #line 837 "perly.y" /* yacc.c:1646  */
1032     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1033
1034     break;
1035
1036   case 116:
1037 #line 839 "perly.y" /* yacc.c:1646  */
1038     { (yyval.opval) = newLOGOP((ps[-1].val.ival), 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1039
1040     break;
1041
1042   case 117:
1043 #line 841 "perly.y" /* yacc.c:1646  */
1044     { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1045
1046     break;
1047
1048   case 119:
1049 #line 847 "perly.y" /* yacc.c:1646  */
1050     { (yyval.opval) = (ps[-1].val.opval); }
1051
1052     break;
1053
1054   case 120:
1055 #line 849 "perly.y" /* yacc.c:1646  */
1056     {
1057                           OP* term = (ps[0].val.opval);
1058                           (yyval.opval) = op_append_elem(OP_LIST, (ps[-2].val.opval), term);
1059                         }
1060
1061     break;
1062
1063   case 122:
1064 #line 858 "perly.y" /* yacc.c:1646  */
1065     { (yyval.opval) = op_convert_list((ps[-2].val.ival), OPf_STACKED,
1066                                 op_prepend_elem(OP_LIST, newGVREF((ps[-2].val.ival),(ps[-1].val.opval)), (ps[0].val.opval)) );
1067                         }
1068
1069     break;
1070
1071   case 123:
1072 #line 862 "perly.y" /* yacc.c:1646  */
1073     { (yyval.opval) = op_convert_list((ps[-4].val.ival), OPf_STACKED,
1074                                 op_prepend_elem(OP_LIST, newGVREF((ps[-4].val.ival),(ps[-2].val.opval)), (ps[-1].val.opval)) );
1075                         }
1076
1077     break;
1078
1079   case 124:
1080 #line 866 "perly.y" /* yacc.c:1646  */
1081     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
1082                                 op_append_elem(OP_LIST,
1083                                     op_prepend_elem(OP_LIST, scalar((ps[-5].val.opval)), (ps[-1].val.opval)),
1084                                     newMETHOP(OP_METHOD, 0, (ps[-3].val.opval))));
1085                         }
1086
1087     break;
1088
1089   case 125:
1090 #line 872 "perly.y" /* yacc.c:1646  */
1091     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
1092                                 op_append_elem(OP_LIST, scalar((ps[-2].val.opval)),
1093                                     newMETHOP(OP_METHOD, 0, (ps[0].val.opval))));
1094                         }
1095
1096     break;
1097
1098   case 126:
1099 #line 877 "perly.y" /* yacc.c:1646  */
1100     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
1101                                 op_append_elem(OP_LIST,
1102                                     op_prepend_elem(OP_LIST, (ps[-1].val.opval), (ps[0].val.opval)),
1103                                     newMETHOP(OP_METHOD, 0, (ps[-2].val.opval))));
1104                         }
1105
1106     break;
1107
1108   case 127:
1109 #line 883 "perly.y" /* yacc.c:1646  */
1110     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
1111                                 op_append_elem(OP_LIST,
1112                                     op_prepend_elem(OP_LIST, (ps[-3].val.opval), (ps[-1].val.opval)),
1113                                     newMETHOP(OP_METHOD, 0, (ps[-4].val.opval))));
1114                         }
1115
1116     break;
1117
1118   case 128:
1119 #line 889 "perly.y" /* yacc.c:1646  */
1120     { (yyval.opval) = op_convert_list((ps[-1].val.ival), 0, (ps[0].val.opval)); }
1121
1122     break;
1123
1124   case 129:
1125 #line 891 "perly.y" /* yacc.c:1646  */
1126     { (yyval.opval) = op_convert_list((ps[-3].val.ival), 0, (ps[-1].val.opval)); }
1127
1128     break;
1129
1130   case 130:
1131 #line 893 "perly.y" /* yacc.c:1646  */
1132     { SvREFCNT_inc_simple_void(PL_compcv);
1133                           (yyval.opval) = newANONATTRSUB((ps[-1].val.ival), 0, NULL, (ps[0].val.opval)); }
1134
1135     break;
1136
1137   case 131:
1138 #line 896 "perly.y" /* yacc.c:1646  */
1139     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1140                                  op_append_elem(OP_LIST,
1141                                    op_prepend_elem(OP_LIST, (ps[-1].val.opval), (ps[0].val.opval)), (ps[-4].val.opval)));
1142                         }
1143
1144     break;
1145
1146   case 134:
1147 #line 911 "perly.y" /* yacc.c:1646  */
1148     { (yyval.opval) = newBINOP(OP_GELEM, 0, (ps[-4].val.opval), scalar((ps[-2].val.opval))); }
1149
1150     break;
1151
1152   case 135:
1153 #line 913 "perly.y" /* yacc.c:1646  */
1154     { (yyval.opval) = newBINOP(OP_AELEM, 0, oopsAV((ps[-3].val.opval)), scalar((ps[-1].val.opval)));
1155                         }
1156
1157     break;
1158
1159   case 136:
1160 #line 916 "perly.y" /* yacc.c:1646  */
1161     { (yyval.opval) = newBINOP(OP_AELEM, 0,
1162                                         ref(newAVREF((ps[-4].val.opval)),OP_RV2AV),
1163                                         scalar((ps[-1].val.opval)));
1164                         }
1165
1166     break;
1167
1168   case 137:
1169 #line 921 "perly.y" /* yacc.c:1646  */
1170     { (yyval.opval) = newBINOP(OP_AELEM, 0,
1171                                         ref(newAVREF((ps[-3].val.opval)),OP_RV2AV),
1172                                         scalar((ps[-1].val.opval)));
1173                         }
1174
1175     break;
1176
1177   case 138:
1178 #line 926 "perly.y" /* yacc.c:1646  */
1179     { (yyval.opval) = newBINOP(OP_HELEM, 0, oopsHV((ps[-4].val.opval)), jmaybe((ps[-2].val.opval)));
1180                         }
1181
1182     break;
1183
1184   case 139:
1185 #line 929 "perly.y" /* yacc.c:1646  */
1186     { (yyval.opval) = newBINOP(OP_HELEM, 0,
1187                                         ref(newHVREF((ps[-5].val.opval)),OP_RV2HV),
1188                                         jmaybe((ps[-2].val.opval))); }
1189
1190     break;
1191
1192   case 140:
1193 #line 933 "perly.y" /* yacc.c:1646  */
1194     { (yyval.opval) = newBINOP(OP_HELEM, 0,
1195                                         ref(newHVREF((ps[-4].val.opval)),OP_RV2HV),
1196                                         jmaybe((ps[-2].val.opval))); }
1197
1198     break;
1199
1200   case 141:
1201 #line 937 "perly.y" /* yacc.c:1646  */
1202     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1203                                    newCVREF(0, scalar((ps[-3].val.opval)))); }
1204
1205     break;
1206
1207   case 142:
1208 #line 940 "perly.y" /* yacc.c:1646  */
1209     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1210                                    op_append_elem(OP_LIST, (ps[-1].val.opval),
1211                                        newCVREF(0, scalar((ps[-4].val.opval))))); }
1212
1213     break;
1214
1215   case 143:
1216 #line 945 "perly.y" /* yacc.c:1646  */
1217     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1218                                    op_append_elem(OP_LIST, (ps[-1].val.opval),
1219                                                newCVREF(0, scalar((ps[-3].val.opval))))); }
1220
1221     break;
1222
1223   case 144:
1224 #line 949 "perly.y" /* yacc.c:1646  */
1225     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1226                                    newCVREF(0, scalar((ps[-2].val.opval)))); }
1227
1228     break;
1229
1230   case 145:
1231 #line 952 "perly.y" /* yacc.c:1646  */
1232     { (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), (ps[-4].val.opval)); }
1233
1234     break;
1235
1236   case 146:
1237 #line 954 "perly.y" /* yacc.c:1646  */
1238     { (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), (ps[-3].val.opval)); }
1239
1240     break;
1241
1242   case 147:
1243 #line 956 "perly.y" /* yacc.c:1646  */
1244     { (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), NULL); }
1245
1246     break;
1247
1248   case 148:
1249 #line 961 "perly.y" /* yacc.c:1646  */
1250     { (yyval.opval) = newASSIGNOP(OPf_STACKED, (ps[-2].val.opval), (ps[-1].val.ival), (ps[0].val.opval)); }
1251
1252     break;
1253
1254   case 149:
1255 #line 963 "perly.y" /* yacc.c:1646  */
1256     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1257
1258     break;
1259
1260   case 150:
1261 #line 965 "perly.y" /* yacc.c:1646  */
1262     {   if ((ps[-1].val.ival) != OP_REPEAT)
1263                                 scalar((ps[-2].val.opval));
1264                             (yyval.opval) = newBINOP((ps[-1].val.ival), 0, (ps[-2].val.opval), scalar((ps[0].val.opval)));
1265                         }
1266
1267     break;
1268
1269   case 151:
1270 #line 970 "perly.y" /* yacc.c:1646  */
1271     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1272
1273     break;
1274
1275   case 152:
1276 #line 972 "perly.y" /* yacc.c:1646  */
1277     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1278
1279     break;
1280
1281   case 153:
1282 #line 974 "perly.y" /* yacc.c:1646  */
1283     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1284
1285     break;
1286
1287   case 154:
1288 #line 976 "perly.y" /* yacc.c:1646  */
1289     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1290
1291     break;
1292
1293   case 155:
1294 #line 978 "perly.y" /* yacc.c:1646  */
1295     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1296
1297     break;
1298
1299   case 156:
1300 #line 980 "perly.y" /* yacc.c:1646  */
1301     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1302
1303     break;
1304
1305   case 157:
1306 #line 982 "perly.y" /* yacc.c:1646  */
1307     { (yyval.opval) = newRANGE((ps[-1].val.ival), scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1308
1309     break;
1310
1311   case 158:
1312 #line 984 "perly.y" /* yacc.c:1646  */
1313     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1314
1315     break;
1316
1317   case 159:
1318 #line 986 "perly.y" /* yacc.c:1646  */
1319     { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1320
1321     break;
1322
1323   case 160:
1324 #line 988 "perly.y" /* yacc.c:1646  */
1325     { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1326
1327     break;
1328
1329   case 161:
1330 #line 990 "perly.y" /* yacc.c:1646  */
1331     { (yyval.opval) = bind_match((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); }
1332
1333     break;
1334
1335   case 162:
1336 #line 995 "perly.y" /* yacc.c:1646  */
1337     { (yyval.opval) = newUNOP(OP_NEGATE, 0, scalar((ps[0].val.opval))); }
1338
1339     break;
1340
1341   case 163:
1342 #line 997 "perly.y" /* yacc.c:1646  */
1343     { (yyval.opval) = (ps[0].val.opval); }
1344
1345     break;
1346
1347   case 164:
1348 #line 1000 "perly.y" /* yacc.c:1646  */
1349     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[0].val.opval))); }
1350
1351     break;
1352
1353   case 165:
1354 #line 1002 "perly.y" /* yacc.c:1646  */
1355     { (yyval.opval) = newUNOP((ps[-1].val.ival), 0, scalar((ps[0].val.opval))); }
1356
1357     break;
1358
1359   case 166:
1360 #line 1004 "perly.y" /* yacc.c:1646  */
1361     { (yyval.opval) = newUNOP(OP_POSTINC, 0,
1362                                         op_lvalue(scalar((ps[-1].val.opval)), OP_POSTINC)); }
1363
1364     break;
1365
1366   case 167:
1367 #line 1007 "perly.y" /* yacc.c:1646  */
1368     { (yyval.opval) = newUNOP(OP_POSTDEC, 0,
1369                                         op_lvalue(scalar((ps[-1].val.opval)), OP_POSTDEC));}
1370
1371     break;
1372
1373   case 168:
1374 #line 1010 "perly.y" /* yacc.c:1646  */
1375     { (yyval.opval) = op_convert_list(OP_JOIN, 0,
1376                                        op_append_elem(
1377                                         OP_LIST,
1378                                         newSVREF(scalar(
1379                                             newSVOP(OP_CONST,0,
1380                                                     newSVpvs("\""))
1381                                         )),
1382                                         (ps[-1].val.opval)
1383                                        ));
1384                         }
1385
1386     break;
1387
1388   case 169:
1389 #line 1021 "perly.y" /* yacc.c:1646  */
1390     { (yyval.opval) = newUNOP(OP_PREINC, 0,
1391                                         op_lvalue(scalar((ps[0].val.opval)), OP_PREINC)); }
1392
1393     break;
1394
1395   case 170:
1396 #line 1024 "perly.y" /* yacc.c:1646  */
1397     { (yyval.opval) = newUNOP(OP_PREDEC, 0,
1398                                         op_lvalue(scalar((ps[0].val.opval)), OP_PREDEC)); }
1399
1400     break;
1401
1402   case 171:
1403 #line 1031 "perly.y" /* yacc.c:1646  */
1404     { (yyval.opval) = newANONLIST((ps[-1].val.opval)); }
1405
1406     break;
1407
1408   case 172:
1409 #line 1033 "perly.y" /* yacc.c:1646  */
1410     { (yyval.opval) = newANONLIST(NULL);}
1411
1412     break;
1413
1414   case 173:
1415 #line 1035 "perly.y" /* yacc.c:1646  */
1416     { (yyval.opval) = newANONHASH((ps[-2].val.opval)); }
1417
1418     break;
1419
1420   case 174:
1421 #line 1037 "perly.y" /* yacc.c:1646  */
1422     { (yyval.opval) = newANONHASH(NULL); }
1423
1424     break;
1425
1426   case 175:
1427 #line 1039 "perly.y" /* yacc.c:1646  */
1428     { SvREFCNT_inc_simple_void(PL_compcv);
1429                           (yyval.opval) = newANONATTRSUB((ps[-3].val.ival), (ps[-2].val.opval), (ps[-1].val.opval), (ps[0].val.opval)); }
1430
1431     break;
1432
1433   case 176:
1434 #line 1042 "perly.y" /* yacc.c:1646  */
1435     {
1436                           OP *body;
1437                           if (parser->copline > (line_t)(ps[-2].val.ival))
1438                               parser->copline = (line_t)(ps[-2].val.ival);
1439                           body = block_end((ps[-5].val.ival),
1440                                 op_append_list(OP_LINESEQ, (ps[-4].val.opval), (ps[-1].val.opval)));
1441                           SvREFCNT_inc_simple_void(PL_compcv);
1442                           (yyval.opval) = newANONATTRSUB((ps[-6].val.ival), NULL, (ps[-3].val.opval), body);
1443                         }
1444
1445     break;
1446
1447   case 177:
1448 #line 1056 "perly.y" /* yacc.c:1646  */
1449     { (yyval.opval) = dofile((ps[0].val.opval), (ps[-1].val.ival));}
1450
1451     break;
1452
1453   case 178:
1454 #line 1058 "perly.y" /* yacc.c:1646  */
1455     { (yyval.opval) = newUNOP(OP_NULL, OPf_SPECIAL, op_scope((ps[0].val.opval)));}
1456
1457     break;
1458
1459   case 183:
1460 #line 1066 "perly.y" /* yacc.c:1646  */
1461     { (yyval.opval) = newCONDOP(0, (ps[-4].val.opval), (ps[-2].val.opval), (ps[0].val.opval)); }
1462
1463     break;
1464
1465   case 184:
1466 #line 1068 "perly.y" /* yacc.c:1646  */
1467     { (yyval.opval) = newUNOP(OP_REFGEN, 0, (ps[0].val.opval)); }
1468
1469     break;
1470
1471   case 185:
1472 #line 1070 "perly.y" /* yacc.c:1646  */
1473     { (yyval.opval) = newUNOP(OP_REFGEN, 0, localize((ps[0].val.opval),1)); }
1474
1475     break;
1476
1477   case 186:
1478 #line 1072 "perly.y" /* yacc.c:1646  */
1479     { (yyval.opval) = (ps[0].val.opval); }
1480
1481     break;
1482
1483   case 187:
1484 #line 1074 "perly.y" /* yacc.c:1646  */
1485     { (yyval.opval) = localize((ps[0].val.opval),0); }
1486
1487     break;
1488
1489   case 188:
1490 #line 1076 "perly.y" /* yacc.c:1646  */
1491     { (yyval.opval) = sawparens((ps[-1].val.opval)); }
1492
1493     break;
1494
1495   case 189:
1496 #line 1078 "perly.y" /* yacc.c:1646  */
1497     { (yyval.opval) = (ps[0].val.opval); }
1498
1499     break;
1500
1501   case 190:
1502 #line 1080 "perly.y" /* yacc.c:1646  */
1503     { (yyval.opval) = sawparens(newNULLLIST()); }
1504
1505     break;
1506
1507   case 191:
1508 #line 1082 "perly.y" /* yacc.c:1646  */
1509     { (yyval.opval) = (ps[0].val.opval); }
1510
1511     break;
1512
1513   case 192:
1514 #line 1084 "perly.y" /* yacc.c:1646  */
1515     { (yyval.opval) = (ps[0].val.opval); }
1516
1517     break;
1518
1519   case 193:
1520 #line 1086 "perly.y" /* yacc.c:1646  */
1521     { (yyval.opval) = (ps[0].val.opval); }
1522
1523     break;
1524
1525   case 194:
1526 #line 1088 "perly.y" /* yacc.c:1646  */
1527     { (yyval.opval) = (ps[0].val.opval); }
1528
1529     break;
1530
1531   case 195:
1532 #line 1090 "perly.y" /* yacc.c:1646  */
1533     { (yyval.opval) = newUNOP(OP_AV2ARYLEN, 0, ref((ps[0].val.opval), OP_AV2ARYLEN));}
1534
1535     break;
1536
1537   case 196:
1538 #line 1092 "perly.y" /* yacc.c:1646  */
1539     { (yyval.opval) = (ps[0].val.opval); }
1540
1541     break;
1542
1543   case 197:
1544 #line 1094 "perly.y" /* yacc.c:1646  */
1545     { (yyval.opval) = op_prepend_elem(OP_ASLICE,
1546                                 newOP(OP_PUSHMARK, 0),
1547                                     newLISTOP(OP_ASLICE, 0,
1548                                         list((ps[-1].val.opval)),
1549                                         ref((ps[-3].val.opval), OP_ASLICE)));
1550                           if ((yyval.opval) && (ps[-3].val.opval))
1551                               (yyval.opval)->op_private |=
1552                                   (ps[-3].val.opval)->op_private & OPpSLICEWARNING;
1553                         }
1554
1555     break;
1556
1557   case 198:
1558 #line 1104 "perly.y" /* yacc.c:1646  */
1559     { (yyval.opval) = op_prepend_elem(OP_KVASLICE,
1560                                 newOP(OP_PUSHMARK, 0),
1561                                     newLISTOP(OP_KVASLICE, 0,
1562                                         list((ps[-1].val.opval)),
1563                                         ref(oopsAV((ps[-3].val.opval)), OP_KVASLICE)));
1564                           if ((yyval.opval) && (ps[-3].val.opval))
1565                               (yyval.opval)->op_private |=
1566                                   (ps[-3].val.opval)->op_private & OPpSLICEWARNING;
1567                         }
1568
1569     break;
1570
1571   case 199:
1572 #line 1114 "perly.y" /* yacc.c:1646  */
1573     { (yyval.opval) = op_prepend_elem(OP_HSLICE,
1574                                 newOP(OP_PUSHMARK, 0),
1575                                     newLISTOP(OP_HSLICE, 0,
1576                                         list((ps[-2].val.opval)),
1577                                         ref(oopsHV((ps[-4].val.opval)), OP_HSLICE)));
1578                           if ((yyval.opval) && (ps[-4].val.opval))
1579                               (yyval.opval)->op_private |=
1580                                   (ps[-4].val.opval)->op_private & OPpSLICEWARNING;
1581                         }
1582
1583     break;
1584
1585   case 200:
1586 #line 1124 "perly.y" /* yacc.c:1646  */
1587     { (yyval.opval) = op_prepend_elem(OP_KVHSLICE,
1588                                 newOP(OP_PUSHMARK, 0),
1589                                     newLISTOP(OP_KVHSLICE, 0,
1590                                         list((ps[-2].val.opval)),
1591                                         ref((ps[-4].val.opval), OP_KVHSLICE)));
1592                           if ((yyval.opval) && (ps[-4].val.opval))
1593                               (yyval.opval)->op_private |=
1594                                   (ps[-4].val.opval)->op_private & OPpSLICEWARNING;
1595                         }
1596
1597     break;
1598
1599   case 201:
1600 #line 1134 "perly.y" /* yacc.c:1646  */
1601     { (yyval.opval) = (ps[0].val.opval); }
1602
1603     break;
1604
1605   case 202:
1606 #line 1136 "perly.y" /* yacc.c:1646  */
1607     { (yyval.opval) = newUNOP(OP_ENTERSUB, 0, scalar((ps[0].val.opval))); }
1608
1609     break;
1610
1611   case 203:
1612 #line 1138 "perly.y" /* yacc.c:1646  */
1613     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[-2].val.opval)));
1614                         }
1615
1616     break;
1617
1618   case 204:
1619 #line 1141 "perly.y" /* yacc.c:1646  */
1620     {
1621                           (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1622                                 op_append_elem(OP_LIST, (ps[-1].val.opval), scalar((ps[-3].val.opval))));
1623                         }
1624
1625     break;
1626
1627   case 205:
1628 #line 1146 "perly.y" /* yacc.c:1646  */
1629     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1630                             op_append_elem(OP_LIST, (ps[0].val.opval), scalar((ps[-1].val.opval))));
1631                         }
1632
1633     break;
1634
1635   case 206:
1636 #line 1150 "perly.y" /* yacc.c:1646  */
1637     { (yyval.opval) = newSVREF((ps[-3].val.opval)); }
1638
1639     break;
1640
1641   case 207:
1642 #line 1152 "perly.y" /* yacc.c:1646  */
1643     { (yyval.opval) = newAVREF((ps[-3].val.opval)); }
1644
1645     break;
1646
1647   case 208:
1648 #line 1154 "perly.y" /* yacc.c:1646  */
1649     { (yyval.opval) = newHVREF((ps[-3].val.opval)); }
1650
1651     break;
1652
1653   case 209:
1654 #line 1156 "perly.y" /* yacc.c:1646  */
1655     { (yyval.opval) = newUNOP(OP_ENTERSUB, 0,
1656                                        scalar(newCVREF((ps[-1].val.ival),(ps[-3].val.opval)))); }
1657
1658     break;
1659
1660   case 210:
1661 #line 1159 "perly.y" /* yacc.c:1646  */
1662     { (yyval.opval) = newGVREF(0,(ps[-3].val.opval)); }
1663
1664     break;
1665
1666   case 211:
1667 #line 1161 "perly.y" /* yacc.c:1646  */
1668     { (yyval.opval) = newOP((ps[0].val.ival), OPf_SPECIAL);
1669                             PL_hints |= HINT_BLOCK_SCOPE; }
1670
1671     break;
1672
1673   case 212:
1674 #line 1164 "perly.y" /* yacc.c:1646  */
1675     { (yyval.opval) = newLOOPEX((ps[-1].val.ival),(ps[0].val.opval)); }
1676
1677     break;
1678
1679   case 213:
1680 #line 1166 "perly.y" /* yacc.c:1646  */
1681     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[0].val.opval))); }
1682
1683     break;
1684
1685   case 214:
1686 #line 1168 "perly.y" /* yacc.c:1646  */
1687     { (yyval.opval) = newOP((ps[0].val.ival), 0); }
1688
1689     break;
1690
1691   case 215:
1692 #line 1170 "perly.y" /* yacc.c:1646  */
1693     { (yyval.opval) = newUNOP((ps[-1].val.ival), 0, (ps[0].val.opval)); }
1694
1695     break;
1696
1697   case 216:
1698 #line 1172 "perly.y" /* yacc.c:1646  */
1699     { (yyval.opval) = newUNOP((ps[-1].val.ival), 0, (ps[0].val.opval)); }
1700
1701     break;
1702
1703   case 217:
1704 #line 1174 "perly.y" /* yacc.c:1646  */
1705     { (yyval.opval) = newOP(OP_REQUIRE, (ps[0].val.ival) ? OPf_SPECIAL : 0); }
1706
1707     break;
1708
1709   case 218:
1710 #line 1176 "perly.y" /* yacc.c:1646  */
1711     { (yyval.opval) = newUNOP(OP_REQUIRE, (ps[-1].val.ival) ? OPf_SPECIAL : 0, (ps[0].val.opval)); }
1712
1713     break;
1714
1715   case 219:
1716 #line 1178 "perly.y" /* yacc.c:1646  */
1717     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[0].val.opval))); }
1718
1719     break;
1720
1721   case 220:
1722 #line 1180 "perly.y" /* yacc.c:1646  */
1723     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1724                             op_append_elem(OP_LIST, (ps[0].val.opval), scalar((ps[-1].val.opval)))); }
1725
1726     break;
1727
1728   case 221:
1729 #line 1183 "perly.y" /* yacc.c:1646  */
1730     { (yyval.opval) = newOP((ps[0].val.ival), 0); }
1731
1732     break;
1733
1734   case 222:
1735 #line 1185 "perly.y" /* yacc.c:1646  */
1736     { (yyval.opval) = newOP((ps[-2].val.ival), 0);}
1737
1738     break;
1739
1740   case 223:
1741 #line 1187 "perly.y" /* yacc.c:1646  */
1742     { (yyval.opval) = (ps[0].val.opval); }
1743
1744     break;
1745
1746   case 224:
1747 #line 1189 "perly.y" /* yacc.c:1646  */
1748     { (yyval.opval) = (ps[-2].val.opval); }
1749
1750     break;
1751
1752   case 225:
1753 #line 1191 "perly.y" /* yacc.c:1646  */
1754     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[0].val.opval))); }
1755
1756     break;
1757
1758   case 226:
1759 #line 1193 "perly.y" /* yacc.c:1646  */
1760     { (yyval.opval) = ((ps[-2].val.ival) == OP_NOT)
1761                           ? newUNOP((ps[-2].val.ival), 0, newSVOP(OP_CONST, 0, newSViv(0)))
1762                           : newOP((ps[-2].val.ival), OPf_SPECIAL); }
1763
1764     break;
1765
1766   case 227:
1767 #line 1197 "perly.y" /* yacc.c:1646  */
1768     { (yyval.opval) = newUNOP((ps[-3].val.ival), 0, (ps[-1].val.opval)); }
1769
1770     break;
1771
1772   case 228:
1773 #line 1199 "perly.y" /* yacc.c:1646  */
1774     {
1775                             if (   (ps[0].val.opval)->op_type != OP_TRANS
1776                                 && (ps[0].val.opval)->op_type != OP_TRANSR
1777                                 && (((PMOP*)(ps[0].val.opval))->op_pmflags & PMf_HAS_CV))
1778                             {
1779                                 (yyval.ival) = start_subparse(FALSE, CVf_ANON);
1780                                 SAVEFREESV(PL_compcv);
1781                             } else
1782                                 (yyval.ival) = 0;
1783                         }
1784
1785     break;
1786
1787   case 229:
1788 #line 1210 "perly.y" /* yacc.c:1646  */
1789     { (yyval.opval) = pmruntime((ps[-5].val.opval), (ps[-2].val.opval), (ps[-1].val.opval), 1, (ps[-4].val.ival)); }
1790
1791     break;
1792
1793   case 232:
1794 #line 1214 "perly.y" /* yacc.c:1646  */
1795     {
1796                           (yyval.opval) = newLISTOP(OP_DIE, 0, newOP(OP_PUSHMARK, 0),
1797                                 newSVOP(OP_CONST, 0, newSVpvs("Unimplemented")));
1798                         }
1799
1800     break;
1801
1802   case 234:
1803 #line 1223 "perly.y" /* yacc.c:1646  */
1804     { (yyval.opval) = my_attrs((ps[-1].val.opval),(ps[0].val.opval)); }
1805
1806     break;
1807
1808   case 235:
1809 #line 1225 "perly.y" /* yacc.c:1646  */
1810     { (yyval.opval) = localize((ps[0].val.opval),1); }
1811
1812     break;
1813
1814   case 236:
1815 #line 1227 "perly.y" /* yacc.c:1646  */
1816     { (yyval.opval) = newUNOP(OP_REFGEN, 0, my_attrs((ps[-1].val.opval),(ps[0].val.opval))); }
1817
1818     break;
1819
1820   case 237:
1821 #line 1232 "perly.y" /* yacc.c:1646  */
1822     { (yyval.opval) = sawparens((ps[-1].val.opval)); }
1823
1824     break;
1825
1826   case 238:
1827 #line 1234 "perly.y" /* yacc.c:1646  */
1828     { (yyval.opval) = sawparens(newNULLLIST()); }
1829
1830     break;
1831
1832   case 239:
1833 #line 1237 "perly.y" /* yacc.c:1646  */
1834     { (yyval.opval) = (ps[0].val.opval); }
1835
1836     break;
1837
1838   case 240:
1839 #line 1239 "perly.y" /* yacc.c:1646  */
1840     { (yyval.opval) = (ps[0].val.opval); }
1841
1842     break;
1843
1844   case 241:
1845 #line 1241 "perly.y" /* yacc.c:1646  */
1846     { (yyval.opval) = (ps[0].val.opval); }
1847
1848     break;
1849
1850   case 242:
1851 #line 1246 "perly.y" /* yacc.c:1646  */
1852     { (yyval.opval) = NULL; }
1853
1854     break;
1855
1856   case 243:
1857 #line 1248 "perly.y" /* yacc.c:1646  */
1858     { (yyval.opval) = (ps[0].val.opval); }
1859
1860     break;
1861
1862   case 244:
1863 #line 1252 "perly.y" /* yacc.c:1646  */
1864     { (yyval.opval) = NULL; }
1865
1866     break;
1867
1868   case 245:
1869 #line 1254 "perly.y" /* yacc.c:1646  */
1870     { (yyval.opval) = (ps[0].val.opval); }
1871
1872     break;
1873
1874   case 246:
1875 #line 1258 "perly.y" /* yacc.c:1646  */
1876     { (yyval.opval) = NULL; }
1877
1878     break;
1879
1880   case 247:
1881 #line 1260 "perly.y" /* yacc.c:1646  */
1882     { (yyval.opval) = (ps[0].val.opval); }
1883
1884     break;
1885
1886   case 248:
1887 #line 1266 "perly.y" /* yacc.c:1646  */
1888     { parser->in_my = 0; (yyval.opval) = my((ps[0].val.opval)); }
1889
1890     break;
1891
1892   case 256:
1893 #line 1283 "perly.y" /* yacc.c:1646  */
1894     { (yyval.opval) = newCVREF((ps[-1].val.ival),(ps[0].val.opval)); }
1895
1896     break;
1897
1898   case 257:
1899 #line 1287 "perly.y" /* yacc.c:1646  */
1900     { (yyval.opval) = newSVREF((ps[0].val.opval)); }
1901
1902     break;
1903
1904   case 258:
1905 #line 1291 "perly.y" /* yacc.c:1646  */
1906     { (yyval.opval) = newAVREF((ps[0].val.opval));
1907                           if ((yyval.opval)) (yyval.opval)->op_private |= (ps[-1].val.ival);
1908                         }
1909
1910     break;
1911
1912   case 259:
1913 #line 1297 "perly.y" /* yacc.c:1646  */
1914     { (yyval.opval) = newHVREF((ps[0].val.opval));
1915                           if ((yyval.opval)) (yyval.opval)->op_private |= (ps[-1].val.ival);
1916                         }
1917
1918     break;
1919
1920   case 260:
1921 #line 1303 "perly.y" /* yacc.c:1646  */
1922     { (yyval.opval) = newAVREF((ps[0].val.opval)); }
1923
1924     break;
1925
1926   case 261:
1927 #line 1305 "perly.y" /* yacc.c:1646  */
1928     { (yyval.opval) = newAVREF((ps[-3].val.opval)); }
1929
1930     break;
1931
1932   case 262:
1933 #line 1309 "perly.y" /* yacc.c:1646  */
1934     { (yyval.opval) = newGVREF(0,(ps[0].val.opval)); }
1935
1936     break;
1937
1938   case 264:
1939 #line 1314 "perly.y" /* yacc.c:1646  */
1940     { (yyval.opval) = newAVREF((ps[-2].val.opval)); }
1941
1942     break;
1943
1944   case 266:
1945 #line 1319 "perly.y" /* yacc.c:1646  */
1946     { (yyval.opval) = newHVREF((ps[-2].val.opval)); }
1947
1948     break;
1949
1950   case 268:
1951 #line 1324 "perly.y" /* yacc.c:1646  */
1952     { (yyval.opval) = newGVREF(0,(ps[-2].val.opval)); }
1953
1954     break;
1955
1956   case 269:
1957 #line 1329 "perly.y" /* yacc.c:1646  */
1958     { (yyval.opval) = scalar((ps[0].val.opval)); }
1959
1960     break;
1961
1962   case 270:
1963 #line 1331 "perly.y" /* yacc.c:1646  */
1964     { (yyval.opval) = scalar((ps[0].val.opval)); }
1965
1966     break;
1967
1968   case 271:
1969 #line 1333 "perly.y" /* yacc.c:1646  */
1970     { (yyval.opval) = op_scope((ps[0].val.opval)); }
1971
1972     break;
1973
1974   case 272:
1975 #line 1336 "perly.y" /* yacc.c:1646  */
1976     { (yyval.opval) = (ps[0].val.opval); }
1977
1978     break;
1979
1980
1981
1982       default: break;
1983     
1984
1985 /* Generated from:
1986  * 68a62998f7c607d7a1fa0fdf2d16ec19074c256dde18dfc475daff70d378e025 perly.y
1987  * 153cba5d215c1a083a0459c43f4d55c45fd0a7093c197d7247a456dcde21ea53 regen_perly.pl
1988  * ex: set ro: */