perly.act

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