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