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