byterun.c

   1 /*
   2  *      Copyright (c) 1996 Malcolm Beattie
   3  *
   4  *      You may distribute under the terms of either the GNU General Public
   5  *      License or the Artistic License, as specified in the README file.
   6  *
   7  */
   8 /*
   9  * This file is autogenerated from bytecode.pl. Changes made here will be lost.
  10  */
  11
  12 #include "EXTERN.h"
  13 #include "perl.h"
  14 #include "bytecode.h"
  15 #include "byterun.h"
  16
  17 #ifdef INDIRECT_BGET_MACROS
  18 void byterun(bs)
  19 struct bytestream bs;
  20 #else
  21 void byterun(fp)
  22 FILE *fp;
  23 #endif /* INDIRECT_BGET_MACROS */
  24 {
  25     int insn;
  26     while ((insn = FGETC()) != EOF) {
  27         switch (insn) {
  28           case INSN_COMMENT:            /* 35 */
  29             {
  30                 comment arg;
  31                 BGET_comment(arg);
  32                 arg = arg;
  33                 break;
  34             }
  35           case INSN_NOP:                /* 10 */
  36             {
  37                 break;
  38             }
  39           case INSN_RET:                /* 0 */
  40             {
  41                 BSET_ret(none);
  42                 break;
  43             }
  44           case INSN_LDSV:               /* 1 */
  45             {
  46                 svindex arg;
  47                 BGET_objindex(arg);
  48                 sv = arg;
  49                 break;
  50             }
  51           case INSN_LDOP:               /* 2 */
  52             {
  53                 opindex arg;
  54                 BGET_objindex(arg);
  55                 op = arg;
  56                 break;
  57             }
  58           case INSN_STSV:               /* 3 */
  59             {
  60                 U32 arg;
  61                 BGET_U32(arg);
  62                 BSET_OBJ_STORE(sv, arg);
  63                 break;
  64             }
  65           case INSN_STOP:               /* 4 */
  66             {
  67                 U32 arg;
  68                 BGET_U32(arg);
  69                 BSET_OBJ_STORE(op, arg);
  70                 break;
  71             }
  72           case INSN_LDSPECSV:           /* 5 */
  73             {
  74                 U8 arg;
  75                 BGET_U8(arg);
  76                 BSET_ldspecsv(sv, arg);
  77                 break;
  78             }
  79           case INSN_NEWSV:              /* 6 */
  80             {
  81                 U8 arg;
  82                 BGET_U8(arg);
  83                 BSET_newsv(sv, arg);
  84                 break;
  85             }
  86           case INSN_NEWOP:              /* 7 */
  87             {
  88                 U8 arg;
  89                 BGET_U8(arg);
  90                 BSET_newop(op, arg);
  91                 break;
  92             }
  93           case INSN_NEWOPN:             /* 8 */
  94             {
  95                 U8 arg;
  96                 BGET_U8(arg);
  97                 BSET_newopn(op, arg);
  98                 break;
  99             }
 100           case INSN_NEWPV:              /* 9 */
 101             {
 102                 PV arg;
 103                 BGET_PV(arg);
 104                 break;
 105             }
 106           case INSN_PV_CUR:             /* 11 */
 107             {
 108                 STRLEN arg;
 109                 BGET_U32(arg);
 110                 pv.xpv_cur = arg;
 111                 break;
 112             }
 113           case INSN_PV_FREE:            /* 12 */
 114             {
 115                 BSET_pv_free(pv);
 116                 break;
 117             }
 118           case INSN_SV_UPGRADE:         /* 13 */
 119             {
 120                 char arg;
 121                 BGET_U8(arg);
 122                 BSET_sv_upgrade(sv, arg);
 123                 break;
 124             }
 125           case INSN_SV_REFCNT:          /* 14 */
 126             {
 127                 U32 arg;
 128                 BGET_U32(arg);
 129                 SvREFCNT(sv) = arg;
 130                 break;
 131             }
 132           case INSN_SV_REFCNT_ADD:              /* 15 */
 133             {
 134                 I32 arg;
 135                 BGET_I32(arg);
 136                 BSET_sv_refcnt_add(SvREFCNT(sv), arg);
 137                 break;
 138             }
 139           case INSN_SV_FLAGS:           /* 16 */
 140             {
 141                 U32 arg;
 142                 BGET_U32(arg);
 143                 SvFLAGS(sv) = arg;
 144                 break;
 145             }
 146           case INSN_XRV:                /* 17 */
 147             {
 148                 svindex arg;
 149                 BGET_objindex(arg);
 150                 SvRV(sv) = arg;
 151                 break;
 152             }
 153           case INSN_XPV:                /* 18 */
 154             {
 155                 BSET_xpv(sv);
 156                 break;
 157             }
 158           case INSN_XIV32:              /* 19 */
 159             {
 160                 I32 arg;
 161                 BGET_I32(arg);
 162                 SvIVX(sv) = arg;
 163                 break;
 164             }
 165           case INSN_XIV64:              /* 20 */
 166             {
 167                 IV64 arg;
 168                 BGET_IV64(arg);
 169                 SvIVX(sv) = arg;
 170                 break;
 171             }
 172           case INSN_XNV:                /* 21 */
 173             {
 174                 double arg;
 175                 BGET_double(arg);
 176                 SvNVX(sv) = arg;
 177                 break;
 178             }
 179           case INSN_XLV_TARGOFF:                /* 22 */
 180             {
 181                 STRLEN arg;
 182                 BGET_U32(arg);
 183                 LvTARGOFF(sv) = arg;
 184                 break;
 185             }
 186           case INSN_XLV_TARGLEN:                /* 23 */
 187             {
 188                 STRLEN arg;
 189                 BGET_U32(arg);
 190                 LvTARGLEN(sv) = arg;
 191                 break;
 192             }
 193           case INSN_XLV_TARG:           /* 24 */
 194             {
 195                 svindex arg;
 196                 BGET_objindex(arg);
 197                 LvTARG(sv) = arg;
 198                 break;
 199             }
 200           case INSN_XLV_TYPE:           /* 25 */
 201             {
 202                 char arg;
 203                 BGET_U8(arg);
 204                 LvTYPE(sv) = arg;
 205                 break;
 206             }
 207           case INSN_XBM_USEFUL:         /* 26 */
 208             {
 209                 I32 arg;
 210                 BGET_I32(arg);
 211                 BmUSEFUL(sv) = arg;
 212                 break;
 213             }
 214           case INSN_XBM_PREVIOUS:               /* 27 */
 215             {
 216                 U16 arg;
 217                 BGET_U16(arg);
 218                 BmPREVIOUS(sv) = arg;
 219                 break;
 220             }
 221           case INSN_XBM_RARE:           /* 28 */
 222             {
 223                 U8 arg;
 224                 BGET_U8(arg);
 225                 BmRARE(sv) = arg;
 226                 break;
 227             }
 228           case INSN_XFM_LINES:          /* 29 */
 229             {
 230                 I32 arg;
 231                 BGET_I32(arg);
 232                 FmLINES(sv) = arg;
 233                 break;
 234             }
 235           case INSN_XIO_LINES:          /* 30 */
 236             {
 237                 long arg;
 238                 BGET_I32(arg);
 239                 IoLINES(sv) = arg;
 240                 break;
 241             }
 242           case INSN_XIO_PAGE:           /* 31 */
 243             {
 244                 long arg;
 245                 BGET_I32(arg);
 246                 IoPAGE(sv) = arg;
 247                 break;
 248             }
 249           case INSN_XIO_PAGE_LEN:               /* 32 */
 250             {
 251                 long arg;
 252                 BGET_I32(arg);
 253                 IoPAGE_LEN(sv) = arg;
 254                 break;
 255             }
 256           case INSN_XIO_LINES_LEFT:             /* 33 */
 257             {
 258                 long arg;
 259                 BGET_I32(arg);
 260                 IoLINES_LEFT(sv) = arg;
 261                 break;
 262             }
 263           case INSN_XIO_TOP_NAME:               /* 34 */
 264             {
 265                 pvcontents arg;
 266                 BGET_pvcontents(arg);
 267                 IoTOP_NAME(sv) = arg;
 268                 break;
 269             }
 270           case INSN_XIO_TOP_GV:         /* 36 */
 271             {
 272                 svindex arg;
 273                 BGET_objindex(arg);
 274                 *(SV**)&IoTOP_GV(sv) = arg;
 275                 break;
 276             }
 277           case INSN_XIO_FMT_NAME:               /* 37 */
 278             {
 279                 pvcontents arg;
 280                 BGET_pvcontents(arg);
 281                 IoFMT_NAME(sv) = arg;
 282                 break;
 283             }
 284           case INSN_XIO_FMT_GV:         /* 38 */
 285             {
 286                 svindex arg;
 287                 BGET_objindex(arg);
 288                 *(SV**)&IoFMT_GV(sv) = arg;
 289                 break;
 290             }
 291           case INSN_XIO_BOTTOM_NAME:            /* 39 */
 292             {
 293                 pvcontents arg;
 294                 BGET_pvcontents(arg);
 295                 IoBOTTOM_NAME(sv) = arg;
 296                 break;
 297             }
 298           case INSN_XIO_BOTTOM_GV:              /* 40 */
 299             {
 300                 svindex arg;
 301                 BGET_objindex(arg);
 302                 *(SV**)&IoBOTTOM_GV(sv) = arg;
 303                 break;
 304             }
 305           case INSN_XIO_SUBPROCESS:             /* 41 */
 306             {
 307                 short arg;
 308                 BGET_U16(arg);
 309                 IoSUBPROCESS(sv) = arg;
 310                 break;
 311             }
 312           case INSN_XIO_TYPE:           /* 42 */
 313             {
 314                 char arg;
 315                 BGET_U8(arg);
 316                 IoTYPE(sv) = arg;
 317                 break;
 318             }
 319           case INSN_XIO_FLAGS:          /* 43 */
 320             {
 321                 char arg;
 322                 BGET_U8(arg);
 323                 IoFLAGS(sv) = arg;
 324                 break;
 325             }
 326           case INSN_XCV_STASH:          /* 44 */
 327             {
 328                 svindex arg;
 329                 BGET_objindex(arg);
 330                 *(SV**)&CvSTASH(sv) = arg;
 331                 break;
 332             }
 333           case INSN_XCV_START:          /* 45 */
 334             {
 335                 opindex arg;
 336                 BGET_objindex(arg);
 337                 CvSTART(sv) = arg;
 338                 break;
 339             }
 340           case INSN_XCV_ROOT:           /* 46 */
 341             {
 342                 opindex arg;
 343                 BGET_objindex(arg);
 344                 CvROOT(sv) = arg;
 345                 break;
 346             }
 347           case INSN_XCV_GV:             /* 47 */
 348             {
 349                 svindex arg;
 350                 BGET_objindex(arg);
 351                 *(SV**)&CvGV(sv) = arg;
 352                 break;
 353             }
 354           case INSN_XCV_FILEGV:         /* 48 */
 355             {
 356                 svindex arg;
 357                 BGET_objindex(arg);
 358                 *(SV**)&CvFILEGV(sv) = arg;
 359                 break;
 360             }
 361           case INSN_XCV_DEPTH:          /* 49 */
 362             {
 363                 long arg;
 364                 BGET_I32(arg);
 365                 CvDEPTH(sv) = arg;
 366                 break;
 367             }
 368           case INSN_XCV_PADLIST:                /* 50 */
 369             {
 370                 svindex arg;
 371                 BGET_objindex(arg);
 372                 *(SV**)&CvPADLIST(sv) = arg;
 373                 break;
 374             }
 375           case INSN_XCV_OUTSIDE:                /* 51 */
 376             {
 377                 svindex arg;
 378                 BGET_objindex(arg);
 379                 *(SV**)&CvOUTSIDE(sv) = arg;
 380                 break;
 381             }
 382           case INSN_XCV_FLAGS:          /* 52 */
 383             {
 384                 U8 arg;
 385                 BGET_U8(arg);
 386                 CvFLAGS(sv) = arg;
 387                 break;
 388             }
 389           case INSN_AV_EXTEND:          /* 53 */
 390             {
 391                 SSize_t arg;
 392                 BGET_I32(arg);
 393                 BSET_av_extend(sv, arg);
 394                 break;
 395             }
 396           case INSN_AV_PUSH:            /* 54 */
 397             {
 398                 svindex arg;
 399                 BGET_objindex(arg);
 400                 BSET_av_push(sv, arg);
 401                 break;
 402             }
 403           case INSN_XAV_FILL:           /* 55 */
 404             {
 405                 SSize_t arg;
 406                 BGET_I32(arg);
 407                 AvFILL(sv) = arg;
 408                 break;
 409             }
 410           case INSN_XAV_MAX:            /* 56 */
 411             {
 412                 SSize_t arg;
 413                 BGET_I32(arg);
 414                 AvMAX(sv) = arg;
 415                 break;
 416             }
 417           case INSN_XAV_FLAGS:          /* 57 */
 418             {
 419                 U8 arg;
 420                 BGET_U8(arg);
 421                 AvFLAGS(sv) = arg;
 422                 break;
 423             }
 424           case INSN_XHV_RITER:          /* 58 */
 425             {
 426                 I32 arg;
 427                 BGET_I32(arg);
 428                 HvRITER(sv) = arg;
 429                 break;
 430             }
 431           case INSN_XHV_NAME:           /* 59 */
 432             {
 433                 pvcontents arg;
 434                 BGET_pvcontents(arg);
 435                 HvNAME(sv) = arg;
 436                 break;
 437             }
 438           case INSN_HV_STORE:           /* 60 */
 439             {
 440                 svindex arg;
 441                 BGET_objindex(arg);
 442                 BSET_hv_store(sv, arg);
 443                 break;
 444             }
 445           case INSN_SV_MAGIC:           /* 61 */
 446             {
 447                 char arg;
 448                 BGET_U8(arg);
 449                 BSET_sv_magic(sv, arg);
 450                 break;
 451             }
 452           case INSN_MG_OBJ:             /* 62 */
 453             {
 454                 svindex arg;
 455                 BGET_objindex(arg);
 456                 SvMAGIC(sv)->mg_obj = arg;
 457                 break;
 458             }
 459           case INSN_MG_PRIVATE:         /* 63 */
 460             {
 461                 U16 arg;
 462                 BGET_U16(arg);
 463                 SvMAGIC(sv)->mg_private = arg;
 464                 break;
 465             }
 466           case INSN_MG_FLAGS:           /* 64 */
 467             {
 468                 U8 arg;
 469                 BGET_U8(arg);
 470                 SvMAGIC(sv)->mg_flags = arg;
 471                 break;
 472             }
 473           case INSN_MG_PV:              /* 65 */
 474             {
 475                 pvcontents arg;
 476                 BGET_pvcontents(arg);
 477                 BSET_mg_pv(SvMAGIC(sv), arg);
 478                 break;
 479             }
 480           case INSN_XMG_STASH:          /* 66 */
 481             {
 482                 svindex arg;
 483                 BGET_objindex(arg);
 484                 *(SV**)&SvSTASH(sv) = arg;
 485                 break;
 486             }
 487           case INSN_GV_FETCHPV:         /* 67 */
 488             {
 489                 strconst arg;
 490                 BGET_strconst(arg);
 491                 BSET_gv_fetchpv(sv, arg);
 492                 break;
 493             }
 494           case INSN_GV_STASHPV:         /* 68 */
 495             {
 496                 strconst arg;
 497                 BGET_strconst(arg);
 498                 BSET_gv_stashpv(sv, arg);
 499                 break;
 500             }
 501           case INSN_GP_SV:              /* 69 */
 502             {
 503                 svindex arg;
 504                 BGET_objindex(arg);
 505                 GvSV(sv) = arg;
 506                 break;
 507             }
 508           case INSN_GP_REFCNT:          /* 70 */
 509             {
 510                 U32 arg;
 511                 BGET_U32(arg);
 512                 GvREFCNT(sv) = arg;
 513                 break;
 514             }
 515           case INSN_GP_REFCNT_ADD:              /* 71 */
 516             {
 517                 I32 arg;
 518                 BGET_I32(arg);
 519                 BSET_gp_refcnt_add(GvREFCNT(sv), arg);
 520                 break;
 521             }
 522           case INSN_GP_AV:              /* 72 */
 523             {
 524                 svindex arg;
 525                 BGET_objindex(arg);
 526                 *(SV**)&GvAV(sv) = arg;
 527                 break;
 528             }
 529           case INSN_GP_HV:              /* 73 */
 530             {
 531                 svindex arg;
 532                 BGET_objindex(arg);
 533                 *(SV**)&GvHV(sv) = arg;
 534                 break;
 535             }
 536           case INSN_GP_CV:              /* 74 */
 537             {
 538                 svindex arg;
 539                 BGET_objindex(arg);
 540                 *(SV**)&GvCV(sv) = arg;
 541                 break;
 542             }
 543           case INSN_GP_FILEGV:          /* 75 */
 544             {
 545                 svindex arg;
 546                 BGET_objindex(arg);
 547                 *(SV**)&GvFILEGV(sv) = arg;
 548                 break;
 549             }
 550           case INSN_GP_IO:              /* 76 */
 551             {
 552                 svindex arg;
 553                 BGET_objindex(arg);
 554                 *(SV**)&GvIOp(sv) = arg;
 555                 break;
 556             }
 557           case INSN_GP_FORM:            /* 77 */
 558             {
 559                 svindex arg;
 560                 BGET_objindex(arg);
 561                 *(SV**)&GvFORM(sv) = arg;
 562                 break;
 563             }
 564           case INSN_GP_CVGEN:           /* 78 */
 565             {
 566                 U32 arg;
 567                 BGET_U32(arg);
 568                 GvCVGEN(sv) = arg;
 569                 break;
 570             }
 571           case INSN_GP_LINE:            /* 79 */
 572             {
 573                 line_t arg;
 574                 BGET_U16(arg);
 575                 GvLINE(sv) = arg;
 576                 break;
 577             }
 578           case INSN_GP_SHARE:           /* 80 */
 579             {
 580                 svindex arg;
 581                 BGET_objindex(arg);
 582                 BSET_gp_share(sv, arg);
 583                 break;
 584             }
 585           case INSN_XGV_FLAGS:          /* 81 */
 586             {
 587                 U8 arg;
 588                 BGET_U8(arg);
 589                 GvFLAGS(sv) = arg;
 590                 break;
 591             }
 592           case INSN_OP_NEXT:            /* 82 */
 593             {
 594                 opindex arg;
 595                 BGET_objindex(arg);
 596                 op->op_next = arg;
 597                 break;
 598             }
 599           case INSN_OP_SIBLING:         /* 83 */
 600             {
 601                 opindex arg;
 602                 BGET_objindex(arg);
 603                 op->op_sibling = arg;
 604                 break;
 605             }
 606           case INSN_OP_PPADDR:          /* 84 */
 607             {
 608                 strconst arg;
 609                 BGET_strconst(arg);
 610                 BSET_op_ppaddr(op->op_ppaddr, arg);
 611                 break;
 612             }
 613           case INSN_OP_TARG:            /* 85 */
 614             {
 615                 PADOFFSET arg;
 616                 BGET_U32(arg);
 617                 op->op_targ = arg;
 618                 break;
 619             }
 620           case INSN_OP_TYPE:            /* 86 */
 621             {
 622                 OPCODE arg;
 623                 BGET_U16(arg);
 624                 BSET_op_type(op, arg);
 625                 break;
 626             }
 627           case INSN_OP_SEQ:             /* 87 */
 628             {
 629                 U16 arg;
 630                 BGET_U16(arg);
 631                 op->op_seq = arg;
 632                 break;
 633             }
 634           case INSN_OP_FLAGS:           /* 88 */
 635             {
 636                 U8 arg;
 637                 BGET_U8(arg);
 638                 op->op_flags = arg;
 639                 break;
 640             }
 641           case INSN_OP_PRIVATE:         /* 89 */
 642             {
 643                 U8 arg;
 644                 BGET_U8(arg);
 645                 op->op_private = arg;
 646                 break;
 647             }
 648           case INSN_OP_FIRST:           /* 90 */
 649             {
 650                 opindex arg;
 651                 BGET_objindex(arg);
 652                 cUNOP->op_first = arg;
 653                 break;
 654             }
 655           case INSN_OP_LAST:            /* 91 */
 656             {
 657                 opindex arg;
 658                 BGET_objindex(arg);
 659                 cBINOP->op_last = arg;
 660                 break;
 661             }
 662           case INSN_OP_OTHER:           /* 92 */
 663             {
 664                 opindex arg;
 665                 BGET_objindex(arg);
 666                 cLOGOP->op_other = arg;
 667                 break;
 668             }
 669           case INSN_OP_TRUE:            /* 93 */
 670             {
 671                 opindex arg;
 672                 BGET_objindex(arg);
 673                 cCONDOP->op_true = arg;
 674                 break;
 675             }
 676           case INSN_OP_FALSE:           /* 94 */
 677             {
 678                 opindex arg;
 679                 BGET_objindex(arg);
 680                 cCONDOP->op_false = arg;
 681                 break;
 682             }
 683           case INSN_OP_CHILDREN:                /* 95 */
 684             {
 685                 U32 arg;
 686                 BGET_U32(arg);
 687                 cLISTOP->op_children = arg;
 688                 break;
 689             }
 690           case INSN_OP_PMREPLROOT:              /* 96 */
 691             {
 692                 opindex arg;
 693                 BGET_objindex(arg);
 694                 cPMOP->op_pmreplroot = arg;
 695                 break;
 696             }
 697           case INSN_OP_PMREPLROOTGV:            /* 97 */
 698             {
 699                 svindex arg;
 700                 BGET_objindex(arg);
 701                 *(SV**)&cPMOP->op_pmreplroot = arg;
 702                 break;
 703             }
 704           case INSN_OP_PMREPLSTART:             /* 98 */
 705             {
 706                 opindex arg;
 707                 BGET_objindex(arg);
 708                 cPMOP->op_pmreplstart = arg;
 709                 break;
 710             }
 711           case INSN_OP_PMNEXT:          /* 99 */
 712             {
 713                 opindex arg;
 714                 BGET_objindex(arg);
 715                 *(OP**)&cPMOP->op_pmnext = arg;
 716                 break;
 717             }
 718           case INSN_PREGCOMP:           /* 100 */
 719             {
 720                 pvcontents arg;
 721                 BGET_pvcontents(arg);
 722                 BSET_pregcomp(op, arg);
 723                 break;
 724             }
 725           case INSN_OP_PMSHORT:         /* 101 */
 726             {
 727                 svindex arg;
 728                 BGET_objindex(arg);
 729                 cPMOP->op_pmshort = arg;
 730                 break;
 731             }
 732           case INSN_OP_PMFLAGS:         /* 102 */
 733             {
 734                 U16 arg;
 735                 BGET_U16(arg);
 736                 cPMOP->op_pmflags = arg;
 737                 break;
 738             }
 739           case INSN_OP_PMPERMFLAGS:             /* 103 */
 740             {
 741                 U16 arg;
 742                 BGET_U16(arg);
 743                 cPMOP->op_pmpermflags = arg;
 744                 break;
 745             }
 746           case INSN_OP_PMSLEN:          /* 104 */
 747             {
 748                 char arg;
 749                 BGET_U8(arg);
 750                 cPMOP->op_pmslen = arg;
 751                 break;
 752             }
 753           case INSN_OP_SV:              /* 105 */
 754             {
 755                 svindex arg;
 756                 BGET_objindex(arg);
 757                 cSVOP->op_sv = arg;
 758                 break;
 759             }
 760           case INSN_OP_GV:              /* 106 */
 761             {
 762                 svindex arg;
 763                 BGET_objindex(arg);
 764                 *(SV**)&cGVOP->op_gv = arg;
 765                 break;
 766             }
 767           case INSN_OP_PV:              /* 107 */
 768             {
 769                 pvcontents arg;
 770                 BGET_pvcontents(arg);
 771                 cPVOP->op_pv = arg;
 772                 break;
 773             }
 774           case INSN_OP_PV_TR:           /* 108 */
 775             {
 776                 op_tr_array arg;
 777                 BGET_op_tr_array(arg);
 778                 cPVOP->op_pv = arg;
 779                 break;
 780             }
 781           case INSN_OP_REDOOP:          /* 109 */
 782             {
 783                 opindex arg;
 784                 BGET_objindex(arg);
 785                 cLOOP->op_redoop = arg;
 786                 break;
 787             }
 788           case INSN_OP_NEXTOP:          /* 110 */
 789             {
 790                 opindex arg;
 791                 BGET_objindex(arg);
 792                 cLOOP->op_nextop = arg;
 793                 break;
 794             }
 795           case INSN_OP_LASTOP:          /* 111 */
 796             {
 797                 opindex arg;
 798                 BGET_objindex(arg);
 799                 cLOOP->op_lastop = arg;
 800                 break;
 801             }
 802           case INSN_COP_LABEL:          /* 112 */
 803             {
 804                 pvcontents arg;
 805                 BGET_pvcontents(arg);
 806                 cCOP->cop_label = arg;
 807                 break;
 808             }
 809           case INSN_COP_STASH:          /* 113 */
 810             {
 811                 svindex arg;
 812                 BGET_objindex(arg);
 813                 *(SV**)&cCOP->cop_stash = arg;
 814                 break;
 815             }
 816           case INSN_COP_FILEGV:         /* 114 */
 817             {
 818                 svindex arg;
 819                 BGET_objindex(arg);
 820                 *(SV**)&cCOP->cop_filegv = arg;
 821                 break;
 822             }
 823           case INSN_COP_SEQ:            /* 115 */
 824             {
 825                 U32 arg;
 826                 BGET_U32(arg);
 827                 cCOP->cop_seq = arg;
 828                 break;
 829             }
 830           case INSN_COP_ARYBASE:                /* 116 */
 831             {
 832                 I32 arg;
 833                 BGET_I32(arg);
 834                 cCOP->cop_arybase = arg;
 835                 break;
 836             }
 837           case INSN_COP_LINE:           /* 117 */
 838             {
 839                 line_t arg;
 840                 BGET_U16(arg);
 841                 cCOP->cop_line = arg;
 842                 break;
 843             }
 844           case INSN_MAIN_START:         /* 118 */
 845             {
 846                 opindex arg;
 847                 BGET_objindex(arg);
 848                 main_start = arg;
 849                 break;
 850             }
 851           case INSN_MAIN_ROOT:          /* 119 */
 852             {
 853                 opindex arg;
 854                 BGET_objindex(arg);
 855                 main_root = arg;
 856                 break;
 857             }
 858           case INSN_CURPAD:             /* 120 */
 859             {
 860                 svindex arg;
 861                 BGET_objindex(arg);
 862                 BSET_curpad(curpad, arg);
 863                 break;
 864             }
 865           default:
 866             croak("Illegal bytecode instruction %d\n", insn);
 867             /* NOTREACHED */
 868         }
 869     }
 870 }