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