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