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