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                           package((ps[(3) - (5)].val.opval));
 647                           if ((ps[(2) - (5)].val.opval))
 648                               package_version((ps[(2) - (5)].val.opval));
 649                         ;}
 650     break;
 651
 652   case 83:
 653 #line 675 "perly.y"
 654     { if (PL_parser->copline > (line_t)IVAL((ps[(4) - (8)].val.i_tkval)))
 655                               PL_parser->copline = (line_t)IVAL((ps[(4) - (8)].val.i_tkval));
 656                           (yyval.opval) = block_end((ps[(5) - (8)].val.ival), (ps[(7) - (8)].val.opval));
 657                           TOKEN_GETMAD((ps[(4) - (8)].val.i_tkval),(yyval.opval),'{');
 658                           TOKEN_GETMAD((ps[(8) - (8)].val.i_tkval),(yyval.opval),'}');
 659                         ;}
 660     break;
 661
 662   case 84:
 663 #line 684 "perly.y"
 664     { CvSPECIAL_on(PL_compcv); /* It's a BEGIN {} */ ;}
 665     break;
 666
 667   case 85:
 668 #line 686 "perly.y"
 669     { SvREFCNT_inc_simple_void(PL_compcv);
 670 #ifdef MAD
 671                           (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));
 672                           token_getmad((ps[(1) - (7)].val.i_tkval),(yyval.opval),'o');
 673                           token_getmad((ps[(7) - (7)].val.i_tkval),(yyval.opval),';');
 674                           if (PL_parser->rsfp_filters &&
 675                                       AvFILLp(PL_parser->rsfp_filters) >= 0)
 676                               append_madprops(newMADPROP('!', MAD_NULL, NULL, 0), (yyval.opval), 0);
 677 #else
 678                           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));
 679                           (yyval.opval) = (OP*)NULL;
 680 #endif
 681                         ;}
 682     break;
 683
 684   case 86:
 685 #line 703 "perly.y"
 686     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
 687                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 688                         ;}
 689     break;
 690
 691   case 87:
 692 #line 707 "perly.y"
 693     { (yyval.opval) = newLOGOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
 694                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 695                         ;}
 696     break;
 697
 698   case 88:
 699 #line 711 "perly.y"
 700     { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
 701                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 702                         ;}
 703     break;
 704
 705   case 90:
 706 #line 719 "perly.y"
 707     {
 708 #ifdef MAD
 709                           OP* op = newNULLLIST();
 710                           token_getmad((ps[(2) - (2)].val.i_tkval),op,',');
 711                           (yyval.opval) = append_elem(OP_LIST, (ps[(1) - (2)].val.opval), op);
 712 #else
 713                           (yyval.opval) = (ps[(1) - (2)].val.opval);
 714 #endif
 715                         ;}
 716     break;
 717
 718   case 91:
 719 #line 729 "perly.y"
 720     {
 721                           OP* term = (ps[(3) - (3)].val.opval);
 722                           DO_MAD(
 723                               term = newUNOP(OP_NULL, 0, term);
 724                               token_getmad((ps[(2) - (3)].val.i_tkval),term,',');
 725                           )
 726                           (yyval.opval) = append_elem(OP_LIST, (ps[(1) - (3)].val.opval), term);
 727                         ;}
 728     break;
 729
 730   case 93:
 731 #line 742 "perly.y"
 732     { (yyval.opval) = convert(IVAL((ps[(1) - (3)].val.i_tkval)), OPf_STACKED,
 733                                 prepend_elem(OP_LIST, newGVREF(IVAL((ps[(1) - (3)].val.i_tkval)),(ps[(2) - (3)].val.opval)), (ps[(3) - (3)].val.opval)) );
 734                           TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
 735                         ;}
 736     break;
 737
 738   case 94:
 739 #line 747 "perly.y"
 740     { (yyval.opval) = convert(IVAL((ps[(1) - (5)].val.i_tkval)), OPf_STACKED,
 741                                 prepend_elem(OP_LIST, newGVREF(IVAL((ps[(1) - (5)].val.i_tkval)),(ps[(3) - (5)].val.opval)), (ps[(4) - (5)].val.opval)) );
 742                           TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'o');
 743                           TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'(');
 744                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),')');
 745                         ;}
 746     break;
 747
 748   case 95:
 749 #line 754 "perly.y"
 750     { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
 751                                 append_elem(OP_LIST,
 752                                     prepend_elem(OP_LIST, scalar((ps[(1) - (6)].val.opval)), (ps[(5) - (6)].val.opval)),
 753                                     newUNOP(OP_METHOD, 0, (ps[(3) - (6)].val.opval))));
 754                           TOKEN_GETMAD((ps[(2) - (6)].val.i_tkval),(yyval.opval),'A');
 755                           TOKEN_GETMAD((ps[(4) - (6)].val.i_tkval),(yyval.opval),'(');
 756                           TOKEN_GETMAD((ps[(6) - (6)].val.i_tkval),(yyval.opval),')');
 757                         ;}
 758     break;
 759
 760   case 96:
 761 #line 763 "perly.y"
 762     { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
 763                                 append_elem(OP_LIST, scalar((ps[(1) - (3)].val.opval)),
 764                                     newUNOP(OP_METHOD, 0, (ps[(3) - (3)].val.opval))));
 765                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'A');
 766                         ;}
 767     break;
 768
 769   case 97:
 770 #line 769 "perly.y"
 771     { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
 772                                 append_elem(OP_LIST,
 773                                     prepend_elem(OP_LIST, (ps[(2) - (3)].val.opval), (ps[(3) - (3)].val.opval)),
 774                                     newUNOP(OP_METHOD, 0, (ps[(1) - (3)].val.opval))));
 775                         ;}
 776     break;
 777
 778   case 98:
 779 #line 775 "perly.y"
 780     { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
 781                                 append_elem(OP_LIST,
 782                                     prepend_elem(OP_LIST, (ps[(2) - (5)].val.opval), (ps[(4) - (5)].val.opval)),
 783                                     newUNOP(OP_METHOD, 0, (ps[(1) - (5)].val.opval))));
 784                           TOKEN_GETMAD((ps[(3) - (5)].val.i_tkval),(yyval.opval),'(');
 785                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),')');
 786                         ;}
 787     break;
 788
 789   case 99:
 790 #line 783 "perly.y"
 791     { (yyval.opval) = convert(IVAL((ps[(1) - (2)].val.i_tkval)), 0, (ps[(2) - (2)].val.opval));
 792                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
 793                         ;}
 794     break;
 795
 796   case 100:
 797 #line 787 "perly.y"
 798     { (yyval.opval) = convert(IVAL((ps[(1) - (4)].val.i_tkval)), 0, (ps[(3) - (4)].val.opval));
 799                           TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'o');
 800                           TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'(');
 801                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
 802                         ;}
 803     break;
 804
 805   case 101:
 806 #line 793 "perly.y"
 807     { SvREFCNT_inc_simple_void(PL_compcv);
 808                           (yyval.opval) = newANONATTRSUB((ps[(2) - (3)].val.ival), 0, (OP*)NULL, (ps[(3) - (3)].val.opval)); ;}
 809     break;
 810
 811   case 102:
 812 #line 796 "perly.y"
 813     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
 814                                  append_elem(OP_LIST,
 815                                    prepend_elem(OP_LIST, (ps[(4) - (5)].val.opval), (ps[(5) - (5)].val.opval)), (ps[(1) - (5)].val.opval)));
 816                         ;}
 817     break;
 818
 819   case 105:
 820 #line 811 "perly.y"
 821     { (yyval.opval) = newBINOP(OP_GELEM, 0, (ps[(1) - (5)].val.opval), scalar((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 818 "perly.y"
 831     { (yyval.opval) = newBINOP(OP_AELEM, 0, oopsAV((ps[(1) - (4)].val.opval)), scalar((ps[(3) - (4)].val.opval)));
 832                           TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'[');
 833                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),']');
 834                         ;}
 835     break;
 836
 837   case 107:
 838 #line 823 "perly.y"
 839     { (yyval.opval) = newBINOP(OP_AELEM, 0,
 840                                         ref(newAVREF((ps[(1) - (5)].val.opval)),OP_RV2AV),
 841                                         scalar((ps[(4) - (5)].val.opval)));
 842                           TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'a');
 843                           TOKEN_GETMAD((ps[(3) - (5)].val.i_tkval),(yyval.opval),'[');
 844                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),']');
 845                         ;}
 846     break;
 847
 848   case 108:
 849 #line 831 "perly.y"
 850     { (yyval.opval) = newBINOP(OP_AELEM, 0,
 851                                         ref(newAVREF((ps[(1) - (4)].val.opval)),OP_RV2AV),
 852                                         scalar((ps[(3) - (4)].val.opval)));
 853                           TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'[');
 854                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),']');
 855                         ;}
 856     break;
 857
 858   case 109:
 859 #line 838 "perly.y"
 860     { (yyval.opval) = newBINOP(OP_HELEM, 0, oopsHV((ps[(1) - (5)].val.opval)), jmaybe((ps[(3) - (5)].val.opval)));
 861                             PL_parser->expect = XOPERATOR;
 862                           TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'{');
 863                           TOKEN_GETMAD((ps[(4) - (5)].val.i_tkval),(yyval.opval),';');
 864                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),'}');
 865                         ;}
 866     break;
 867
 868   case 110:
 869 #line 845 "perly.y"
 870     { (yyval.opval) = newBINOP(OP_HELEM, 0,
 871                                         ref(newHVREF((ps[(1) - (6)].val.opval)),OP_RV2HV),
 872                                         jmaybe((ps[(4) - (6)].val.opval)));
 873                             PL_parser->expect = XOPERATOR;
 874                           TOKEN_GETMAD((ps[(2) - (6)].val.i_tkval),(yyval.opval),'a');
 875                           TOKEN_GETMAD((ps[(3) - (6)].val.i_tkval),(yyval.opval),'{');
 876                           TOKEN_GETMAD((ps[(5) - (6)].val.i_tkval),(yyval.opval),';');
 877                           TOKEN_GETMAD((ps[(6) - (6)].val.i_tkval),(yyval.opval),'}');
 878                         ;}
 879     break;
 880
 881   case 111:
 882 #line 855 "perly.y"
 883     { (yyval.opval) = newBINOP(OP_HELEM, 0,
 884                                         ref(newHVREF((ps[(1) - (5)].val.opval)),OP_RV2HV),
 885                                         jmaybe((ps[(3) - (5)].val.opval)));
 886                             PL_parser->expect = XOPERATOR;
 887                           TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'{');
 888                           TOKEN_GETMAD((ps[(4) - (5)].val.i_tkval),(yyval.opval),';');
 889                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),'}');
 890                         ;}
 891     break;
 892
 893   case 112:
 894 #line 864 "perly.y"
 895     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
 896                                    newCVREF(0, scalar((ps[(1) - (4)].val.opval))));
 897                           TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'a');
 898                           TOKEN_GETMAD((ps[(3) - (4)].val.i_tkval),(yyval.opval),'(');
 899                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
 900                         ;}
 901     break;
 902
 903   case 113:
 904 #line 871 "perly.y"
 905     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
 906                                    append_elem(OP_LIST, (ps[(4) - (5)].val.opval),
 907                                        newCVREF(0, scalar((ps[(1) - (5)].val.opval)))));
 908                           TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'a');
 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) = newUNOP(OP_ENTERSUB, OPf_STACKED,
 917                                    append_elem(OP_LIST, (ps[(3) - (4)].val.opval),
 918                                                newCVREF(0, scalar((ps[(1) - (4)].val.opval)))));
 919                           TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'(');
 920                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
 921                         ;}
 922     break;
 923
 924   case 115:
 925 #line 887 "perly.y"
 926     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
 927                                    newCVREF(0, scalar((ps[(1) - (3)].val.opval))));
 928                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'(');
 929                           TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
 930                         ;}
 931     break;
 932
 933   case 116:
 934 #line 893 "perly.y"
 935     { (yyval.opval) = newSLICEOP(0, (ps[(5) - (6)].val.opval), (ps[(2) - (6)].val.opval));
 936                           TOKEN_GETMAD((ps[(1) - (6)].val.i_tkval),(yyval.opval),'(');
 937                           TOKEN_GETMAD((ps[(3) - (6)].val.i_tkval),(yyval.opval),')');
 938                           TOKEN_GETMAD((ps[(4) - (6)].val.i_tkval),(yyval.opval),'[');
 939                           TOKEN_GETMAD((ps[(6) - (6)].val.i_tkval),(yyval.opval),']');
 940                         ;}
 941     break;
 942
 943   case 117:
 944 #line 900 "perly.y"
 945     { (yyval.opval) = newSLICEOP(0, (ps[(4) - (5)].val.opval), (OP*)NULL);
 946                           TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'(');
 947                           TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),')');
 948                           TOKEN_GETMAD((ps[(3) - (5)].val.i_tkval),(yyval.opval),'[');
 949                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),']');
 950                         ;}
 951     break;
 952
 953   case 118:
 954 #line 910 "perly.y"
 955     { (yyval.opval) = newASSIGNOP(OPf_STACKED, (ps[(1) - (3)].val.opval), IVAL((ps[(2) - (3)].val.i_tkval)), (ps[(3) - (3)].val.opval));
 956                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 957                         ;}
 958     break;
 959
 960   case 119:
 961 #line 914 "perly.y"
 962     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
 963                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 964                         ;}
 965     break;
 966
 967   case 120:
 968 #line 918 "perly.y"
 969     {   if (IVAL((ps[(2) - (3)].val.i_tkval)) != OP_REPEAT)
 970                                 scalar((ps[(1) - (3)].val.opval));
 971                             (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, (ps[(1) - (3)].val.opval), scalar((ps[(3) - (3)].val.opval)));
 972                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 973                         ;}
 974     break;
 975
 976   case 121:
 977 #line 924 "perly.y"
 978     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
 979                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 980                         ;}
 981     break;
 982
 983   case 122:
 984 #line 928 "perly.y"
 985     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
 986                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 987                         ;}
 988     break;
 989
 990   case 123:
 991 #line 932 "perly.y"
 992     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
 993                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 994                         ;}
 995     break;
 996
 997   case 124:
 998 #line 936 "perly.y"
 999     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
1000                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
1001                         ;}
1002     break;
1003
1004   case 125:
1005 #line 940 "perly.y"
1006     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
1007                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
1008                         ;}
1009     break;
1010
1011   case 126:
1012 #line 944 "perly.y"
1013     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
1014                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
1015                         ;}
1016     break;
1017
1018   case 127:
1019 #line 948 "perly.y"
1020     {
1021                           (yyval.opval) = newRANGE(IVAL((ps[(2) - (3)].val.i_tkval)), scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
1022                           DO_MAD({
1023                               UNOP *op;
1024                               op = (UNOP*)(yyval.opval);
1025                               op = (UNOP*)op->op_first; /* get to flop */
1026                               op = (UNOP*)op->op_first; /* get to flip */
1027                               op = (UNOP*)op->op_first; /* get to range */
1028                               token_getmad((ps[(2) - (3)].val.i_tkval),(OP*)op,'o');
1029                             })
1030                         ;}
1031     break;
1032
1033   case 128:
1034 #line 960 "perly.y"
1035     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
1036                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
1037                         ;}
1038     break;
1039
1040   case 129:
1041 #line 964 "perly.y"
1042     { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
1043                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
1044                         ;}
1045     break;
1046
1047   case 130:
1048 #line 968 "perly.y"
1049     { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
1050                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
1051                         ;}
1052     break;
1053
1054   case 131:
1055 #line 972 "perly.y"
1056     { (yyval.opval) = bind_match(IVAL((ps[(2) - (3)].val.i_tkval)), (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
1057                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),
1058                                 ((yyval.opval)->op_type == OP_NOT
1059                                     ? ((UNOP*)(yyval.opval))->op_first : (yyval.opval)),
1060                                 '~');
1061                         ;}
1062     break;
1063
1064   case 132:
1065 #line 982 "perly.y"
1066     { (yyval.opval) = newUNOP(OP_NEGATE, 0, scalar((ps[(2) - (2)].val.opval)));
1067                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1068                         ;}
1069     break;
1070
1071   case 133:
1072 #line 986 "perly.y"
1073     { (yyval.opval) = IF_MAD(
1074                                     newUNOP(OP_NULL, 0, (ps[(2) - (2)].val.opval)),
1075                                     (ps[(2) - (2)].val.opval)
1076                                 );
1077                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'+');
1078                         ;}
1079     break;
1080
1081   case 134:
1082 #line 993 "perly.y"
1083     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[(2) - (2)].val.opval)));
1084                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1085                         ;}
1086     break;
1087
1088   case 135:
1089 #line 997 "perly.y"
1090     { (yyval.opval) = newUNOP(OP_COMPLEMENT, 0, scalar((ps[(2) - (2)].val.opval)));
1091                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1092                         ;}
1093     break;
1094
1095   case 136:
1096 #line 1001 "perly.y"
1097     { (yyval.opval) = newUNOP(OP_POSTINC, 0,
1098                                         mod(scalar((ps[(1) - (2)].val.opval)), OP_POSTINC));
1099                           TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),'o');
1100                         ;}
1101     break;
1102
1103   case 137:
1104 #line 1006 "perly.y"
1105     { (yyval.opval) = newUNOP(OP_POSTDEC, 0,
1106                                         mod(scalar((ps[(1) - (2)].val.opval)), OP_POSTDEC));
1107                           TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),'o');
1108                         ;}
1109     break;
1110
1111   case 138:
1112 #line 1011 "perly.y"
1113     { (yyval.opval) = newUNOP(OP_PREINC, 0,
1114                                         mod(scalar((ps[(2) - (2)].val.opval)), OP_PREINC));
1115                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1116                         ;}
1117     break;
1118
1119   case 139:
1120 #line 1016 "perly.y"
1121     { (yyval.opval) = newUNOP(OP_PREDEC, 0,
1122                                         mod(scalar((ps[(2) - (2)].val.opval)), OP_PREDEC));
1123                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1124                         ;}
1125     break;
1126
1127   case 140:
1128 #line 1025 "perly.y"
1129     { (yyval.opval) = newANONLIST((ps[(2) - (3)].val.opval));
1130                           TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'[');
1131                           TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),']');
1132                         ;}
1133     break;
1134
1135   case 141:
1136 #line 1030 "perly.y"
1137     { (yyval.opval) = newANONLIST((OP*)NULL);
1138                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'[');
1139                           TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),']');
1140                         ;}
1141     break;
1142
1143   case 142:
1144 #line 1035 "perly.y"
1145     { (yyval.opval) = newANONHASH((ps[(2) - (4)].val.opval));
1146                           TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'{');
1147                           TOKEN_GETMAD((ps[(3) - (4)].val.i_tkval),(yyval.opval),';');
1148                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),'}');
1149                         ;}
1150     break;
1151
1152   case 143:
1153 #line 1041 "perly.y"
1154     { (yyval.opval) = newANONHASH((OP*)NULL);
1155                           TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'{');
1156                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),';');
1157                           TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),'}');
1158                         ;}
1159     break;
1160
1161   case 144:
1162 #line 1047 "perly.y"
1163     { SvREFCNT_inc_simple_void(PL_compcv);
1164                           (yyval.opval) = newANONATTRSUB((ps[(2) - (5)].val.ival), (ps[(3) - (5)].val.opval), (ps[(4) - (5)].val.opval), (ps[(5) - (5)].val.opval));
1165                           TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'o');
1166                           OP_GETMAD((ps[(3) - (5)].val.opval),(yyval.opval),'s');
1167                           OP_GETMAD((ps[(4) - (5)].val.opval),(yyval.opval),'a');
1168                         ;}
1169     break;
1170
1171   case 145:
1172 #line 1058 "perly.y"
1173     { (yyval.opval) = dofile((ps[(2) - (2)].val.opval), IVAL((ps[(1) - (2)].val.i_tkval)));
1174                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1175                         ;}
1176     break;
1177
1178   case 146:
1179 #line 1062 "perly.y"
1180     { (yyval.opval) = newUNOP(OP_NULL, OPf_SPECIAL, scope((ps[(2) - (2)].val.opval)));
1181                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'D');
1182                         ;}
1183     break;
1184
1185   case 147:
1186 #line 1066 "perly.y"
1187     { (yyval.opval) = newUNOP(OP_ENTERSUB,
1188                             OPf_SPECIAL|OPf_STACKED,
1189                             prepend_elem(OP_LIST,
1190                                 scalar(newCVREF(
1191                                     (OPpENTERSUB_AMPER<<8),
1192                                     scalar((ps[(2) - (4)].val.opval))
1193                                 )),(OP*)NULL)); dep();
1194                           TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'o');
1195                           TOKEN_GETMAD((ps[(3) - (4)].val.i_tkval),(yyval.opval),'(');
1196                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
1197                         ;}
1198     break;
1199
1200   case 148:
1201 #line 1078 "perly.y"
1202     { (yyval.opval) = newUNOP(OP_ENTERSUB,
1203                             OPf_SPECIAL|OPf_STACKED,
1204                             append_elem(OP_LIST,
1205                                 (ps[(4) - (5)].val.opval),
1206                                 scalar(newCVREF(
1207                                     (OPpENTERSUB_AMPER<<8),
1208                                     scalar((ps[(2) - (5)].val.opval))
1209                                 )))); dep();
1210                           TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'o');
1211                           TOKEN_GETMAD((ps[(3) - (5)].val.i_tkval),(yyval.opval),'(');
1212                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),')');
1213                         ;}
1214     break;
1215
1216   case 149:
1217 #line 1091 "perly.y"
1218     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_SPECIAL|OPf_STACKED,
1219                             prepend_elem(OP_LIST,
1220                                 scalar(newCVREF(0,scalar((ps[(2) - (4)].val.opval)))), (OP*)NULL)); dep();
1221                           TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'o');
1222                           TOKEN_GETMAD((ps[(3) - (4)].val.i_tkval),(yyval.opval),'(');
1223                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
1224                         ;}
1225     break;
1226
1227   case 150:
1228 #line 1099 "perly.y"
1229     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_SPECIAL|OPf_STACKED,
1230                             prepend_elem(OP_LIST,
1231                                 (ps[(4) - (5)].val.opval),
1232                                 scalar(newCVREF(0,scalar((ps[(2) - (5)].val.opval)))))); dep();
1233                           TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'o');
1234                           TOKEN_GETMAD((ps[(3) - (5)].val.i_tkval),(yyval.opval),'(');
1235                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),')');
1236                         ;}
1237     break;
1238
1239   case 155:
1240 #line 1115 "perly.y"
1241     { (yyval.opval) = newCONDOP(0, (ps[(1) - (5)].val.opval), (ps[(3) - (5)].val.opval), (ps[(5) - (5)].val.opval));
1242                           TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'?');
1243                           TOKEN_GETMAD((ps[(4) - (5)].val.i_tkval),(yyval.opval),':');
1244                         ;}
1245     break;
1246
1247   case 156:
1248 #line 1120 "perly.y"
1249     { (yyval.opval) = newUNOP(OP_REFGEN, 0, mod((ps[(2) - (2)].val.opval),OP_REFGEN));
1250                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1251                         ;}
1252     break;
1253
1254   case 157:
1255 #line 1124 "perly.y"
1256     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1257     break;
1258
1259   case 158:
1260 #line 1126 "perly.y"
1261     { (yyval.opval) = localize((ps[(2) - (2)].val.opval),IVAL((ps[(1) - (2)].val.i_tkval)));
1262                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'k');
1263                         ;}
1264     break;
1265
1266   case 159:
1267 #line 1130 "perly.y"
1268     { (yyval.opval) = sawparens(IF_MAD(newUNOP(OP_NULL,0,(ps[(2) - (3)].val.opval)), (ps[(2) - (3)].val.opval)));
1269                           TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'(');
1270                           TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
1271                         ;}
1272     break;
1273
1274   case 160:
1275 #line 1135 "perly.y"
1276     { (yyval.opval) = sawparens(newNULLLIST());
1277                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'(');
1278                           TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),')');
1279                         ;}
1280     break;
1281
1282   case 161:
1283 #line 1140 "perly.y"
1284     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1285     break;
1286
1287   case 162:
1288 #line 1142 "perly.y"
1289     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1290     break;
1291
1292   case 163:
1293 #line 1144 "perly.y"
1294     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1295     break;
1296
1297   case 164:
1298 #line 1146 "perly.y"
1299     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1300     break;
1301
1302   case 165:
1303 #line 1148 "perly.y"
1304     { (yyval.opval) = newUNOP(OP_AV2ARYLEN, 0, ref((ps[(1) - (1)].val.opval), OP_AV2ARYLEN));;}
1305     break;
1306
1307   case 166:
1308 #line 1150 "perly.y"
1309     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1310     break;
1311
1312   case 167:
1313 #line 1152 "perly.y"
1314     { (yyval.opval) = prepend_elem(OP_ASLICE,
1315                                 newOP(OP_PUSHMARK, 0),
1316                                     newLISTOP(OP_ASLICE, 0,
1317                                         list((ps[(3) - (4)].val.opval)),
1318                                         ref((ps[(1) - (4)].val.opval), OP_ASLICE)));
1319                           TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'[');
1320                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),']');
1321                         ;}
1322     break;
1323
1324   case 168:
1325 #line 1161 "perly.y"
1326     { (yyval.opval) = prepend_elem(OP_HSLICE,
1327                                 newOP(OP_PUSHMARK, 0),
1328                                     newLISTOP(OP_HSLICE, 0,
1329                                         list((ps[(3) - (5)].val.opval)),
1330                                         ref(oopsHV((ps[(1) - (5)].val.opval)), OP_HSLICE)));
1331                             PL_parser->expect = XOPERATOR;
1332                           TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'{');
1333                           TOKEN_GETMAD((ps[(4) - (5)].val.i_tkval),(yyval.opval),';');
1334                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),'}');
1335                         ;}
1336     break;
1337
1338   case 169:
1339 #line 1172 "perly.y"
1340     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1341     break;
1342
1343   case 170:
1344 #line 1174 "perly.y"
1345     { (yyval.opval) = newUNOP(OP_ENTERSUB, 0, scalar((ps[(1) - (1)].val.opval))); ;}
1346     break;
1347
1348   case 171:
1349 #line 1176 "perly.y"
1350     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (3)].val.opval)));
1351                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'(');
1352                           TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
1353                         ;}
1354     break;
1355
1356   case 172:
1357 #line 1181 "perly.y"
1358     {
1359                           (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1360                                 append_elem(OP_LIST, (ps[(3) - (4)].val.opval), scalar((ps[(1) - (4)].val.opval))));
1361                           DO_MAD({
1362                               OP* op = (yyval.opval);
1363                               if (op->op_type == OP_CONST) { /* defeat const fold */
1364                                 op = (OP*)op->op_madprop->mad_val;
1365                               }
1366                               token_getmad((ps[(2) - (4)].val.i_tkval),op,'(');
1367                               token_getmad((ps[(4) - (4)].val.i_tkval),op,')');
1368                           })
1369                         ;}
1370     break;
1371
1372   case 173:
1373 #line 1194 "perly.y"
1374     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1375                             append_elem(OP_LIST, (ps[(3) - (3)].val.opval), scalar((ps[(2) - (3)].val.opval))));
1376                           TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
1377                         ;}
1378     break;
1379
1380   case 174:
1381 #line 1199 "perly.y"
1382     { (yyval.opval) = newOP(IVAL((ps[(1) - (1)].val.i_tkval)), OPf_SPECIAL);
1383                             PL_hints |= HINT_BLOCK_SCOPE;
1384                           TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'o');
1385                         ;}
1386     break;
1387
1388   case 175:
1389 #line 1204 "perly.y"
1390     { (yyval.opval) = newLOOPEX(IVAL((ps[(1) - (2)].val.i_tkval)),(ps[(2) - (2)].val.opval));
1391                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1392                         ;}
1393     break;
1394
1395   case 176:
1396 #line 1208 "perly.y"
1397     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[(2) - (2)].val.opval)));
1398                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1399                         ;}
1400     break;
1401
1402   case 177:
1403 #line 1212 "perly.y"
1404     { (yyval.opval) = newOP(IVAL((ps[(1) - (1)].val.i_tkval)), 0);
1405                           TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'o');
1406                         ;}
1407     break;
1408
1409   case 178:
1410 #line 1216 "perly.y"
1411     { (yyval.opval) = newUNOP(IVAL((ps[(1) - (2)].val.i_tkval)), 0, (ps[(2) - (2)].val.opval));
1412                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1413                         ;}
1414     break;
1415
1416   case 179:
1417 #line 1220 "perly.y"
1418     { (yyval.opval) = newUNOP(IVAL((ps[(1) - (2)].val.i_tkval)), 0, (ps[(2) - (2)].val.opval));
1419                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1420                         ;}
1421     break;
1422
1423   case 180:
1424 #line 1224 "perly.y"
1425     { (yyval.opval) = newOP(OP_REQUIRE, (ps[(1) - (1)].val.i_tkval) ? OPf_SPECIAL : 0);
1426                           TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'o');
1427                         ;}
1428     break;
1429
1430   case 181:
1431 #line 1228 "perly.y"
1432     { (yyval.opval) = newUNOP(OP_REQUIRE, (ps[(1) - (2)].val.i_tkval) ? OPf_SPECIAL : 0, (ps[(2) - (2)].val.opval));
1433                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1434                         ;}
1435     break;
1436
1437   case 182:
1438 #line 1232 "perly.y"
1439     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (1)].val.opval))); ;}
1440     break;
1441
1442   case 183:
1443 #line 1234 "perly.y"
1444     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1445                             append_elem(OP_LIST, (ps[(2) - (2)].val.opval), scalar((ps[(1) - (2)].val.opval)))); ;}
1446     break;
1447
1448   case 184:
1449 #line 1237 "perly.y"
1450     { (yyval.opval) = newOP(IVAL((ps[(1) - (1)].val.i_tkval)), 0);
1451                           TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'o');
1452                         ;}
1453     break;
1454
1455   case 185:
1456 #line 1241 "perly.y"
1457     { (yyval.opval) = newOP(IVAL((ps[(1) - (3)].val.i_tkval)), 0);
1458                           TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
1459                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'(');
1460                           TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
1461                         ;}
1462     break;
1463
1464   case 186:
1465 #line 1247 "perly.y"
1466     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1467                                 scalar((ps[(1) - (1)].val.opval))); ;}
1468     break;
1469
1470   case 187:
1471 #line 1250 "perly.y"
1472     { (yyval.opval) = (IVAL((ps[(1) - (3)].val.i_tkval)) == OP_NOT)
1473                             ? newUNOP(IVAL((ps[(1) - (3)].val.i_tkval)), 0, newSVOP(OP_CONST, 0, newSViv(0)))
1474                             : newOP(IVAL((ps[(1) - (3)].val.i_tkval)), OPf_SPECIAL);
1475
1476                           TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
1477                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'(');
1478                           TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
1479                         ;}
1480     break;
1481
1482   case 188:
1483 #line 1259 "perly.y"
1484     { (yyval.opval) = newUNOP(IVAL((ps[(1) - (4)].val.i_tkval)), 0, (ps[(3) - (4)].val.opval));
1485                           TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'o');
1486                           TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'(');
1487                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
1488                         ;}
1489     break;
1490
1491   case 189:
1492 #line 1265 "perly.y"
1493     { (yyval.opval) = pmruntime((ps[(1) - (4)].val.opval), (ps[(3) - (4)].val.opval), 1);
1494                           TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'(');
1495                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
1496                         ;}
1497     break;
1498
1499   case 192:
1500 #line 1272 "perly.y"
1501     {
1502                           (yyval.opval) = newLISTOP(OP_DIE, 0, newOP(OP_PUSHMARK, 0),
1503                                 newSVOP(OP_CONST, 0, newSVpvs("Unimplemented")));
1504                           TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'X');
1505                         ;}
1506     break;
1507
1508   case 194:
1509 #line 1282 "perly.y"
1510     { (yyval.opval) = my_attrs((ps[(2) - (3)].val.opval),(ps[(3) - (3)].val.opval));
1511                           DO_MAD(
1512                               token_getmad((ps[(1) - (3)].val.i_tkval),(yyval.opval),'d');
1513                               append_madprops((ps[(3) - (3)].val.opval)->op_madprop, (yyval.opval), 'a');
1514                               (ps[(3) - (3)].val.opval)->op_madprop = 0;
1515                           )
1516                         ;}
1517     break;
1518
1519   case 195:
1520 #line 1290 "perly.y"
1521     { (yyval.opval) = localize((ps[(2) - (2)].val.opval),IVAL((ps[(1) - (2)].val.i_tkval)));
1522                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'d');
1523                         ;}
1524     break;
1525
1526   case 196:
1527 #line 1297 "perly.y"
1528     { (yyval.opval) = sawparens((ps[(2) - (3)].val.opval));
1529                           TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'(');
1530                           TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
1531                         ;}
1532     break;
1533
1534   case 197:
1535 #line 1302 "perly.y"
1536     { (yyval.opval) = sawparens(newNULLLIST());
1537                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'(');
1538                           TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),')');
1539                         ;}
1540     break;
1541
1542   case 198:
1543 #line 1307 "perly.y"
1544     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1545     break;
1546
1547   case 199:
1548 #line 1309 "perly.y"
1549     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1550     break;
1551
1552   case 200:
1553 #line 1311 "perly.y"
1554     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1555     break;
1556
1557   case 201:
1558 #line 1316 "perly.y"
1559     { (yyval.opval) = (OP*)NULL; ;}
1560     break;
1561
1562   case 202:
1563 #line 1318 "perly.y"
1564     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1565     break;
1566
1567   case 203:
1568 #line 1322 "perly.y"
1569     { (yyval.opval) = (OP*)NULL; ;}
1570     break;
1571
1572   case 204:
1573 #line 1324 "perly.y"
1574     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1575     break;
1576
1577   case 205:
1578 #line 1326 "perly.y"
1579     {
1580 #ifdef MAD
1581                           OP* op = newNULLLIST();
1582                           token_getmad((ps[(2) - (2)].val.i_tkval),op,',');
1583                           (yyval.opval) = append_elem(OP_LIST, (ps[(1) - (2)].val.opval), op);
1584 #else
1585                           (yyval.opval) = (ps[(1) - (2)].val.opval);
1586 #endif
1587
1588                         ;}
1589     break;
1590
1591   case 206:
1592 #line 1341 "perly.y"
1593     { PL_parser->in_my = 0; (yyval.opval) = my((ps[(1) - (1)].val.opval)); ;}
1594     break;
1595
1596   case 207:
1597 #line 1345 "perly.y"
1598     { (yyval.opval) = newCVREF(IVAL((ps[(1) - (2)].val.i_tkval)),(ps[(2) - (2)].val.opval));
1599                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'&');
1600                         ;}
1601     break;
1602
1603   case 208:
1604 #line 1351 "perly.y"
1605     { (yyval.opval) = newSVREF((ps[(2) - (2)].val.opval));
1606                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'$');
1607                         ;}
1608     break;
1609
1610   case 209:
1611 #line 1357 "perly.y"
1612     { (yyval.opval) = newAVREF((ps[(2) - (2)].val.opval));
1613                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'@');
1614                         ;}
1615     break;
1616
1617   case 210:
1618 #line 1363 "perly.y"
1619     { (yyval.opval) = newHVREF((ps[(2) - (2)].val.opval));
1620                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'%');
1621                         ;}
1622     break;
1623
1624   case 211:
1625 #line 1369 "perly.y"
1626     { (yyval.opval) = newAVREF((ps[(2) - (2)].val.opval));
1627                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'l');
1628                         ;}
1629     break;
1630
1631   case 212:
1632 #line 1375 "perly.y"
1633     { (yyval.opval) = newGVREF(0,(ps[(2) - (2)].val.opval));
1634                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'*');
1635                         ;}
1636     break;
1637
1638   case 213:
1639 #line 1382 "perly.y"
1640     { (yyval.opval) = scalar((ps[(1) - (1)].val.opval)); ;}
1641     break;
1642
1643   case 214:
1644 #line 1384 "perly.y"
1645     { (yyval.opval) = scalar((ps[(1) - (1)].val.opval)); ;}
1646     break;
1647
1648   case 215:
1649 #line 1386 "perly.y"
1650     { (yyval.opval) = scope((ps[(1) - (1)].val.opval)); ;}
1651     break;
1652
1653   case 216:
1654 #line 1389 "perly.y"
1655     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1656     break;
1657
1658
1659 /* Line 1267 of yacc.c.  */
1660
1661       default: break;
1662