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