source: trunk/third/perl/scope.c @ 10724

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