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