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