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