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 139 "perly.y"
   9                         {
  10                           parser->expect = XSTATE;
  11                           (yyval.ival) = 0;
  12                         }
  13
  14     break;
  15
  16   case 3:
  17 #line 144 "perly.y"
  18                         {
  19                           newPROG(block_end((ps[-1].val.ival),(ps[0].val.opval)));
  20                           PL_compiling.cop_seq = 0;
  21                           (yyval.ival) = 0;
  22                         }
  23
  24     break;
  25
  26   case 4:
  27 #line 150 "perly.y"
  28                         {
  29                           parser->expect = XTERM;
  30                           (yyval.ival) = 0;
  31                         }
  32
  33     break;
  34
  35   case 5:
  36 #line 155 "perly.y"
  37                         {
  38                           PL_eval_root = (ps[0].val.opval);
  39                           (yyval.ival) = 0;
  40                         }
  41
  42     break;
  43
  44   case 6:
  45 #line 160 "perly.y"
  46                         {
  47                           parser->expect = XBLOCK;
  48                           (yyval.ival) = 0;
  49                         }
  50
  51     break;
  52
  53   case 7:
  54 #line 165 "perly.y"
  55                         {
  56                           PL_pad_reset_pending = TRUE;
  57                           PL_eval_root = (ps[0].val.opval);
  58                           (yyval.ival) = 0;
  59                           yyunlex();
  60                           parser->yychar = yytoken = YYEOF;
  61                         }
  62
  63     break;
  64
  65   case 8:
  66 #line 173 "perly.y"
  67                         {
  68                           parser->expect = XSTATE;
  69                           (yyval.ival) = 0;
  70                         }
  71
  72     break;
  73
  74   case 9:
  75 #line 178 "perly.y"
  76                         {
  77                           PL_pad_reset_pending = TRUE;
  78                           PL_eval_root = (ps[0].val.opval);
  79                           (yyval.ival) = 0;
  80                           yyunlex();
  81                           parser->yychar = yytoken = YYEOF;
  82                         }
  83
  84     break;
  85
  86   case 10:
  87 #line 186 "perly.y"
  88                         {
  89                           parser->expect = XSTATE;
  90                           (yyval.ival) = 0;
  91                         }
  92
  93     break;
  94
  95   case 11:
  96 #line 191 "perly.y"
  97                         {
  98                           PL_pad_reset_pending = TRUE;
  99                           PL_eval_root = (ps[0].val.opval);
 100                           (yyval.ival) = 0;
 101                           yyunlex();
 102                           parser->yychar = yytoken = YYEOF;
 103                         }
 104
 105     break;
 106
 107   case 12:
 108 #line 199 "perly.y"
 109                         {
 110                           parser->expect = XSTATE;
 111                           (yyval.ival) = 0;
 112                         }
 113
 114     break;
 115
 116   case 13:
 117 #line 204 "perly.y"
 118                         {
 119                           PL_eval_root = (ps[0].val.opval);
 120                           (yyval.ival) = 0;
 121                         }
 122
 123     break;
 124
 125   case 14:
 126 #line 209 "perly.y"
 127                         {
 128                           parser->expect = XSTATE;
 129                           (yyval.ival) = 0;
 130                         }
 131
 132     break;
 133
 134   case 15:
 135 #line 214 "perly.y"
 136                         {
 137                           PL_eval_root = (ps[0].val.opval);
 138                           (yyval.ival) = 0;
 139                         }
 140
 141     break;
 142
 143   case 16:
 144 #line 222 "perly.y"
 145                         { if (parser->copline > (line_t)(ps[-3].val.ival))
 146                               parser->copline = (line_t)(ps[-3].val.ival);
 147                           (yyval.opval) = block_end((ps[-2].val.ival), (ps[-1].val.opval));
 148                         }
 149
 150     break;
 151
 152   case 17:
 153 #line 230 "perly.y"
 154                         { if (parser->copline > (line_t)(ps[-6].val.ival))
 155                               parser->copline = (line_t)(ps[-6].val.ival);
 156                           (yyval.opval) = block_end((ps[-5].val.ival), (ps[-2].val.opval));
 157                         }
 158
 159     break;
 160
 161   case 18:
 162 #line 237 "perly.y"
 163                         { (yyval.ival) = block_start(TRUE);
 164                           parser->parsed_sub = 0; }
 165
 166     break;
 167
 168   case 19:
 169 #line 242 "perly.y"
 170                         { if (parser->copline > (line_t)(ps[-3].val.ival))
 171                               parser->copline = (line_t)(ps[-3].val.ival);
 172                           (yyval.opval) = block_end((ps[-2].val.ival), (ps[-1].val.opval));
 173                         }
 174
 175     break;
 176
 177   case 20:
 178 #line 249 "perly.y"
 179                         { (yyval.ival) = block_start(FALSE);
 180                           parser->parsed_sub = 0; }
 181
 182     break;
 183
 184   case 21:
 185 #line 255 "perly.y"
 186                         { (yyval.opval) = NULL; }
 187
 188     break;
 189
 190   case 22:
 191 #line 257 "perly.y"
 192                         {   (yyval.opval) = op_append_list(OP_LINESEQ, (ps[-1].val.opval), (ps[0].val.opval));
 193                             PL_pad_reset_pending = TRUE;
 194                             if ((ps[-1].val.opval) && (ps[0].val.opval))
 195                                 PL_hints |= HINT_BLOCK_SCOPE;
 196                         }
 197
 198     break;
 199
 200   case 23:
 201 #line 266 "perly.y"
 202                         { (yyval.opval) = NULL; }
 203
 204     break;
 205
 206   case 24:
 207 #line 268 "perly.y"
 208                         {   (yyval.opval) = op_append_list(OP_LINESEQ, (ps[-1].val.opval), (ps[0].val.opval));
 209                             PL_pad_reset_pending = TRUE;
 210                             if ((ps[-1].val.opval) && (ps[0].val.opval))
 211                                 PL_hints |= HINT_BLOCK_SCOPE;
 212                         }
 213
 214     break;
 215
 216   case 25:
 217 #line 277 "perly.y"
 218                         {
 219                           (yyval.opval) = (ps[0].val.opval) ? newSTATEOP(0, NULL, (ps[0].val.opval)) : NULL;
 220                         }
 221
 222     break;
 223
 224   case 26:
 225 #line 281 "perly.y"
 226                         { (yyval.opval) = (ps[0].val.opval); }
 227
 228     break;
 229
 230   case 27:
 231 #line 285 "perly.y"
 232                         {
 233                           SV *label = cSVOPx_sv((ps[-1].val.opval));
 234                           (yyval.opval) = newSTATEOP(SvFLAGS(label) & SVf_UTF8,
 235                                             savepv(SvPVX_const(label)), (ps[0].val.opval));
 236                           op_free((ps[-1].val.opval));
 237                         }
 238
 239     break;
 240
 241   case 28:
 242 #line 292 "perly.y"
 243                         {
 244                           SV *label = cSVOPx_sv((ps[-1].val.opval));
 245                           (yyval.opval) = newSTATEOP(SvFLAGS(label) & SVf_UTF8,
 246                                             savepv(SvPVX_const(label)), (ps[0].val.opval));
 247                           op_free((ps[-1].val.opval));
 248                         }
 249
 250     break;
 251
 252   case 29:
 253 #line 302 "perly.y"
 254                         { (yyval.opval) = (ps[0].val.opval); }
 255
 256     break;
 257
 258   case 30:
 259 #line 304 "perly.y"
 260                         {
 261                           CV *fmtcv = PL_compcv;
 262                           newFORM((ps[-2].val.ival), (ps[-1].val.opval), (ps[0].val.opval));
 263                           (yyval.opval) = NULL;
 264                           if (CvOUTSIDE(fmtcv) && !CvEVAL(CvOUTSIDE(fmtcv))) {
 265                               pad_add_weakref(fmtcv);
 266                           }
 267                           parser->parsed_sub = 1;
 268                         }
 269
 270     break;
 271
 272   case 31:
 273 #line 316 "perly.y"
 274                         {
 275                           init_named_cv(PL_compcv, (ps[-1].val.opval));
 276                           parser->in_my = 0;
 277                           parser->in_my_stash = NULL;
 278                         }
 279
 280     break;
 281
 282   case 32:
 283 #line 322 "perly.y"
 284                         {
 285                           SvREFCNT_inc_simple_void(PL_compcv);
 286                           (ps[-5].val.opval)->op_type == OP_CONST
 287                               ? newATTRSUB((ps[-4].val.ival), (ps[-5].val.opval), (ps[-2].val.opval), (ps[-1].val.opval), (ps[0].val.opval))
 288                               : newMYSUB((ps[-4].val.ival), (ps[-5].val.opval), (ps[-2].val.opval), (ps[-1].val.opval), (ps[0].val.opval))
 289                           ;
 290                           (yyval.opval) = NULL;
 291                           intro_my();
 292                           parser->parsed_sub = 1;
 293                         }
 294
 295     break;
 296
 297   case 33:
 298 #line 337 "perly.y"
 299                         {
 300                           init_named_cv(PL_compcv, (ps[-1].val.opval));
 301                           parser->in_my = 0;
 302                           parser->in_my_stash = NULL;
 303                         }
 304
 305     break;
 306
 307   case 34:
 308 #line 343 "perly.y"
 309                         {
 310                           SvREFCNT_inc_simple_void(PL_compcv);
 311                           (ps[-4].val.opval)->op_type == OP_CONST
 312                               ? newATTRSUB((ps[-3].val.ival), (ps[-4].val.opval), NULL, (ps[-1].val.opval), (ps[0].val.opval))
 313                               : newMYSUB(  (ps[-3].val.ival), (ps[-4].val.opval), NULL, (ps[-1].val.opval), (ps[0].val.opval))
 314                           ;
 315                           (yyval.opval) = NULL;
 316                           intro_my();
 317                           parser->parsed_sub = 1;
 318                         }
 319
 320     break;
 321
 322   case 35:
 323 #line 354 "perly.y"
 324                         {
 325                           package((ps[-1].val.opval));
 326                           if ((ps[-2].val.opval))
 327                               package_version((ps[-2].val.opval));
 328                           (yyval.opval) = NULL;
 329                         }
 330
 331     break;
 332
 333   case 36:
 334 #line 361 "perly.y"
 335                         { CvSPECIAL_on(PL_compcv); /* It's a BEGIN {} */ }
 336
 337     break;
 338
 339   case 37:
 340 #line 363 "perly.y"
 341                         {
 342                           SvREFCNT_inc_simple_void(PL_compcv);
 343                           utilize((ps[-6].val.ival), (ps[-5].val.ival), (ps[-3].val.opval), (ps[-2].val.opval), (ps[-1].val.opval));
 344                           parser->parsed_sub = 1;
 345                           (yyval.opval) = NULL;
 346                         }
 347
 348     break;
 349
 350   case 38:
 351 #line 370 "perly.y"
 352                         {
 353                           (yyval.opval) = block_end((ps[-4].val.ival),
 354                               newCONDOP(0, (ps[-3].val.opval), op_scope((ps[-1].val.opval)), (ps[0].val.opval)));
 355                           parser->copline = (line_t)(ps[-6].val.ival);
 356                         }
 357
 358     break;
 359
 360   case 39:
 361 #line 376 "perly.y"
 362                         {
 363                           (yyval.opval) = block_end((ps[-4].val.ival),
 364                               newCONDOP(0, (ps[-3].val.opval), (ps[0].val.opval), op_scope((ps[-1].val.opval))));
 365                           parser->copline = (line_t)(ps[-6].val.ival);
 366                         }
 367
 368     break;
 369
 370   case 40:
 371 #line 382 "perly.y"
 372                         {
 373                           (yyval.opval) = block_end((ps[-3].val.ival), newGIVENOP((ps[-2].val.opval), op_scope((ps[0].val.opval)), 0));
 374                           parser->copline = (line_t)(ps[-5].val.ival);
 375                         }
 376
 377     break;
 378
 379   case 41:
 380 #line 387 "perly.y"
 381                         { (yyval.opval) = block_end((ps[-3].val.ival), newWHENOP((ps[-2].val.opval), op_scope((ps[0].val.opval)))); }
 382
 383     break;
 384
 385   case 42:
 386 #line 389 "perly.y"
 387                         { (yyval.opval) = newWHENOP(0, op_scope((ps[0].val.opval))); }
 388
 389     break;
 390
 391   case 43:
 392 #line 391 "perly.y"
 393                         {
 394                           (yyval.opval) = block_end((ps[-5].val.ival),
 395                                   newWHILEOP(0, 1, NULL,
 396                                       (ps[-4].val.opval), (ps[-1].val.opval), (ps[0].val.opval), (ps[-2].val.ival)));
 397                           parser->copline = (line_t)(ps[-7].val.ival);
 398                         }
 399
 400     break;
 401
 402   case 44:
 403 #line 398 "perly.y"
 404                         {
 405                           (yyval.opval) = block_end((ps[-5].val.ival),
 406                                   newWHILEOP(0, 1, NULL,
 407                                       (ps[-4].val.opval), (ps[-1].val.opval), (ps[0].val.opval), (ps[-2].val.ival)));
 408                           parser->copline = (line_t)(ps[-7].val.ival);
 409                         }
 410
 411     break;
 412
 413   case 45:
 414 #line 405 "perly.y"
 415                         { parser->expect = XTERM; }
 416
 417     break;
 418
 419   case 46:
 420 #line 407 "perly.y"
 421                         { parser->expect = XTERM; }
 422
 423     break;
 424
 425   case 47:
 426 #line 410 "perly.y"
 427                         {
 428                           OP *initop = (ps[-9].val.opval);
 429                           OP *forop = newWHILEOP(0, 1, NULL,
 430                                       scalar((ps[-6].val.opval)), (ps[0].val.opval), (ps[-2].val.opval), (ps[-3].val.ival));
 431                           if (initop) {
 432                               forop = op_prepend_elem(OP_LINESEQ, initop,
 433                                   op_append_elem(OP_LINESEQ,
 434                                       newOP(OP_UNSTACK, OPf_SPECIAL),
 435                                       forop));
 436                           }
 437                           PL_hints |= HINT_BLOCK_SCOPE;
 438                           (yyval.opval) = block_end((ps[-10].val.ival), forop);
 439                           parser->copline = (line_t)(ps[-12].val.ival);
 440                         }
 441
 442     break;
 443
 444   case 48:
 445 #line 425 "perly.y"
 446                         {
 447                           (yyval.opval) = block_end((ps[-6].val.ival), newFOROP(0, (ps[-5].val.opval), (ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval)));
 448                           parser->copline = (line_t)(ps[-8].val.ival);
 449                         }
 450
 451     break;
 452
 453   case 49:
 454 #line 430 "perly.y"
 455                         {
 456                           (yyval.opval) = block_end((ps[-8].val.ival), newFOROP(0, (ps[-6].val.opval), (ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval)));
 457                           parser->copline = (line_t)(ps[-10].val.ival);
 458                         }
 459
 460     break;
 461
 462   case 50:
 463 #line 435 "perly.y"
 464                         {
 465                           (yyval.opval) = block_end((ps[-4].val.ival), newFOROP(0,
 466                                       op_lvalue((ps[-6].val.opval), OP_ENTERLOOP), (ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval)));
 467                           parser->copline = (line_t)(ps[-7].val.ival);
 468                         }
 469
 470     break;
 471
 472   case 51:
 473 #line 441 "perly.y"
 474                         { parser->in_my = 0; (yyval.opval) = my((ps[0].val.opval)); }
 475
 476     break;
 477
 478   case 52:
 479 #line 443 "perly.y"
 480                         {
 481                           (yyval.opval) = block_end(
 482                                 (ps[-7].val.ival),
 483                                 newFOROP(0,
 484                                          op_lvalue(
 485                                             newUNOP(OP_REFGEN, 0,
 486                                                     (ps[-5].val.opval)),
 487                                             OP_ENTERLOOP),
 488                                          (ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval))
 489                           );
 490                           parser->copline = (line_t)(ps[-9].val.ival);
 491                         }
 492
 493     break;
 494
 495   case 53:
 496 #line 456 "perly.y"
 497                         {
 498                           (yyval.opval) = block_end((ps[-4].val.ival), newFOROP(
 499                                 0, op_lvalue(newUNOP(OP_REFGEN, 0,
 500                                                      (ps[-6].val.opval)),
 501                                              OP_ENTERLOOP), (ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval)));
 502                           parser->copline = (line_t)(ps[-8].val.ival);
 503                         }
 504
 505     break;
 506
 507   case 54:
 508 #line 464 "perly.y"
 509                         {
 510                           (yyval.opval) = block_end((ps[-4].val.ival),
 511                                   newFOROP(0, NULL, (ps[-3].val.opval), (ps[-1].val.opval), (ps[0].val.opval)));
 512                           parser->copline = (line_t)(ps[-6].val.ival);
 513                         }
 514
 515     break;
 516
 517   case 55:
 518 #line 470 "perly.y"
 519                         { parser->in_my = 1; }
 520
 521     break;
 522
 523   case 56:
 524 #line 472 "perly.y"
 525                         { parser->in_my = 0; intro_my(); }
 526
 527     break;
 528
 529   case 57:
 530 #line 474 "perly.y"
 531                         {
 532                           (yyval.opval) = newTRYCATCHOP(0,
 533                                   (ps[-8].val.opval), (ps[-3].val.opval), block_end((ps[-4].val.ival), op_scope((ps[0].val.opval))));
 534                           parser->copline = (line_t)(ps[-9].val.ival);
 535                         }
 536
 537     break;
 538
 539   case 58:
 540 #line 480 "perly.y"
 541                         {
 542                           /* a block is a loop that happens once */
 543                           (yyval.opval) = newWHILEOP(0, 1, NULL,
 544                                   NULL, (ps[-1].val.opval), (ps[0].val.opval), 0);
 545                         }
 546
 547     break;
 548
 549   case 59:
 550 #line 486 "perly.y"
 551                         {
 552                           package((ps[-2].val.opval));
 553                           if ((ps[-3].val.opval)) {
 554                               package_version((ps[-3].val.opval));
 555                           }
 556                         }
 557
 558     break;
 559
 560   case 60:
 561 #line 493 "perly.y"
 562                         {
 563                           /* a block is a loop that happens once */
 564                           (yyval.opval) = newWHILEOP(0, 1, NULL,
 565                                   NULL, block_end((ps[-3].val.ival), (ps[-1].val.opval)), NULL, 0);
 566                           if (parser->copline > (line_t)(ps[-4].val.ival))
 567                               parser->copline = (line_t)(ps[-4].val.ival);
 568                         }
 569
 570     break;
 571
 572   case 61:
 573 #line 501 "perly.y"
 574                         {
 575                           (yyval.opval) = (ps[-1].val.opval);
 576                         }
 577
 578     break;
 579
 580   case 62:
 581 #line 505 "perly.y"
 582                         {
 583                           (yyval.opval) = newDEFEROP(0, op_scope((ps[0].val.opval)));
 584                         }
 585
 586     break;
 587
 588   case 63:
 589 #line 509 "perly.y"
 590                         {
 591                           (yyval.opval) = newLISTOP(OP_DIE, 0, newOP(OP_PUSHMARK, 0),
 592                                 newSVOP(OP_CONST, 0, newSVpvs("Unimplemented")));
 593                         }
 594
 595     break;
 596
 597   case 64:
 598 #line 514 "perly.y"
 599                         {
 600                           (yyval.opval) = NULL;
 601                           parser->copline = NOLINE;
 602                         }
 603
 604     break;
 605
 606   case 65:
 607 #line 522 "perly.y"
 608                         { OP *list;
 609                           if ((ps[0].val.opval)) {
 610                               OP *term = (ps[0].val.opval);
 611                               list = op_append_elem(OP_LIST, (ps[-1].val.opval), term);
 612                           }
 613                           else {
 614                               list = (ps[-1].val.opval);
 615                           }
 616                           if (parser->copline == NOLINE)
 617                                parser->copline = CopLINE(PL_curcop)-1;
 618                           else parser->copline--;
 619                           (yyval.opval) = newSTATEOP(0, NULL,
 620                                           op_convert_list(OP_FORMLINE, 0, list));
 621                         }
 622
 623     break;
 624
 625   case 66:
 626 #line 539 "perly.y"
 627                         { (yyval.opval) = NULL; }
 628
 629     break;
 630
 631   case 67:
 632 #line 541 "perly.y"
 633                         { (yyval.opval) = op_unscope((ps[-1].val.opval)); }
 634
 635     break;
 636
 637   case 69:
 638 #line 549 "perly.y"
 639                         { (yyval.opval) = NULL; }
 640
 641     break;
 642
 643   case 70:
 644 #line 551 "perly.y"
 645                         { (yyval.opval) = (ps[0].val.opval); }
 646
 647     break;
 648
 649   case 71:
 650 #line 553 "perly.y"
 651                         { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[0].val.opval), (ps[-2].val.opval)); }
 652
 653     break;
 654
 655   case 72:
 656 #line 555 "perly.y"
 657                         { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[0].val.opval), (ps[-2].val.opval)); }
 658
 659     break;
 660
 661   case 73:
 662 #line 557 "perly.y"
 663                         { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, scalar((ps[0].val.opval)), (ps[-2].val.opval)); }
 664
 665     break;
 666
 667   case 74:
 668 #line 559 "perly.y"
 669                         { (yyval.opval) = newLOOPOP(OPf_PARENS, 1, (ps[0].val.opval), (ps[-2].val.opval)); }
 670
 671     break;
 672
 673   case 75:
 674 #line 561 "perly.y"
 675                         { (yyval.opval) = newFOROP(0, NULL, (ps[0].val.opval), (ps[-2].val.opval), NULL);
 676                           parser->copline = (line_t)(ps[-1].val.ival); }
 677
 678     break;
 679
 680   case 76:
 681 #line 564 "perly.y"
 682                         { (yyval.opval) = newWHENOP((ps[0].val.opval), op_scope((ps[-2].val.opval))); }
 683
 684     break;
 685
 686   case 77:
 687 #line 569 "perly.y"
 688                         { (yyval.opval) = NULL; }
 689
 690     break;
 691
 692   case 78:
 693 #line 571 "perly.y"
 694                         {
 695                           ((ps[0].val.opval))->op_flags |= OPf_PARENS;
 696                           (yyval.opval) = op_scope((ps[0].val.opval));
 697                         }
 698
 699     break;
 700
 701   case 79:
 702 #line 576 "perly.y"
 703                         { parser->copline = (line_t)(ps[-5].val.ival);
 704                             (yyval.opval) = newCONDOP(0,
 705                                 newSTATEOP(OPf_SPECIAL,NULL,(ps[-3].val.opval)),
 706                                 op_scope((ps[-1].val.opval)), (ps[0].val.opval));
 707                           PL_hints |= HINT_BLOCK_SCOPE;
 708                         }
 709
 710     break;
 711
 712   case 80:
 713 #line 586 "perly.y"
 714                         { (yyval.opval) = NULL; }
 715
 716     break;
 717
 718   case 81:
 719 #line 588 "perly.y"
 720                         { (yyval.opval) = op_scope((ps[0].val.opval)); }
 721
 722     break;
 723
 724   case 82:
 725 #line 593 "perly.y"
 726                         { (yyval.ival) = (PL_min_intro_pending &&
 727                             PL_max_intro_pending >=  PL_min_intro_pending);
 728                           intro_my(); }
 729
 730     break;
 731
 732   case 83:
 733 #line 599 "perly.y"
 734                         { (yyval.opval) = NULL; }
 735
 736     break;
 737
 738   case 85:
 739 #line 605 "perly.y"
 740                         { YYSTYPE tmplval;
 741                           (void)scan_num("1", &tmplval);
 742                           (yyval.opval) = tmplval.opval; }
 743
 744     break;
 745
 746   case 87:
 747 #line 613 "perly.y"
 748                         { (yyval.opval) = invert(scalar((ps[0].val.opval))); }
 749
 750     break;
 751
 752   case 88:
 753 #line 618 "perly.y"
 754                         { (yyval.opval) = (ps[0].val.opval); intro_my(); }
 755
 756     break;
 757
 758   case 89:
 759 #line 622 "perly.y"
 760                         { (yyval.opval) = (ps[0].val.opval); intro_my(); }
 761
 762     break;
 763
 764   case 90:
 765 #line 625 "perly.y"
 766                                 { (yyval.opval) = (ps[0].val.opval); }
 767
 768     break;
 769
 770   case 91:
 771 #line 626 "perly.y"
 772                         { (yyval.opval) = NULL; }
 773
 774     break;
 775
 776   case 92:
 777 #line 630 "perly.y"
 778                         { (yyval.ival) = start_subparse(FALSE, 0);
 779                             SAVEFREESV(PL_compcv); }
 780
 781     break;
 782
 783   case 93:
 784 #line 636 "perly.y"
 785                         { (yyval.ival) = start_subparse(FALSE, CVf_ANON);
 786                             SAVEFREESV(PL_compcv); }
 787
 788     break;
 789
 790   case 94:
 791 #line 641 "perly.y"
 792                         { (yyval.ival) = start_subparse(TRUE, 0);
 793                             SAVEFREESV(PL_compcv); }
 794
 795     break;
 796
 797   case 97:
 798 #line 652 "perly.y"
 799                         { (yyval.opval) = NULL; }
 800
 801     break;
 802
 803   case 99:
 804 #line 658 "perly.y"
 805                         { (yyval.opval) = NULL; }
 806
 807     break;
 808
 809   case 100:
 810 #line 660 "perly.y"
 811                         { (yyval.opval) = (ps[0].val.opval); }
 812
 813     break;
 814
 815   case 101:
 816 #line 662 "perly.y"
 817                         { (yyval.opval) = NULL; }
 818
 819     break;
 820
 821   case 102:
 822 #line 667 "perly.y"
 823                         { (yyval.opval) = (ps[0].val.opval); }
 824
 825     break;
 826
 827   case 103:
 828 #line 669 "perly.y"
 829                         { (yyval.opval) = NULL; }
 830
 831     break;
 832
 833   case 104:
 834 #line 680 "perly.y"
 835                         { parser->in_my = 0; (yyval.opval) = NULL; }
 836
 837     break;
 838
 839   case 105:
 840 #line 682 "perly.y"
 841                         { parser->in_my = 0; (yyval.opval) = (ps[0].val.opval); }
 842
 843     break;
 844
 845   case 106:
 846 #line 687 "perly.y"
 847                         { (yyval.ival) = '@'; }
 848
 849     break;
 850
 851   case 107:
 852 #line 689 "perly.y"
 853                         { (yyval.ival) = '%'; }
 854
 855     break;
 856
 857   case 108:
 858 #line 693 "perly.y"
 859                         {
 860                             I32 sigil   = (ps[-2].val.ival);
 861                             OP *var     = (ps[-1].val.opval);
 862                             OP *defexpr = (ps[0].val.opval);
 863
 864                             if (parser->sig_slurpy)
 865                                 yyerror("Multiple slurpy parameters not allowed");
 866                             parser->sig_slurpy = (char)sigil;
 867
 868                             if (defexpr)
 869                                 yyerror("A slurpy parameter may not have "
 870                                         "a default value");
 871
 872                             (yyval.opval) = var ? newSTATEOP(0, NULL, var) : NULL;
 873                         }
 874
 875     break;
 876
 877   case 109:
 878 #line 712 "perly.y"
 879                         { (yyval.opval) = NULL; }
 880
 881     break;
 882
 883   case 110:
 884 #line 714 "perly.y"
 885                         { (yyval.opval) = newOP(OP_NULL, 0); }
 886
 887     break;
 888
 889   case 111:
 890 #line 716 "perly.y"
 891                         { (yyval.opval) = (ps[0].val.opval); }
 892
 893     break;
 894
 895   case 112:
 896 #line 722 "perly.y"
 897                         {
 898                             OP *var     = (ps[-1].val.opval);
 899                             OP *defexpr = (ps[0].val.opval);
 900
 901                             if (parser->sig_slurpy)
 902                                 yyerror("Slurpy parameter not last");
 903
 904                             parser->sig_elems++;
 905
 906                             if (defexpr) {
 907                                 parser->sig_optelems++;
 908
 909                                 if (   defexpr->op_type == OP_NULL
 910                                     && !(defexpr->op_flags & OPf_KIDS))
 911                                 {
 912                                     /* handle '$=' special case */
 913                                     if (var)
 914                                         yyerror("Optional parameter "
 915                                                     "lacks default expression");
 916                                     op_free(defexpr);
 917                                 }
 918                                 else {
 919                                     /* a normal '=default' expression */
 920                                     OP *defop = (OP*)alloc_LOGOP(OP_ARGDEFELEM,
 921                                                         defexpr,
 922                                                         LINKLIST(defexpr));
 923                                     /* re-purpose op_targ to hold @_ index */
 924                                     defop->op_targ =
 925                                         (PADOFFSET)(parser->sig_elems - 1);
 926
 927                                     if (var) {
 928                                         var->op_flags |= OPf_STACKED;
 929                                         (void)op_sibling_splice(var,
 930                                                         NULL, 0, defop);
 931                                         scalar(defop);
 932                                     }
 933                                     else
 934                                         var = newUNOP(OP_NULL, 0, defop);
 935
 936                                     LINKLIST(var);
 937                                     /* NB: normally the first child of a
 938                                      * logop is executed before the logop,
 939                                      * and it pushes a boolean result
 940                                      * ready for the logop. For ARGDEFELEM,
 941                                      * the op itself does the boolean
 942                                      * calculation, so set the first op to
 943                                      * it instead.
 944                                      */
 945                                     var->op_next = defop;
 946                                     defexpr->op_next = var;
 947                                 }
 948                             }
 949                             else {
 950                                 if (parser->sig_optelems)
 951                                     yyerror("Mandatory parameter "
 952                                             "follows optional parameter");
 953                             }
 954
 955                             (yyval.opval) = var ? newSTATEOP(0, NULL, var) : NULL;
 956                         }
 957
 958     break;
 959
 960   case 113:
 961 #line 787 "perly.y"
 962                         { parser->in_my = KEY_sigvar; (yyval.opval) = (ps[0].val.opval); }
 963
 964     break;
 965
 966   case 114:
 967 #line 789 "perly.y"
 968                         { parser->in_my = KEY_sigvar; (yyval.opval) = (ps[0].val.opval); }
 969
 970     break;
 971
 972   case 115:
 973 #line 795 "perly.y"
 974                         { (yyval.opval) = (ps[-1].val.opval); }
 975
 976     break;
 977
 978   case 116:
 979 #line 797 "perly.y"
 980                         {
 981                           (yyval.opval) = op_append_list(OP_LINESEQ, (ps[-2].val.opval), (ps[0].val.opval));
 982                         }
 983
 984     break;
 985
 986   case 117:
 987 #line 801 "perly.y"
 988                         { (yyval.opval) = (ps[0].val.opval); }
 989
 990     break;
 991
 992   case 118:
 993 #line 806 "perly.y"
 994                         { (yyval.opval) = NULL; }
 995
 996     break;
 997
 998   case 119:
 999 #line 808 "perly.y"
1000                         { (yyval.opval) = (ps[0].val.opval); }
1001
1002     break;
1003
1004   case 120:
1005 #line 812 "perly.y"
1006                         { (yyval.opval) = NULL; }
1007
1008     break;
1009
1010   case 121:
1011 #line 814 "perly.y"
1012                         { (yyval.opval) = (ps[0].val.opval); }
1013
1014     break;
1015
1016   case 122:
1017 #line 818 "perly.y"
1018                         { (yyval.opval) = (ps[-1].val.opval); }
1019
1020     break;
1021
1022   case 123:
1023 #line 821 "perly.y"
1024                         {
1025                             ENTER;
1026                             SAVEIV(parser->sig_elems);
1027                             SAVEIV(parser->sig_optelems);
1028                             SAVEI8(parser->sig_slurpy);
1029                             parser->sig_elems    = 0;
1030                             parser->sig_optelems = 0;
1031                             parser->sig_slurpy   = 0;
1032                             parser->in_my        = KEY_sigvar;
1033                         }
1034
1035     break;
1036
1037   case 124:
1038 #line 832 "perly.y"
1039                         {
1040                             OP            *sigops = (ps[0].val.opval);
1041                             struct op_argcheck_aux *aux;
1042                             OP            *check;
1043
1044                             if (!FEATURE_SIGNATURES_IS_ENABLED)
1045                                 Perl_croak(aTHX_ "Experimental "
1046                                     "subroutine signatures not enabled");
1047
1048                             /* We shouldn't get here otherwise */
1049                             Perl_ck_warner_d(aTHX_
1050                                 packWARN(WARN_EXPERIMENTAL__SIGNATURES),
1051                                 "The signatures feature is experimental");
1052
1053                             aux = (struct op_argcheck_aux*)
1054                                     PerlMemShared_malloc(
1055                                         sizeof(struct op_argcheck_aux));
1056                             aux->params     = parser->sig_elems;
1057                             aux->opt_params = parser->sig_optelems;
1058                             aux->slurpy     = parser->sig_slurpy;
1059                             check = newUNOP_AUX(OP_ARGCHECK, 0, NULL,
1060                                             (UNOP_AUX_item *)aux);
1061                             sigops = op_prepend_elem(OP_LINESEQ, check, sigops);
1062                             sigops = op_prepend_elem(OP_LINESEQ,
1063                                                 newSTATEOP(0, NULL, NULL),
1064                                                 sigops);
1065                             /* a nextstate at the end handles context
1066                              * correctly for an empty sub body */
1067                             sigops = op_append_elem(OP_LINESEQ,
1068                                                 sigops,
1069                                                 newSTATEOP(0, NULL, NULL));
1070                             /* wrap the list of arg ops in a NULL aux op.
1071                               This serves two purposes. First, it makes
1072                               the arg list a separate subtree from the
1073                               body of the sub, and secondly the null op
1074                               may in future be upgraded to an OP_SIGNATURE
1075                               when implemented. For now leave it as
1076                               ex-argcheck */
1077                             (yyval.opval) = newUNOP_AUX(OP_ARGCHECK, 0, sigops, NULL);
1078                             op_null((yyval.opval));
1079
1080                             parser->in_my = 0;
1081                             /* tell the toker that attrributes can follow
1082                              * this sig, but only so that the toker
1083                              * can skip through any (illegal) trailing
1084                              * attribute text then give a useful error
1085                              * message about "attributes before sig",
1086                              * rather than falling over ina mess at
1087                              * unrecognised syntax.
1088                              */
1089                             parser->expect = XATTRBLOCK;
1090                             parser->sig_seen = TRUE;
1091                             LEAVE;
1092                         }
1093
1094     break;
1095
1096   case 125:
1097 #line 889 "perly.y"
1098                         { (yyval.opval) = (ps[0].val.opval); }
1099
1100     break;
1101
1102   case 126:
1103 #line 890 "perly.y"
1104                                 { (yyval.opval) = NULL; }
1105
1106     break;
1107
1108   case 127:
1109 #line 896 "perly.y"
1110                         {
1111                           if (parser->copline > (line_t)(ps[-2].val.ival))
1112                               parser->copline = (line_t)(ps[-2].val.ival);
1113                           (yyval.opval) = block_end((ps[-3].val.ival), (ps[-1].val.opval));
1114                         }
1115
1116     break;
1117
1118   case 128:
1119 #line 906 "perly.y"
1120                            { (yyval.opval) = (ps[0].val.opval); }
1121
1122     break;
1123
1124   case 129:
1125 #line 907 "perly.y"
1126                                    { (yyval.opval) = NULL; }
1127
1128     break;
1129
1130   case 130:
1131 #line 911 "perly.y"
1132                         {
1133                           if (parser->copline > (line_t)(ps[-2].val.ival))
1134                               parser->copline = (line_t)(ps[-2].val.ival);
1135                           (yyval.opval) = block_end((ps[-4].val.ival),
1136                                 op_append_list(OP_LINESEQ, (ps[-3].val.opval), (ps[-1].val.opval)));
1137                         }
1138
1139     break;
1140
1141   case 131:
1142 #line 922 "perly.y"
1143                         { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1144
1145     break;
1146
1147   case 132:
1148 #line 924 "perly.y"
1149                         { (yyval.opval) = newLOGOP((ps[-1].val.ival), 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1150
1151     break;
1152
1153   case 134:
1154 #line 930 "perly.y"
1155                         { (yyval.opval) = (ps[-1].val.opval); }
1156
1157     break;
1158
1159   case 135:
1160 #line 932 "perly.y"
1161                         {
1162                           OP* term = (ps[0].val.opval);
1163                           (yyval.opval) = op_append_elem(OP_LIST, (ps[-2].val.opval), term);
1164                         }
1165
1166     break;
1167
1168   case 137:
1169 #line 941 "perly.y"
1170                         { (yyval.opval) = op_convert_list((ps[-2].val.ival), OPf_STACKED,
1171                                 op_prepend_elem(OP_LIST, newGVREF((ps[-2].val.ival),(ps[-1].val.opval)), (ps[0].val.opval)) );
1172                         }
1173
1174     break;
1175
1176   case 138:
1177 #line 945 "perly.y"
1178                         { (yyval.opval) = op_convert_list((ps[-4].val.ival), OPf_STACKED,
1179                                 op_prepend_elem(OP_LIST, newGVREF((ps[-4].val.ival),(ps[-2].val.opval)), (ps[-1].val.opval)) );
1180                         }
1181
1182     break;
1183
1184   case 139:
1185 #line 949 "perly.y"
1186                         { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
1187                                 op_append_elem(OP_LIST,
1188                                     op_prepend_elem(OP_LIST, scalar((ps[-5].val.opval)), (ps[-1].val.opval)),
1189                                     newMETHOP(OP_METHOD, 0, (ps[-3].val.opval))));
1190                         }
1191
1192     break;
1193
1194   case 140:
1195 #line 955 "perly.y"
1196                         { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
1197                                 op_append_elem(OP_LIST, scalar((ps[-2].val.opval)),
1198                                     newMETHOP(OP_METHOD, 0, (ps[0].val.opval))));
1199                         }
1200
1201     break;
1202
1203   case 141:
1204 #line 960 "perly.y"
1205                         { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
1206                                 op_append_elem(OP_LIST,
1207                                     op_prepend_elem(OP_LIST, (ps[-1].val.opval), (ps[0].val.opval)),
1208                                     newMETHOP(OP_METHOD, 0, (ps[-2].val.opval))));
1209                         }
1210
1211     break;
1212
1213   case 142:
1214 #line 966 "perly.y"
1215                         { (yyval.opval) = op_convert_list(OP_ENTERSUB, OPf_STACKED,
1216                                 op_append_elem(OP_LIST,
1217                                     op_prepend_elem(OP_LIST, (ps[-3].val.opval), (ps[-1].val.opval)),
1218                                     newMETHOP(OP_METHOD, 0, (ps[-4].val.opval))));
1219                         }
1220
1221     break;
1222
1223   case 143:
1224 #line 972 "perly.y"
1225                         { (yyval.opval) = op_convert_list((ps[-1].val.ival), 0, (ps[0].val.opval)); }
1226
1227     break;
1228
1229   case 144:
1230 #line 974 "perly.y"
1231                         { (yyval.opval) = op_convert_list((ps[-3].val.ival), 0, (ps[-1].val.opval)); }
1232
1233     break;
1234
1235   case 145:
1236 #line 976 "perly.y"
1237                         { (yyval.opval) = op_convert_list((ps[-3].val.ival), 0, (ps[-1].val.opval)); }
1238
1239     break;
1240
1241   case 146:
1242 #line 978 "perly.y"
1243                         { SvREFCNT_inc_simple_void(PL_compcv);
1244                           (yyval.opval) = newANONATTRSUB((ps[-1].val.ival), 0, NULL, (ps[0].val.opval)); }
1245
1246     break;
1247
1248   case 147:
1249 #line 981 "perly.y"
1250                         { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1251                                  op_append_elem(OP_LIST,
1252                                    op_prepend_elem(OP_LIST, (ps[-1].val.opval), (ps[0].val.opval)), (ps[-4].val.opval)));
1253                         }
1254
1255     break;
1256
1257   case 150:
1258 #line 996 "perly.y"
1259                         { (yyval.opval) = newBINOP(OP_GELEM, 0, (ps[-4].val.opval), scalar((ps[-2].val.opval))); }
1260
1261     break;
1262
1263   case 151:
1264 #line 998 "perly.y"
1265                         { (yyval.opval) = newBINOP(OP_AELEM, 0, oopsAV((ps[-3].val.opval)), scalar((ps[-1].val.opval)));
1266                         }
1267
1268     break;
1269
1270   case 152:
1271 #line 1001 "perly.y"
1272                         { (yyval.opval) = newBINOP(OP_AELEM, 0,
1273                                         ref(newAVREF((ps[-4].val.opval)),OP_RV2AV),
1274                                         scalar((ps[-1].val.opval)));
1275                         }
1276
1277     break;
1278
1279   case 153:
1280 #line 1006 "perly.y"
1281                         { (yyval.opval) = newBINOP(OP_AELEM, 0,
1282                                         ref(newAVREF((ps[-3].val.opval)),OP_RV2AV),
1283                                         scalar((ps[-1].val.opval)));
1284                         }
1285
1286     break;
1287
1288   case 154:
1289 #line 1011 "perly.y"
1290                         { (yyval.opval) = newBINOP(OP_HELEM, 0, oopsHV((ps[-4].val.opval)), jmaybe((ps[-2].val.opval)));
1291                         }
1292
1293     break;
1294
1295   case 155:
1296 #line 1014 "perly.y"
1297                         { (yyval.opval) = newBINOP(OP_HELEM, 0,
1298                                         ref(newHVREF((ps[-5].val.opval)),OP_RV2HV),
1299                                         jmaybe((ps[-2].val.opval))); }
1300
1301     break;
1302
1303   case 156:
1304 #line 1018 "perly.y"
1305                         { (yyval.opval) = newBINOP(OP_HELEM, 0,
1306                                         ref(newHVREF((ps[-4].val.opval)),OP_RV2HV),
1307                                         jmaybe((ps[-2].val.opval))); }
1308
1309     break;
1310
1311   case 157:
1312 #line 1022 "perly.y"
1313                         { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1314                                    newCVREF(0, scalar((ps[-3].val.opval))));
1315                           if (parser->expect == XBLOCK)
1316                               parser->expect = XOPERATOR;
1317                         }
1318
1319     break;
1320
1321   case 158:
1322 #line 1028 "perly.y"
1323                         { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1324                                    op_append_elem(OP_LIST, (ps[-1].val.opval),
1325                                        newCVREF(0, scalar((ps[-4].val.opval)))));
1326                           if (parser->expect == XBLOCK)
1327                               parser->expect = XOPERATOR;
1328                         }
1329
1330     break;
1331
1332   case 159:
1333 #line 1036 "perly.y"
1334                         { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1335                                    op_append_elem(OP_LIST, (ps[-1].val.opval),
1336                                                newCVREF(0, scalar((ps[-3].val.opval)))));
1337                           if (parser->expect == XBLOCK)
1338                               parser->expect = XOPERATOR;
1339                         }
1340
1341     break;
1342
1343   case 160:
1344 #line 1043 "perly.y"
1345                         { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1346                                    newCVREF(0, scalar((ps[-2].val.opval))));
1347                           if (parser->expect == XBLOCK)
1348                               parser->expect = XOPERATOR;
1349                         }
1350
1351     break;
1352
1353   case 161:
1354 #line 1049 "perly.y"
1355                         { (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), (ps[-4].val.opval)); }
1356
1357     break;
1358
1359   case 162:
1360 #line 1051 "perly.y"
1361                         { (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), (ps[-3].val.opval)); }
1362
1363     break;
1364
1365   case 163:
1366 #line 1053 "perly.y"
1367                         { (yyval.opval) = newSLICEOP(0, (ps[-1].val.opval), NULL); }
1368
1369     break;
1370
1371   case 164:
1372 #line 1058 "perly.y"
1373                         { (yyval.opval) = newASSIGNOP(OPf_STACKED, (ps[-2].val.opval), (ps[-1].val.ival), (ps[0].val.opval)); }
1374
1375     break;
1376
1377   case 165:
1378 #line 1060 "perly.y"
1379                         { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1380
1381     break;
1382
1383   case 166:
1384 #line 1062 "perly.y"
1385                         {   if ((ps[-1].val.ival) != OP_REPEAT)
1386                                 scalar((ps[-2].val.opval));
1387                             (yyval.opval) = newBINOP((ps[-1].val.ival), 0, (ps[-2].val.opval), scalar((ps[0].val.opval)));
1388                         }
1389
1390     break;
1391
1392   case 167:
1393 #line 1067 "perly.y"
1394                         { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1395
1396     break;
1397
1398   case 168:
1399 #line 1069 "perly.y"
1400                         { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1401
1402     break;
1403
1404   case 169:
1405 #line 1071 "perly.y"
1406                         { (yyval.opval) = (ps[0].val.opval); }
1407
1408     break;
1409
1410   case 170:
1411 #line 1073 "perly.y"
1412                         { (yyval.opval) = (ps[0].val.opval); }
1413
1414     break;
1415
1416   case 171:
1417 #line 1075 "perly.y"
1418                         { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1419
1420     break;
1421
1422   case 172:
1423 #line 1077 "perly.y"
1424                         { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1425
1426     break;
1427
1428   case 173:
1429 #line 1079 "perly.y"
1430                         { (yyval.opval) = newRANGE((ps[-1].val.ival), scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1431
1432     break;
1433
1434   case 174:
1435 #line 1081 "perly.y"
1436                         { (yyval.opval) = newLOGOP(OP_AND, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1437
1438     break;
1439
1440   case 175:
1441 #line 1083 "perly.y"
1442                         { (yyval.opval) = newLOGOP(OP_OR, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1443
1444     break;
1445
1446   case 176:
1447 #line 1085 "perly.y"
1448                         { (yyval.opval) = newLOGOP(OP_DOR, 0, (ps[-2].val.opval), (ps[0].val.opval)); }
1449
1450     break;
1451
1452   case 177:
1453 #line 1087 "perly.y"
1454                         { (yyval.opval) = bind_match((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); }
1455
1456     break;
1457
1458   case 178:
1459 #line 1091 "perly.y"
1460                         { (yyval.opval) = cmpchain_finish((ps[0].val.opval)); }
1461
1462     break;
1463
1464   case 179:
1465 #line 1093 "perly.y"
1466                         { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1467
1468     break;
1469
1470   case 180:
1471 #line 1095 "perly.y"
1472                         { yyerror("syntax error"); YYERROR; }
1473
1474     break;
1475
1476   case 181:
1477 #line 1097 "perly.y"
1478                         { yyerror("syntax error"); YYERROR; }
1479
1480     break;
1481
1482   case 182:
1483 #line 1101 "perly.y"
1484                         { (yyval.opval) = cmpchain_start((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); }
1485
1486     break;
1487
1488   case 183:
1489 #line 1103 "perly.y"
1490                         { (yyval.opval) = cmpchain_extend((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); }
1491
1492     break;
1493
1494   case 184:
1495 #line 1107 "perly.y"
1496                         { (yyval.opval) = cmpchain_finish((ps[0].val.opval)); }
1497
1498     break;
1499
1500   case 185:
1501 #line 1109 "perly.y"
1502                         { (yyval.opval) = newBINOP((ps[-1].val.ival), 0, scalar((ps[-2].val.opval)), scalar((ps[0].val.opval))); }
1503
1504     break;
1505
1506   case 186:
1507 #line 1111 "perly.y"
1508                         { yyerror("syntax error"); YYERROR; }
1509
1510     break;
1511
1512   case 187:
1513 #line 1113 "perly.y"
1514                         { yyerror("syntax error"); YYERROR; }
1515
1516     break;
1517
1518   case 188:
1519 #line 1117 "perly.y"
1520                         { (yyval.opval) = cmpchain_start((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); }
1521
1522     break;
1523
1524   case 189:
1525 #line 1119 "perly.y"
1526                         { (yyval.opval) = cmpchain_extend((ps[-1].val.ival), (ps[-2].val.opval), (ps[0].val.opval)); }
1527
1528     break;
1529
1530   case 190:
1531 #line 1124 "perly.y"
1532                         { (yyval.opval) = newUNOP(OP_NEGATE, 0, scalar((ps[0].val.opval))); }
1533
1534     break;
1535
1536   case 191:
1537 #line 1126 "perly.y"
1538                         { (yyval.opval) = (ps[0].val.opval); }
1539
1540     break;
1541
1542   case 192:
1543 #line 1129 "perly.y"
1544                         { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[0].val.opval))); }
1545
1546     break;
1547
1548   case 193:
1549 #line 1131 "perly.y"
1550                         { (yyval.opval) = newUNOP((ps[-1].val.ival), 0, scalar((ps[0].val.opval))); }
1551
1552     break;
1553
1554   case 194:
1555 #line 1133 "perly.y"
1556                         { (yyval.opval) = newUNOP(OP_POSTINC, 0,
1557                                         op_lvalue(scalar((ps[-1].val.opval)), OP_POSTINC)); }
1558
1559     break;
1560
1561   case 195:
1562 #line 1136 "perly.y"
1563                         { (yyval.opval) = newUNOP(OP_POSTDEC, 0,
1564                                         op_lvalue(scalar((ps[-1].val.opval)), OP_POSTDEC));}
1565
1566     break;
1567
1568   case 196:
1569 #line 1139 "perly.y"
1570                         { (yyval.opval) = op_convert_list(OP_JOIN, 0,
1571                                        op_append_elem(
1572                                         OP_LIST,
1573                                         newSVREF(scalar(
1574                                             newSVOP(OP_CONST,0,
1575                                                     newSVpvs("\""))
1576                                         )),
1577                                         (ps[-1].val.opval)
1578                                        ));
1579                         }
1580
1581     break;
1582
1583   case 197:
1584 #line 1150 "perly.y"
1585                         { (yyval.opval) = newUNOP(OP_PREINC, 0,
1586                                         op_lvalue(scalar((ps[0].val.opval)), OP_PREINC)); }
1587
1588     break;
1589
1590   case 198:
1591 #line 1153 "perly.y"
1592                         { (yyval.opval) = newUNOP(OP_PREDEC, 0,
1593                                         op_lvalue(scalar((ps[0].val.opval)), OP_PREDEC)); }
1594
1595     break;
1596
1597   case 199:
1598 #line 1160 "perly.y"
1599                         { (yyval.opval) = newANONLIST((ps[-1].val.opval)); }
1600
1601     break;
1602
1603   case 200:
1604 #line 1162 "perly.y"
1605                         { (yyval.opval) = newANONLIST(NULL);}
1606
1607     break;
1608
1609   case 201:
1610 #line 1164 "perly.y"
1611                         { (yyval.opval) = newANONHASH((ps[-2].val.opval)); }
1612
1613     break;
1614
1615   case 202:
1616 #line 1166 "perly.y"
1617                         { (yyval.opval) = newANONHASH(NULL); }
1618
1619     break;
1620
1621   case 203:
1622 #line 1168 "perly.y"
1623                         { SvREFCNT_inc_simple_void(PL_compcv);
1624                           (yyval.opval) = newANONATTRSUB((ps[-3].val.ival), (ps[-2].val.opval), (ps[-1].val.opval), (ps[0].val.opval)); }
1625
1626     break;
1627
1628   case 204:
1629 #line 1171 "perly.y"
1630                         { SvREFCNT_inc_simple_void(PL_compcv);
1631                           (yyval.opval) = newANONATTRSUB((ps[-2].val.ival), NULL, (ps[-1].val.opval), (ps[0].val.opval)); }
1632
1633     break;
1634
1635   case 205:
1636 #line 1177 "perly.y"
1637                         { (yyval.opval) = dofile((ps[0].val.opval), (ps[-1].val.ival));}
1638
1639     break;
1640
1641   case 206:
1642 #line 1179 "perly.y"
1643                         { (yyval.opval) = newUNOP(OP_NULL, OPf_SPECIAL, op_scope((ps[0].val.opval)));}
1644
1645     break;
1646
1647   case 211:
1648 #line 1187 "perly.y"
1649                         { (yyval.opval) = newCONDOP(0, (ps[-4].val.opval), (ps[-2].val.opval), (ps[0].val.opval)); }
1650
1651     break;
1652
1653   case 212:
1654 #line 1189 "perly.y"
1655                         { (yyval.opval) = newUNOP(OP_REFGEN, 0, (ps[0].val.opval)); }
1656
1657     break;
1658
1659   case 213:
1660 #line 1191 "perly.y"
1661                         { (yyval.opval) = newUNOP(OP_REFGEN, 0, localize((ps[0].val.opval),1)); }
1662
1663     break;
1664
1665   case 214:
1666 #line 1193 "perly.y"
1667                         { (yyval.opval) = (ps[0].val.opval); }
1668
1669     break;
1670
1671   case 215:
1672 #line 1195 "perly.y"
1673                         { (yyval.opval) = localize((ps[0].val.opval),0); }
1674
1675     break;
1676
1677   case 216:
1678 #line 1197 "perly.y"
1679                         { (yyval.opval) = sawparens((ps[-1].val.opval)); }
1680
1681     break;
1682
1683   case 217:
1684 #line 1199 "perly.y"
1685                         { (yyval.opval) = (ps[0].val.opval); }
1686
1687     break;
1688
1689   case 218:
1690 #line 1201 "perly.y"
1691                         { (yyval.opval) = sawparens(newNULLLIST()); }
1692
1693     break;
1694
1695   case 219:
1696 #line 1203 "perly.y"
1697                         { (yyval.opval) = (ps[0].val.opval); }
1698
1699     break;
1700
1701   case 220:
1702 #line 1205 "perly.y"
1703                         { (yyval.opval) = (ps[0].val.opval); }
1704
1705     break;
1706
1707   case 221:
1708 #line 1207 "perly.y"
1709                         { (yyval.opval) = (ps[0].val.opval); }
1710
1711     break;
1712
1713   case 222:
1714 #line 1209 "perly.y"
1715                         { (yyval.opval) = (ps[0].val.opval); }
1716
1717     break;
1718
1719   case 223:
1720 #line 1211 "perly.y"
1721                         { (yyval.opval) = newUNOP(OP_AV2ARYLEN, 0, ref((ps[0].val.opval), OP_AV2ARYLEN));}
1722
1723     break;
1724
1725   case 224:
1726 #line 1213 "perly.y"
1727                         { (yyval.opval) = (ps[0].val.opval); }
1728
1729     break;
1730
1731   case 225:
1732 #line 1215 "perly.y"
1733                         { (yyval.opval) = op_prepend_elem(OP_ASLICE,
1734                                 newOP(OP_PUSHMARK, 0),
1735                                     newLISTOP(OP_ASLICE, 0,
1736                                         list((ps[-1].val.opval)),
1737                                         ref((ps[-3].val.opval), OP_ASLICE)));
1738                           if ((yyval.opval) && (ps[-3].val.opval))
1739                               (yyval.opval)->op_private |=
1740                                   (ps[-3].val.opval)->op_private & OPpSLICEWARNING;
1741                         }
1742
1743     break;
1744
1745   case 226:
1746 #line 1225 "perly.y"
1747                         { (yyval.opval) = op_prepend_elem(OP_KVASLICE,
1748                                 newOP(OP_PUSHMARK, 0),
1749                                     newLISTOP(OP_KVASLICE, 0,
1750                                         list((ps[-1].val.opval)),
1751                                         ref(oopsAV((ps[-3].val.opval)), OP_KVASLICE)));
1752                           if ((yyval.opval) && (ps[-3].val.opval))
1753                               (yyval.opval)->op_private |=
1754                                   (ps[-3].val.opval)->op_private & OPpSLICEWARNING;
1755                         }
1756
1757     break;
1758
1759   case 227:
1760 #line 1235 "perly.y"
1761                         { (yyval.opval) = op_prepend_elem(OP_HSLICE,
1762                                 newOP(OP_PUSHMARK, 0),
1763                                     newLISTOP(OP_HSLICE, 0,
1764                                         list((ps[-2].val.opval)),
1765                                         ref(oopsHV((ps[-4].val.opval)), OP_HSLICE)));
1766                           if ((yyval.opval) && (ps[-4].val.opval))
1767                               (yyval.opval)->op_private |=
1768                                   (ps[-4].val.opval)->op_private & OPpSLICEWARNING;
1769                         }
1770
1771     break;
1772
1773   case 228:
1774 #line 1245 "perly.y"
1775                         { (yyval.opval) = op_prepend_elem(OP_KVHSLICE,
1776                                 newOP(OP_PUSHMARK, 0),
1777                                     newLISTOP(OP_KVHSLICE, 0,
1778                                         list((ps[-2].val.opval)),
1779                                         ref((ps[-4].val.opval), OP_KVHSLICE)));
1780                           if ((yyval.opval) && (ps[-4].val.opval))
1781                               (yyval.opval)->op_private |=
1782                                   (ps[-4].val.opval)->op_private & OPpSLICEWARNING;
1783                         }
1784
1785     break;
1786
1787   case 229:
1788 #line 1255 "perly.y"
1789                         { (yyval.opval) = (ps[0].val.opval); }
1790
1791     break;
1792
1793   case 230:
1794 #line 1257 "perly.y"
1795                         { (yyval.opval) = newUNOP(OP_ENTERSUB, 0, scalar((ps[0].val.opval))); }
1796
1797     break;
1798
1799   case 231:
1800 #line 1259 "perly.y"
1801                         { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[-2].val.opval)));
1802                         }
1803
1804     break;
1805
1806   case 232:
1807 #line 1262 "perly.y"
1808                         {
1809                           (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1810                                 op_append_elem(OP_LIST, (ps[-1].val.opval), scalar((ps[-3].val.opval))));
1811                         }
1812
1813     break;
1814
1815   case 233:
1816 #line 1267 "perly.y"
1817                         { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1818                             op_append_elem(OP_LIST, (ps[0].val.opval), scalar((ps[-1].val.opval))));
1819                         }
1820
1821     break;
1822
1823   case 234:
1824 #line 1271 "perly.y"
1825                         { (yyval.opval) = newSVREF((ps[-3].val.opval)); }
1826
1827     break;
1828
1829   case 235:
1830 #line 1273 "perly.y"
1831                         { (yyval.opval) = newAVREF((ps[-3].val.opval)); }
1832
1833     break;
1834
1835   case 236:
1836 #line 1275 "perly.y"
1837                         { (yyval.opval) = newHVREF((ps[-3].val.opval)); }
1838
1839     break;
1840
1841   case 237:
1842 #line 1277 "perly.y"
1843                         { (yyval.opval) = newUNOP(OP_ENTERSUB, 0,
1844                                        scalar(newCVREF((ps[-1].val.ival),(ps[-3].val.opval)))); }
1845
1846     break;
1847
1848   case 238:
1849 #line 1280 "perly.y"
1850                         { (yyval.opval) = newGVREF(0,(ps[-3].val.opval)); }
1851
1852     break;
1853
1854   case 239:
1855 #line 1282 "perly.y"
1856                         { (yyval.opval) = newOP((ps[0].val.ival), OPf_SPECIAL);
1857                             PL_hints |= HINT_BLOCK_SCOPE; }
1858
1859     break;
1860
1861   case 240:
1862 #line 1285 "perly.y"
1863                         { (yyval.opval) = newLOOPEX((ps[-1].val.ival),(ps[0].val.opval)); }
1864
1865     break;
1866
1867   case 241:
1868 #line 1287 "perly.y"
1869                         { (yyval.opval) = newUNOP(OP_NOT, 0, scalar((ps[0].val.opval))); }
1870
1871     break;
1872
1873   case 242:
1874 #line 1289 "perly.y"
1875                         { (yyval.opval) = newOP((ps[0].val.ival), 0); }
1876
1877     break;
1878
1879   case 243:
1880 #line 1291 "perly.y"
1881                         { (yyval.opval) = newUNOP((ps[-1].val.ival), 0, (ps[0].val.opval)); }
1882
1883     break;
1884
1885   case 244:
1886 #line 1293 "perly.y"
1887                         { (yyval.opval) = newUNOP((ps[-1].val.ival), 0, (ps[0].val.opval)); }
1888
1889     break;
1890
1891   case 245:
1892 #line 1295 "perly.y"
1893                         { (yyval.opval) = newOP(OP_REQUIRE, (ps[0].val.ival) ? OPf_SPECIAL : 0); }
1894
1895     break;
1896
1897   case 246:
1898 #line 1297 "perly.y"
1899                         { (yyval.opval) = newUNOP(OP_REQUIRE, (ps[-1].val.ival) ? OPf_SPECIAL : 0, (ps[0].val.opval)); }
1900
1901     break;
1902
1903   case 247:
1904 #line 1299 "perly.y"
1905                         { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[0].val.opval))); }
1906
1907     break;
1908
1909   case 248:
1910 #line 1301 "perly.y"
1911                         { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED,
1912                             op_append_elem(OP_LIST, (ps[0].val.opval), scalar((ps[-1].val.opval)))); }
1913
1914     break;
1915
1916   case 249:
1917 #line 1304 "perly.y"
1918                         { (yyval.opval) = newOP((ps[0].val.ival), 0); }
1919
1920     break;
1921
1922   case 250:
1923 #line 1306 "perly.y"
1924                         { (yyval.opval) = newOP((ps[-2].val.ival), 0);}
1925
1926     break;
1927
1928   case 251:
1929 #line 1308 "perly.y"
1930                         { (yyval.opval) = (ps[0].val.opval); }
1931
1932     break;
1933
1934   case 252:
1935 #line 1310 "perly.y"
1936                         { (yyval.opval) = (ps[-2].val.opval); }
1937
1938     break;
1939
1940   case 253:
1941 #line 1312 "perly.y"
1942                         { (yyval.opval) = newUNOP(OP_ENTERSUB, OPf_STACKED, scalar((ps[0].val.opval))); }
1943
1944     break;
1945
1946   case 254:
1947 #line 1314 "perly.y"
1948                         { (yyval.opval) = ((ps[-2].val.ival) == OP_NOT)
1949                           ? newUNOP((ps[-2].val.ival), 0, newSVOP(OP_CONST, 0, newSViv(0)))
1950                           : newOP((ps[-2].val.ival), OPf_SPECIAL); }
1951
1952     break;
1953
1954   case 255:
1955 #line 1318 "perly.y"
1956                         { (yyval.opval) = newUNOP((ps[-3].val.ival), 0, (ps[-1].val.opval)); }
1957
1958     break;
1959
1960   case 256:
1961 #line 1320 "perly.y"
1962                         {
1963                             if (   (ps[0].val.opval)->op_type != OP_TRANS
1964                                 && (ps[0].val.opval)->op_type != OP_TRANSR
1965                                 && (((PMOP*)(ps[0].val.opval))->op_pmflags & PMf_HAS_CV))
1966                             {
1967                                 (yyval.ival) = start_subparse(FALSE, CVf_ANON);
1968                                 SAVEFREESV(PL_compcv);
1969                             } else
1970                                 (yyval.ival) = 0;
1971                         }
1972
1973     break;
1974
1975   case 257:
1976 #line 1331 "perly.y"
1977                         { (yyval.opval) = pmruntime((ps[-5].val.opval), (ps[-2].val.opval), (ps[-1].val.opval), 1, (ps[-4].val.ival)); }
1978
1979     break;
1980
1981   case 261:
1982 #line 1339 "perly.y"
1983                         { (yyval.opval) = my_attrs((ps[-1].val.opval),(ps[0].val.opval)); }
1984
1985     break;
1986
1987   case 262:
1988 #line 1341 "perly.y"
1989                         { (yyval.opval) = localize((ps[0].val.opval),1); }
1990
1991     break;
1992
1993   case 263:
1994 #line 1343 "perly.y"
1995                         { (yyval.opval) = newUNOP(OP_REFGEN, 0, my_attrs((ps[-1].val.opval),(ps[0].val.opval))); }
1996
1997     break;
1998
1999   case 264:
2000 #line 1348 "perly.y"
2001                         { (yyval.opval) = sawparens((ps[-1].val.opval)); }
2002
2003     break;
2004
2005   case 265:
2006 #line 1350 "perly.y"
2007                         { (yyval.opval) = sawparens(newNULLLIST()); }
2008
2009     break;
2010
2011   case 266:
2012 #line 1353 "perly.y"
2013                         { (yyval.opval) = (ps[0].val.opval); }
2014
2015     break;
2016
2017   case 267:
2018 #line 1355 "perly.y"
2019                         { (yyval.opval) = (ps[0].val.opval); }
2020
2021     break;
2022
2023   case 268:
2024 #line 1357 "perly.y"
2025                         { (yyval.opval) = (ps[0].val.opval); }
2026
2027     break;
2028
2029   case 269:
2030 #line 1362 "perly.y"
2031                         { (yyval.opval) = NULL; }
2032
2033     break;
2034
2035   case 270:
2036 #line 1364 "perly.y"
2037                         { (yyval.opval) = (ps[0].val.opval); }
2038
2039     break;
2040
2041   case 271:
2042 #line 1368 "perly.y"
2043                         { (yyval.opval) = NULL; }
2044
2045     break;
2046
2047   case 272:
2048 #line 1370 "perly.y"
2049                         { (yyval.opval) = (ps[0].val.opval); }
2050
2051     break;
2052
2053   case 273:
2054 #line 1374 "perly.y"
2055                         { (yyval.opval) = NULL; }
2056
2057     break;
2058
2059   case 274:
2060 #line 1376 "perly.y"
2061                         { (yyval.opval) = (ps[0].val.opval); }
2062
2063     break;
2064
2065   case 275:
2066 #line 1382 "perly.y"
2067                         { parser->in_my = 0; (yyval.opval) = my((ps[0].val.opval)); }
2068
2069     break;
2070
2071   case 276:
2072 #line 1387 "perly.y"
2073                         { (yyval.opval) = (ps[-1].val.opval); }
2074
2075     break;
2076
2077   case 277:
2078 #line 1389 "perly.y"
2079                         {
2080                           (yyval.opval) = op_append_elem(OP_LIST, (ps[-2].val.opval), (ps[0].val.opval));
2081                         }
2082
2083     break;
2084
2085   case 279:
2086 #line 1396 "perly.y"
2087                         { parser->in_my = 0; (yyval.opval) = (ps[0].val.opval); }
2088
2089     break;
2090
2091   case 287:
2092 #line 1413 "perly.y"
2093                         { (yyval.opval) = newCVREF((ps[-1].val.ival),(ps[0].val.opval)); }
2094
2095     break;
2096
2097   case 288:
2098 #line 1417 "perly.y"
2099                         { (yyval.opval) = newSVREF((ps[0].val.opval)); }
2100
2101     break;
2102
2103   case 289:
2104 #line 1421 "perly.y"
2105                         { (yyval.opval) = newAVREF((ps[0].val.opval));
2106                           if ((yyval.opval)) (yyval.opval)->op_private |= (ps[-1].val.ival);
2107                         }
2108
2109     break;
2110
2111   case 290:
2112 #line 1427 "perly.y"
2113                         { (yyval.opval) = newHVREF((ps[0].val.opval));
2114                           if ((yyval.opval)) (yyval.opval)->op_private |= (ps[-1].val.ival);
2115                         }
2116
2117     break;
2118
2119   case 291:
2120 #line 1433 "perly.y"
2121                         { (yyval.opval) = newAVREF((ps[0].val.opval)); }
2122
2123     break;
2124
2125   case 292:
2126 #line 1435 "perly.y"
2127                         { (yyval.opval) = newAVREF((ps[-3].val.opval)); }
2128
2129     break;
2130
2131   case 293:
2132 #line 1439 "perly.y"
2133                         { (yyval.opval) = newGVREF(0,(ps[0].val.opval)); }
2134
2135     break;
2136
2137   case 295:
2138 #line 1444 "perly.y"
2139                         { (yyval.opval) = newAVREF((ps[-2].val.opval)); }
2140
2141     break;
2142
2143   case 297:
2144 #line 1449 "perly.y"
2145                         { (yyval.opval) = newHVREF((ps[-2].val.opval)); }
2146
2147     break;
2148
2149   case 299:
2150 #line 1454 "perly.y"
2151                         { (yyval.opval) = newGVREF(0,(ps[-2].val.opval)); }
2152
2153     break;
2154
2155   case 300:
2156 #line 1459 "perly.y"
2157                         { (yyval.opval) = scalar((ps[0].val.opval)); }
2158
2159     break;
2160
2161   case 301:
2162 #line 1461 "perly.y"
2163                         { (yyval.opval) = scalar((ps[0].val.opval)); }
2164
2165     break;
2166
2167   case 302:
2168 #line 1463 "perly.y"
2169                         { (yyval.opval) = op_scope((ps[0].val.opval)); }
2170
2171     break;
2172
2173   case 303:
2174 #line 1466 "perly.y"
2175                         { (yyval.opval) = (ps[0].val.opval); }
2176
2177     break;
2178
2179
2180
2181
2182       default: break;
2183
2184
2185 /* Generated from:
2186  * 15f94e78bed944fe5a2da8ead4096a620ad573562953c479348c65e9eaa51629 perly.y
2187  * acf1cbfd2545faeaaa58b1cf0cf9d7f98b5be0752eb7a54528ef904a9e2e1ca7 regen_perly.pl
2188  * ex: set ro: */