scope.c

   1 /*    scope.c
   2  *
   3  *    Copyright (c) 1991-1997, Larry Wall
   4  *
   5  *    You may distribute under the terms of either the GNU General Public
   6  *    License or the Artistic License, as specified in the README file.
   7  *
   8  */
   9
  10 /*
  11  * "For the fashion of Minas Tirith was such that it was built on seven
  12  * levels..."
  13  */
  14
  15 #include "EXTERN.h"
  16 #include "perl.h"
  17
  18 SV**
  19 stack_grow(sp, p, n)
  20 SV** sp;
  21 SV** p;
  22 int n;
  23 {
  24     dTHR;
  25     stack_sp = sp;
  26     av_extend(curstack, (p - stack_base) + (n) + 128);
  27     return stack_sp;
  28 }
  29
  30 I32
  31 cxinc()
  32 {
  33     dTHR;
  34     cxstack_max = cxstack_max * 3 / 2;
  35     Renew(cxstack, cxstack_max + 1, CONTEXT);   /* XXX should fix CXINC macro */
  36     return cxstack_ix + 1;
  37 }
  38
  39 void
  40 push_return(retop)
  41 OP *retop;
  42 {
  43     dTHR;
  44     if (retstack_ix == retstack_max) {
  45         retstack_max = retstack_max * 3 / 2;
  46         Renew(retstack, retstack_max, OP*);
  47     }
  48     retstack[retstack_ix++] = retop;
  49 }
  50
  51 OP *
  52 pop_return()
  53 {
  54     dTHR;
  55     if (retstack_ix > 0)
  56         return retstack[--retstack_ix];
  57     else
  58         return Nullop;
  59 }
  60
  61 void
  62 push_scope()
  63 {
  64     dTHR;
  65     if (scopestack_ix == scopestack_max) {
  66         scopestack_max = scopestack_max * 3 / 2;
  67         Renew(scopestack, scopestack_max, I32);
  68     }
  69     scopestack[scopestack_ix++] = savestack_ix;
  70
  71 }
  72
  73 void
  74 pop_scope()
  75 {
  76     dTHR;
  77     I32 oldsave = scopestack[--scopestack_ix];
  78     LEAVE_SCOPE(oldsave);
  79 }
  80
  81 void
  82 markstack_grow()
  83 {
  84     dTHR;
  85     I32 oldmax = markstack_max - markstack;
  86     I32 newmax = oldmax * 3 / 2;
  87
  88     Renew(markstack, newmax, I32);
  89     markstack_ptr = markstack + oldmax;
  90     markstack_max = markstack + newmax;
  91 }
  92
  93 void
  94 savestack_grow()
  95 {
  96     dTHR;
  97     savestack_max = savestack_max * 3 / 2;
  98     Renew(savestack, savestack_max, ANY);
  99 }
 100
 101 void
 102 free_tmps()
 103 {
 104     dTHR;
 105     /* XXX should tmps_floor live in cxstack? */
 106     I32 myfloor = tmps_floor;
 107     while (tmps_ix > myfloor) {      /* clean up after last statement */
 108         SV* sv = tmps_stack[tmps_ix];
 109         tmps_stack[tmps_ix--] = Nullsv;
 110         if (sv) {
 111 #ifdef DEBUGGING
 112             SvTEMP_off(sv);
 113 #endif
 114             SvREFCNT_dec(sv);           /* note, can modify tmps_ix!!! */
 115         }
 116     }
 117 }
 118
 119 static SV *
 120 save_scalar_at(sptr)
 121 SV **sptr;
 122 {
 123     dTHR;
 124     register SV *sv;
 125     SV *osv = *sptr;
 126
 127     sv = *sptr = NEWSV(0,0);
 128     if (SvTYPE(osv) >= SVt_PVMG && SvMAGIC(osv) && SvTYPE(osv) != SVt_PVGV) {
 129         sv_upgrade(sv, SvTYPE(osv));
 130         if (SvGMAGICAL(osv)) {
 131             MAGIC* mg;
 132             bool oldtainted = tainted;
 133             mg_get(osv);
 134             if (tainting && tainted && (mg = mg_find(osv, 't'))) {
 135                 SAVESPTR(mg->mg_obj);
 136                 mg->mg_obj = osv;
 137             }
 138             SvFLAGS(osv) |= (SvFLAGS(osv) &
 139                 (SVp_IOK|SVp_NOK|SVp_POK)) >> PRIVSHIFT;
 140             tainted = oldtainted;
 141         }
 142         SvMAGIC(sv) = SvMAGIC(osv);
 143         SvFLAGS(sv) |= SvMAGICAL(osv);
 144         localizing = 1;
 145         SvSETMAGIC(sv);
 146         localizing = 0;
 147     }
 148     return sv;
 149 }
 150
 151 SV *
 152 save_scalar(gv)
 153 GV *gv;
 154 {
 155     dTHR;
 156     SSCHECK(3);
 157     SSPUSHPTR(gv);
 158     SSPUSHPTR(GvSV(gv));
 159     SSPUSHINT(SAVEt_SV);
 160     return save_scalar_at(&GvSV(gv));
 161 }
 162
 163 SV*
 164 save_svref(sptr)
 165 SV **sptr;
 166 {
 167     dTHR;
 168     SSCHECK(3);
 169     SSPUSHPTR(sptr);
 170     SSPUSHPTR(*sptr);
 171     SSPUSHINT(SAVEt_SVREF);
 172     return save_scalar_at(sptr);
 173 }
 174
 175 void
 176 save_gp(gv, empty)
 177 GV *gv;
 178 I32 empty;
 179 {
 180     SSCHECK(3);
 181     SSPUSHPTR(SvREFCNT_inc(gv));
 182     SSPUSHPTR(GvGP(gv));
 183     SSPUSHINT(SAVEt_GP);
 184
 185     if (empty) {
 186         register GP *gp;
 187         Newz(602, gp, 1, GP);
 188         GvGP(gv) = gp_ref(gp);
 189         GvSV(gv) = NEWSV(72,0);
 190         GvLINE(gv) = curcop->cop_line;
 191         GvEGV(gv) = gv;
 192     }
 193     else {
 194         gp_ref(GvGP(gv));
 195         GvINTRO_on(gv);
 196     }
 197 }
 198
 199 AV *
 200 save_ary(gv)
 201 GV *gv;
 202 {
 203     dTHR;
 204     SSCHECK(3);
 205     SSPUSHPTR(gv);
 206     SSPUSHPTR(GvAVn(gv));
 207     SSPUSHINT(SAVEt_AV);
 208
 209     GvAV(gv) = Null(AV*);
 210     return GvAVn(gv);
 211 }
 212
 213 HV *
 214 save_hash(gv)
 215 GV *gv;
 216 {
 217     dTHR;
 218     SSCHECK(3);
 219     SSPUSHPTR(gv);
 220     SSPUSHPTR(GvHVn(gv));
 221     SSPUSHINT(SAVEt_HV);
 222
 223     GvHV(gv) = Null(HV*);
 224     return GvHVn(gv);
 225 }
 226
 227 void
 228 save_item(item)
 229 register SV *item;
 230 {
 231     dTHR;
 232     register SV *sv;
 233
 234     SSCHECK(3);
 235     SSPUSHPTR(item);            /* remember the pointer */
 236     sv = NEWSV(0,0);
 237     sv_setsv(sv,item);
 238     SSPUSHPTR(sv);              /* remember the value */
 239     SSPUSHINT(SAVEt_ITEM);
 240 }
 241
 242 void
 243 save_int(intp)
 244 int *intp;
 245 {
 246     dTHR;
 247     SSCHECK(3);
 248     SSPUSHINT(*intp);
 249     SSPUSHPTR(intp);
 250     SSPUSHINT(SAVEt_INT);
 251 }
 252
 253 void
 254 save_long(longp)
 255 long *longp;
 256 {
 257     dTHR;
 258     SSCHECK(3);
 259     SSPUSHLONG(*longp);
 260     SSPUSHPTR(longp);
 261     SSPUSHINT(SAVEt_LONG);
 262 }
 263
 264 void
 265 save_I32(intp)
 266 I32 *intp;
 267 {
 268     dTHR;
 269     SSCHECK(3);
 270     SSPUSHINT(*intp);
 271     SSPUSHPTR(intp);
 272     SSPUSHINT(SAVEt_I32);
 273 }
 274
 275 void
 276 save_I16(intp)
 277 I16 *intp;
 278 {
 279     SSCHECK(3);
 280     SSPUSHINT(*intp);
 281     SSPUSHPTR(intp);
 282     SSPUSHINT(SAVEt_I16);
 283 }
 284
 285 void
 286 save_iv(ivp)
 287 IV *ivp;
 288 {
 289     dTHR;
 290     SSCHECK(3);
 291     SSPUSHIV(*ivp);
 292     SSPUSHPTR(ivp);
 293     SSPUSHINT(SAVEt_IV);
 294 }
 295
 296 /* Cannot use save_sptr() to store a char* since the SV** cast will
 297  * force word-alignment and we'll miss the pointer.
 298  */
 299 void
 300 save_pptr(pptr)
 301 char **pptr;
 302 {
 303     dTHR;
 304     SSCHECK(3);
 305     SSPUSHPTR(*pptr);
 306     SSPUSHPTR(pptr);
 307     SSPUSHINT(SAVEt_PPTR);
 308 }
 309
 310 void
 311 save_sptr(sptr)
 312 SV **sptr;
 313 {
 314     dTHR;
 315     SSCHECK(3);
 316     SSPUSHPTR(*sptr);
 317     SSPUSHPTR(sptr);
 318     SSPUSHINT(SAVEt_SPTR);
 319 }
 320
 321 void
 322 save_nogv(gv)
 323 GV *gv;
 324 {
 325     dTHR;
 326     SSCHECK(2);
 327     SSPUSHPTR(gv);
 328     SSPUSHINT(SAVEt_NSTAB);
 329 }
 330
 331 void
 332 save_hptr(hptr)
 333 HV **hptr;
 334 {
 335     dTHR;
 336     SSCHECK(3);
 337     SSPUSHPTR(*hptr);
 338     SSPUSHPTR(hptr);
 339     SSPUSHINT(SAVEt_HPTR);
 340 }
 341
 342 void
 343 save_aptr(aptr)
 344 AV **aptr;
 345 {
 346     dTHR;
 347     SSCHECK(3);
 348     SSPUSHPTR(*aptr);
 349     SSPUSHPTR(aptr);
 350     SSPUSHINT(SAVEt_APTR);
 351 }
 352
 353 void
 354 save_freesv(sv)
 355 SV *sv;
 356 {
 357     dTHR;
 358     SSCHECK(2);
 359     SSPUSHPTR(sv);
 360     SSPUSHINT(SAVEt_FREESV);
 361 }
 362
 363 void
 364 save_freeop(o)
 365 OP *o;
 366 {
 367     dTHR;
 368     SSCHECK(2);
 369     SSPUSHPTR(o);
 370     SSPUSHINT(SAVEt_FREEOP);
 371 }
 372
 373 void
 374 save_freepv(pv)
 375 char *pv;
 376 {
 377     dTHR;
 378     SSCHECK(2);
 379     SSPUSHPTR(pv);
 380     SSPUSHINT(SAVEt_FREEPV);
 381 }
 382
 383 void
 384 save_clearsv(svp)
 385 SV** svp;
 386 {
 387     dTHR;
 388     SSCHECK(2);
 389     SSPUSHLONG((long)(svp-curpad));
 390     SSPUSHINT(SAVEt_CLEARSV);
 391 }
 392
 393 void
 394 save_delete(hv,key,klen)
 395 HV *hv;
 396 char *key;
 397 I32 klen;
 398 {
 399     dTHR;
 400     SSCHECK(4);
 401     SSPUSHINT(klen);
 402     SSPUSHPTR(key);
 403     SSPUSHPTR(hv);
 404     SSPUSHINT(SAVEt_DELETE);
 405 }
 406
 407 void
 408 save_list(sarg,maxsarg)
 409 register SV **sarg;
 410 I32 maxsarg;
 411 {
 412     dTHR;
 413     register SV *sv;
 414     register I32 i;
 415
 416     SSCHECK(3 * maxsarg);
 417     for (i = 1; i <= maxsarg; i++) {
 418         SSPUSHPTR(sarg[i]);             /* remember the pointer */
 419         sv = NEWSV(0,0);
 420         sv_setsv(sv,sarg[i]);
 421         SSPUSHPTR(sv);                  /* remember the value */
 422         SSPUSHINT(SAVEt_ITEM);
 423     }
 424 }
 425
 426 void
 427 save_destructor(f,p)
 428 void (*f) _((void*));
 429 void* p;
 430 {
 431     dTHR;
 432     SSCHECK(3);
 433     SSPUSHDPTR(f);
 434     SSPUSHPTR(p);
 435     SSPUSHINT(SAVEt_DESTRUCTOR);
 436 }
 437
 438 void
 439 leave_scope(base)
 440 I32 base;
 441 {
 442     dTHR;
 443     register SV *sv;
 444     register SV *value;
 445     register GV *gv;
 446     register AV *av;
 447     register HV *hv;
 448     register void* ptr;
 449
 450     if (base < -1)
 451         croak("panic: corrupt saved stack index");
 452     while (savestack_ix > base) {
 453         switch (SSPOPINT) {
 454         case SAVEt_ITEM:                        /* normal string */
 455             value = (SV*)SSPOPPTR;
 456             sv = (SV*)SSPOPPTR;
 457             sv_replace(sv,value);
 458             localizing = 2;
 459             SvSETMAGIC(sv);
 460             localizing = 0;
 461             break;
 462         case SAVEt_SV:                          /* scalar reference */
 463             value = (SV*)SSPOPPTR;
 464             gv = (GV*)SSPOPPTR;
 465             ptr = &GvSV(gv);
 466             goto restore_sv;
 467         case SAVEt_SVREF:                       /* scalar reference */
 468             value = (SV*)SSPOPPTR;
 469             ptr = SSPOPPTR;
 470         restore_sv:
 471             sv = *(SV**)ptr;
 472             if (SvTYPE(sv) >= SVt_PVMG && SvMAGIC(sv) &&
 473                 SvTYPE(sv) != SVt_PVGV)
 474             {
 475                 (void)SvUPGRADE(value, SvTYPE(sv));
 476                 SvMAGIC(value) = SvMAGIC(sv);
 477                 SvFLAGS(value) |= SvMAGICAL(sv);
 478                 SvMAGICAL_off(sv);
 479                 SvMAGIC(sv) = 0;
 480             }
 481             else if (SvTYPE(value) >= SVt_PVMG && SvMAGIC(value) &&
 482                      SvTYPE(value) != SVt_PVGV)
 483             {
 484                 SvFLAGS(value) |= (SvFLAGS(value) &
 485                                    (SVp_IOK|SVp_NOK|SVp_POK)) >> PRIVSHIFT;
 486                 SvMAGICAL_off(value);
 487                 SvMAGIC(value) = 0;
 488             }
 489             SvREFCNT_dec(sv);
 490             *(SV**)ptr = value;
 491             localizing = 2;
 492             SvSETMAGIC(value);
 493             localizing = 0;
 494             break;
 495         case SAVEt_AV:                          /* array reference */
 496             av = (AV*)SSPOPPTR;
 497             gv = (GV*)SSPOPPTR;
 498             SvREFCNT_dec(GvAV(gv));
 499             GvAV(gv) = av;
 500             break;
 501         case SAVEt_HV:                          /* hash reference */
 502             hv = (HV*)SSPOPPTR;
 503             gv = (GV*)SSPOPPTR;
 504             SvREFCNT_dec(GvHV(gv));
 505             GvHV(gv) = hv;
 506             break;
 507         case SAVEt_INT:                         /* int reference */
 508             ptr = SSPOPPTR;
 509             *(int*)ptr = (int)SSPOPINT;
 510             break;
 511         case SAVEt_LONG:                        /* long reference */
 512             ptr = SSPOPPTR;
 513             *(long*)ptr = (long)SSPOPLONG;
 514             break;
 515         case SAVEt_I32:                         /* I32 reference */
 516             ptr = SSPOPPTR;
 517             *(I32*)ptr = (I32)SSPOPINT;
 518             break;
 519         case SAVEt_I16:                         /* I16 reference */
 520             ptr = SSPOPPTR;
 521             *(I16*)ptr = (I16)SSPOPINT;
 522             break;
 523         case SAVEt_IV:                          /* IV reference */
 524             ptr = SSPOPPTR;
 525             *(IV*)ptr = (IV)SSPOPIV;
 526             break;
 527         case SAVEt_SPTR:                        /* SV* reference */
 528             ptr = SSPOPPTR;
 529             *(SV**)ptr = (SV*)SSPOPPTR;
 530             break;
 531         case SAVEt_PPTR:                        /* char* reference */
 532             ptr = SSPOPPTR;
 533             *(char**)ptr = (char*)SSPOPPTR;
 534             break;
 535         case SAVEt_HPTR:                        /* HV* reference */
 536             ptr = SSPOPPTR;
 537             *(HV**)ptr = (HV*)SSPOPPTR;
 538             break;
 539         case SAVEt_APTR:                        /* AV* reference */
 540             ptr = SSPOPPTR;
 541             *(AV**)ptr = (AV*)SSPOPPTR;
 542             break;
 543         case SAVEt_NSTAB:
 544             gv = (GV*)SSPOPPTR;
 545             (void)sv_clear((SV*)gv);
 546             break;
 547         case SAVEt_GP:                          /* scalar reference */
 548             ptr = SSPOPPTR;
 549             gv = (GV*)SSPOPPTR;
 550             gp_free(gv);
 551             GvGP(gv) = (GP*)ptr;
 552             SvREFCNT_dec(gv);
 553             break;
 554         case SAVEt_FREESV:
 555             ptr = SSPOPPTR;
 556             SvREFCNT_dec((SV*)ptr);
 557             break;
 558         case SAVEt_FREEOP:
 559             ptr = SSPOPPTR;
 560             if (comppad)
 561                 curpad = AvARRAY(comppad);
 562             op_free((OP*)ptr);
 563             break;
 564         case SAVEt_FREEPV:
 565             ptr = SSPOPPTR;
 566             Safefree((char*)ptr);
 567             break;
 568         case SAVEt_CLEARSV:
 569             ptr = (void*)&curpad[SSPOPLONG];
 570             sv = *(SV**)ptr;
 571             if (SvREFCNT(sv) <= 1) { /* Can clear pad variable in place. */
 572                 if (SvTHINKFIRST(sv)) {
 573                     if (SvREADONLY(sv))
 574                         croak("panic: leave_scope clearsv");
 575                     if (SvROK(sv))
 576                         sv_unref(sv);
 577                 }
 578                 if (SvMAGICAL(sv))
 579                     mg_free(sv);
 580
 581                 switch (SvTYPE(sv)) {
 582                 case SVt_NULL:
 583                     break;
 584                 case SVt_PVAV:
 585                     av_clear((AV*)sv);
 586                     break;
 587                 case SVt_PVHV:
 588                     hv_clear((HV*)sv);
 589                     break;
 590                 case SVt_PVCV:
 591                     croak("panic: leave_scope pad code");
 592                 case SVt_RV:
 593                 case SVt_IV:
 594                 case SVt_NV:
 595                     (void)SvOK_off(sv);
 596                     break;
 597                 default:
 598                     (void)SvOK_off(sv);
 599                     (void)SvOOK_off(sv);
 600                     break;
 601                 }
 602             }
 603             else {      /* Someone has a claim on this, so abandon it. */
 604                 U32 padflags = SvFLAGS(sv) & (SVs_PADBUSY|SVs_PADMY|SVs_PADTMP);
 605                 SvREFCNT_dec(sv);       /* Cast current value to the winds. */
 606                 switch (SvTYPE(sv)) {   /* Console ourselves with a new value */
 607                 case SVt_PVAV:  *(SV**)ptr = (SV*)newAV();      break;
 608                 case SVt_PVHV:  *(SV**)ptr = (SV*)newHV();      break;
 609                 default:        *(SV**)ptr = NEWSV(0,0);        break;
 610                 }
 611                 SvFLAGS(*(SV**)ptr) |= padflags; /* preserve pad nature */
 612             }
 613             break;
 614         case SAVEt_DELETE:
 615             ptr = SSPOPPTR;
 616             hv = (HV*)ptr;
 617             ptr = SSPOPPTR;
 618             (void)hv_delete(hv, (char*)ptr, (U32)SSPOPINT, G_DISCARD);
 619             Safefree(ptr);
 620             break;
 621         case SAVEt_DESTRUCTOR:
 622             ptr = SSPOPPTR;
 623             (*SSPOPDPTR)(ptr);
 624             break;
 625         case SAVEt_REGCONTEXT:
 626             {
 627                 I32 delta = SSPOPINT;
 628                 savestack_ix -= delta;  /* regexp must have croaked */
 629             }
 630             break;
 631         case SAVEt_STACK_POS:           /* Position on Perl stack */
 632             {
 633                 I32 delta = SSPOPINT;
 634                 stack_sp = stack_base + delta;
 635             }
 636             break;
 637         default:
 638             croak("panic: leave_scope inconsistency");
 639         }
 640     }
 641 }
 642
 643 #ifdef DEBUGGING
 644
 645 void
 646 cx_dump(cx)
 647 CONTEXT* cx;
 648 {
 649     dTHR;
 650     PerlIO_printf(Perl_debug_log, "CX %d = %s\n", cx - cxstack, block_type[cx->cx_type]);
 651     if (cx->cx_type != CXt_SUBST) {
 652         PerlIO_printf(Perl_debug_log, "BLK_OLDSP = %ld\n", (long)cx->blk_oldsp);
 653         PerlIO_printf(Perl_debug_log, "BLK_OLDCOP = 0x%lx\n", (long)cx->blk_oldcop);
 654         PerlIO_printf(Perl_debug_log, "BLK_OLDMARKSP = %ld\n", (long)cx->blk_oldmarksp);
 655         PerlIO_printf(Perl_debug_log, "BLK_OLDSCOPESP = %ld\n", (long)cx->blk_oldscopesp);
 656         PerlIO_printf(Perl_debug_log, "BLK_OLDRETSP = %ld\n", (long)cx->blk_oldretsp);
 657         PerlIO_printf(Perl_debug_log, "BLK_OLDPM = 0x%lx\n", (long)cx->blk_oldpm);
 658         PerlIO_printf(Perl_debug_log, "BLK_GIMME = %s\n", cx->blk_gimme ? "LIST" : "SCALAR");
 659     }
 660     switch (cx->cx_type) {
 661     case CXt_NULL:
 662     case CXt_BLOCK:
 663         break;
 664     case CXt_SUB:
 665         PerlIO_printf(Perl_debug_log, "BLK_SUB.CV = 0x%lx\n",
 666                 (long)cx->blk_sub.cv);
 667         PerlIO_printf(Perl_debug_log, "BLK_SUB.GV = 0x%lx\n",
 668                 (long)cx->blk_sub.gv);
 669         PerlIO_printf(Perl_debug_log, "BLK_SUB.DFOUTGV = 0x%lx\n",
 670                 (long)cx->blk_sub.dfoutgv);
 671         PerlIO_printf(Perl_debug_log, "BLK_SUB.OLDDEPTH = %ld\n",
 672                 (long)cx->blk_sub.olddepth);
 673         PerlIO_printf(Perl_debug_log, "BLK_SUB.HASARGS = %d\n",
 674                 (int)cx->blk_sub.hasargs);
 675         break;
 676     case CXt_EVAL:
 677         PerlIO_printf(Perl_debug_log, "BLK_EVAL.OLD_IN_EVAL = %ld\n",
 678                 (long)cx->blk_eval.old_in_eval);
 679         PerlIO_printf(Perl_debug_log, "BLK_EVAL.OLD_OP_TYPE = %s (%s)\n",
 680                 op_name[cx->blk_eval.old_op_type],
 681                 op_desc[cx->blk_eval.old_op_type]);
 682         PerlIO_printf(Perl_debug_log, "BLK_EVAL.OLD_NAME = %s\n",
 683                 cx->blk_eval.old_name);
 684         PerlIO_printf(Perl_debug_log, "BLK_EVAL.OLD_EVAL_ROOT = 0x%lx\n",
 685                 (long)cx->blk_eval.old_eval_root);
 686         break;
 687
 688     case CXt_LOOP:
 689         PerlIO_printf(Perl_debug_log, "BLK_LOOP.LABEL = %s\n",
 690                 cx->blk_loop.label);
 691         PerlIO_printf(Perl_debug_log, "BLK_LOOP.RESETSP = %ld\n",
 692                 (long)cx->blk_loop.resetsp);
 693         PerlIO_printf(Perl_debug_log, "BLK_LOOP.REDO_OP = 0x%lx\n",
 694                 (long)cx->blk_loop.redo_op);
 695         PerlIO_printf(Perl_debug_log, "BLK_LOOP.NEXT_OP = 0x%lx\n",
 696                 (long)cx->blk_loop.next_op);
 697         PerlIO_printf(Perl_debug_log, "BLK_LOOP.LAST_OP = 0x%lx\n",
 698                 (long)cx->blk_loop.last_op);
 699         PerlIO_printf(Perl_debug_log, "BLK_LOOP.ITERIX = %ld\n",
 700                 (long)cx->blk_loop.iterix);
 701         PerlIO_printf(Perl_debug_log, "BLK_LOOP.ITERARY = 0x%lx\n",
 702                 (long)cx->blk_loop.iterary);
 703         PerlIO_printf(Perl_debug_log, "BLK_LOOP.ITERVAR = 0x%lx\n",
 704                 (long)cx->blk_loop.itervar);
 705         if (cx->blk_loop.itervar)
 706             PerlIO_printf(Perl_debug_log, "BLK_LOOP.ITERSAVE = 0x%lx\n",
 707                 (long)cx->blk_loop.itersave);
 708         PerlIO_printf(Perl_debug_log, "BLK_LOOP.ITERLVAL = 0x%lx\n",
 709                 (long)cx->blk_loop.iterlval);
 710         break;
 711
 712     case CXt_SUBST:
 713         PerlIO_printf(Perl_debug_log, "SB_ITERS = %ld\n",
 714                 (long)cx->sb_iters);
 715         PerlIO_printf(Perl_debug_log, "SB_MAXITERS = %ld\n",
 716                 (long)cx->sb_maxiters);
 717         PerlIO_printf(Perl_debug_log, "SB_SAFEBASE = %ld\n",
 718                 (long)cx->sb_safebase);
 719         PerlIO_printf(Perl_debug_log, "SB_ONCE = %ld\n",
 720                 (long)cx->sb_once);
 721         PerlIO_printf(Perl_debug_log, "SB_ORIG = %s\n",
 722                 cx->sb_orig);
 723         PerlIO_printf(Perl_debug_log, "SB_DSTR = 0x%lx\n",
 724                 (long)cx->sb_dstr);
 725         PerlIO_printf(Perl_debug_log, "SB_TARG = 0x%lx\n",
 726                 (long)cx->sb_targ);
 727         PerlIO_printf(Perl_debug_log, "SB_S = 0x%lx\n",
 728                 (long)cx->sb_s);
 729         PerlIO_printf(Perl_debug_log, "SB_M = 0x%lx\n",
 730                 (long)cx->sb_m);
 731         PerlIO_printf(Perl_debug_log, "SB_STREND = 0x%lx\n",
 732                 (long)cx->sb_strend);
 733         PerlIO_printf(Perl_debug_log, "SB_RXRES = 0x%lx\n",
 734                 (long)cx->sb_rxres);
 735         break;
 736     }
 737 }
 738 #endif