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