This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Replace multiple 'use vars' by 'our' in regen.
[perl5.git] / perly.act
1 /* -*- buffer-read-only: t -*-
2    !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!!
3    This file is built by ./regen_perly.pl from perly.y.
4    Any changes made here will be lost!
5  */
6
7 case 2:
8 #line 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) = newLISTOP(OP_DIE, 0, newOP(OP_PUSHMARK, 0),
567                                 newSVOP(OP_CONST, 0, newSVpvs("Unimplemented")));
568                         }
569
570     break;
571
572   case 57:
573 #line 490 "perly.y" /* yacc.c:1646  */
574     {
575                           (yyval.opval) = NULL;
576                           parser->copline = NOLINE;
577                         }
578
579     break;
580
581   case 58:
582 #line 498 "perly.y" /* yacc.c:1646  */
583     { OP *list;
584                           if ((ps[0].val.opval)) {
585                               OP *term = (ps[0].val.opval);
586                               list = op_append_elem(OP_LIST, (ps[-1].val.opval), term);
587                           }
588                           else {
589                               list = (ps[-1].val.opval);
590                           }
591                           if (parser->copline == NOLINE)
592                                parser->copline = CopLINE(PL_curcop)-1;
593                           else parser->copline--;
594                           (yyval.opval) = newSTATEOP(0, NULL,
595                                           op_convert_list(OP_FORMLINE, 0, list));
596                         }
597
598     break;
599
600   case 59:
601 #line 515 "perly.y" /* yacc.c:1646  */
602     { (yyval.opval) = NULL; }
603
604     break;
605
606   case 60:
607 #line 517 "perly.y" /* yacc.c:1646  */
608     { (yyval.opval) = op_unscope((ps[-1].val.opval)); }
609
610     break;
611
612   case 61:
613 #line 522 "perly.y" /* yacc.c:1646  */
614     { (yyval.opval) = NULL; }
615
616     break;
617
618   case 62:
619 #line 524 "perly.y" /* yacc.c:1646  */
620     { (yyval.opval) = (ps[0].val.opval); }
621
622     break;
623
624   case 63:
625 #line 526 "perly.y" /* yacc.c:1646  */
626     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[0].val.opval), (ps[-2].val.opval)); }
627
628     break;
629
630   case 64:
631 #line 528 "perly.y" /* yacc.c:1646  */
632     { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[0].val.opval), (ps[-2].val.opval)); }
633
634     break;
635
636   case 65:
637 #line 530 "perly.y" /* yacc.c:1646  */
638     { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, scalar((ps[0].val.opval)), (ps[-2].val.opval)); }
639
640     break;
641
642   case 66:
643 #line 532 "perly.y" /* yacc.c:1646  */
644     { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, (ps[0].val.opval), (ps[-2].val.opval)); }
645
646     break;
647
648   case 67:
649 #line 534 "perly.y" /* yacc.c:1646  */
650     { (yyval.opval) = newFOROP(0, NULL, (ps[0].val.opval), (ps[-2].val.opval), NULL);
651                           parser->copline = (line_t)(ps[-1].val.ival); }
652
653     break;
654
655   case 68:
656 #line 537 "perly.y" /* yacc.c:1646  */
657     { (yyval.opval) = newWHENOP((ps[0].val.opval), op_scope((ps[-2].val.opval))); }
658
659     break;
660
661   case 69:
662 #line 542 "perly.y" /* yacc.c:1646  */
663     { (yyval.opval) = NULL; }
664
665     break;
666
667   case 70:
668 #line 544 "perly.y" /* yacc.c:1646  */
669     {
670                           ((ps[0].val.opval))->op_flags |= OPf_PARENS;
671                           (yyval.opval) = op_scope((ps[0].val.opval));
672                         }
673
674     break;
675
676   case 71:
677 #line 549 "perly.y" /* yacc.c:1646  */
678     { parser->copline = (line_t)(ps[-5].val.ival);
679                             (yyval.opval) = newCONDOP(0,
680                                 newSTATEOP(OPf_SPECIAL,NULL,(ps[-3].val.opval)),
681                                 op_scope((ps[-1].val.opval)), (ps[0].val.opval));
682                           PL_hints |= HINT_BLOCK_SCOPE;
683                         }
684
685     break;
686
687   case 72:
688 #line 559 "perly.y" /* yacc.c:1646  */
689     { (yyval.opval) = NULL; }
690
691     break;
692
693   case 73:
694 #line 561 "perly.y" /* yacc.c:1646  */
695     { (yyval.opval) = op_scope((ps[0].val.opval)); }
696
697     break;
698
699   case 74:
700 #line 566 "perly.y" /* yacc.c:1646  */
701     { (yyval.ival) = (PL_min_intro_pending &&
702                             PL_max_intro_pending >=  PL_min_intro_pending);
703                           intro_my(); }
704
705     break;
706
707   case 75:
708 #line 572 "perly.y" /* yacc.c:1646  */
709     { (yyval.opval) = NULL; }
710
711     break;
712
713   case 77:
714 #line 578 "perly.y" /* yacc.c:1646  */
715     { YYSTYPE tmplval;
716                           (void)scan_num("1", &tmplval);
717                           (yyval.opval) = tmplval.opval; }
718
719     break;
720
721   case 79:
722 #line 586 "perly.y" /* yacc.c:1646  */
723     { (yyval.opval) = invert(scalar((ps[0].val.opval))); }
724
725     break;
726
727   case 80:
728 #line 591 "perly.y" /* yacc.c:1646  */
729     { (yyval.opval) = (ps[0].val.opval); intro_my(); }
730
731     break;
732
733   case 81:
734 #line 595 "perly.y" /* yacc.c:1646  */
735     { (yyval.opval) = (ps[0].val.opval); intro_my(); }
736
737     break;
738
739   case 82:
740 #line 598 "perly.y" /* yacc.c:1646  */
741     { (yyval.opval) = (ps[0].val.opval); }
742
743     break;
744
745   case 83:
746 #line 599 "perly.y" /* yacc.c:1646  */
747     { (yyval.opval) = NULL; }
748
749     break;
750
751   case 84:
752 #line 603 "perly.y" /* yacc.c:1646  */
753     { (yyval.ival) = start_subparse(FALSE, 0);
754                             SAVEFREESV(PL_compcv); }
755
756     break;
757
758   case 85:
759 #line 609 "perly.y" /* yacc.c:1646  */
760     { (yyval.ival) = start_subparse(FALSE, CVf_ANON);
761                             SAVEFREESV(PL_compcv); }
762
763     break;
764
765   case 86:
766 #line 614 "perly.y" /* yacc.c:1646  */
767     { (yyval.ival) = start_subparse(TRUE, 0);
768                             SAVEFREESV(PL_compcv); }
769
770     break;
771
772   case 89:
773 #line 625 "perly.y" /* yacc.c:1646  */
774     { (yyval.opval) = NULL; }
775
776     break;
777
778   case 91:
779 #line 631 "perly.y" /* yacc.c:1646  */
780     { (yyval.opval) = NULL; }
781
782     break;
783
784   case 92:
785 #line 633 "perly.y" /* yacc.c:1646  */
786     { (yyval.opval) = (ps[0].val.opval); }
787
788     break;
789
790   case 93:
791 #line 635 "perly.y" /* yacc.c:1646  */
792     { (yyval.opval) = NULL; }
793
794     break;
795
796   case 94:
797 #line 640 "perly.y" /* yacc.c:1646  */
798     { (yyval.opval) = (ps[0].val.opval); }
799
800     break;
801
802   case 95:
803 #line 642 "perly.y" /* yacc.c:1646  */
804     { (yyval.opval) = NULL; }
805
806     break;
807
808   case 96:
809 #line 653 "perly.y" /* yacc.c:1646  */
810     { parser->in_my = 0; (yyval.opval) = NULL; }
811
812     break;
813
814   case 97:
815 #line 655 "perly.y" /* yacc.c:1646  */
816     { parser->in_my = 0; (yyval.opval) = (ps[0].val.opval); }
817
818     break;
819
820   case 98:
821 #line 660 "perly.y" /* yacc.c:1646  */
822     { (yyval.ival) = '@'; }
823
824     break;
825
826   case 99:
827 #line 662 "perly.y" /* yacc.c:1646  */
828     { (yyval.ival) = '%'; }
829
830     break;
831
832   case 100:
833 #line 666 "perly.y" /* yacc.c:1646  */
834     {
835                             I32 sigil   = (ps[-2].val.ival);
836                             OP *var     = (ps[-1].val.opval);
837                             OP *defexpr = (ps[0].val.opval);
838
839                             if (parser->sig_slurpy)
840                                 yyerror("Multiple slurpy parameters not allowed");
841                             parser->sig_slurpy = (char)sigil;
842
843                             if (defexpr)
844                                 yyerror("A slurpy parameter may not have "
845                                         "a default value");
846
847                             (yyval.opval) = var ? newSTATEOP(0, NULL, var) : NULL;
848                         }
849
850     break;
851
852   case 101:
853 #line 685 "perly.y" /* yacc.c:1646  */
854     { (yyval.opval) = NULL; }
855
856     break;
857
858   case 102:
859 #line 687 "perly.y" /* yacc.c:1646  */
860     { (yyval.opval) = newOP(OP_NULL, 0); }
861
862     break;
863
864   case 103:
865 #line 689 "perly.y" /* yacc.c:1646  */
866     { (yyval.opval) = (ps[0].val.opval); }
867
868     break;
869
870   case 104:
871 #line 695 "perly.y" /* yacc.c:1646  */
872     {
873                             OP *var     = (ps[-1].val.opval);
874                             OP *defexpr = (ps[0].val.opval);
875
876                             if (parser->sig_slurpy)
877                                 yyerror("Slurpy parameter not last");
878
879                             parser->sig_elems++;
880
881                             if (defexpr) {
882                                 parser->sig_optelems++;
883
884                                 if (   defexpr->op_type == OP_NULL
885                                     && !(defexpr->op_flags & OPf_KIDS))
886                                 {
887                                     /* handle '$=' special case */
888                                     if (var)
889                                         yyerror("Optional parameter "
890                                                     "lacks default expression");
891                                     op_free(defexpr);
892                                 }
893                                 else { 
894                                     /* a normal '=default' expression */ 
895                                     OP *defop = (OP*)alloc_LOGOP(OP_ARGDEFELEM,
896                                                         defexpr,
897                                                         LINKLIST(defexpr));
898                                     /* re-purpose op_targ to hold @_ index */
899                                     defop->op_targ =
900                                         (PADOFFSET)(parser->sig_elems - 1);
901
902                                     if (var) {
903                                         var->op_flags |= OPf_STACKED;
904                                         (void)op_sibling_splice(var,
905                                                         NULL, 0, defop);
906                                         scalar(defop);
907                                     }
908                                     else
909                                         var = newUNOP(OP_NULL, 0, defop);
910
911                                     LINKLIST(var);
912                                     /* NB: normally the first child of a
913                                      * logop is executed before the logop,
914                                      * and it pushes a boolean result
915                                      * ready for the logop. For ARGDEFELEM,
916                                      * the op itself does the boolean
917                                      * calculation, so set the first op to
918                                      * it instead.
919                                      */
920                                     var->op_next = defop;
921                                     defexpr->op_next = var;
922                                 }
923                             }
924                             else {
925                                 if (parser->sig_optelems)
926                                     yyerror("Mandatory parameter "
927                                             "follows optional parameter");
928                             }
929
930                             (yyval.opval) = var ? newSTATEOP(0, NULL, var) : NULL;
931                         }
932
933     break;
934
935   case 105:
936 #line 760 "perly.y" /* yacc.c:1646  */
937     { parser->in_my = KEY_sigvar; (yyval.opval) = (ps[0].val.opval); }
938
939     break;
940
941   case 106:
942 #line 762 "perly.y" /* yacc.c:1646  */
943     { parser->in_my = KEY_sigvar; (yyval.opval) = (ps[0].val.opval); }
944
945     break;
946
947   case 107:
948 #line 768 "perly.y" /* yacc.c:1646  */
949     { (yyval.opval) = (ps[-1].val.opval); }
950
951     break;
952
953   case 108:
954 #line 770 "perly.y" /* yacc.c:1646  */
955     {
956                           (yyval.opval) = op_append_list(OP_LINESEQ, (ps[-2].val.opval), (ps[0].val.opval));
957                         }
958
959     break;
960
961   case 109:
962 #line 774 "perly.y" /* yacc.c:1646  */
963     { (yyval.opval) = (ps[0].val.opval); }
964
965     break;
966
967   case 110:
968 #line 779 "perly.y" /* yacc.c:1646  */
969     { (yyval.opval) = NULL; }
970
971     break;
972
973   case 111:
974 #line 781 "perly.y" /* yacc.c:1646  */
975     { (yyval.opval) = (ps[0].val.opval); }
976
977     break;
978
979   case 112:
980 #line 785 "perly.y" /* yacc.c:1646  */
981     {
982                             ENTER;
983                             SAVEIV(parser->sig_elems);
984                             SAVEIV(parser->sig_optelems);
985                             SAVEI8(parser->sig_slurpy);
986                             parser->sig_elems    = 0;
987                             parser->sig_optelems = 0;
988                             parser->sig_slurpy   = 0;
989                             parser->in_my        = KEY_sigvar;
990                         }
991
992     break;
993
994   case 113:
995 #line 797 "perly.y" /* yacc.c:1646  */
996     {
997                             OP            *sigops = (ps[-1].val.opval);
998                             UNOP_AUX_item *aux;
999                             OP            *check;
1000
1001                             if (!parser->error_count) {
1002                                 assert(FEATURE_SIGNATURES_IS_ENABLED);
1003                             }
1004
1005                             /* We shouldn't get here otherwise */
1006                             Perl_ck_warner_d(aTHX_
1007                                 packWARN(WARN_EXPERIMENTAL__SIGNATURES),
1008                                 "The signatures feature is experimental");
1009
1010                             aux = (UNOP_AUX_item*)PerlMemShared_malloc(
1011                                 sizeof(UNOP_AUX_item) * 3);
1012                             aux[0].iv = parser->sig_elems;
1013                             aux[1].iv = parser->sig_optelems;
1014                             aux[2].iv = parser->sig_slurpy;
1015                             check = newUNOP_AUX(OP_ARGCHECK, 0, NULL, aux);
1016                             sigops = op_prepend_elem(OP_LINESEQ, check, sigops);
1017                             sigops = op_prepend_elem(OP_LINESEQ,
1018                                                 newSTATEOP(0, NULL, NULL),
1019                                                 sigops);
1020                             /* a nextstate at the end handles context
1021                              * correctly for an empty sub body */
1022                             (yyval.opval) = op_append_elem(OP_LINESEQ,
1023                                                 sigops,
1024                                                 newSTATEOP(0, NULL, NULL));
1025
1026                             parser->in_my = 0;
1027                             parser->expect = XATTRBLOCK;
1028                             LEAVE;
1029                         }
1030
1031     break;
1032
1033   case 115:
1034 #line 837 "perly.y" /* yacc.c:1646  */
1035     { (yyval.opval) = NULL; }
1036
1037     break;
1038
1039   case 116:
1040 #line 842 "perly.y" /* yacc.c:1646  */
1041     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1042
1043     break;
1044
1045   case 117:
1046 #line 844 "perly.y" /* yacc.c:1646  */
1047     { (yyval.opval) = newLOGOP((ps[-1].val.ival), 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1048
1049     break;
1050
1051   case 118:
1052 #line 846 "perly.y" /* yacc.c:1646  */
1053     { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1054
1055     break;
1056
1057   case 120:
1058 #line 852 "perly.y" /* yacc.c:1646  */
1059     { (yyval.opval) = (ps[-1].val.opval); }
1060
1061     break;
1062
1063   case 121:
1064 #line 854 "perly.y" /* yacc.c:1646  */
1065     {
1066                           OP* term = (ps[0].val.opval);
1067                           (yyval.opval) = op_append_elem(OP_LIST, (ps[-2].val.opval), term);
1068                         }
1069
1070     break;
1071
1072   case 123:
1073 #line 863 "perly.y" /* yacc.c:1646  */
1074     { (yyval.opval) = op_convert_list((ps[-2].val.ival), OPf_STACKED,
1075                                 op_prepend_elem(OP_LIST, newGVREF((ps[-2].val.ival),(ps[-1].val.opval)), (ps[0].val.opval)) );
1076                         }
1077
1078     break;
1079
1080   case 124:
1081 #line 867 "perly.y" /* yacc.c:1646  */
1082     { (yyval.opval) = op_convert_list((ps[-4].val.ival), OPf_STACKED,
1083                                 op_prepend_elem(OP_LIST, newGVREF((ps[-4].val.ival),(ps[-2].val.opval)), (ps[-1].val.opval)) );
1084                         }
1085
1086     break;
1087
1088   case 125:
1089 #line 871 "perly.y" /* yacc.c:1646  */
1090     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
1091                                 op_append_elem(OP_LIST,
1092                                     op_prepend_elem(OP_LIST, scalar((ps[-5].val.opval)), (ps[-1].val.opval)),
1093                                     newMETHOP(OP_METHOD, 0, (ps[-3].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, scalar((ps[-2].val.opval)),
1102                                     newMETHOP(OP_METHOD, 0, (ps[0].val.opval))));
1103                         }
1104
1105     break;
1106
1107   case 127:
1108 #line 882 "perly.y" /* yacc.c:1646  */
1109     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
1110                                 op_append_elem(OP_LIST,
1111                                     op_prepend_elem(OP_LIST, (ps[-1].val.opval), (ps[0].val.opval)),
1112                                     newMETHOP(OP_METHOD, 0, (ps[-2].val.opval))));
1113                         }
1114
1115     break;
1116
1117   case 128:
1118 #line 888 "perly.y" /* yacc.c:1646  */
1119     { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
1120                                 op_append_elem(OP_LIST,
1121                                     op_prepend_elem(OP_LIST, (ps[-3].val.opval), (ps[-1].val.opval)),
1122                                     newMETHOP(OP_METHOD, 0, (ps[-4].val.opval))));
1123                         }
1124
1125     break;
1126
1127   case 129:
1128 #line 894 "perly.y" /* yacc.c:1646  */
1129     { (yyval.opval) = op_convert_list((ps[-1].val.ival), 0, (ps[0].val.opval)); }
1130
1131     break;
1132
1133   case 130:
1134 #line 896 "perly.y" /* yacc.c:1646  */
1135     { (yyval.opval) = op_convert_list((ps[-3].val.ival), 0, (ps[-1].val.opval)); }
1136
1137     break;
1138
1139   case 131:
1140 #line 898 "perly.y" /* yacc.c:1646  */
1141     { SvREFCNT_inc_simple_void(PL_compcv);
1142                           (yyval.opval) = newANONATTRSUB((ps[-1].val.ival), 0, NULL, (ps[0].val.opval)); }
1143
1144     break;
1145
1146   case 132:
1147 #line 901 "perly.y" /* yacc.c:1646  */
1148     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1149                                  op_append_elem(OP_LIST,
1150                                    op_prepend_elem(OP_LIST, (ps[-1].val.opval), (ps[0].val.opval)), (ps[-4].val.opval)));
1151                         }
1152
1153     break;
1154
1155   case 135:
1156 #line 916 "perly.y" /* yacc.c:1646  */
1157     { (yyval.opval) = newBINOP(OP_GELEM, 0, (ps[-4].val.opval), scalar((ps[-2].val.opval))); }
1158
1159     break;
1160
1161   case 136:
1162 #line 918 "perly.y" /* yacc.c:1646  */
1163     { (yyval.opval) = newBINOP(OP_AELEM, 0, oopsAV((ps[-3].val.opval)), 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[-4].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_AELEM, 0,
1180                                         ref(newAVREF((ps[-3].val.opval)),OP_RV2AV),
1181                                         scalar((ps[-1].val.opval)));
1182                         }
1183
1184     break;
1185
1186   case 139:
1187 #line 931 "perly.y" /* yacc.c:1646  */
1188     { (yyval.opval) = newBINOP(OP_HELEM, 0, oopsHV((ps[-4].val.opval)), jmaybe((ps[-2].val.opval)));
1189                         }
1190
1191     break;
1192
1193   case 140:
1194 #line 934 "perly.y" /* yacc.c:1646  */
1195     { (yyval.opval) = newBINOP(OP_HELEM, 0,
1196                                         ref(newHVREF((ps[-5].val.opval)),OP_RV2HV),
1197                                         jmaybe((ps[-2].val.opval))); }
1198
1199     break;
1200
1201   case 141:
1202 #line 938 "perly.y" /* yacc.c:1646  */
1203     { (yyval.opval) = newBINOP(OP_HELEM, 0,
1204                                         ref(newHVREF((ps[-4].val.opval)),OP_RV2HV),
1205                                         jmaybe((ps[-2].val.opval))); }
1206
1207     break;
1208
1209   case 142:
1210 #line 942 "perly.y" /* yacc.c:1646  */
1211     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1212                                    newCVREF(0, scalar((ps[-3].val.opval)))); }
1213
1214     break;
1215
1216   case 143:
1217 #line 945 "perly.y" /* yacc.c:1646  */
1218     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1219                                    op_append_elem(OP_LIST, (ps[-1].val.opval),
1220                                        newCVREF(0, scalar((ps[-4].val.opval))))); }
1221
1222     break;
1223
1224   case 144:
1225 #line 950 "perly.y" /* yacc.c:1646  */
1226     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1227                                    op_append_elem(OP_LIST, (ps[-1].val.opval),
1228                                                newCVREF(0, scalar((ps[-3].val.opval))))); }
1229
1230     break;
1231
1232   case 145:
1233 #line 954 "perly.y" /* yacc.c:1646  */
1234     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1235                                    newCVREF(0, scalar((ps[-2].val.opval)))); }
1236
1237     break;
1238
1239   case 146:
1240 #line 957 "perly.y" /* yacc.c:1646  */
1241     { (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), (ps[-4].val.opval)); }
1242
1243     break;
1244
1245   case 147:
1246 #line 959 "perly.y" /* yacc.c:1646  */
1247     { (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), (ps[-3].val.opval)); }
1248
1249     break;
1250
1251   case 148:
1252 #line 961 "perly.y" /* yacc.c:1646  */
1253     { (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), NULL); }
1254
1255     break;
1256
1257   case 149:
1258 #line 966 "perly.y" /* yacc.c:1646  */
1259     { (yyval.opval) = newASSIGNOP(OPf_STACKED, (ps[-2].val.opval), (ps[-1].val.ival), (ps[0].val.opval)); }
1260
1261     break;
1262
1263   case 150:
1264 #line 968 "perly.y" /* yacc.c:1646  */
1265     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1266
1267     break;
1268
1269   case 151:
1270 #line 970 "perly.y" /* yacc.c:1646  */
1271     {   if ((ps[-1].val.ival) != OP_REPEAT)
1272                                 scalar((ps[-2].val.opval));
1273                             (yyval.opval) = newBINOP((ps[-1].val.ival), 0, (ps[-2].val.opval), scalar((ps[0].val.opval)));
1274                         }
1275
1276     break;
1277
1278   case 152:
1279 #line 975 "perly.y" /* yacc.c:1646  */
1280     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1281
1282     break;
1283
1284   case 153:
1285 #line 977 "perly.y" /* yacc.c:1646  */
1286     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1287
1288     break;
1289
1290   case 154:
1291 #line 979 "perly.y" /* yacc.c:1646  */
1292     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1293
1294     break;
1295
1296   case 155:
1297 #line 981 "perly.y" /* yacc.c:1646  */
1298     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1299
1300     break;
1301
1302   case 156:
1303 #line 983 "perly.y" /* yacc.c:1646  */
1304     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1305
1306     break;
1307
1308   case 157:
1309 #line 985 "perly.y" /* yacc.c:1646  */
1310     { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1311
1312     break;
1313
1314   case 158:
1315 #line 987 "perly.y" /* yacc.c:1646  */
1316     { (yyval.opval) = newRANGE((ps[-1].val.ival), scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1317
1318     break;
1319
1320   case 159:
1321 #line 989 "perly.y" /* yacc.c:1646  */
1322     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1323
1324     break;
1325
1326   case 160:
1327 #line 991 "perly.y" /* yacc.c:1646  */
1328     { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1329
1330     break;
1331
1332   case 161:
1333 #line 993 "perly.y" /* yacc.c:1646  */
1334     { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1335
1336     break;
1337
1338   case 162:
1339 #line 995 "perly.y" /* yacc.c:1646  */
1340     { (yyval.opval) = bind_match((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); }
1341
1342     break;
1343
1344   case 163:
1345 #line 1000 "perly.y" /* yacc.c:1646  */
1346     { (yyval.opval) = newUNOP(OP_NEGATE, 0, scalar((ps[0].val.opval))); }
1347
1348     break;
1349
1350   case 164:
1351 #line 1002 "perly.y" /* yacc.c:1646  */
1352     { (yyval.opval) = (ps[0].val.opval); }
1353
1354     break;
1355
1356   case 165:
1357 #line 1005 "perly.y" /* yacc.c:1646  */
1358     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[0].val.opval))); }
1359
1360     break;
1361
1362   case 166:
1363 #line 1007 "perly.y" /* yacc.c:1646  */
1364     { (yyval.opval) = newUNOP((ps[-1].val.ival), 0, scalar((ps[0].val.opval))); }
1365
1366     break;
1367
1368   case 167:
1369 #line 1009 "perly.y" /* yacc.c:1646  */
1370     { (yyval.opval) = newUNOP(OP_POSTINC, 0,
1371                                         op_lvalue(scalar((ps[-1].val.opval)), OP_POSTINC)); }
1372
1373     break;
1374
1375   case 168:
1376 #line 1012 "perly.y" /* yacc.c:1646  */
1377     { (yyval.opval) = newUNOP(OP_POSTDEC, 0,
1378                                         op_lvalue(scalar((ps[-1].val.opval)), OP_POSTDEC));}
1379
1380     break;
1381
1382   case 169:
1383 #line 1015 "perly.y" /* yacc.c:1646  */
1384     { (yyval.opval) = op_convert_list(OP_JOIN, 0,
1385                                        op_append_elem(
1386                                         OP_LIST,
1387                                         newSVREF(scalar(
1388                                             newSVOP(OP_CONST,0,
1389                                                     newSVpvs("\""))
1390                                         )),
1391                                         (ps[-1].val.opval)
1392                                        ));
1393                         }
1394
1395     break;
1396
1397   case 170:
1398 #line 1026 "perly.y" /* yacc.c:1646  */
1399     { (yyval.opval) = newUNOP(OP_PREINC, 0,
1400                                         op_lvalue(scalar((ps[0].val.opval)), OP_PREINC)); }
1401
1402     break;
1403
1404   case 171:
1405 #line 1029 "perly.y" /* yacc.c:1646  */
1406     { (yyval.opval) = newUNOP(OP_PREDEC, 0,
1407                                         op_lvalue(scalar((ps[0].val.opval)), OP_PREDEC)); }
1408
1409     break;
1410
1411   case 172:
1412 #line 1036 "perly.y" /* yacc.c:1646  */
1413     { (yyval.opval) = newANONLIST((ps[-1].val.opval)); }
1414
1415     break;
1416
1417   case 173:
1418 #line 1038 "perly.y" /* yacc.c:1646  */
1419     { (yyval.opval) = newANONLIST(NULL);}
1420
1421     break;
1422
1423   case 174:
1424 #line 1040 "perly.y" /* yacc.c:1646  */
1425     { (yyval.opval) = newANONHASH((ps[-2].val.opval)); }
1426
1427     break;
1428
1429   case 175:
1430 #line 1042 "perly.y" /* yacc.c:1646  */
1431     { (yyval.opval) = newANONHASH(NULL); }
1432
1433     break;
1434
1435   case 176:
1436 #line 1044 "perly.y" /* yacc.c:1646  */
1437     { SvREFCNT_inc_simple_void(PL_compcv);
1438                           (yyval.opval) = newANONATTRSUB((ps[-3].val.ival), (ps[-2].val.opval), (ps[-1].val.opval), (ps[0].val.opval)); }
1439
1440     break;
1441
1442   case 177:
1443 #line 1047 "perly.y" /* yacc.c:1646  */
1444     {
1445                           OP *body;
1446                           if (parser->copline > (line_t)(ps[-2].val.ival))
1447                               parser->copline = (line_t)(ps[-2].val.ival);
1448                           body = block_end((ps[-5].val.ival),
1449                                 op_append_list(OP_LINESEQ, (ps[-4].val.opval), (ps[-1].val.opval)));
1450                           SvREFCNT_inc_simple_void(PL_compcv);
1451                           (yyval.opval) = newANONATTRSUB((ps[-6].val.ival), NULL, (ps[-3].val.opval), body);
1452                         }
1453
1454     break;
1455
1456   case 178:
1457 #line 1061 "perly.y" /* yacc.c:1646  */
1458     { (yyval.opval) = dofile((ps[0].val.opval), (ps[-1].val.ival));}
1459
1460     break;
1461
1462   case 179:
1463 #line 1063 "perly.y" /* yacc.c:1646  */
1464     { (yyval.opval) = newUNOP(OP_NULL, OPf_SPECIAL, op_scope((ps[0].val.opval)));}
1465
1466     break;
1467
1468   case 184:
1469 #line 1071 "perly.y" /* yacc.c:1646  */
1470     { (yyval.opval) = newCONDOP(0, (ps[-4].val.opval), (ps[-2].val.opval), (ps[0].val.opval)); }
1471
1472     break;
1473
1474   case 185:
1475 #line 1073 "perly.y" /* yacc.c:1646  */
1476     { (yyval.opval) = newUNOP(OP_REFGEN, 0, (ps[0].val.opval)); }
1477
1478     break;
1479
1480   case 186:
1481 #line 1075 "perly.y" /* yacc.c:1646  */
1482     { (yyval.opval) = newUNOP(OP_REFGEN, 0, localize((ps[0].val.opval),1)); }
1483
1484     break;
1485
1486   case 187:
1487 #line 1077 "perly.y" /* yacc.c:1646  */
1488     { (yyval.opval) = (ps[0].val.opval); }
1489
1490     break;
1491
1492   case 188:
1493 #line 1079 "perly.y" /* yacc.c:1646  */
1494     { (yyval.opval) = localize((ps[0].val.opval),0); }
1495
1496     break;
1497
1498   case 189:
1499 #line 1081 "perly.y" /* yacc.c:1646  */
1500     { (yyval.opval) = sawparens((ps[-1].val.opval)); }
1501
1502     break;
1503
1504   case 190:
1505 #line 1083 "perly.y" /* yacc.c:1646  */
1506     { (yyval.opval) = (ps[0].val.opval); }
1507
1508     break;
1509
1510   case 191:
1511 #line 1085 "perly.y" /* yacc.c:1646  */
1512     { (yyval.opval) = sawparens(newNULLLIST()); }
1513
1514     break;
1515
1516   case 192:
1517 #line 1087 "perly.y" /* yacc.c:1646  */
1518     { (yyval.opval) = (ps[0].val.opval); }
1519
1520     break;
1521
1522   case 193:
1523 #line 1089 "perly.y" /* yacc.c:1646  */
1524     { (yyval.opval) = (ps[0].val.opval); }
1525
1526     break;
1527
1528   case 194:
1529 #line 1091 "perly.y" /* yacc.c:1646  */
1530     { (yyval.opval) = (ps[0].val.opval); }
1531
1532     break;
1533
1534   case 195:
1535 #line 1093 "perly.y" /* yacc.c:1646  */
1536     { (yyval.opval) = (ps[0].val.opval); }
1537
1538     break;
1539
1540   case 196:
1541 #line 1095 "perly.y" /* yacc.c:1646  */
1542     { (yyval.opval) = newUNOP(OP_AV2ARYLEN, 0, ref((ps[0].val.opval), OP_AV2ARYLEN));}
1543
1544     break;
1545
1546   case 197:
1547 #line 1097 "perly.y" /* yacc.c:1646  */
1548     { (yyval.opval) = (ps[0].val.opval); }
1549
1550     break;
1551
1552   case 198:
1553 #line 1099 "perly.y" /* yacc.c:1646  */
1554     { (yyval.opval) = op_prepend_elem(OP_ASLICE,
1555                                 newOP(OP_PUSHMARK, 0),
1556                                     newLISTOP(OP_ASLICE, 0,
1557                                         list((ps[-1].val.opval)),
1558                                         ref((ps[-3].val.opval), OP_ASLICE)));
1559                           if ((yyval.opval) && (ps[-3].val.opval))
1560                               (yyval.opval)->op_private |=
1561                                   (ps[-3].val.opval)->op_private & OPpSLICEWARNING;
1562                         }
1563
1564     break;
1565
1566   case 199:
1567 #line 1109 "perly.y" /* yacc.c:1646  */
1568     { (yyval.opval) = op_prepend_elem(OP_KVASLICE,
1569                                 newOP(OP_PUSHMARK, 0),
1570                                     newLISTOP(OP_KVASLICE, 0,
1571                                         list((ps[-1].val.opval)),
1572                                         ref(oopsAV((ps[-3].val.opval)), OP_KVASLICE)));
1573                           if ((yyval.opval) && (ps[-3].val.opval))
1574                               (yyval.opval)->op_private |=
1575                                   (ps[-3].val.opval)->op_private & OPpSLICEWARNING;
1576                         }
1577
1578     break;
1579
1580   case 200:
1581 #line 1119 "perly.y" /* yacc.c:1646  */
1582     { (yyval.opval) = op_prepend_elem(OP_HSLICE,
1583                                 newOP(OP_PUSHMARK, 0),
1584                                     newLISTOP(OP_HSLICE, 0,
1585                                         list((ps[-2].val.opval)),
1586                                         ref(oopsHV((ps[-4].val.opval)), OP_HSLICE)));
1587                           if ((yyval.opval) && (ps[-4].val.opval))
1588                               (yyval.opval)->op_private |=
1589                                   (ps[-4].val.opval)->op_private & OPpSLICEWARNING;
1590                         }
1591
1592     break;
1593
1594   case 201:
1595 #line 1129 "perly.y" /* yacc.c:1646  */
1596     { (yyval.opval) = op_prepend_elem(OP_KVHSLICE,
1597                                 newOP(OP_PUSHMARK, 0),
1598                                     newLISTOP(OP_KVHSLICE, 0,
1599                                         list((ps[-2].val.opval)),
1600                                         ref((ps[-4].val.opval), OP_KVHSLICE)));
1601                           if ((yyval.opval) && (ps[-4].val.opval))
1602                               (yyval.opval)->op_private |=
1603                                   (ps[-4].val.opval)->op_private & OPpSLICEWARNING;
1604                         }
1605
1606     break;
1607
1608   case 202:
1609 #line 1139 "perly.y" /* yacc.c:1646  */
1610     { (yyval.opval) = (ps[0].val.opval); }
1611
1612     break;
1613
1614   case 203:
1615 #line 1141 "perly.y" /* yacc.c:1646  */
1616     { (yyval.opval) = newUNOP(OP_ENTERSUB, 0, scalar((ps[0].val.opval))); }
1617
1618     break;
1619
1620   case 204:
1621 #line 1143 "perly.y" /* yacc.c:1646  */
1622     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[-2].val.opval)));
1623                         }
1624
1625     break;
1626
1627   case 205:
1628 #line 1146 "perly.y" /* yacc.c:1646  */
1629     {
1630                           (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1631                                 op_append_elem(OP_LIST, (ps[-1].val.opval), scalar((ps[-3].val.opval))));
1632                         }
1633
1634     break;
1635
1636   case 206:
1637 #line 1151 "perly.y" /* yacc.c:1646  */
1638     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1639                             op_append_elem(OP_LIST, (ps[0].val.opval), scalar((ps[-1].val.opval))));
1640                         }
1641
1642     break;
1643
1644   case 207:
1645 #line 1155 "perly.y" /* yacc.c:1646  */
1646     { (yyval.opval) = newSVREF((ps[-3].val.opval)); }
1647
1648     break;
1649
1650   case 208:
1651 #line 1157 "perly.y" /* yacc.c:1646  */
1652     { (yyval.opval) = newAVREF((ps[-3].val.opval)); }
1653
1654     break;
1655
1656   case 209:
1657 #line 1159 "perly.y" /* yacc.c:1646  */
1658     { (yyval.opval) = newHVREF((ps[-3].val.opval)); }
1659
1660     break;
1661
1662   case 210:
1663 #line 1161 "perly.y" /* yacc.c:1646  */
1664     { (yyval.opval) = newUNOP(OP_ENTERSUB, 0,
1665                                        scalar(newCVREF((ps[-1].val.ival),(ps[-3].val.opval)))); }
1666
1667     break;
1668
1669   case 211:
1670 #line 1164 "perly.y" /* yacc.c:1646  */
1671     { (yyval.opval) = newGVREF(0,(ps[-3].val.opval)); }
1672
1673     break;
1674
1675   case 212:
1676 #line 1166 "perly.y" /* yacc.c:1646  */
1677     { (yyval.opval) = newOP((ps[0].val.ival), OPf_SPECIAL);
1678                             PL_hints |= HINT_BLOCK_SCOPE; }
1679
1680     break;
1681
1682   case 213:
1683 #line 1169 "perly.y" /* yacc.c:1646  */
1684     { (yyval.opval) = newLOOPEX((ps[-1].val.ival),(ps[0].val.opval)); }
1685
1686     break;
1687
1688   case 214:
1689 #line 1171 "perly.y" /* yacc.c:1646  */
1690     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[0].val.opval))); }
1691
1692     break;
1693
1694   case 215:
1695 #line 1173 "perly.y" /* yacc.c:1646  */
1696     { (yyval.opval) = newOP((ps[0].val.ival), 0); }
1697
1698     break;
1699
1700   case 216:
1701 #line 1175 "perly.y" /* yacc.c:1646  */
1702     { (yyval.opval) = newUNOP((ps[-1].val.ival), 0, (ps[0].val.opval)); }
1703
1704     break;
1705
1706   case 217:
1707 #line 1177 "perly.y" /* yacc.c:1646  */
1708     { (yyval.opval) = newUNOP((ps[-1].val.ival), 0, (ps[0].val.opval)); }
1709
1710     break;
1711
1712   case 218:
1713 #line 1179 "perly.y" /* yacc.c:1646  */
1714     { (yyval.opval) = newOP(OP_REQUIRE, (ps[0].val.ival) ? OPf_SPECIAL : 0); }
1715
1716     break;
1717
1718   case 219:
1719 #line 1181 "perly.y" /* yacc.c:1646  */
1720     { (yyval.opval) = newUNOP(OP_REQUIRE, (ps[-1].val.ival) ? OPf_SPECIAL : 0, (ps[0].val.opval)); }
1721
1722     break;
1723
1724   case 220:
1725 #line 1183 "perly.y" /* yacc.c:1646  */
1726     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[0].val.opval))); }
1727
1728     break;
1729
1730   case 221:
1731 #line 1185 "perly.y" /* yacc.c:1646  */
1732     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1733                             op_append_elem(OP_LIST, (ps[0].val.opval), scalar((ps[-1].val.opval)))); }
1734
1735     break;
1736
1737   case 222:
1738 #line 1188 "perly.y" /* yacc.c:1646  */
1739     { (yyval.opval) = newOP((ps[0].val.ival), 0); }
1740
1741     break;
1742
1743   case 223:
1744 #line 1190 "perly.y" /* yacc.c:1646  */
1745     { (yyval.opval) = newOP((ps[-2].val.ival), 0);}
1746
1747     break;
1748
1749   case 224:
1750 #line 1192 "perly.y" /* yacc.c:1646  */
1751     { (yyval.opval) = (ps[0].val.opval); }
1752
1753     break;
1754
1755   case 225:
1756 #line 1194 "perly.y" /* yacc.c:1646  */
1757     { (yyval.opval) = (ps[-2].val.opval); }
1758
1759     break;
1760
1761   case 226:
1762 #line 1196 "perly.y" /* yacc.c:1646  */
1763     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[0].val.opval))); }
1764
1765     break;
1766
1767   case 227:
1768 #line 1198 "perly.y" /* yacc.c:1646  */
1769     { (yyval.opval) = ((ps[-2].val.ival) == OP_NOT)
1770                           ? newUNOP((ps[-2].val.ival), 0, newSVOP(OP_CONST, 0, newSViv(0)))
1771                           : newOP((ps[-2].val.ival), OPf_SPECIAL); }
1772
1773     break;
1774
1775   case 228:
1776 #line 1202 "perly.y" /* yacc.c:1646  */
1777     { (yyval.opval) = newUNOP((ps[-3].val.ival), 0, (ps[-1].val.opval)); }
1778
1779     break;
1780
1781   case 229:
1782 #line 1204 "perly.y" /* yacc.c:1646  */
1783     {
1784                             if (   (ps[0].val.opval)->op_type != OP_TRANS
1785                                 && (ps[0].val.opval)->op_type != OP_TRANSR
1786                                 && (((PMOP*)(ps[0].val.opval))->op_pmflags & PMf_HAS_CV))
1787                             {
1788                                 (yyval.ival) = start_subparse(FALSE, CVf_ANON);
1789                                 SAVEFREESV(PL_compcv);
1790                             } else
1791                                 (yyval.ival) = 0;
1792                         }
1793
1794     break;
1795
1796   case 230:
1797 #line 1215 "perly.y" /* yacc.c:1646  */
1798     { (yyval.opval) = pmruntime((ps[-5].val.opval), (ps[-2].val.opval), (ps[-1].val.opval), 1, (ps[-4].val.ival)); }
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  * 4667736d3c31a5169bab73c89d70a27dbce5ea4fe7e3c332a236f8a210aafdc2 perly.y
1987  * b6fae5748f9bef6db4740aa5e122b84ac5181852d42474d0ecad621fa4253306 regen_perly.pl
1988  * ex: set ro: */