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