${^LAST_FH}
[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 85:
721 #line 700 "perly.y"
722     { (yyval.opval) = (OP*)NULL; ;}
723     break;
724
725   case 86:
726 #line 702 "perly.y"
727     { (yyval.opval) = (ps[(2) - (2)].val.opval);
728                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),':');
729                         ;}
730     break;
731
732   case 87:
733 #line 706 "perly.y"
734     { (yyval.opval) = IF_MAD(
735                                     newOP(OP_NULL, 0),
736                                     (OP*)NULL
737                                 );
738                           TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),':');
739                         ;}
740     break;
741
742   case 88:
743 #line 716 "perly.y"
744     { (yyval.opval) = (ps[(2) - (2)].val.opval);
745                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),':');
746                         ;}
747     break;
748
749   case 89:
750 #line 720 "perly.y"
751     { (yyval.opval) = IF_MAD(
752                                     newOP(OP_NULL, 0),
753                                     (OP*)NULL
754                                 );
755                           TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),':');
756                         ;}
757     break;
758
759   case 90:
760 #line 729 "perly.y"
761     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
762     break;
763
764   case 91:
765 #line 730 "perly.y"
766     { (yyval.opval) = IF_MAD(
767                                     newOP(OP_NULL,0),
768                                     (OP*)NULL
769                                 );
770                           PL_parser->expect = XSTATE;
771                           TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),';');
772                         ;}
773     break;
774
775   case 92:
776 #line 741 "perly.y"
777     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
778                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
779                         ;}
780     break;
781
782   case 93:
783 #line 745 "perly.y"
784     { (yyval.opval) = newLOGOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
785                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
786                         ;}
787     break;
788
789   case 94:
790 #line 749 "perly.y"
791     { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
792                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
793                         ;}
794     break;
795
796   case 96:
797 #line 757 "perly.y"
798     {
799 #ifdef MAD
800                           OP* op = newNULLLIST();
801                           token_getmad((ps[(2) - (2)].val.i_tkval),op,',');
802                           (yyval.opval) = op_append_elem(OP_LIST, (ps[(1) - (2)].val.opval), op);
803 #else
804                           (yyval.opval) = (ps[(1) - (2)].val.opval);
805 #endif
806                         ;}
807     break;
808
809   case 97:
810 #line 767 "perly.y"
811     { 
812                           OP* term = (ps[(3) - (3)].val.opval);
813                           DO_MAD(
814                               term = newUNOP(OP_NULL, 0, term);
815                               token_getmad((ps[(2) - (3)].val.i_tkval),term,',');
816                           )
817                           (yyval.opval) = op_append_elem(OP_LIST, (ps[(1) - (3)].val.opval), term);
818                         ;}
819     break;
820
821   case 99:
822 #line 780 "perly.y"
823     { (yyval.opval) = convert(IVAL((ps[(1) - (3)].val.i_tkval)), OPf_STACKED,
824                                 op_prepend_elem(OP_LIST, newGVREF(IVAL((ps[(1) - (3)].val.i_tkval)),(ps[(2) - (3)].val.opval)), (ps[(3) - (3)].val.opval)) );
825                           TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
826                         ;}
827     break;
828
829   case 100:
830 #line 785 "perly.y"
831     { (yyval.opval) = convert(IVAL((ps[(1) - (5)].val.i_tkval)), OPf_STACKED,
832                                 op_prepend_elem(OP_LIST, newGVREF(IVAL((ps[(1) - (5)].val.i_tkval)),(ps[(3) - (5)].val.opval)), (ps[(4) - (5)].val.opval)) );
833                           TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'o');
834                           TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'(');
835                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),')');
836                         ;}
837     break;
838
839   case 101:
840 #line 792 "perly.y"
841     { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
842                                 op_append_elem(OP_LIST,
843                                     op_prepend_elem(OP_LIST, scalar((ps[(1) - (6)].val.opval)), (ps[(5) - (6)].val.opval)),
844                                     newUNOP(OP_METHOD, 0, (ps[(3) - (6)].val.opval))));
845                           TOKEN_GETMAD((ps[(2) - (6)].val.i_tkval),(yyval.opval),'A');
846                           TOKEN_GETMAD((ps[(4) - (6)].val.i_tkval),(yyval.opval),'(');
847                           TOKEN_GETMAD((ps[(6) - (6)].val.i_tkval),(yyval.opval),')');
848                         ;}
849     break;
850
851   case 102:
852 #line 801 "perly.y"
853     { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
854                                 op_append_elem(OP_LIST, scalar((ps[(1) - (3)].val.opval)),
855                                     newUNOP(OP_METHOD, 0, (ps[(3) - (3)].val.opval))));
856                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'A');
857                         ;}
858     break;
859
860   case 103:
861 #line 807 "perly.y"
862     { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
863                                 op_append_elem(OP_LIST,
864                                     op_prepend_elem(OP_LIST, (ps[(2) - (3)].val.opval), (ps[(3) - (3)].val.opval)),
865                                     newUNOP(OP_METHOD, 0, (ps[(1) - (3)].val.opval))));
866                         ;}
867     break;
868
869   case 104:
870 #line 813 "perly.y"
871     { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
872                                 op_append_elem(OP_LIST,
873                                     op_prepend_elem(OP_LIST, (ps[(2) - (5)].val.opval), (ps[(4) - (5)].val.opval)),
874                                     newUNOP(OP_METHOD, 0, (ps[(1) - (5)].val.opval))));
875                           TOKEN_GETMAD((ps[(3) - (5)].val.i_tkval),(yyval.opval),'(');
876                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),')');
877                         ;}
878     break;
879
880   case 105:
881 #line 821 "perly.y"
882     { (yyval.opval) = convert(IVAL((ps[(1) - (2)].val.i_tkval)), 0, (ps[(2) - (2)].val.opval));
883                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
884                         ;}
885     break;
886
887   case 106:
888 #line 825 "perly.y"
889     { (yyval.opval) = convert(IVAL((ps[(1) - (4)].val.i_tkval)), 0, (ps[(3) - (4)].val.opval));
890                           TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'o');
891                           TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'(');
892                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
893                         ;}
894     break;
895
896   case 107:
897 #line 831 "perly.y"
898     { SvREFCNT_inc_simple_void(PL_compcv);
899                           (yyval.opval) = newANONATTRSUB((ps[(2) - (3)].val.ival), 0, (OP*)NULL, (ps[(3) - (3)].val.opval)); ;}
900     break;
901
902   case 108:
903 #line 834 "perly.y"
904     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
905                                  op_append_elem(OP_LIST,
906                                    op_prepend_elem(OP_LIST, (ps[(4) - (5)].val.opval), (ps[(5) - (5)].val.opval)), (ps[(1) - (5)].val.opval)));
907                         ;}
908     break;
909
910   case 111:
911 #line 849 "perly.y"
912     { (yyval.opval) = newBINOP(OP_GELEM, 0, (ps[(1) - (5)].val.opval), scalar((ps[(3) - (5)].val.opval)));
913                             PL_parser->expect = XOPERATOR;
914                           TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'{');
915                           TOKEN_GETMAD((ps[(4) - (5)].val.i_tkval),(yyval.opval),';');
916                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),'}');
917                         ;}
918     break;
919
920   case 112:
921 #line 856 "perly.y"
922     { (yyval.opval) = newBINOP(OP_AELEM, 0, oopsAV((ps[(1) - (4)].val.opval)), scalar((ps[(3) - (4)].val.opval)));
923                           TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'[');
924                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),']');
925                         ;}
926     break;
927
928   case 113:
929 #line 861 "perly.y"
930     { (yyval.opval) = newBINOP(OP_AELEM, 0,
931                                         ref(newAVREF((ps[(1) - (5)].val.opval)),OP_RV2AV),
932                                         scalar((ps[(4) - (5)].val.opval)));
933                           TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'a');
934                           TOKEN_GETMAD((ps[(3) - (5)].val.i_tkval),(yyval.opval),'[');
935                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),']');
936                         ;}
937     break;
938
939   case 114:
940 #line 869 "perly.y"
941     { (yyval.opval) = newBINOP(OP_AELEM, 0,
942                                         ref(newAVREF((ps[(1) - (4)].val.opval)),OP_RV2AV),
943                                         scalar((ps[(3) - (4)].val.opval)));
944                           TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'[');
945                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),']');
946                         ;}
947     break;
948
949   case 115:
950 #line 876 "perly.y"
951     { (yyval.opval) = newBINOP(OP_HELEM, 0, oopsHV((ps[(1) - (5)].val.opval)), jmaybe((ps[(3) - (5)].val.opval)));
952                             PL_parser->expect = XOPERATOR;
953                           TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'{');
954                           TOKEN_GETMAD((ps[(4) - (5)].val.i_tkval),(yyval.opval),';');
955                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),'}');
956                         ;}
957     break;
958
959   case 116:
960 #line 883 "perly.y"
961     { (yyval.opval) = newBINOP(OP_HELEM, 0,
962                                         ref(newHVREF((ps[(1) - (6)].val.opval)),OP_RV2HV),
963                                         jmaybe((ps[(4) - (6)].val.opval)));
964                             PL_parser->expect = XOPERATOR;
965                           TOKEN_GETMAD((ps[(2) - (6)].val.i_tkval),(yyval.opval),'a');
966                           TOKEN_GETMAD((ps[(3) - (6)].val.i_tkval),(yyval.opval),'{');
967                           TOKEN_GETMAD((ps[(5) - (6)].val.i_tkval),(yyval.opval),';');
968                           TOKEN_GETMAD((ps[(6) - (6)].val.i_tkval),(yyval.opval),'}');
969                         ;}
970     break;
971
972   case 117:
973 #line 893 "perly.y"
974     { (yyval.opval) = newBINOP(OP_HELEM, 0,
975                                         ref(newHVREF((ps[(1) - (5)].val.opval)),OP_RV2HV),
976                                         jmaybe((ps[(3) - (5)].val.opval)));
977                             PL_parser->expect = XOPERATOR;
978                           TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'{');
979                           TOKEN_GETMAD((ps[(4) - (5)].val.i_tkval),(yyval.opval),';');
980                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),'}');
981                         ;}
982     break;
983
984   case 118:
985 #line 902 "perly.y"
986     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
987                                    newCVREF(0, scalar((ps[(1) - (4)].val.opval))));
988                           TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'a');
989                           TOKEN_GETMAD((ps[(3) - (4)].val.i_tkval),(yyval.opval),'(');
990                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
991                         ;}
992     break;
993
994   case 119:
995 #line 909 "perly.y"
996     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
997                                    op_append_elem(OP_LIST, (ps[(4) - (5)].val.opval),
998                                        newCVREF(0, scalar((ps[(1) - (5)].val.opval)))));
999                           TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'a');
1000                           TOKEN_GETMAD((ps[(3) - (5)].val.i_tkval),(yyval.opval),'(');
1001                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),')');
1002                         ;}
1003     break;
1004
1005   case 120:
1006 #line 918 "perly.y"
1007     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1008                                    op_append_elem(OP_LIST, (ps[(3) - (4)].val.opval),
1009                                                newCVREF(0, scalar((ps[(1) - (4)].val.opval)))));
1010                           TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'(');
1011                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
1012                         ;}
1013     break;
1014
1015   case 121:
1016 #line 925 "perly.y"
1017     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1018                                    newCVREF(0, scalar((ps[(1) - (3)].val.opval))));
1019                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'(');
1020                           TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
1021                         ;}
1022     break;
1023
1024   case 122:
1025 #line 931 "perly.y"
1026     { (yyval.opval) = newSLICEOP(0, (ps[(5) - (6)].val.opval), (ps[(2) - (6)].val.opval));
1027                           TOKEN_GETMAD((ps[(1) - (6)].val.i_tkval),(yyval.opval),'(');
1028                           TOKEN_GETMAD((ps[(3) - (6)].val.i_tkval),(yyval.opval),')');
1029                           TOKEN_GETMAD((ps[(4) - (6)].val.i_tkval),(yyval.opval),'[');
1030                           TOKEN_GETMAD((ps[(6) - (6)].val.i_tkval),(yyval.opval),']');
1031                         ;}
1032     break;
1033
1034   case 123:
1035 #line 938 "perly.y"
1036     { (yyval.opval) = newSLICEOP(0, (ps[(3) - (4)].val.opval), (ps[(1) - (4)].val.opval));
1037                           TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'[');
1038                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),']');
1039                         ;}
1040     break;
1041
1042   case 124:
1043 #line 943 "perly.y"
1044     { (yyval.opval) = newSLICEOP(0, (ps[(4) - (5)].val.opval), (OP*)NULL);
1045                           TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'(');
1046                           TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),')');
1047                           TOKEN_GETMAD((ps[(3) - (5)].val.i_tkval),(yyval.opval),'[');
1048                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),']');
1049                         ;}
1050     break;
1051
1052   case 125:
1053 #line 953 "perly.y"
1054     { (yyval.opval) = newASSIGNOP(OPf_STACKED, (ps[(1) - (3)].val.opval), IVAL((ps[(2) - (3)].val.i_tkval)), (ps[(3) - (3)].val.opval));
1055                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
1056                         ;}
1057     break;
1058
1059   case 126:
1060 #line 957 "perly.y"
1061     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
1062                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
1063                         ;}
1064     break;
1065
1066   case 127:
1067 #line 961 "perly.y"
1068     {   if (IVAL((ps[(2) - (3)].val.i_tkval)) != OP_REPEAT)
1069                                 scalar((ps[(1) - (3)].val.opval));
1070                             (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, (ps[(1) - (3)].val.opval), scalar((ps[(3) - (3)].val.opval)));
1071                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
1072                         ;}
1073     break;
1074
1075   case 128:
1076 #line 967 "perly.y"
1077     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
1078                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
1079                         ;}
1080     break;
1081
1082   case 129:
1083 #line 971 "perly.y"
1084     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
1085                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
1086                         ;}
1087     break;
1088
1089   case 130:
1090 #line 975 "perly.y"
1091     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
1092                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
1093                         ;}
1094     break;
1095
1096   case 131:
1097 #line 979 "perly.y"
1098     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
1099                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
1100                         ;}
1101     break;
1102
1103   case 132:
1104 #line 983 "perly.y"
1105     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
1106                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
1107                         ;}
1108     break;
1109
1110   case 133:
1111 #line 987 "perly.y"
1112     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
1113                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
1114                         ;}
1115     break;
1116
1117   case 134:
1118 #line 991 "perly.y"
1119     {
1120                           (yyval.opval) = newRANGE(IVAL((ps[(2) - (3)].val.i_tkval)), scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
1121                           DO_MAD({
1122                               UNOP *op;
1123                               op = (UNOP*)(yyval.opval);
1124                               op = (UNOP*)op->op_first; /* get to flop */
1125                               op = (UNOP*)op->op_first; /* get to flip */
1126                               op = (UNOP*)op->op_first; /* get to range */
1127                               token_getmad((ps[(2) - (3)].val.i_tkval),(OP*)op,'o');
1128                             })
1129                         ;}
1130     break;
1131
1132   case 135:
1133 #line 1003 "perly.y"
1134     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
1135                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
1136                         ;}
1137     break;
1138
1139   case 136:
1140 #line 1007 "perly.y"
1141     { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
1142                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
1143                         ;}
1144     break;
1145
1146   case 137:
1147 #line 1011 "perly.y"
1148     { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
1149                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
1150                         ;}
1151     break;
1152
1153   case 138:
1154 #line 1015 "perly.y"
1155     { (yyval.opval) = bind_match(IVAL((ps[(2) - (3)].val.i_tkval)), (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
1156                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),
1157                                 ((yyval.opval)->op_type == OP_NOT
1158                                     ? ((UNOP*)(yyval.opval))->op_first : (yyval.opval)),
1159                                 '~');
1160                         ;}
1161     break;
1162
1163   case 139:
1164 #line 1025 "perly.y"
1165     { (yyval.opval) = newUNOP(OP_NEGATE, 0, scalar((ps[(2) - (2)].val.opval)));
1166                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1167                         ;}
1168     break;
1169
1170   case 140:
1171 #line 1029 "perly.y"
1172     { (yyval.opval) = IF_MAD(
1173                                     newUNOP(OP_NULL, 0, (ps[(2) - (2)].val.opval)),
1174                                     (ps[(2) - (2)].val.opval)
1175                                 );
1176                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'+');
1177                         ;}
1178     break;
1179
1180   case 141:
1181 #line 1036 "perly.y"
1182     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[(2) - (2)].val.opval)));
1183                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1184                         ;}
1185     break;
1186
1187   case 142:
1188 #line 1040 "perly.y"
1189     { (yyval.opval) = newUNOP(OP_COMPLEMENT, 0, scalar((ps[(2) - (2)].val.opval)));
1190                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1191                         ;}
1192     break;
1193
1194   case 143:
1195 #line 1044 "perly.y"
1196     { (yyval.opval) = newUNOP(OP_POSTINC, 0,
1197                                         op_lvalue(scalar((ps[(1) - (2)].val.opval)), OP_POSTINC));
1198                           TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),'o');
1199                         ;}
1200     break;
1201
1202   case 144:
1203 #line 1049 "perly.y"
1204     { (yyval.opval) = newUNOP(OP_POSTDEC, 0,
1205                                         op_lvalue(scalar((ps[(1) - (2)].val.opval)), OP_POSTDEC));
1206                           TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),'o');
1207                         ;}
1208     break;
1209
1210   case 145:
1211 #line 1054 "perly.y"
1212     { (yyval.opval) = newUNOP(OP_PREINC, 0,
1213                                         op_lvalue(scalar((ps[(2) - (2)].val.opval)), OP_PREINC));
1214                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1215                         ;}
1216     break;
1217
1218   case 146:
1219 #line 1059 "perly.y"
1220     { (yyval.opval) = newUNOP(OP_PREDEC, 0,
1221                                         op_lvalue(scalar((ps[(2) - (2)].val.opval)), OP_PREDEC));
1222                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1223                         ;}
1224     break;
1225
1226   case 147:
1227 #line 1068 "perly.y"
1228     { (yyval.opval) = newANONLIST((ps[(2) - (3)].val.opval));
1229                           TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'[');
1230                           TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),']');
1231                         ;}
1232     break;
1233
1234   case 148:
1235 #line 1073 "perly.y"
1236     { (yyval.opval) = newANONLIST((OP*)NULL);
1237                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'[');
1238                           TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),']');
1239                         ;}
1240     break;
1241
1242   case 149:
1243 #line 1078 "perly.y"
1244     { (yyval.opval) = newANONHASH((ps[(2) - (4)].val.opval));
1245                           TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'{');
1246                           TOKEN_GETMAD((ps[(3) - (4)].val.i_tkval),(yyval.opval),';');
1247                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),'}');
1248                         ;}
1249     break;
1250
1251   case 150:
1252 #line 1084 "perly.y"
1253     { (yyval.opval) = newANONHASH((OP*)NULL);
1254                           TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'{');
1255                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),';');
1256                           TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),'}');
1257                         ;}
1258     break;
1259
1260   case 151:
1261 #line 1090 "perly.y"
1262     { SvREFCNT_inc_simple_void(PL_compcv);
1263                           (yyval.opval) = newANONATTRSUB((ps[(2) - (5)].val.ival), (ps[(3) - (5)].val.opval), (ps[(4) - (5)].val.opval), (ps[(5) - (5)].val.opval));
1264                           TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'o');
1265                           OP_GETMAD((ps[(3) - (5)].val.opval),(yyval.opval),'s');
1266                           OP_GETMAD((ps[(4) - (5)].val.opval),(yyval.opval),'a');
1267                         ;}
1268     break;
1269
1270   case 152:
1271 #line 1101 "perly.y"
1272     { (yyval.opval) = dofile((ps[(2) - (2)].val.opval), IVAL((ps[(1) - (2)].val.i_tkval)));
1273                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1274                         ;}
1275     break;
1276
1277   case 153:
1278 #line 1105 "perly.y"
1279     { (yyval.opval) = newUNOP(OP_NULL, OPf_SPECIAL, op_scope((ps[(2) - (2)].val.opval)));
1280                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'D');
1281                         ;}
1282     break;
1283
1284   case 154:
1285 #line 1109 "perly.y"
1286     { (yyval.opval) = newUNOP(OP_ENTERSUB,
1287                             OPf_SPECIAL|OPf_STACKED,
1288                             op_prepend_elem(OP_LIST,
1289                                 scalar(newCVREF(
1290                                     (OPpENTERSUB_AMPER<<8),
1291                                     scalar((ps[(2) - (4)].val.opval))
1292                                 )),(OP*)NULL)); dep();
1293                           TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'o');
1294                           TOKEN_GETMAD((ps[(3) - (4)].val.i_tkval),(yyval.opval),'(');
1295                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
1296                         ;}
1297     break;
1298
1299   case 155:
1300 #line 1121 "perly.y"
1301     { (yyval.opval) = newUNOP(OP_ENTERSUB,
1302                             OPf_SPECIAL|OPf_STACKED,
1303                             op_append_elem(OP_LIST,
1304                                 (ps[(4) - (5)].val.opval),
1305                                 scalar(newCVREF(
1306                                     (OPpENTERSUB_AMPER<<8),
1307                                     scalar((ps[(2) - (5)].val.opval))
1308                                 )))); dep();
1309                           TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'o');
1310                           TOKEN_GETMAD((ps[(3) - (5)].val.i_tkval),(yyval.opval),'(');
1311                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),')');
1312                         ;}
1313     break;
1314
1315   case 156:
1316 #line 1134 "perly.y"
1317     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_SPECIAL|OPf_STACKED,
1318                             op_prepend_elem(OP_LIST,
1319                                 scalar(newCVREF(0,scalar((ps[(2) - (4)].val.opval)))), (OP*)NULL)); dep();
1320                           TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'o');
1321                           TOKEN_GETMAD((ps[(3) - (4)].val.i_tkval),(yyval.opval),'(');
1322                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
1323                         ;}
1324     break;
1325
1326   case 157:
1327 #line 1142 "perly.y"
1328     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_SPECIAL|OPf_STACKED,
1329                             op_prepend_elem(OP_LIST,
1330                                 (ps[(4) - (5)].val.opval),
1331                                 scalar(newCVREF(0,scalar((ps[(2) - (5)].val.opval)))))); dep();
1332                           TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'o');
1333                           TOKEN_GETMAD((ps[(3) - (5)].val.i_tkval),(yyval.opval),'(');
1334                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),')');
1335                         ;}
1336     break;
1337
1338   case 162:
1339 #line 1158 "perly.y"
1340     { (yyval.opval) = newCONDOP(0, (ps[(1) - (5)].val.opval), (ps[(3) - (5)].val.opval), (ps[(5) - (5)].val.opval));
1341                           TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'?');
1342                           TOKEN_GETMAD((ps[(4) - (5)].val.i_tkval),(yyval.opval),':');
1343                         ;}
1344     break;
1345
1346   case 163:
1347 #line 1163 "perly.y"
1348     { (yyval.opval) = newUNOP(OP_REFGEN, 0, op_lvalue((ps[(2) - (2)].val.opval),OP_REFGEN));
1349                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1350                         ;}
1351     break;
1352
1353   case 164:
1354 #line 1167 "perly.y"
1355     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1356     break;
1357
1358   case 165:
1359 #line 1169 "perly.y"
1360     { (yyval.opval) = localize((ps[(2) - (2)].val.opval),IVAL((ps[(1) - (2)].val.i_tkval)));
1361                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'k');
1362                         ;}
1363     break;
1364
1365   case 166:
1366 #line 1173 "perly.y"
1367     { (yyval.opval) = sawparens(IF_MAD(newUNOP(OP_NULL,0,(ps[(2) - (3)].val.opval)), (ps[(2) - (3)].val.opval)));
1368                           TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'(');
1369                           TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
1370                         ;}
1371     break;
1372
1373   case 167:
1374 #line 1178 "perly.y"
1375     { (yyval.opval) = IF_MAD(newUNOP(OP_NULL,0,(ps[(1) - (1)].val.opval)), (ps[(1) - (1)].val.opval)); ;}
1376     break;
1377
1378   case 168:
1379 #line 1180 "perly.y"
1380     { (yyval.opval) = sawparens(newNULLLIST());
1381                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'(');
1382                           TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),')');
1383                         ;}
1384     break;
1385
1386   case 169:
1387 #line 1185 "perly.y"
1388     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1389     break;
1390
1391   case 170:
1392 #line 1187 "perly.y"
1393     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1394     break;
1395
1396   case 171:
1397 #line 1189 "perly.y"
1398     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1399     break;
1400
1401   case 172:
1402 #line 1191 "perly.y"
1403     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1404     break;
1405
1406   case 173:
1407 #line 1193 "perly.y"
1408     { (yyval.opval) = newUNOP(OP_AV2ARYLEN, 0, ref((ps[(1) - (1)].val.opval), OP_AV2ARYLEN));;}
1409     break;
1410
1411   case 174:
1412 #line 1195 "perly.y"
1413     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1414     break;
1415
1416   case 175:
1417 #line 1197 "perly.y"
1418     { (yyval.opval) = op_prepend_elem(OP_ASLICE,
1419                                 newOP(OP_PUSHMARK, 0),
1420                                     newLISTOP(OP_ASLICE, 0,
1421                                         list((ps[(3) - (4)].val.opval)),
1422                                         ref((ps[(1) - (4)].val.opval), OP_ASLICE)));
1423                           TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'[');
1424                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),']');
1425                         ;}
1426     break;
1427
1428   case 176:
1429 #line 1206 "perly.y"
1430     { (yyval.opval) = op_prepend_elem(OP_HSLICE,
1431                                 newOP(OP_PUSHMARK, 0),
1432                                     newLISTOP(OP_HSLICE, 0,
1433                                         list((ps[(3) - (5)].val.opval)),
1434                                         ref(oopsHV((ps[(1) - (5)].val.opval)), OP_HSLICE)));
1435                             PL_parser->expect = XOPERATOR;
1436                           TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'{');
1437                           TOKEN_GETMAD((ps[(4) - (5)].val.i_tkval),(yyval.opval),';');
1438                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),'}');
1439                         ;}
1440     break;
1441
1442   case 177:
1443 #line 1217 "perly.y"
1444     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1445     break;
1446
1447   case 178:
1448 #line 1219 "perly.y"
1449     { (yyval.opval) = newUNOP(OP_ENTERSUB, 0, scalar((ps[(1) - (1)].val.opval))); ;}
1450     break;
1451
1452   case 179:
1453 #line 1221 "perly.y"
1454     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (3)].val.opval)));
1455                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'(');
1456                           TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
1457                         ;}
1458     break;
1459
1460   case 180:
1461 #line 1226 "perly.y"
1462     {
1463                           (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1464                                 op_append_elem(OP_LIST, (ps[(3) - (4)].val.opval), scalar((ps[(1) - (4)].val.opval))));
1465                           DO_MAD({
1466                               OP* op = (yyval.opval);
1467                               if (op->op_type == OP_CONST) { /* defeat const fold */
1468                                 op = (OP*)op->op_madprop->mad_val;
1469                               }
1470                               token_getmad((ps[(2) - (4)].val.i_tkval),op,'(');
1471                               token_getmad((ps[(4) - (4)].val.i_tkval),op,')');
1472                           })
1473                         ;}
1474     break;
1475
1476   case 181:
1477 #line 1239 "perly.y"
1478     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1479                             op_append_elem(OP_LIST, (ps[(3) - (3)].val.opval), scalar((ps[(2) - (3)].val.opval))));
1480                           TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
1481                         ;}
1482     break;
1483
1484   case 182:
1485 #line 1244 "perly.y"
1486     { (yyval.opval) = newOP(IVAL((ps[(1) - (1)].val.i_tkval)), OPf_SPECIAL);
1487                             PL_hints |= HINT_BLOCK_SCOPE;
1488                           TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'o');
1489                         ;}
1490     break;
1491
1492   case 183:
1493 #line 1249 "perly.y"
1494     { (yyval.opval) = newLOOPEX(IVAL((ps[(1) - (2)].val.i_tkval)),(ps[(2) - (2)].val.opval));
1495                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1496                         ;}
1497     break;
1498
1499   case 184:
1500 #line 1253 "perly.y"
1501     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[(2) - (2)].val.opval)));
1502                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1503                         ;}
1504     break;
1505
1506   case 185:
1507 #line 1257 "perly.y"
1508     { (yyval.opval) = newOP(IVAL((ps[(1) - (1)].val.i_tkval)), 0);
1509                           TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'o');
1510                         ;}
1511     break;
1512
1513   case 186:
1514 #line 1261 "perly.y"
1515     { (yyval.opval) = newUNOP(IVAL((ps[(1) - (2)].val.i_tkval)), 0, (ps[(2) - (2)].val.opval));
1516                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1517                         ;}
1518     break;
1519
1520   case 187:
1521 #line 1265 "perly.y"
1522     { (yyval.opval) = newUNOP(IVAL((ps[(1) - (2)].val.i_tkval)), 0, (ps[(2) - (2)].val.opval));
1523                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1524                         ;}
1525     break;
1526
1527   case 188:
1528 #line 1269 "perly.y"
1529     { (yyval.opval) = newOP(OP_REQUIRE, (ps[(1) - (1)].val.i_tkval) ? OPf_SPECIAL : 0);
1530                           TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'o');
1531                         ;}
1532     break;
1533
1534   case 189:
1535 #line 1273 "perly.y"
1536     { (yyval.opval) = newUNOP(OP_REQUIRE, (ps[(1) - (2)].val.i_tkval) ? OPf_SPECIAL : 0, (ps[(2) - (2)].val.opval));
1537                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1538                         ;}
1539     break;
1540
1541   case 190:
1542 #line 1277 "perly.y"
1543     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (1)].val.opval))); ;}
1544     break;
1545
1546   case 191:
1547 #line 1279 "perly.y"
1548     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1549                             op_append_elem(OP_LIST, (ps[(2) - (2)].val.opval), scalar((ps[(1) - (2)].val.opval)))); ;}
1550     break;
1551
1552   case 192:
1553 #line 1282 "perly.y"
1554     { (yyval.opval) = newOP(IVAL((ps[(1) - (1)].val.i_tkval)), 0);
1555                           TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'o');
1556                         ;}
1557     break;
1558
1559   case 193:
1560 #line 1286 "perly.y"
1561     { (yyval.opval) = newOP(IVAL((ps[(1) - (3)].val.i_tkval)), 0);
1562                           TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
1563                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'(');
1564                           TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
1565                         ;}
1566     break;
1567
1568   case 194:
1569 #line 1292 "perly.y"
1570     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1571     break;
1572
1573   case 195:
1574 #line 1294 "perly.y"
1575     { (yyval.opval) = (ps[(1) - (3)].val.opval);
1576                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'(');
1577                           TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
1578                         ;}
1579     break;
1580
1581   case 196:
1582 #line 1299 "perly.y"
1583     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1584                                 scalar((ps[(1) - (1)].val.opval))); ;}
1585     break;
1586
1587   case 197:
1588 #line 1302 "perly.y"
1589     { (yyval.opval) = (IVAL((ps[(1) - (3)].val.i_tkval)) == OP_NOT)
1590                             ? newUNOP(IVAL((ps[(1) - (3)].val.i_tkval)), 0, newSVOP(OP_CONST, 0, newSViv(0)))
1591                             : newOP(IVAL((ps[(1) - (3)].val.i_tkval)), OPf_SPECIAL);
1592
1593                           TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
1594                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'(');
1595                           TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
1596                         ;}
1597     break;
1598
1599   case 198:
1600 #line 1311 "perly.y"
1601     { (yyval.opval) = newUNOP(IVAL((ps[(1) - (4)].val.i_tkval)), 0, (ps[(3) - (4)].val.opval));
1602                           TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'o');
1603                           TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'(');
1604                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
1605                         ;}
1606     break;
1607
1608   case 199:
1609 #line 1317 "perly.y"
1610     {
1611                             if (   (ps[(1) - (1)].val.opval)->op_type != OP_TRANS
1612                                 && (ps[(1) - (1)].val.opval)->op_type != OP_TRANSR
1613                                 && (((PMOP*)(ps[(1) - (1)].val.opval))->op_pmflags & PMf_HAS_CV))
1614                             {
1615                                 (yyval.ival) = start_subparse(FALSE, CVf_ANON);
1616                                 SAVEFREESV(PL_compcv);
1617                             } else
1618                                 (yyval.ival) = 0;
1619                         ;}
1620     break;
1621
1622   case 200:
1623 #line 1328 "perly.y"
1624     { (yyval.opval) = pmruntime((ps[(1) - (5)].val.opval), (ps[(4) - (5)].val.opval), 1, (ps[(2) - (5)].val.ival));
1625                           TOKEN_GETMAD((ps[(3) - (5)].val.i_tkval),(yyval.opval),'(');
1626                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),')');
1627                         ;}
1628     break;
1629
1630   case 203:
1631 #line 1335 "perly.y"
1632     {
1633                           (yyval.opval) = newLISTOP(OP_DIE, 0, newOP(OP_PUSHMARK, 0),
1634                                 newSVOP(OP_CONST, 0, newSVpvs("Unimplemented")));
1635                           TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'X');
1636                         ;}
1637     break;
1638
1639   case 205:
1640 #line 1345 "perly.y"
1641     { (yyval.opval) = my_attrs((ps[(2) - (3)].val.opval),(ps[(3) - (3)].val.opval));
1642                           DO_MAD(
1643                               token_getmad((ps[(1) - (3)].val.i_tkval),(yyval.opval),'d');
1644                               append_madprops((ps[(3) - (3)].val.opval)->op_madprop, (yyval.opval), 'a');
1645                               (ps[(3) - (3)].val.opval)->op_madprop = 0;
1646                           )
1647                         ;}
1648     break;
1649
1650   case 206:
1651 #line 1353 "perly.y"
1652     { (yyval.opval) = localize((ps[(2) - (2)].val.opval),IVAL((ps[(1) - (2)].val.i_tkval)));
1653                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'d');
1654                         ;}
1655     break;
1656
1657   case 207:
1658 #line 1360 "perly.y"
1659     { (yyval.opval) = sawparens((ps[(2) - (3)].val.opval));
1660                           TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'(');
1661                           TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
1662                         ;}
1663     break;
1664
1665   case 208:
1666 #line 1365 "perly.y"
1667     { (yyval.opval) = sawparens(newNULLLIST());
1668                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'(');
1669                           TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),')');
1670                         ;}
1671     break;
1672
1673   case 209:
1674 #line 1370 "perly.y"
1675     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1676     break;
1677
1678   case 210:
1679 #line 1372 "perly.y"
1680     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1681     break;
1682
1683   case 211:
1684 #line 1374 "perly.y"
1685     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1686     break;
1687
1688   case 212:
1689 #line 1379 "perly.y"
1690     { (yyval.opval) = (OP*)NULL; ;}
1691     break;
1692
1693   case 213:
1694 #line 1381 "perly.y"
1695     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1696     break;
1697
1698   case 214:
1699 #line 1385 "perly.y"
1700     { (yyval.opval) = (OP*)NULL; ;}
1701     break;
1702
1703   case 215:
1704 #line 1387 "perly.y"
1705     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1706     break;
1707
1708   case 216:
1709 #line 1393 "perly.y"
1710     { PL_parser->in_my = 0; (yyval.opval) = my((ps[(1) - (1)].val.opval)); ;}
1711     break;
1712
1713   case 217:
1714 #line 1397 "perly.y"
1715     { (yyval.opval) = newCVREF(IVAL((ps[(1) - (2)].val.i_tkval)),(ps[(2) - (2)].val.opval));
1716                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'&');
1717                         ;}
1718     break;
1719
1720   case 218:
1721 #line 1403 "perly.y"
1722     { (yyval.opval) = newSVREF((ps[(2) - (2)].val.opval));
1723                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'$');
1724                         ;}
1725     break;
1726
1727   case 219:
1728 #line 1409 "perly.y"
1729     { (yyval.opval) = newAVREF((ps[(2) - (2)].val.opval));
1730                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'@');
1731                         ;}
1732     break;
1733
1734   case 220:
1735 #line 1415 "perly.y"
1736     { (yyval.opval) = newHVREF((ps[(2) - (2)].val.opval));
1737                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'%');
1738                         ;}
1739     break;
1740
1741   case 221:
1742 #line 1421 "perly.y"
1743     { (yyval.opval) = newAVREF((ps[(2) - (2)].val.opval));
1744                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'l');
1745                         ;}
1746     break;
1747
1748   case 222:
1749 #line 1427 "perly.y"
1750     { (yyval.opval) = newGVREF(0,(ps[(2) - (2)].val.opval));
1751                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'*');
1752                         ;}
1753     break;
1754
1755   case 223:
1756 #line 1434 "perly.y"
1757     { (yyval.opval) = scalar((ps[(1) - (1)].val.opval)); ;}
1758     break;
1759
1760   case 224:
1761 #line 1436 "perly.y"
1762     { (yyval.opval) = scalar((ps[(1) - (1)].val.opval)); ;}
1763     break;
1764
1765   case 225:
1766 #line 1438 "perly.y"
1767     { (yyval.opval) = op_scope((ps[(1) - (1)].val.opval)); ;}
1768     break;
1769
1770   case 226:
1771 #line 1441 "perly.y"
1772     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1773     break;
1774
1775
1776 /* Line 1267 of yacc.c.  */
1777
1778       default: break;
1779     
1780
1781 /* Generated from:
1782  * 8f20aa8c321935dad8457c5b097cd153aacc2f87cd51dc911d1d791d045b642f perly.y
1783  * 4a3ced51fe6585f6ec59e65e1ffd74bc976c498b0e6992eaab337219fee72e51 regen_perly.pl
1784  * ex: set ro: */