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