perly.act

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