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