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