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