scope.c

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