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