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