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