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