perly.act

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