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