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