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