perly.act

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