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