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