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