Move I18N::LangTags from ext/ to dist/
[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[(2) - (3)].val.opval));
610                           token_getmad((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
611                           token_getmad((ps[(3) - (3)].val.i_tkval),(yyval.opval),';');
612 #else
613                           package((ps[(2) - (3)].val.opval));
614                           (yyval.opval) = (OP*)NULL;
615 #endif
616                         ;}
617     break;
618
619   case 80:
620 #line 650 "perly.y"
621     { CvSPECIAL_on(PL_compcv); /* It's a BEGIN {} */ ;}
622     break;
623
624   case 81:
625 #line 652 "perly.y"
626     { SvREFCNT_inc_simple_void(PL_compcv);
627 #ifdef MAD
628                           (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));
629                           token_getmad((ps[(1) - (7)].val.i_tkval),(yyval.opval),'o');
630                           token_getmad((ps[(7) - (7)].val.i_tkval),(yyval.opval),';');
631                           if (PL_parser->rsfp_filters &&
632                                       AvFILLp(PL_parser->rsfp_filters) >= 0)
633                               append_madprops(newMADPROP('!', MAD_NULL, NULL, 0), (yyval.opval), 0);
634 #else
635                           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));
636                           (yyval.opval) = (OP*)NULL;
637 #endif
638                         ;}
639     break;
640
641   case 82:
642 #line 669 "perly.y"
643     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
644                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
645                         ;}
646     break;
647
648   case 83:
649 #line 673 "perly.y"
650     { (yyval.opval) = newLOGOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
651                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
652                         ;}
653     break;
654
655   case 84:
656 #line 677 "perly.y"
657     { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
658                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
659                         ;}
660     break;
661
662   case 86:
663 #line 685 "perly.y"
664     {
665 #ifdef MAD
666                           OP* op = newNULLLIST();
667                           token_getmad((ps[(2) - (2)].val.i_tkval),op,',');
668                           (yyval.opval) = append_elem(OP_LIST, (ps[(1) - (2)].val.opval), op);
669 #else
670                           (yyval.opval) = (ps[(1) - (2)].val.opval);
671 #endif
672                         ;}
673     break;
674
675   case 87:
676 #line 695 "perly.y"
677     { 
678                           OP* term = (ps[(3) - (3)].val.opval);
679                           DO_MAD(
680                               term = newUNOP(OP_NULL, 0, term);
681                               token_getmad((ps[(2) - (3)].val.i_tkval),term,',');
682                           )
683                           (yyval.opval) = append_elem(OP_LIST, (ps[(1) - (3)].val.opval), term);
684                         ;}
685     break;
686
687   case 89:
688 #line 708 "perly.y"
689     { (yyval.opval) = convert(IVAL((ps[(1) - (3)].val.i_tkval)), OPf_STACKED,
690                                 prepend_elem(OP_LIST, newGVREF(IVAL((ps[(1) - (3)].val.i_tkval)),(ps[(2) - (3)].val.opval)), (ps[(3) - (3)].val.opval)) );
691                           TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
692                         ;}
693     break;
694
695   case 90:
696 #line 713 "perly.y"
697     { (yyval.opval) = convert(IVAL((ps[(1) - (5)].val.i_tkval)), OPf_STACKED,
698                                 prepend_elem(OP_LIST, newGVREF(IVAL((ps[(1) - (5)].val.i_tkval)),(ps[(3) - (5)].val.opval)), (ps[(4) - (5)].val.opval)) );
699                           TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'o');
700                           TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'(');
701                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),')');
702                         ;}
703     break;
704
705   case 91:
706 #line 720 "perly.y"
707     { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
708                                 append_elem(OP_LIST,
709                                     prepend_elem(OP_LIST, scalar((ps[(1) - (6)].val.opval)), (ps[(5) - (6)].val.opval)),
710                                     newUNOP(OP_METHOD, 0, (ps[(3) - (6)].val.opval))));
711                           TOKEN_GETMAD((ps[(2) - (6)].val.i_tkval),(yyval.opval),'A');
712                           TOKEN_GETMAD((ps[(4) - (6)].val.i_tkval),(yyval.opval),'(');
713                           TOKEN_GETMAD((ps[(6) - (6)].val.i_tkval),(yyval.opval),')');
714                         ;}
715     break;
716
717   case 92:
718 #line 729 "perly.y"
719     { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
720                                 append_elem(OP_LIST, scalar((ps[(1) - (3)].val.opval)),
721                                     newUNOP(OP_METHOD, 0, (ps[(3) - (3)].val.opval))));
722                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'A');
723                         ;}
724     break;
725
726   case 93:
727 #line 735 "perly.y"
728     { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
729                                 append_elem(OP_LIST,
730                                     prepend_elem(OP_LIST, (ps[(2) - (3)].val.opval), (ps[(3) - (3)].val.opval)),
731                                     newUNOP(OP_METHOD, 0, (ps[(1) - (3)].val.opval))));
732                         ;}
733     break;
734
735   case 94:
736 #line 741 "perly.y"
737     { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
738                                 append_elem(OP_LIST,
739                                     prepend_elem(OP_LIST, (ps[(2) - (5)].val.opval), (ps[(4) - (5)].val.opval)),
740                                     newUNOP(OP_METHOD, 0, (ps[(1) - (5)].val.opval))));
741                           TOKEN_GETMAD((ps[(3) - (5)].val.i_tkval),(yyval.opval),'(');
742                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),')');
743                         ;}
744     break;
745
746   case 95:
747 #line 749 "perly.y"
748     { (yyval.opval) = convert(IVAL((ps[(1) - (2)].val.i_tkval)), 0, (ps[(2) - (2)].val.opval));
749                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
750                         ;}
751     break;
752
753   case 96:
754 #line 753 "perly.y"
755     { (yyval.opval) = convert(IVAL((ps[(1) - (4)].val.i_tkval)), 0, (ps[(3) - (4)].val.opval));
756                           TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'o');
757                           TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'(');
758                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
759                         ;}
760     break;
761
762   case 97:
763 #line 759 "perly.y"
764     { SvREFCNT_inc_simple_void(PL_compcv);
765                           (yyval.opval) = newANONATTRSUB((ps[(2) - (3)].val.ival), 0, (OP*)NULL, (ps[(3) - (3)].val.opval)); ;}
766     break;
767
768   case 98:
769 #line 762 "perly.y"
770     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
771                                  append_elem(OP_LIST,
772                                    prepend_elem(OP_LIST, (ps[(4) - (5)].val.opval), (ps[(5) - (5)].val.opval)), (ps[(1) - (5)].val.opval)));
773                         ;}
774     break;
775
776   case 101:
777 #line 777 "perly.y"
778     { (yyval.opval) = newBINOP(OP_GELEM, 0, (ps[(1) - (5)].val.opval), scalar((ps[(3) - (5)].val.opval)));
779                             PL_parser->expect = XOPERATOR;
780                           TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'{');
781                           TOKEN_GETMAD((ps[(4) - (5)].val.i_tkval),(yyval.opval),';');
782                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),'}');
783                         ;}
784     break;
785
786   case 102:
787 #line 784 "perly.y"
788     { (yyval.opval) = newBINOP(OP_AELEM, 0, oopsAV((ps[(1) - (4)].val.opval)), scalar((ps[(3) - (4)].val.opval)));
789                           TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'[');
790                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),']');
791                         ;}
792     break;
793
794   case 103:
795 #line 789 "perly.y"
796     { (yyval.opval) = newBINOP(OP_AELEM, 0,
797                                         ref(newAVREF((ps[(1) - (5)].val.opval)),OP_RV2AV),
798                                         scalar((ps[(4) - (5)].val.opval)));
799                           TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'a');
800                           TOKEN_GETMAD((ps[(3) - (5)].val.i_tkval),(yyval.opval),'[');
801                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),']');
802                         ;}
803     break;
804
805   case 104:
806 #line 797 "perly.y"
807     { (yyval.opval) = newBINOP(OP_AELEM, 0,
808                                         ref(newAVREF((ps[(1) - (4)].val.opval)),OP_RV2AV),
809                                         scalar((ps[(3) - (4)].val.opval)));
810                           TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'[');
811                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),']');
812                         ;}
813     break;
814
815   case 105:
816 #line 804 "perly.y"
817     { (yyval.opval) = newBINOP(OP_HELEM, 0, oopsHV((ps[(1) - (5)].val.opval)), jmaybe((ps[(3) - (5)].val.opval)));
818                             PL_parser->expect = XOPERATOR;
819                           TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'{');
820                           TOKEN_GETMAD((ps[(4) - (5)].val.i_tkval),(yyval.opval),';');
821                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),'}');
822                         ;}
823     break;
824
825   case 106:
826 #line 811 "perly.y"
827     { (yyval.opval) = newBINOP(OP_HELEM, 0,
828                                         ref(newHVREF((ps[(1) - (6)].val.opval)),OP_RV2HV),
829                                         jmaybe((ps[(4) - (6)].val.opval)));
830                             PL_parser->expect = XOPERATOR;
831                           TOKEN_GETMAD((ps[(2) - (6)].val.i_tkval),(yyval.opval),'a');
832                           TOKEN_GETMAD((ps[(3) - (6)].val.i_tkval),(yyval.opval),'{');
833                           TOKEN_GETMAD((ps[(5) - (6)].val.i_tkval),(yyval.opval),';');
834                           TOKEN_GETMAD((ps[(6) - (6)].val.i_tkval),(yyval.opval),'}');
835                         ;}
836     break;
837
838   case 107:
839 #line 821 "perly.y"
840     { (yyval.opval) = newBINOP(OP_HELEM, 0,
841                                         ref(newHVREF((ps[(1) - (5)].val.opval)),OP_RV2HV),
842                                         jmaybe((ps[(3) - (5)].val.opval)));
843                             PL_parser->expect = XOPERATOR;
844                           TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'{');
845                           TOKEN_GETMAD((ps[(4) - (5)].val.i_tkval),(yyval.opval),';');
846                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),'}');
847                         ;}
848     break;
849
850   case 108:
851 #line 830 "perly.y"
852     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
853                                    newCVREF(0, scalar((ps[(1) - (4)].val.opval))));
854                           TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'a');
855                           TOKEN_GETMAD((ps[(3) - (4)].val.i_tkval),(yyval.opval),'(');
856                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
857                         ;}
858     break;
859
860   case 109:
861 #line 837 "perly.y"
862     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
863                                    append_elem(OP_LIST, (ps[(4) - (5)].val.opval),
864                                        newCVREF(0, scalar((ps[(1) - (5)].val.opval)))));
865                           TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'a');
866                           TOKEN_GETMAD((ps[(3) - (5)].val.i_tkval),(yyval.opval),'(');
867                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),')');
868                         ;}
869     break;
870
871   case 110:
872 #line 846 "perly.y"
873     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
874                                    append_elem(OP_LIST, (ps[(3) - (4)].val.opval),
875                                                newCVREF(0, scalar((ps[(1) - (4)].val.opval)))));
876                           TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'(');
877                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
878                         ;}
879     break;
880
881   case 111:
882 #line 853 "perly.y"
883     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
884                                    newCVREF(0, scalar((ps[(1) - (3)].val.opval))));
885                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'(');
886                           TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
887                         ;}
888     break;
889
890   case 112:
891 #line 859 "perly.y"
892     { (yyval.opval) = newSLICEOP(0, (ps[(5) - (6)].val.opval), (ps[(2) - (6)].val.opval));
893                           TOKEN_GETMAD((ps[(1) - (6)].val.i_tkval),(yyval.opval),'(');
894                           TOKEN_GETMAD((ps[(3) - (6)].val.i_tkval),(yyval.opval),')');
895                           TOKEN_GETMAD((ps[(4) - (6)].val.i_tkval),(yyval.opval),'[');
896                           TOKEN_GETMAD((ps[(6) - (6)].val.i_tkval),(yyval.opval),']');
897                         ;}
898     break;
899
900   case 113:
901 #line 866 "perly.y"
902     { (yyval.opval) = newSLICEOP(0, (ps[(4) - (5)].val.opval), (OP*)NULL);
903                           TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'(');
904                           TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),')');
905                           TOKEN_GETMAD((ps[(3) - (5)].val.i_tkval),(yyval.opval),'[');
906                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),']');
907                         ;}
908     break;
909
910   case 114:
911 #line 876 "perly.y"
912     { (yyval.opval) = newASSIGNOP(OPf_STACKED, (ps[(1) - (3)].val.opval), IVAL((ps[(2) - (3)].val.i_tkval)), (ps[(3) - (3)].val.opval));
913                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
914                         ;}
915     break;
916
917   case 115:
918 #line 880 "perly.y"
919     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
920                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
921                         ;}
922     break;
923
924   case 116:
925 #line 884 "perly.y"
926     {   if (IVAL((ps[(2) - (3)].val.i_tkval)) != OP_REPEAT)
927                                 scalar((ps[(1) - (3)].val.opval));
928                             (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, (ps[(1) - (3)].val.opval), scalar((ps[(3) - (3)].val.opval)));
929                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
930                         ;}
931     break;
932
933   case 117:
934 #line 890 "perly.y"
935     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
936                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
937                         ;}
938     break;
939
940   case 118:
941 #line 894 "perly.y"
942     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
943                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
944                         ;}
945     break;
946
947   case 119:
948 #line 898 "perly.y"
949     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
950                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
951                         ;}
952     break;
953
954   case 120:
955 #line 902 "perly.y"
956     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
957                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
958                         ;}
959     break;
960
961   case 121:
962 #line 906 "perly.y"
963     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
964                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
965                         ;}
966     break;
967
968   case 122:
969 #line 910 "perly.y"
970     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
971                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
972                         ;}
973     break;
974
975   case 123:
976 #line 914 "perly.y"
977     {
978                           (yyval.opval) = newRANGE(IVAL((ps[(2) - (3)].val.i_tkval)), scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
979                           DO_MAD({
980                               UNOP *op;
981                               op = (UNOP*)(yyval.opval);
982                               op = (UNOP*)op->op_first; /* get to flop */
983                               op = (UNOP*)op->op_first; /* get to flip */
984                               op = (UNOP*)op->op_first; /* get to range */
985                               token_getmad((ps[(2) - (3)].val.i_tkval),(OP*)op,'o');
986                             })
987                         ;}
988     break;
989
990   case 124:
991 #line 926 "perly.y"
992     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
993                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
994                         ;}
995     break;
996
997   case 125:
998 #line 930 "perly.y"
999     { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
1000                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
1001                         ;}
1002     break;
1003
1004   case 126:
1005 #line 934 "perly.y"
1006     { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
1007                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
1008                         ;}
1009     break;
1010
1011   case 127:
1012 #line 938 "perly.y"
1013     { (yyval.opval) = bind_match(IVAL((ps[(2) - (3)].val.i_tkval)), (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
1014                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),
1015                                 ((yyval.opval)->op_type == OP_NOT
1016                                     ? ((UNOP*)(yyval.opval))->op_first : (yyval.opval)),
1017                                 '~');
1018                         ;}
1019     break;
1020
1021   case 128:
1022 #line 948 "perly.y"
1023     { (yyval.opval) = newUNOP(OP_NEGATE, 0, scalar((ps[(2) - (2)].val.opval)));
1024                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1025                         ;}
1026     break;
1027
1028   case 129:
1029 #line 952 "perly.y"
1030     { (yyval.opval) = IF_MAD(
1031                                     newUNOP(OP_NULL, 0, (ps[(2) - (2)].val.opval)),
1032                                     (ps[(2) - (2)].val.opval)
1033                                 );
1034                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'+');
1035                         ;}
1036     break;
1037
1038   case 130:
1039 #line 959 "perly.y"
1040     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[(2) - (2)].val.opval)));
1041                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1042                         ;}
1043     break;
1044
1045   case 131:
1046 #line 963 "perly.y"
1047     { (yyval.opval) = newUNOP(OP_COMPLEMENT, 0, scalar((ps[(2) - (2)].val.opval)));
1048                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1049                         ;}
1050     break;
1051
1052   case 132:
1053 #line 967 "perly.y"
1054     { (yyval.opval) = newUNOP(OP_POSTINC, 0,
1055                                         mod(scalar((ps[(1) - (2)].val.opval)), OP_POSTINC));
1056                           TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),'o');
1057                         ;}
1058     break;
1059
1060   case 133:
1061 #line 972 "perly.y"
1062     { (yyval.opval) = newUNOP(OP_POSTDEC, 0,
1063                                         mod(scalar((ps[(1) - (2)].val.opval)), OP_POSTDEC));
1064                           TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),'o');
1065                         ;}
1066     break;
1067
1068   case 134:
1069 #line 977 "perly.y"
1070     { (yyval.opval) = newUNOP(OP_PREINC, 0,
1071                                         mod(scalar((ps[(2) - (2)].val.opval)), OP_PREINC));
1072                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1073                         ;}
1074     break;
1075
1076   case 135:
1077 #line 982 "perly.y"
1078     { (yyval.opval) = newUNOP(OP_PREDEC, 0,
1079                                         mod(scalar((ps[(2) - (2)].val.opval)), OP_PREDEC));
1080                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1081                         ;}
1082     break;
1083
1084   case 136:
1085 #line 991 "perly.y"
1086     { (yyval.opval) = newANONLIST((ps[(2) - (3)].val.opval));
1087                           TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'[');
1088                           TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),']');
1089                         ;}
1090     break;
1091
1092   case 137:
1093 #line 996 "perly.y"
1094     { (yyval.opval) = newANONLIST((OP*)NULL);
1095                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'[');
1096                           TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),']');
1097                         ;}
1098     break;
1099
1100   case 138:
1101 #line 1001 "perly.y"
1102     { (yyval.opval) = newANONHASH((ps[(2) - (4)].val.opval));
1103                           TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'{');
1104                           TOKEN_GETMAD((ps[(3) - (4)].val.i_tkval),(yyval.opval),';');
1105                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),'}');
1106                         ;}
1107     break;
1108
1109   case 139:
1110 #line 1007 "perly.y"
1111     { (yyval.opval) = newANONHASH((OP*)NULL);
1112                           TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'{');
1113                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),';');
1114                           TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),'}');
1115                         ;}
1116     break;
1117
1118   case 140:
1119 #line 1013 "perly.y"
1120     { SvREFCNT_inc_simple_void(PL_compcv);
1121                           (yyval.opval) = newANONATTRSUB((ps[(2) - (5)].val.ival), (ps[(3) - (5)].val.opval), (ps[(4) - (5)].val.opval), (ps[(5) - (5)].val.opval));
1122                           TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'o');
1123                           OP_GETMAD((ps[(3) - (5)].val.opval),(yyval.opval),'s');
1124                           OP_GETMAD((ps[(4) - (5)].val.opval),(yyval.opval),'a');
1125                         ;}
1126     break;
1127
1128   case 141:
1129 #line 1024 "perly.y"
1130     { (yyval.opval) = dofile((ps[(2) - (2)].val.opval), IVAL((ps[(1) - (2)].val.i_tkval)));
1131                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1132                         ;}
1133     break;
1134
1135   case 142:
1136 #line 1028 "perly.y"
1137     { (yyval.opval) = newUNOP(OP_NULL, OPf_SPECIAL, scope((ps[(2) - (2)].val.opval)));
1138                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'D');
1139                         ;}
1140     break;
1141
1142   case 143:
1143 #line 1032 "perly.y"
1144     { (yyval.opval) = newUNOP(OP_ENTERSUB,
1145                             OPf_SPECIAL|OPf_STACKED,
1146                             prepend_elem(OP_LIST,
1147                                 scalar(newCVREF(
1148                                     (OPpENTERSUB_AMPER<<8),
1149                                     scalar((ps[(2) - (4)].val.opval))
1150                                 )),(OP*)NULL)); dep();
1151                           TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'o');
1152                           TOKEN_GETMAD((ps[(3) - (4)].val.i_tkval),(yyval.opval),'(');
1153                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
1154                         ;}
1155     break;
1156
1157   case 144:
1158 #line 1044 "perly.y"
1159     { (yyval.opval) = newUNOP(OP_ENTERSUB,
1160                             OPf_SPECIAL|OPf_STACKED,
1161                             append_elem(OP_LIST,
1162                                 (ps[(4) - (5)].val.opval),
1163                                 scalar(newCVREF(
1164                                     (OPpENTERSUB_AMPER<<8),
1165                                     scalar((ps[(2) - (5)].val.opval))
1166                                 )))); dep();
1167                           TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'o');
1168                           TOKEN_GETMAD((ps[(3) - (5)].val.i_tkval),(yyval.opval),'(');
1169                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),')');
1170                         ;}
1171     break;
1172
1173   case 145:
1174 #line 1057 "perly.y"
1175     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_SPECIAL|OPf_STACKED,
1176                             prepend_elem(OP_LIST,
1177                                 scalar(newCVREF(0,scalar((ps[(2) - (4)].val.opval)))), (OP*)NULL)); dep();
1178                           TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'o');
1179                           TOKEN_GETMAD((ps[(3) - (4)].val.i_tkval),(yyval.opval),'(');
1180                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
1181                         ;}
1182     break;
1183
1184   case 146:
1185 #line 1065 "perly.y"
1186     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_SPECIAL|OPf_STACKED,
1187                             prepend_elem(OP_LIST,
1188                                 (ps[(4) - (5)].val.opval),
1189                                 scalar(newCVREF(0,scalar((ps[(2) - (5)].val.opval)))))); dep();
1190                           TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'o');
1191                           TOKEN_GETMAD((ps[(3) - (5)].val.i_tkval),(yyval.opval),'(');
1192                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),')');
1193                         ;}
1194     break;
1195
1196   case 151:
1197 #line 1081 "perly.y"
1198     { (yyval.opval) = newCONDOP(0, (ps[(1) - (5)].val.opval), (ps[(3) - (5)].val.opval), (ps[(5) - (5)].val.opval));
1199                           TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'?');
1200                           TOKEN_GETMAD((ps[(4) - (5)].val.i_tkval),(yyval.opval),':');
1201                         ;}
1202     break;
1203
1204   case 152:
1205 #line 1086 "perly.y"
1206     { (yyval.opval) = newUNOP(OP_REFGEN, 0, mod((ps[(2) - (2)].val.opval),OP_REFGEN));
1207                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1208                         ;}
1209     break;
1210
1211   case 153:
1212 #line 1090 "perly.y"
1213     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1214     break;
1215
1216   case 154:
1217 #line 1092 "perly.y"
1218     { (yyval.opval) = localize((ps[(2) - (2)].val.opval),IVAL((ps[(1) - (2)].val.i_tkval)));
1219                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'k');
1220                         ;}
1221     break;
1222
1223   case 155:
1224 #line 1096 "perly.y"
1225     { (yyval.opval) = sawparens(IF_MAD(newUNOP(OP_NULL,0,(ps[(2) - (3)].val.opval)), (ps[(2) - (3)].val.opval)));
1226                           TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'(');
1227                           TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
1228                         ;}
1229     break;
1230
1231   case 156:
1232 #line 1101 "perly.y"
1233     { (yyval.opval) = sawparens(newNULLLIST());
1234                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'(');
1235                           TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),')');
1236                         ;}
1237     break;
1238
1239   case 157:
1240 #line 1106 "perly.y"
1241     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1242     break;
1243
1244   case 158:
1245 #line 1108 "perly.y"
1246     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1247     break;
1248
1249   case 159:
1250 #line 1110 "perly.y"
1251     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1252     break;
1253
1254   case 160:
1255 #line 1112 "perly.y"
1256     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1257     break;
1258
1259   case 161:
1260 #line 1114 "perly.y"
1261     { (yyval.opval) = newUNOP(OP_AV2ARYLEN, 0, ref((ps[(1) - (1)].val.opval), OP_AV2ARYLEN));;}
1262     break;
1263
1264   case 162:
1265 #line 1116 "perly.y"
1266     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1267     break;
1268
1269   case 163:
1270 #line 1118 "perly.y"
1271     { (yyval.opval) = prepend_elem(OP_ASLICE,
1272                                 newOP(OP_PUSHMARK, 0),
1273                                     newLISTOP(OP_ASLICE, 0,
1274                                         list((ps[(3) - (4)].val.opval)),
1275                                         ref((ps[(1) - (4)].val.opval), OP_ASLICE)));
1276                           TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'[');
1277                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),']');
1278                         ;}
1279     break;
1280
1281   case 164:
1282 #line 1127 "perly.y"
1283     { (yyval.opval) = prepend_elem(OP_HSLICE,
1284                                 newOP(OP_PUSHMARK, 0),
1285                                     newLISTOP(OP_HSLICE, 0,
1286                                         list((ps[(3) - (5)].val.opval)),
1287                                         ref(oopsHV((ps[(1) - (5)].val.opval)), OP_HSLICE)));
1288                             PL_parser->expect = XOPERATOR;
1289                           TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'{');
1290                           TOKEN_GETMAD((ps[(4) - (5)].val.i_tkval),(yyval.opval),';');
1291                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),'}');
1292                         ;}
1293     break;
1294
1295   case 165:
1296 #line 1138 "perly.y"
1297     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1298     break;
1299
1300   case 166:
1301 #line 1140 "perly.y"
1302     { (yyval.opval) = newUNOP(OP_ENTERSUB, 0, scalar((ps[(1) - (1)].val.opval))); ;}
1303     break;
1304
1305   case 167:
1306 #line 1142 "perly.y"
1307     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (3)].val.opval)));
1308                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'(');
1309                           TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
1310                         ;}
1311     break;
1312
1313   case 168:
1314 #line 1147 "perly.y"
1315     {
1316                           (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1317                                 append_elem(OP_LIST, (ps[(3) - (4)].val.opval), scalar((ps[(1) - (4)].val.opval))));
1318                           DO_MAD({
1319                               OP* op = (yyval.opval);
1320                               if (op->op_type == OP_CONST) { /* defeat const fold */
1321                                 op = (OP*)op->op_madprop->mad_val;
1322                               }
1323                               token_getmad((ps[(2) - (4)].val.i_tkval),op,'(');
1324                               token_getmad((ps[(4) - (4)].val.i_tkval),op,')');
1325                           })
1326                         ;}
1327     break;
1328
1329   case 169:
1330 #line 1160 "perly.y"
1331     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1332                             append_elem(OP_LIST, (ps[(3) - (3)].val.opval), scalar((ps[(2) - (3)].val.opval))));
1333                           TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
1334                         ;}
1335     break;
1336
1337   case 170:
1338 #line 1165 "perly.y"
1339     { (yyval.opval) = newOP(IVAL((ps[(1) - (1)].val.i_tkval)), OPf_SPECIAL);
1340                             PL_hints |= HINT_BLOCK_SCOPE;
1341                           TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'o');
1342                         ;}
1343     break;
1344
1345   case 171:
1346 #line 1170 "perly.y"
1347     { (yyval.opval) = newLOOPEX(IVAL((ps[(1) - (2)].val.i_tkval)),(ps[(2) - (2)].val.opval));
1348                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1349                         ;}
1350     break;
1351
1352   case 172:
1353 #line 1174 "perly.y"
1354     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[(2) - (2)].val.opval)));
1355                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1356                         ;}
1357     break;
1358
1359   case 173:
1360 #line 1178 "perly.y"
1361     { (yyval.opval) = newOP(IVAL((ps[(1) - (1)].val.i_tkval)), 0);
1362                           TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'o');
1363                         ;}
1364     break;
1365
1366   case 174:
1367 #line 1182 "perly.y"
1368     { (yyval.opval) = newUNOP(IVAL((ps[(1) - (2)].val.i_tkval)), 0, (ps[(2) - (2)].val.opval));
1369                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1370                         ;}
1371     break;
1372
1373   case 175:
1374 #line 1186 "perly.y"
1375     { (yyval.opval) = newUNOP(IVAL((ps[(1) - (2)].val.i_tkval)), 0, (ps[(2) - (2)].val.opval));
1376                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1377                         ;}
1378     break;
1379
1380   case 176:
1381 #line 1190 "perly.y"
1382     { (yyval.opval) = newOP(OP_REQUIRE, (ps[(1) - (1)].val.i_tkval) ? OPf_SPECIAL : 0);
1383                           TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'o');
1384                         ;}
1385     break;
1386
1387   case 177:
1388 #line 1194 "perly.y"
1389     { (yyval.opval) = newUNOP(OP_REQUIRE, (ps[(1) - (2)].val.i_tkval) ? OPf_SPECIAL : 0, (ps[(2) - (2)].val.opval));
1390                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1391                         ;}
1392     break;
1393
1394   case 178:
1395 #line 1198 "perly.y"
1396     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (1)].val.opval))); ;}
1397     break;
1398
1399   case 179:
1400 #line 1200 "perly.y"
1401     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1402                             append_elem(OP_LIST, (ps[(2) - (2)].val.opval), scalar((ps[(1) - (2)].val.opval)))); ;}
1403     break;
1404
1405   case 180:
1406 #line 1203 "perly.y"
1407     { (yyval.opval) = newOP(IVAL((ps[(1) - (1)].val.i_tkval)), 0);
1408                           TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'o');
1409                         ;}
1410     break;
1411
1412   case 181:
1413 #line 1207 "perly.y"
1414     { (yyval.opval) = newOP(IVAL((ps[(1) - (3)].val.i_tkval)), 0);
1415                           TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
1416                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'(');
1417                           TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
1418                         ;}
1419     break;
1420
1421   case 182:
1422 #line 1213 "perly.y"
1423     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1424                                 scalar((ps[(1) - (1)].val.opval))); ;}
1425     break;
1426
1427   case 183:
1428 #line 1216 "perly.y"
1429     { (yyval.opval) = (IVAL((ps[(1) - (3)].val.i_tkval)) == OP_NOT)
1430                             ? newUNOP(IVAL((ps[(1) - (3)].val.i_tkval)), 0, newSVOP(OP_CONST, 0, newSViv(0)))
1431                             : newOP(IVAL((ps[(1) - (3)].val.i_tkval)), OPf_SPECIAL);
1432
1433                           TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
1434                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'(');
1435                           TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
1436                         ;}
1437     break;
1438
1439   case 184:
1440 #line 1225 "perly.y"
1441     { (yyval.opval) = newUNOP(IVAL((ps[(1) - (4)].val.i_tkval)), 0, (ps[(3) - (4)].val.opval));
1442                           TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'o');
1443                           TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'(');
1444                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
1445                         ;}
1446     break;
1447
1448   case 185:
1449 #line 1231 "perly.y"
1450     { (yyval.opval) = pmruntime((ps[(1) - (4)].val.opval), (ps[(3) - (4)].val.opval), 1);
1451                           TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'(');
1452                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
1453                         ;}
1454     break;
1455
1456   case 188:
1457 #line 1238 "perly.y"
1458     {
1459                           (yyval.opval) = newLISTOP(OP_DIE, 0, newOP(OP_PUSHMARK, 0),
1460                                 newSVOP(OP_CONST, 0, newSVpvs("Unimplemented")));
1461                           TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'X');
1462                         ;}
1463     break;
1464
1465   case 189:
1466 #line 1247 "perly.y"
1467     { (yyval.opval) = my_attrs((ps[(2) - (3)].val.opval),(ps[(3) - (3)].val.opval));
1468                           DO_MAD(
1469                               token_getmad((ps[(1) - (3)].val.i_tkval),(yyval.opval),'d');
1470                               append_madprops((ps[(3) - (3)].val.opval)->op_madprop, (yyval.opval), 'a');
1471                               (ps[(3) - (3)].val.opval)->op_madprop = 0;
1472                           )
1473                         ;}
1474     break;
1475
1476   case 190:
1477 #line 1255 "perly.y"
1478     { (yyval.opval) = localize((ps[(2) - (2)].val.opval),IVAL((ps[(1) - (2)].val.i_tkval)));
1479                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'d');
1480                         ;}
1481     break;
1482
1483   case 191:
1484 #line 1262 "perly.y"
1485     { (yyval.opval) = sawparens((ps[(2) - (3)].val.opval));
1486                           TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'(');
1487                           TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
1488                         ;}
1489     break;
1490
1491   case 192:
1492 #line 1267 "perly.y"
1493     { (yyval.opval) = sawparens(newNULLLIST());
1494                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'(');
1495                           TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),')');
1496                         ;}
1497     break;
1498
1499   case 193:
1500 #line 1272 "perly.y"
1501     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1502     break;
1503
1504   case 194:
1505 #line 1274 "perly.y"
1506     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1507     break;
1508
1509   case 195:
1510 #line 1276 "perly.y"
1511     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1512     break;
1513
1514   case 196:
1515 #line 1281 "perly.y"
1516     { (yyval.opval) = (OP*)NULL; ;}
1517     break;
1518
1519   case 197:
1520 #line 1283 "perly.y"
1521     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1522     break;
1523
1524   case 198:
1525 #line 1287 "perly.y"
1526     { (yyval.opval) = (OP*)NULL; ;}
1527     break;
1528
1529   case 199:
1530 #line 1289 "perly.y"
1531     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1532     break;
1533
1534   case 200:
1535 #line 1291 "perly.y"
1536     {
1537 #ifdef MAD
1538                           OP* op = newNULLLIST();
1539                           token_getmad((ps[(2) - (2)].val.i_tkval),op,',');
1540                           (yyval.opval) = append_elem(OP_LIST, (ps[(1) - (2)].val.opval), op);
1541 #else
1542                           (yyval.opval) = (ps[(1) - (2)].val.opval);
1543 #endif
1544
1545                         ;}
1546     break;
1547
1548   case 201:
1549 #line 1306 "perly.y"
1550     { PL_parser->in_my = 0; (yyval.opval) = my((ps[(1) - (1)].val.opval)); ;}
1551     break;
1552
1553   case 202:
1554 #line 1310 "perly.y"
1555     { (yyval.opval) = newCVREF(IVAL((ps[(1) - (2)].val.i_tkval)),(ps[(2) - (2)].val.opval));
1556                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'&');
1557                         ;}
1558     break;
1559
1560   case 203:
1561 #line 1316 "perly.y"
1562     { (yyval.opval) = newSVREF((ps[(2) - (2)].val.opval));
1563                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'$');
1564                         ;}
1565     break;
1566
1567   case 204:
1568 #line 1322 "perly.y"
1569     { (yyval.opval) = newAVREF((ps[(2) - (2)].val.opval));
1570                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'@');
1571                         ;}
1572     break;
1573
1574   case 205:
1575 #line 1328 "perly.y"
1576     { (yyval.opval) = newHVREF((ps[(2) - (2)].val.opval));
1577                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'%');
1578                         ;}
1579     break;
1580
1581   case 206:
1582 #line 1334 "perly.y"
1583     { (yyval.opval) = newAVREF((ps[(2) - (2)].val.opval));
1584                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'l');
1585                         ;}
1586     break;
1587
1588   case 207:
1589 #line 1340 "perly.y"
1590     { (yyval.opval) = newGVREF(0,(ps[(2) - (2)].val.opval));
1591                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'*');
1592                         ;}
1593     break;
1594
1595   case 208:
1596 #line 1347 "perly.y"
1597     { (yyval.opval) = scalar((ps[(1) - (1)].val.opval)); ;}
1598     break;
1599
1600   case 209:
1601 #line 1349 "perly.y"
1602     { (yyval.opval) = scalar((ps[(1) - (1)].val.opval)); ;}
1603     break;
1604
1605   case 210:
1606 #line 1351 "perly.y"
1607     { (yyval.opval) = scope((ps[(1) - (1)].val.opval)); ;}
1608     break;
1609
1610   case 211:
1611 #line 1354 "perly.y"
1612     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1613     break;
1614
1615
1616 /* Line 1267 of yacc.c.  */
1617
1618       default: break;
1619