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