Initial 3-way merge from (5.001m, thr1m, 5.003) plus fixups.
[perl.git] / 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