perly.act

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