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