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