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