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