perly.act

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