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