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