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