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                                            CopLABEL_alloc(((ps[(1) - (12)].val.p_tkval))->tk_lval.pval),
 328                                            ((ps[(5) - (12)].val.opval) ? newOP(OP_NULL, 0) : (ps[(5) - (12)].val.opval)) ),
 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_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(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(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(PL_compcv);
 496 #ifdef MAD
 497                           OP* o = newSVOP(OP_ANONCODE, 0,
 498                             (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)));
 499                           (yyval.opval) = newOP(OP_NULL,0);
 500                           op_getmad(o,(yyval.opval),'&');
 501                           op_getmad((ps[(3) - (6)].val.opval),(yyval.opval),'n');
 502                           op_getmad((ps[(4) - (6)].val.opval),(yyval.opval),'s');
 503                           op_getmad((ps[(5) - (6)].val.opval),(yyval.opval),'a');
 504                           token_getmad((ps[(1) - (6)].val.i_tkval),(yyval.opval),'d');
 505                           append_madprops((ps[(6) - (6)].val.opval)->op_madprop, (yyval.opval), 0);
 506                           (ps[(6) - (6)].val.opval)->op_madprop = 0;
 507 #else
 508                           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));
 509                           (yyval.opval) = Nullop;
 510 #endif
 511                         ;}
 512     break;
 513
 514   case 66:
 515 #line 558 "perly.y"
 516     { (yyval.ival) = start_subparse(FALSE, 0);
 517                             SAVEFREESV(PL_compcv); ;}
 518     break;
 519
 520   case 67:
 521 #line 564 "perly.y"
 522     { (yyval.ival) = start_subparse(FALSE, CVf_ANON);
 523                             SAVEFREESV(PL_compcv); ;}
 524     break;
 525
 526   case 68:
 527 #line 569 "perly.y"
 528     { (yyval.ival) = start_subparse(TRUE, 0);
 529                             SAVEFREESV(PL_compcv); ;}
 530     break;
 531
 532   case 69:
 533 #line 574 "perly.y"
 534     { const char *const name = SvPV_nolen_const(((SVOP*)(ps[(1) - (1)].val.opval))->op_sv);
 535                           if (strEQ(name, "BEGIN") || strEQ(name, "END")
 536                               || strEQ(name, "INIT") || strEQ(name, "CHECK")
 537                               || strEQ(name, "UNITCHECK"))
 538                               CvSPECIAL_on(PL_compcv);
 539                           (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
 540     break;
 541
 542   case 70:
 543 #line 584 "perly.y"
 544     { (yyval.opval) = Nullop; ;}
 545     break;
 546
 547   case 72:
 548 #line 590 "perly.y"
 549     { (yyval.opval) = Nullop; ;}
 550     break;
 551
 552   case 73:
 553 #line 592 "perly.y"
 554     { (yyval.opval) = (ps[(2) - (2)].val.opval);
 555                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),':');
 556                         ;}
 557     break;
 558
 559   case 74:
 560 #line 596 "perly.y"
 561     { (yyval.opval) = IF_MAD(
 562                                     newOP(OP_NULL, 0),
 563                                     Nullop
 564                                 );
 565                           TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),':');
 566                         ;}
 567     break;
 568
 569   case 75:
 570 #line 606 "perly.y"
 571     { (yyval.opval) = (ps[(2) - (2)].val.opval);
 572                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),':');
 573                         ;}
 574     break;
 575
 576   case 76:
 577 #line 610 "perly.y"
 578     { (yyval.opval) = IF_MAD(
 579                                     newOP(OP_NULL, 0),
 580                                     Nullop
 581                                 );
 582                           TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),':');
 583                         ;}
 584     break;
 585
 586   case 77:
 587 #line 619 "perly.y"
 588     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
 589     break;
 590
 591   case 78:
 592 #line 620 "perly.y"
 593     { (yyval.opval) = IF_MAD(
 594                                     newOP(OP_NULL,0),
 595                                     Nullop
 596                                 );
 597                           PL_expect = XSTATE;
 598                           TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),';');
 599                         ;}
 600     break;
 601
 602   case 79:
 603 #line 630 "perly.y"
 604     {
 605 #ifdef MAD
 606                           (yyval.opval) = package((ps[(2) - (3)].val.opval));
 607                           token_getmad((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
 608                           token_getmad((ps[(3) - (3)].val.i_tkval),(yyval.opval),';');
 609 #else
 610                           package((ps[(2) - (3)].val.opval));
 611                           (yyval.opval) = Nullop;
 612 #endif
 613                         ;}
 614     break;
 615
 616   case 80:
 617 #line 643 "perly.y"
 618     { CvSPECIAL_on(PL_compcv); /* It's a BEGIN {} */ ;}
 619     break;
 620
 621   case 81:
 622 #line 645 "perly.y"
 623     { SvREFCNT_inc(PL_compcv);
 624 #ifdef MAD
 625                           (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));
 626                           token_getmad((ps[(1) - (7)].val.i_tkval),(yyval.opval),'o');
 627                           token_getmad((ps[(7) - (7)].val.i_tkval),(yyval.opval),';');
 628                           if (PL_rsfp_filters && AvFILLp(PL_rsfp_filters) >= 0)
 629                               append_madprops(newMADPROP('!', MAD_PV, "", 0), (yyval.opval), 0);
 630 #else
 631                           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));
 632                           (yyval.opval) = Nullop;
 633 #endif
 634                         ;}
 635     break;
 636
 637   case 82:
 638 #line 661 "perly.y"
 639     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
 640                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 641                         ;}
 642     break;
 643
 644   case 83:
 645 #line 665 "perly.y"
 646     { (yyval.opval) = newLOGOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
 647                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 648                         ;}
 649     break;
 650
 651   case 84:
 652 #line 669 "perly.y"
 653     { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
 654                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 655                         ;}
 656     break;
 657
 658   case 86:
 659 #line 677 "perly.y"
 660     {
 661 #ifdef MAD
 662                           OP* op = newNULLLIST();
 663                           token_getmad((ps[(2) - (2)].val.i_tkval),op,',');
 664                           (yyval.opval) = append_elem(OP_LIST, (ps[(1) - (2)].val.opval), op);
 665 #else
 666                           (yyval.opval) = (ps[(1) - (2)].val.opval);
 667 #endif
 668                         ;}
 669     break;
 670
 671   case 87:
 672 #line 687 "perly.y"
 673     {
 674                           OP* term = (ps[(3) - (3)].val.opval);
 675                           DO_MAD(
 676                               term = newUNOP(OP_NULL, 0, term);
 677                               token_getmad((ps[(2) - (3)].val.i_tkval),term,',');
 678                           )
 679                           (yyval.opval) = append_elem(OP_LIST, (ps[(1) - (3)].val.opval), term);
 680                         ;}
 681     break;
 682
 683   case 89:
 684 #line 700 "perly.y"
 685     { (yyval.opval) = convert(IVAL((ps[(1) - (3)].val.i_tkval)), OPf_STACKED,
 686                                 prepend_elem(OP_LIST, newGVREF(IVAL((ps[(1) - (3)].val.i_tkval)),(ps[(2) - (3)].val.opval)), (ps[(3) - (3)].val.opval)) );
 687                           TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
 688                         ;}
 689     break;
 690
 691   case 90:
 692 #line 705 "perly.y"
 693     { (yyval.opval) = convert(IVAL((ps[(1) - (5)].val.i_tkval)), OPf_STACKED,
 694                                 prepend_elem(OP_LIST, newGVREF(IVAL((ps[(1) - (5)].val.i_tkval)),(ps[(3) - (5)].val.opval)), (ps[(4) - (5)].val.opval)) );
 695                           TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'o');
 696                           TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'(');
 697                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),')');
 698                         ;}
 699     break;
 700
 701   case 91:
 702 #line 712 "perly.y"
 703     { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
 704                                 append_elem(OP_LIST,
 705                                     prepend_elem(OP_LIST, scalar((ps[(1) - (6)].val.opval)), (ps[(5) - (6)].val.opval)),
 706                                     newUNOP(OP_METHOD, 0, (ps[(3) - (6)].val.opval))));
 707                           TOKEN_GETMAD((ps[(2) - (6)].val.i_tkval),(yyval.opval),'A');
 708                           TOKEN_GETMAD((ps[(4) - (6)].val.i_tkval),(yyval.opval),'(');
 709                           TOKEN_GETMAD((ps[(6) - (6)].val.i_tkval),(yyval.opval),')');
 710                         ;}
 711     break;
 712
 713   case 92:
 714 #line 721 "perly.y"
 715     { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
 716                                 append_elem(OP_LIST, scalar((ps[(1) - (3)].val.opval)),
 717                                     newUNOP(OP_METHOD, 0, (ps[(3) - (3)].val.opval))));
 718                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'A');
 719                         ;}
 720     break;
 721
 722   case 93:
 723 #line 727 "perly.y"
 724     { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
 725                                 append_elem(OP_LIST,
 726                                     prepend_elem(OP_LIST, (ps[(2) - (3)].val.opval), (ps[(3) - (3)].val.opval)),
 727                                     newUNOP(OP_METHOD, 0, (ps[(1) - (3)].val.opval))));
 728                         ;}
 729     break;
 730
 731   case 94:
 732 #line 733 "perly.y"
 733     { (yyval.opval) = convert(OP_ENTERSUB, OPf_STACKED,
 734                                 append_elem(OP_LIST,
 735                                     prepend_elem(OP_LIST, (ps[(2) - (5)].val.opval), (ps[(4) - (5)].val.opval)),
 736                                     newUNOP(OP_METHOD, 0, (ps[(1) - (5)].val.opval))));
 737                           TOKEN_GETMAD((ps[(3) - (5)].val.i_tkval),(yyval.opval),'(');
 738                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),')');
 739                         ;}
 740     break;
 741
 742   case 95:
 743 #line 741 "perly.y"
 744     { (yyval.opval) = convert(IVAL((ps[(1) - (2)].val.i_tkval)), 0, (ps[(2) - (2)].val.opval));
 745                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
 746                         ;}
 747     break;
 748
 749   case 96:
 750 #line 745 "perly.y"
 751     { (yyval.opval) = convert(IVAL((ps[(1) - (4)].val.i_tkval)), 0, (ps[(3) - (4)].val.opval));
 752                           TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'o');
 753                           TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'(');
 754                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
 755                         ;}
 756     break;
 757
 758   case 97:
 759 #line 751 "perly.y"
 760     { SvREFCNT_inc(PL_compcv);
 761                           (yyval.opval) = newANONATTRSUB((ps[(2) - (3)].val.ival), 0, Nullop, (ps[(3) - (3)].val.opval)); ;}
 762     break;
 763
 764   case 98:
 765 #line 754 "perly.y"
 766     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
 767                                  append_elem(OP_LIST,
 768                                    prepend_elem(OP_LIST, (ps[(4) - (5)].val.opval), (ps[(5) - (5)].val.opval)), (ps[(1) - (5)].val.opval)));
 769                         ;}
 770     break;
 771
 772   case 101:
 773 #line 769 "perly.y"
 774     { (yyval.opval) = newBINOP(OP_GELEM, 0, (ps[(1) - (5)].val.opval), scalar((ps[(3) - (5)].val.opval)));
 775                             PL_expect = XOPERATOR;
 776                           TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'{');
 777                           TOKEN_GETMAD((ps[(4) - (5)].val.i_tkval),(yyval.opval),';');
 778                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),'}');
 779                         ;}
 780     break;
 781
 782   case 102:
 783 #line 776 "perly.y"
 784     { (yyval.opval) = newBINOP(OP_AELEM, 0, oopsAV((ps[(1) - (4)].val.opval)), scalar((ps[(3) - (4)].val.opval)));
 785                           TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'[');
 786                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),']');
 787                         ;}
 788     break;
 789
 790   case 103:
 791 #line 781 "perly.y"
 792     { (yyval.opval) = newBINOP(OP_AELEM, 0,
 793                                         ref(newAVREF((ps[(1) - (5)].val.opval)),OP_RV2AV),
 794                                         scalar((ps[(4) - (5)].val.opval)));
 795                           TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'a');
 796                           TOKEN_GETMAD((ps[(3) - (5)].val.i_tkval),(yyval.opval),'[');
 797                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),']');
 798                         ;}
 799     break;
 800
 801   case 104:
 802 #line 789 "perly.y"
 803     { (yyval.opval) = newBINOP(OP_AELEM, 0,
 804                                         ref(newAVREF((ps[(1) - (4)].val.opval)),OP_RV2AV),
 805                                         scalar((ps[(3) - (4)].val.opval)));
 806                           TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'[');
 807                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),']');
 808                         ;}
 809     break;
 810
 811   case 105:
 812 #line 796 "perly.y"
 813     { (yyval.opval) = newBINOP(OP_HELEM, 0, oopsHV((ps[(1) - (5)].val.opval)), jmaybe((ps[(3) - (5)].val.opval)));
 814                             PL_expect = XOPERATOR;
 815                           TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'{');
 816                           TOKEN_GETMAD((ps[(4) - (5)].val.i_tkval),(yyval.opval),';');
 817                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),'}');
 818                         ;}
 819     break;
 820
 821   case 106:
 822 #line 803 "perly.y"
 823     { (yyval.opval) = newBINOP(OP_HELEM, 0,
 824                                         ref(newHVREF((ps[(1) - (6)].val.opval)),OP_RV2HV),
 825                                         jmaybe((ps[(4) - (6)].val.opval)));
 826                             PL_expect = XOPERATOR;
 827                           TOKEN_GETMAD((ps[(2) - (6)].val.i_tkval),(yyval.opval),'a');
 828                           TOKEN_GETMAD((ps[(3) - (6)].val.i_tkval),(yyval.opval),'{');
 829                           TOKEN_GETMAD((ps[(5) - (6)].val.i_tkval),(yyval.opval),';');
 830                           TOKEN_GETMAD((ps[(6) - (6)].val.i_tkval),(yyval.opval),'}');
 831                         ;}
 832     break;
 833
 834   case 107:
 835 #line 813 "perly.y"
 836     { (yyval.opval) = newBINOP(OP_HELEM, 0,
 837                                         ref(newHVREF((ps[(1) - (5)].val.opval)),OP_RV2HV),
 838                                         jmaybe((ps[(3) - (5)].val.opval)));
 839                             PL_expect = XOPERATOR;
 840                           TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'{');
 841                           TOKEN_GETMAD((ps[(4) - (5)].val.i_tkval),(yyval.opval),';');
 842                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),'}');
 843                         ;}
 844     break;
 845
 846   case 108:
 847 #line 822 "perly.y"
 848     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
 849                                    newCVREF(0, scalar((ps[(1) - (4)].val.opval))));
 850                           TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'a');
 851                           TOKEN_GETMAD((ps[(3) - (4)].val.i_tkval),(yyval.opval),'(');
 852                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
 853                         ;}
 854     break;
 855
 856   case 109:
 857 #line 829 "perly.y"
 858     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
 859                                    append_elem(OP_LIST, (ps[(4) - (5)].val.opval),
 860                                        newCVREF(0, scalar((ps[(1) - (5)].val.opval)))));
 861                           TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'a');
 862                           TOKEN_GETMAD((ps[(3) - (5)].val.i_tkval),(yyval.opval),'(');
 863                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),')');
 864                         ;}
 865     break;
 866
 867   case 110:
 868 #line 838 "perly.y"
 869     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
 870                                    append_elem(OP_LIST, (ps[(3) - (4)].val.opval),
 871                                                newCVREF(0, scalar((ps[(1) - (4)].val.opval)))));
 872                           TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'(');
 873                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
 874                         ;}
 875     break;
 876
 877   case 111:
 878 #line 845 "perly.y"
 879     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
 880                                    newCVREF(0, scalar((ps[(1) - (3)].val.opval))));
 881                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'(');
 882                           TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
 883                         ;}
 884     break;
 885
 886   case 112:
 887 #line 851 "perly.y"
 888     { (yyval.opval) = newSLICEOP(0, (ps[(5) - (6)].val.opval), (ps[(2) - (6)].val.opval));
 889                           TOKEN_GETMAD((ps[(1) - (6)].val.i_tkval),(yyval.opval),'(');
 890                           TOKEN_GETMAD((ps[(3) - (6)].val.i_tkval),(yyval.opval),')');
 891                           TOKEN_GETMAD((ps[(4) - (6)].val.i_tkval),(yyval.opval),'[');
 892                           TOKEN_GETMAD((ps[(6) - (6)].val.i_tkval),(yyval.opval),']');
 893                         ;}
 894     break;
 895
 896   case 113:
 897 #line 858 "perly.y"
 898     { (yyval.opval) = newSLICEOP(0, (ps[(4) - (5)].val.opval), Nullop);
 899                           TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'(');
 900                           TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),')');
 901                           TOKEN_GETMAD((ps[(3) - (5)].val.i_tkval),(yyval.opval),'[');
 902                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),']');
 903                         ;}
 904     break;
 905
 906   case 114:
 907 #line 868 "perly.y"
 908     { (yyval.opval) = newASSIGNOP(OPf_STACKED, (ps[(1) - (3)].val.opval), IVAL((ps[(2) - (3)].val.i_tkval)), (ps[(3) - (3)].val.opval));
 909                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 910                         ;}
 911     break;
 912
 913   case 115:
 914 #line 872 "perly.y"
 915     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
 916                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 917                         ;}
 918     break;
 919
 920   case 116:
 921 #line 876 "perly.y"
 922     {   if (IVAL((ps[(2) - (3)].val.i_tkval)) != OP_REPEAT)
 923                                 scalar((ps[(1) - (3)].val.opval));
 924                             (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, (ps[(1) - (3)].val.opval), scalar((ps[(3) - (3)].val.opval)));
 925                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 926                         ;}
 927     break;
 928
 929   case 117:
 930 #line 882 "perly.y"
 931     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
 932                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 933                         ;}
 934     break;
 935
 936   case 118:
 937 #line 886 "perly.y"
 938     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
 939                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 940                         ;}
 941     break;
 942
 943   case 119:
 944 #line 890 "perly.y"
 945     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
 946                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 947                         ;}
 948     break;
 949
 950   case 120:
 951 #line 894 "perly.y"
 952     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
 953                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 954                         ;}
 955     break;
 956
 957   case 121:
 958 #line 898 "perly.y"
 959     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
 960                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 961                         ;}
 962     break;
 963
 964   case 122:
 965 #line 902 "perly.y"
 966     { (yyval.opval) = newBINOP(IVAL((ps[(2) - (3)].val.i_tkval)), 0, scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
 967                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 968                         ;}
 969     break;
 970
 971   case 123:
 972 #line 906 "perly.y"
 973     {
 974                           (yyval.opval) = newRANGE(IVAL((ps[(2) - (3)].val.i_tkval)), scalar((ps[(1) - (3)].val.opval)), scalar((ps[(3) - (3)].val.opval)));
 975                           DO_MAD(
 976                               UNOP *op;
 977                               op = (UNOP*)(yyval.opval);
 978                               op = (UNOP*)op->op_first; /* get to flop */
 979                               op = (UNOP*)op->op_first; /* get to flip */
 980                               op = (UNOP*)op->op_first; /* get to range */
 981                               token_getmad((ps[(2) - (3)].val.i_tkval),(OP*)op,'o');
 982                             )
 983                         ;}
 984     break;
 985
 986   case 124:
 987 #line 918 "perly.y"
 988     { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
 989                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 990                         ;}
 991     break;
 992
 993   case 125:
 994 #line 922 "perly.y"
 995     { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
 996                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
 997                         ;}
 998     break;
 999
1000   case 126:
1001 #line 926 "perly.y"
1002     { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
1003                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'o');
1004                         ;}
1005     break;
1006
1007   case 127:
1008 #line 930 "perly.y"
1009     { (yyval.opval) = bind_match(IVAL((ps[(2) - (3)].val.i_tkval)), (ps[(1) - (3)].val.opval), (ps[(3) - (3)].val.opval));
1010                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),
1011                                 ((yyval.opval)->op_type == OP_NOT
1012                                     ? ((UNOP*)(yyval.opval))->op_first : (yyval.opval)),
1013                                 '~');
1014                         ;}
1015     break;
1016
1017   case 128:
1018 #line 940 "perly.y"
1019     { (yyval.opval) = newUNOP(OP_NEGATE, 0, scalar((ps[(2) - (2)].val.opval)));
1020                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1021                         ;}
1022     break;
1023
1024   case 129:
1025 #line 944 "perly.y"
1026     { (yyval.opval) = IF_MAD(
1027                                     newUNOP(OP_NULL, 0, (ps[(2) - (2)].val.opval)),
1028                                     (ps[(2) - (2)].val.opval)
1029                                 );
1030                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'+');
1031                         ;}
1032     break;
1033
1034   case 130:
1035 #line 951 "perly.y"
1036     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[(2) - (2)].val.opval)));
1037                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1038                         ;}
1039     break;
1040
1041   case 131:
1042 #line 955 "perly.y"
1043     { (yyval.opval) = newUNOP(OP_COMPLEMENT, 0, scalar((ps[(2) - (2)].val.opval)));
1044                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1045                         ;}
1046     break;
1047
1048   case 132:
1049 #line 959 "perly.y"
1050     { (yyval.opval) = newUNOP(OP_POSTINC, 0,
1051                                         mod(scalar((ps[(1) - (2)].val.opval)), OP_POSTINC));
1052                           TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),'o');
1053                         ;}
1054     break;
1055
1056   case 133:
1057 #line 964 "perly.y"
1058     { (yyval.opval) = newUNOP(OP_POSTDEC, 0,
1059                                         mod(scalar((ps[(1) - (2)].val.opval)), OP_POSTDEC));
1060                           TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),'o');
1061                         ;}
1062     break;
1063
1064   case 134:
1065 #line 969 "perly.y"
1066     { (yyval.opval) = newUNOP(OP_PREINC, 0,
1067                                         mod(scalar((ps[(2) - (2)].val.opval)), OP_PREINC));
1068                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1069                         ;}
1070     break;
1071
1072   case 135:
1073 #line 974 "perly.y"
1074     { (yyval.opval) = newUNOP(OP_PREDEC, 0,
1075                                         mod(scalar((ps[(2) - (2)].val.opval)), OP_PREDEC));
1076                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1077                         ;}
1078     break;
1079
1080   case 136:
1081 #line 983 "perly.y"
1082     { (yyval.opval) = newANONLIST((ps[(2) - (3)].val.opval));
1083                           TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'[');
1084                           TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),']');
1085                         ;}
1086     break;
1087
1088   case 137:
1089 #line 988 "perly.y"
1090     { (yyval.opval) = newANONLIST(Nullop);
1091                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'[');
1092                           TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),']');
1093                         ;}
1094     break;
1095
1096   case 138:
1097 #line 993 "perly.y"
1098     { (yyval.opval) = newANONHASH((ps[(2) - (4)].val.opval));
1099                           TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'{');
1100                           TOKEN_GETMAD((ps[(3) - (4)].val.i_tkval),(yyval.opval),';');
1101                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),'}');
1102                         ;}
1103     break;
1104
1105   case 139:
1106 #line 999 "perly.y"
1107     { (yyval.opval) = newANONHASH(Nullop);
1108                           TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'{');
1109                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),';');
1110                           TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),'}');
1111                         ;}
1112     break;
1113
1114   case 140:
1115 #line 1005 "perly.y"
1116     { SvREFCNT_inc(PL_compcv);
1117                           (yyval.opval) = newANONATTRSUB((ps[(2) - (5)].val.ival), (ps[(3) - (5)].val.opval), (ps[(4) - (5)].val.opval), (ps[(5) - (5)].val.opval));
1118                           TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'o');
1119                           OP_GETMAD((ps[(3) - (5)].val.opval),(yyval.opval),'s');
1120                           OP_GETMAD((ps[(4) - (5)].val.opval),(yyval.opval),'a');
1121                         ;}
1122     break;
1123
1124   case 141:
1125 #line 1016 "perly.y"
1126     { (yyval.opval) = dofile((ps[(2) - (2)].val.opval), IVAL((ps[(1) - (2)].val.i_tkval)));
1127                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1128                         ;}
1129     break;
1130
1131   case 142:
1132 #line 1020 "perly.y"
1133     { (yyval.opval) = newUNOP(OP_NULL, OPf_SPECIAL, scope((ps[(2) - (2)].val.opval)));
1134                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'D');
1135                         ;}
1136     break;
1137
1138   case 143:
1139 #line 1024 "perly.y"
1140     { (yyval.opval) = newUNOP(OP_ENTERSUB,
1141                             OPf_SPECIAL|OPf_STACKED,
1142                             prepend_elem(OP_LIST,
1143                                 scalar(newCVREF(
1144                                     (OPpENTERSUB_AMPER<<8),
1145                                     scalar((ps[(2) - (4)].val.opval))
1146                                 )),Nullop)); dep();
1147                           TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'o');
1148                           TOKEN_GETMAD((ps[(3) - (4)].val.i_tkval),(yyval.opval),'(');
1149                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
1150                         ;}
1151     break;
1152
1153   case 144:
1154 #line 1036 "perly.y"
1155     { (yyval.opval) = newUNOP(OP_ENTERSUB,
1156                             OPf_SPECIAL|OPf_STACKED,
1157                             append_elem(OP_LIST,
1158                                 (ps[(4) - (5)].val.opval),
1159                                 scalar(newCVREF(
1160                                     (OPpENTERSUB_AMPER<<8),
1161                                     scalar((ps[(2) - (5)].val.opval))
1162                                 )))); dep();
1163                           TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'o');
1164                           TOKEN_GETMAD((ps[(3) - (5)].val.i_tkval),(yyval.opval),'(');
1165                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),')');
1166                         ;}
1167     break;
1168
1169   case 145:
1170 #line 1049 "perly.y"
1171     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_SPECIAL|OPf_STACKED,
1172                             prepend_elem(OP_LIST,
1173                                 scalar(newCVREF(0,scalar((ps[(2) - (4)].val.opval)))), Nullop)); dep();
1174                           TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'o');
1175                           TOKEN_GETMAD((ps[(3) - (4)].val.i_tkval),(yyval.opval),'(');
1176                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
1177                         ;}
1178     break;
1179
1180   case 146:
1181 #line 1057 "perly.y"
1182     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_SPECIAL|OPf_STACKED,
1183                             prepend_elem(OP_LIST,
1184                                 (ps[(4) - (5)].val.opval),
1185                                 scalar(newCVREF(0,scalar((ps[(2) - (5)].val.opval)))))); dep();
1186                           TOKEN_GETMAD((ps[(1) - (5)].val.i_tkval),(yyval.opval),'o');
1187                           TOKEN_GETMAD((ps[(3) - (5)].val.i_tkval),(yyval.opval),'(');
1188                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),')');
1189                         ;}
1190     break;
1191
1192   case 151:
1193 #line 1073 "perly.y"
1194     { (yyval.opval) = newCONDOP(0, (ps[(1) - (5)].val.opval), (ps[(3) - (5)].val.opval), (ps[(5) - (5)].val.opval));
1195                           TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'?');
1196                           TOKEN_GETMAD((ps[(4) - (5)].val.i_tkval),(yyval.opval),':');
1197                         ;}
1198     break;
1199
1200   case 152:
1201 #line 1078 "perly.y"
1202     { (yyval.opval) = newUNOP(OP_REFGEN, 0, mod((ps[(2) - (2)].val.opval),OP_REFGEN));
1203                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1204                         ;}
1205     break;
1206
1207   case 153:
1208 #line 1082 "perly.y"
1209     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1210     break;
1211
1212   case 154:
1213 #line 1084 "perly.y"
1214     { (yyval.opval) = localize((ps[(2) - (2)].val.opval),IVAL((ps[(1) - (2)].val.i_tkval)));
1215                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'d');
1216                         ;}
1217     break;
1218
1219   case 155:
1220 #line 1088 "perly.y"
1221     { (yyval.opval) = sawparens(IF_MAD(newUNOP(OP_NULL,0,(ps[(2) - (3)].val.opval)), (ps[(2) - (3)].val.opval)));
1222                           TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'(');
1223                           TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
1224                         ;}
1225     break;
1226
1227   case 156:
1228 #line 1093 "perly.y"
1229     { (yyval.opval) = sawparens(newNULLLIST());
1230                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'(');
1231                           TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),')');
1232                         ;}
1233     break;
1234
1235   case 157:
1236 #line 1098 "perly.y"
1237     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1238     break;
1239
1240   case 158:
1241 #line 1100 "perly.y"
1242     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1243     break;
1244
1245   case 159:
1246 #line 1102 "perly.y"
1247     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1248     break;
1249
1250   case 160:
1251 #line 1104 "perly.y"
1252     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1253     break;
1254
1255   case 161:
1256 #line 1106 "perly.y"
1257     { (yyval.opval) = newUNOP(OP_AV2ARYLEN, 0, ref((ps[(1) - (1)].val.opval), OP_AV2ARYLEN));;}
1258     break;
1259
1260   case 162:
1261 #line 1108 "perly.y"
1262     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1263     break;
1264
1265   case 163:
1266 #line 1110 "perly.y"
1267     { (yyval.opval) = prepend_elem(OP_ASLICE,
1268                                 newOP(OP_PUSHMARK, 0),
1269                                     newLISTOP(OP_ASLICE, 0,
1270                                         list((ps[(3) - (4)].val.opval)),
1271                                         ref((ps[(1) - (4)].val.opval), OP_ASLICE)));
1272                           TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'[');
1273                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),']');
1274                         ;}
1275     break;
1276
1277   case 164:
1278 #line 1119 "perly.y"
1279     { (yyval.opval) = prepend_elem(OP_HSLICE,
1280                                 newOP(OP_PUSHMARK, 0),
1281                                     newLISTOP(OP_HSLICE, 0,
1282                                         list((ps[(3) - (5)].val.opval)),
1283                                         ref(oopsHV((ps[(1) - (5)].val.opval)), OP_HSLICE)));
1284                             PL_expect = XOPERATOR;
1285                           TOKEN_GETMAD((ps[(2) - (5)].val.i_tkval),(yyval.opval),'{');
1286                           TOKEN_GETMAD((ps[(4) - (5)].val.i_tkval),(yyval.opval),';');
1287                           TOKEN_GETMAD((ps[(5) - (5)].val.i_tkval),(yyval.opval),'}');
1288                         ;}
1289     break;
1290
1291   case 165:
1292 #line 1130 "perly.y"
1293     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1294     break;
1295
1296   case 166:
1297 #line 1132 "perly.y"
1298     { (yyval.opval) = newUNOP(OP_ENTERSUB, 0, scalar((ps[(1) - (1)].val.opval))); ;}
1299     break;
1300
1301   case 167:
1302 #line 1134 "perly.y"
1303     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (3)].val.opval)));
1304                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'(');
1305                           TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
1306                         ;}
1307     break;
1308
1309   case 168:
1310 #line 1139 "perly.y"
1311     {
1312                           (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1313                                 append_elem(OP_LIST, (ps[(3) - (4)].val.opval), scalar((ps[(1) - (4)].val.opval))));
1314                           DO_MAD(
1315                               OP* op = (yyval.opval);
1316                               if (op->op_type == OP_CONST) { /* defeat const fold */
1317                                 op = (OP*)op->op_madprop->mad_val;
1318                               }
1319                               token_getmad((ps[(2) - (4)].val.i_tkval),op,'(');
1320                               token_getmad((ps[(4) - (4)].val.i_tkval),op,')');
1321                           )
1322                         ;}
1323     break;
1324
1325   case 169:
1326 #line 1152 "perly.y"
1327     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1328                             append_elem(OP_LIST, (ps[(3) - (3)].val.opval), scalar((ps[(2) - (3)].val.opval))));
1329                           TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
1330                         ;}
1331     break;
1332
1333   case 170:
1334 #line 1157 "perly.y"
1335     { (yyval.opval) = newOP(IVAL((ps[(1) - (1)].val.i_tkval)), OPf_SPECIAL);
1336                             PL_hints |= HINT_BLOCK_SCOPE;
1337                           TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'o');
1338                         ;}
1339     break;
1340
1341   case 171:
1342 #line 1162 "perly.y"
1343     { (yyval.opval) = newLOOPEX(IVAL((ps[(1) - (2)].val.i_tkval)),(ps[(2) - (2)].val.opval));
1344                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1345                         ;}
1346     break;
1347
1348   case 172:
1349 #line 1166 "perly.y"
1350     { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[(2) - (2)].val.opval)));
1351                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1352                         ;}
1353     break;
1354
1355   case 173:
1356 #line 1170 "perly.y"
1357     { (yyval.opval) = newOP(IVAL((ps[(1) - (1)].val.i_tkval)), 0);
1358                           TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'o');
1359                         ;}
1360     break;
1361
1362   case 174:
1363 #line 1174 "perly.y"
1364     { (yyval.opval) = newUNOP(IVAL((ps[(1) - (2)].val.i_tkval)), 0, (ps[(2) - (2)].val.opval));
1365                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1366                         ;}
1367     break;
1368
1369   case 175:
1370 #line 1178 "perly.y"
1371     { (yyval.opval) = newUNOP(IVAL((ps[(1) - (2)].val.i_tkval)), 0, (ps[(2) - (2)].val.opval));
1372                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'o');
1373                         ;}
1374     break;
1375
1376   case 176:
1377 #line 1182 "perly.y"
1378     { (yyval.opval) = newOP(OP_REQUIRE, (ps[(1) - (1)].val.i_tkval) ? OPf_SPECIAL : 0); ;}
1379     break;
1380
1381   case 177:
1382 #line 1184 "perly.y"
1383     { (yyval.opval) = newUNOP(OP_REQUIRE, (ps[(1) - (2)].val.i_tkval) ? OPf_SPECIAL : 0, (ps[(2) - (2)].val.opval)); ;}
1384     break;
1385
1386   case 178:
1387 #line 1186 "perly.y"
1388     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[(1) - (1)].val.opval))); ;}
1389     break;
1390
1391   case 179:
1392 #line 1188 "perly.y"
1393     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1394                             append_elem(OP_LIST, (ps[(2) - (2)].val.opval), scalar((ps[(1) - (2)].val.opval)))); ;}
1395     break;
1396
1397   case 180:
1398 #line 1191 "perly.y"
1399     { (yyval.opval) = newOP(IVAL((ps[(1) - (1)].val.i_tkval)), 0);
1400                           TOKEN_GETMAD((ps[(1) - (1)].val.i_tkval),(yyval.opval),'o');
1401                         ;}
1402     break;
1403
1404   case 181:
1405 #line 1195 "perly.y"
1406     { (yyval.opval) = newOP(IVAL((ps[(1) - (3)].val.i_tkval)), 0);
1407                           TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
1408                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'(');
1409                           TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
1410                         ;}
1411     break;
1412
1413   case 182:
1414 #line 1201 "perly.y"
1415     { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1416                                 scalar((ps[(1) - (1)].val.opval))); ;}
1417     break;
1418
1419   case 183:
1420 #line 1204 "perly.y"
1421     { (yyval.opval) = (IVAL((ps[(1) - (3)].val.i_tkval)) == OP_NOT)
1422                             ? newUNOP(IVAL((ps[(1) - (3)].val.i_tkval)), 0, newSVOP(OP_CONST, 0, newSViv(0)))
1423                             : newOP(IVAL((ps[(1) - (3)].val.i_tkval)), OPf_SPECIAL);
1424
1425                           TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'o');
1426                           TOKEN_GETMAD((ps[(2) - (3)].val.i_tkval),(yyval.opval),'(');
1427                           TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
1428                         ;}
1429     break;
1430
1431   case 184:
1432 #line 1213 "perly.y"
1433     { (yyval.opval) = newUNOP(IVAL((ps[(1) - (4)].val.i_tkval)), 0, (ps[(3) - (4)].val.opval));
1434                           TOKEN_GETMAD((ps[(1) - (4)].val.i_tkval),(yyval.opval),'o');
1435                           TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'(');
1436                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
1437                         ;}
1438     break;
1439
1440   case 185:
1441 #line 1219 "perly.y"
1442     { (yyval.opval) = pmruntime((ps[(1) - (4)].val.opval), (ps[(3) - (4)].val.opval), 1);
1443                           TOKEN_GETMAD((ps[(2) - (4)].val.i_tkval),(yyval.opval),'(');
1444                           TOKEN_GETMAD((ps[(4) - (4)].val.i_tkval),(yyval.opval),')');
1445                         ;}
1446     break;
1447
1448   case 188:
1449 #line 1229 "perly.y"
1450     { (yyval.opval) = my_attrs((ps[(2) - (3)].val.opval),(ps[(3) - (3)].val.opval));
1451                           DO_MAD(
1452                               token_getmad((ps[(1) - (3)].val.i_tkval),(yyval.opval),'d');
1453                               append_madprops((ps[(3) - (3)].val.opval)->op_madprop, (yyval.opval), 'a');
1454                               (ps[(3) - (3)].val.opval)->op_madprop = 0;
1455                           )
1456                         ;}
1457     break;
1458
1459   case 189:
1460 #line 1237 "perly.y"
1461     { (yyval.opval) = localize((ps[(2) - (2)].val.opval),IVAL((ps[(1) - (2)].val.i_tkval)));
1462                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'d');
1463                         ;}
1464     break;
1465
1466   case 190:
1467 #line 1244 "perly.y"
1468     { (yyval.opval) = sawparens((ps[(2) - (3)].val.opval));
1469                           TOKEN_GETMAD((ps[(1) - (3)].val.i_tkval),(yyval.opval),'(');
1470                           TOKEN_GETMAD((ps[(3) - (3)].val.i_tkval),(yyval.opval),')');
1471                         ;}
1472     break;
1473
1474   case 191:
1475 #line 1249 "perly.y"
1476     { (yyval.opval) = sawparens(newNULLLIST());
1477                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'(');
1478                           TOKEN_GETMAD((ps[(2) - (2)].val.i_tkval),(yyval.opval),')');
1479                         ;}
1480     break;
1481
1482   case 192:
1483 #line 1254 "perly.y"
1484     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1485     break;
1486
1487   case 193:
1488 #line 1256 "perly.y"
1489     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1490     break;
1491
1492   case 194:
1493 #line 1258 "perly.y"
1494     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1495     break;
1496
1497   case 195:
1498 #line 1263 "perly.y"
1499     { (yyval.opval) = Nullop; ;}
1500     break;
1501
1502   case 196:
1503 #line 1265 "perly.y"
1504     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1505     break;
1506
1507   case 197:
1508 #line 1269 "perly.y"
1509     { (yyval.opval) = Nullop; ;}
1510     break;
1511
1512   case 198:
1513 #line 1271 "perly.y"
1514     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1515     break;
1516
1517   case 199:
1518 #line 1273 "perly.y"
1519     {
1520 #ifdef MAD
1521                           OP* op = newNULLLIST();
1522                           token_getmad((ps[(2) - (2)].val.i_tkval),op,',');
1523                           (yyval.opval) = append_elem(OP_LIST, (ps[(1) - (2)].val.opval), op);
1524 #else
1525                           (yyval.opval) = (ps[(1) - (2)].val.opval);
1526 #endif
1527
1528                         ;}
1529     break;
1530
1531   case 200:
1532 #line 1288 "perly.y"
1533     { PL_in_my = 0; (yyval.opval) = my((ps[(1) - (1)].val.opval)); ;}
1534     break;
1535
1536   case 201:
1537 #line 1292 "perly.y"
1538     { (yyval.opval) = newCVREF(IVAL((ps[(1) - (2)].val.i_tkval)),(ps[(2) - (2)].val.opval));
1539                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'&');
1540                         ;}
1541     break;
1542
1543   case 202:
1544 #line 1298 "perly.y"
1545     { (yyval.opval) = newSVREF((ps[(2) - (2)].val.opval));
1546                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'$');
1547                         ;}
1548     break;
1549
1550   case 203:
1551 #line 1304 "perly.y"
1552     { (yyval.opval) = newAVREF((ps[(2) - (2)].val.opval));
1553                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'@');
1554                         ;}
1555     break;
1556
1557   case 204:
1558 #line 1310 "perly.y"
1559     { (yyval.opval) = newHVREF((ps[(2) - (2)].val.opval));
1560                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'%');
1561                         ;}
1562     break;
1563
1564   case 205:
1565 #line 1316 "perly.y"
1566     { (yyval.opval) = newAVREF((ps[(2) - (2)].val.opval));
1567                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'l');
1568                         ;}
1569     break;
1570
1571   case 206:
1572 #line 1322 "perly.y"
1573     { (yyval.opval) = newGVREF(0,(ps[(2) - (2)].val.opval));
1574                           TOKEN_GETMAD((ps[(1) - (2)].val.i_tkval),(yyval.opval),'*');
1575                         ;}
1576     break;
1577
1578   case 207:
1579 #line 1329 "perly.y"
1580     { (yyval.opval) = scalar((ps[(1) - (1)].val.opval)); ;}
1581     break;
1582
1583   case 208:
1584 #line 1331 "perly.y"
1585     { (yyval.opval) = scalar((ps[(1) - (1)].val.opval)); ;}
1586     break;
1587
1588   case 209:
1589 #line 1333 "perly.y"
1590     { (yyval.opval) = scope((ps[(1) - (1)].val.opval)); ;}
1591     break;
1592
1593   case 210:
1594 #line 1336 "perly.y"
1595     { (yyval.opval) = (ps[(1) - (1)].val.opval); ;}
1596     break;
1597
1598
1599 /* Line 1267 of yacc.c.  */
1600
1601       default: break;
1602