perly.act

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