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