This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Initial check-in of perl compiler.
[perl5.git] / B.xs
1 /*      B.xs
2  *
3  *      Copyright (c) 1996 Malcolm Beattie
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 #include "EXTERN.h"
11 #include "perl.h"
12 #include "XSUB.h"
13 #include "INTERN.h"
14 #include "bytecode.h"
15 #include "byterun.h"
16 #include "ccop.h"
17
18 static char *svclassnames[] = {
19     "B::NULL",
20     "B::IV",
21     "B::NV",
22     "B::RV",
23     "B::PV",
24     "B::PVIV",
25     "B::PVNV",
26     "B::PVMG",
27     "B::BM",
28     "B::PVLV",
29     "B::AV",
30     "B::HV",
31     "B::CV",
32     "B::GV",
33     "B::FM",
34     "B::IO",
35 };
36
37 static SV *
38 make_sv_object(arg, sv)
39 SV *arg;
40 SV *sv;
41 {
42     char *type = 0;
43     IV iv;
44     
45     for (iv = 0; iv < sizeof(specialsv_list)/sizeof(SV*); iv++) {
46         if (sv == specialsv_list[iv]) {
47             type = "B::SPECIAL";
48             break;
49         }
50     }
51     if (!type) {
52         type = svclassnames[SvTYPE(sv)];
53         iv = (IV)sv;
54     }
55     sv_setiv(newSVrv(arg, type), iv);
56     return arg;
57 }
58
59 static SV *
60 make_mg_object(arg, mg)
61 SV *arg;
62 MAGIC *mg;
63 {
64     sv_setiv(newSVrv(arg, "B::MAGIC"), (IV)mg);
65     return arg;
66 }
67
68 static SV *
69 cstring(sv)
70 SV *sv;
71 {
72     SV *sstr = newSVpv("", 0);
73     STRLEN len;
74     char *s;
75
76     if (!SvOK(sv))
77         sv_setpvn(sstr, "0", 1);
78     else
79     {
80         /* XXX Optimise? */
81         s = SvPV(sv, len);
82         sv_catpv(sstr, "\"");
83         for (; len; len--, s++)
84         {
85             /* At least try a little for readability */
86             if (*s == '"')
87                 sv_catpv(sstr, "\\\"");
88             else if (*s == '\\')
89                 sv_catpv(sstr, "\\\\");
90             else if (*s >= ' ' && *s < 127) /* XXX not portable */
91                 sv_catpvn(sstr, s, 1);
92             else if (*s == '\n')
93                 sv_catpv(sstr, "\\n");
94             else if (*s == '\r')
95                 sv_catpv(sstr, "\\r");
96             else if (*s == '\t')
97                 sv_catpv(sstr, "\\t");
98             else if (*s == '\a')
99                 sv_catpv(sstr, "\\a");
100             else if (*s == '\b')
101                 sv_catpv(sstr, "\\b");
102             else if (*s == '\f')
103                 sv_catpv(sstr, "\\f");
104             else if (*s == '\v')
105                 sv_catpv(sstr, "\\v");
106             else
107             {
108                 /* no trigraph support */
109                 char escbuff[5]; /* to fit backslash, 3 octals + trailing \0 */
110                 /* Don't want promotion of a signed -1 char in sprintf args */
111                 unsigned char c = (unsigned char) *s;
112                 sprintf(escbuff, "\\%03o", c);
113                 sv_catpv(sstr, escbuff);
114             }
115             /* XXX Add line breaks if string is long */
116         }
117         sv_catpv(sstr, "\"");
118     }
119     return sstr;
120 }
121
122 static SV *
123 cchar(sv)
124 SV *sv;
125 {
126     SV *sstr = newSVpv("'", 0);
127     char *s = SvPV(sv, na);
128
129     if (*s == '\'')
130         sv_catpv(sstr, "\\'");
131     else if (*s == '\\')
132         sv_catpv(sstr, "\\\\");
133     else if (*s >= ' ' && *s < 127) /* XXX not portable */
134         sv_catpvn(sstr, s, 1);
135     else if (*s == '\n')
136         sv_catpv(sstr, "\\n");
137     else if (*s == '\r')
138         sv_catpv(sstr, "\\r");
139     else if (*s == '\t')
140         sv_catpv(sstr, "\\t");
141     else if (*s == '\a')
142         sv_catpv(sstr, "\\a");
143     else if (*s == '\b')
144         sv_catpv(sstr, "\\b");
145     else if (*s == '\f')
146         sv_catpv(sstr, "\\f");
147     else if (*s == '\v')
148         sv_catpv(sstr, "\\v");
149     else
150     {
151         /* no trigraph support */
152         char escbuff[5]; /* to fit backslash, 3 octals + trailing \0 */
153         /* Don't want promotion of a signed -1 char in sprintf args */
154         unsigned char c = (unsigned char) *s;
155         sprintf(escbuff, "\\%03o", c);
156         sv_catpv(sstr, escbuff);
157     }
158     sv_catpv(sstr, "'");
159     return sstr;
160 }
161
162 void *
163 bset_obj_store(obj, ix)
164 void *obj;
165 I32 ix;
166 {
167     if (ix > obj_list_fill) {
168         if (obj_list_fill == -1)
169             New(666, obj_list, ix + 1, void*);
170         else
171             Renew(obj_list, ix + 1, void*);
172         obj_list_fill = ix;
173     }
174     obj_list[ix] = obj;
175     return obj;
176 }
177
178 #ifdef INDIRECT_BGET_MACROS
179 void freadpv(len, data)
180 U32 len;
181 void *data;
182 {
183     New(666, pv.xpv_pv, len, char);
184     fread(pv.xpv_pv, 1, len, (FILE*)data);
185     pv.xpv_len = len;
186     pv.xpv_cur = len - 1;
187 }
188
189 void byteload_fh(fp)
190 FILE *fp;
191 {
192     struct bytestream bs;
193     bs.data = fp;
194     bs.fgetc = (int(*) _((void*)))fgetc;
195     bs.fread = (int(*) _((char*,size_t,size_t,void*)))fread;
196     bs.freadpv = freadpv;
197     byterun(bs);
198 }
199
200 static int fgetc_fromstring(data)
201 void *data;
202 {
203     char **strp = (char **)data;
204     return *(*strp)++;
205 }
206
207 static int fread_fromstring(argp, elemsize, nelem, data)
208 char *argp;
209 size_t elemsize;
210 size_t nelem;
211 void *data;
212 {
213     char **strp = (char **)data;
214     size_t len = elemsize * nelem;
215     
216     memcpy(argp, *strp, len);
217     *strp += len;
218     return (int)len;
219 }
220
221 static void freadpv_fromstring(len, data)
222 U32 len;
223 void *data;
224 {
225     char **strp = (char **)data;
226     
227     New(666, pv.xpv_pv, len, char);
228     memcpy(pv.xpv_pv, *strp, len);
229     pv.xpv_len = len;
230     pv.xpv_cur = len - 1;
231     *strp += len;
232 }    
233
234 void byteload_string(str)
235 char *str;
236 {
237     struct bytestream bs;
238     bs.data = &str;
239     bs.fgetc = fgetc_fromstring;
240     bs.fread = fread_fromstring;
241     bs.freadpv = freadpv_fromstring;
242     byterun(bs);
243 }
244 #else
245 void byteload_fh(fp)
246 FILE *fp;
247 {
248     byterun(fp);
249 }
250
251 void byteload_string(str)
252 char *str;
253 {
254     croak("Must compile with -DINDIRECT_BGET_MACROS for byteload_string");
255 }    
256 #endif /* INDIRECT_BGET_MACROS */
257
258
259 typedef OP      *B__OP;
260 typedef UNOP    *B__UNOP;
261 typedef BINOP   *B__BINOP;
262 typedef LOGOP   *B__LOGOP;
263 typedef CONDOP  *B__CONDOP;
264 typedef LISTOP  *B__LISTOP;
265 typedef PMOP    *B__PMOP;
266 typedef SVOP    *B__SVOP;
267 typedef GVOP    *B__GVOP;
268 typedef PVOP    *B__PVOP;
269 typedef LOOP    *B__LOOP;
270 typedef COP     *B__COP;
271
272 typedef SV      *B__SV;
273 typedef SV      *B__IV;
274 typedef SV      *B__PV;
275 typedef SV      *B__NV;
276 typedef SV      *B__PVMG;
277 typedef SV      *B__PVLV;
278 typedef SV      *B__BM;
279 typedef SV      *B__RV;
280 typedef AV      *B__AV;
281 typedef HV      *B__HV;
282 typedef CV      *B__CV;
283 typedef GV      *B__GV;
284 typedef IO      *B__IO;
285
286 typedef MAGIC   *B__MAGIC;
287
288 MODULE = B      PACKAGE = B     PREFIX = B_
289
290 PROTOTYPES: DISABLE
291
292 #define B_main_cv()     main_cv
293 #define B_main_root()   main_root
294 #define B_main_start()  main_start
295 #define B_comppadlist() (main_cv ? CvPADLIST(main_cv) : CvPADLIST(compcv))
296 #define B_sv_undef()    &sv_undef
297 #define B_sv_yes()      &sv_yes
298 #define B_sv_no()       &sv_no
299
300 B::CV
301 B_main_cv()
302
303 B::OP
304 B_main_root()
305
306 B::OP
307 B_main_start()
308
309 B::AV
310 B_comppadlist()
311
312 B::SV
313 B_sv_undef()
314
315 B::SV
316 B_sv_yes()
317
318 B::SV
319 B_sv_no()
320
321 MODULE = B      PACKAGE = B
322
323
324 void
325 byteload_fh(fp)
326         FILE *  fp
327
328 void
329 byteload_string(str)
330         char *  str
331
332 #define address(sv) (IV)sv
333
334 IV
335 address(sv)
336         SV *    sv
337
338 B::SV
339 svref_2object(sv)
340         SV *    sv
341     CODE:
342         if (!SvROK(sv))
343             croak("argument is not a reference");
344         RETVAL = (SV*)SvRV(sv);
345     OUTPUT:
346         RETVAL
347
348 void
349 ppname(opnum)
350         int     opnum
351     CODE:
352         ST(0) = sv_newmortal();
353         if (opnum >= 0 && opnum < sizeof(ppnames)/sizeof(char*))
354             sv_setpv(ST(0), ppnames[opnum]);
355
356 void
357 hash(sv)
358         SV *    sv
359     CODE:
360         char *s;
361         STRLEN len;
362         U32 hash = 0;
363         char hexhash[11]; /* must fit "0xffffffff" plus trailing \0 */
364         s = SvPV(sv, len);
365         while (len--)
366             hash = hash * 33 + *s++;
367         sprintf(hexhash, "0x%x", hash);
368         ST(0) = sv_2mortal(newSVpv(hexhash, 0));
369
370 #define cast_I32(foo) (I32)foo
371 IV
372 cast_I32(i)
373         IV      i
374
375 void
376 minus_c()
377     CODE:
378         minus_c = TRUE;
379
380 SV *
381 cstring(sv)
382         SV *    sv
383
384 SV *
385 cchar(sv)
386         SV *    sv
387
388 #define OP_next(o)      o->op_next
389 #define OP_sibling(o)   o->op_sibling
390 #define OP_ppaddr(o)    ppnames[o->op_type]
391 #define OP_targ(o)      o->op_targ
392 #define OP_type(o)      o->op_type
393 #define OP_seq(o)       o->op_seq
394 #define OP_flags(o)     o->op_flags
395 #define OP_private(o)   o->op_private
396
397 MODULE = B      PACKAGE = B::OP         PREFIX = OP_
398
399 B::OP
400 OP_next(o)
401         B::OP           o
402
403 B::OP
404 OP_sibling(o)
405         B::OP           o
406
407 char *
408 OP_ppaddr(o)
409         B::OP           o
410
411 U16
412 OP_targ(o)
413         B::OP           o
414
415 U16
416 OP_type(o)
417         B::OP           o
418
419 U16
420 OP_seq(o)
421         B::OP           o
422
423 U8
424 OP_flags(o)
425         B::OP           o
426
427 U8
428 OP_private(o)
429         B::OP           o
430
431 #define UNOP_first(o)   o->op_first
432
433 MODULE = B      PACKAGE = B::UNOP               PREFIX = UNOP_
434
435 B::OP 
436 UNOP_first(o)
437         B::UNOP o
438
439 #define BINOP_last(o)   o->op_last
440
441 MODULE = B      PACKAGE = B::BINOP              PREFIX = BINOP_
442
443 B::OP
444 BINOP_last(o)
445         B::BINOP        o
446
447 #define LOGOP_other(o)  o->op_other
448
449 MODULE = B      PACKAGE = B::LOGOP              PREFIX = LOGOP_
450
451 B::OP
452 LOGOP_other(o)
453         B::LOGOP        o
454
455 #define CONDOP_true(o)  o->op_true
456 #define CONDOP_false(o) o->op_false
457
458 MODULE = B      PACKAGE = B::CONDOP             PREFIX = CONDOP_
459
460 B::OP
461 CONDOP_true(o)
462         B::CONDOP       o
463
464 B::OP
465 CONDOP_false(o)
466         B::CONDOP       o
467
468 #define LISTOP_children(o)      o->op_children
469
470 MODULE = B      PACKAGE = B::LISTOP             PREFIX = LISTOP_
471
472 U32
473 LISTOP_children(o)
474         B::LISTOP       o
475
476 #define PMOP_pmreplroot(o)      o->op_pmreplroot
477 #define PMOP_pmreplstart(o)     o->op_pmreplstart
478 #define PMOP_pmnext(o)          o->op_pmnext
479 #define PMOP_pmregexp(o)        o->op_pmregexp
480 #define PMOP_pmshort(o)         o->op_pmshort
481 #define PMOP_pmflags(o)         o->op_pmflags
482 #define PMOP_pmpermflags(o)     o->op_pmpermflags
483 #define PMOP_pmslen(o)          o->op_pmslen
484
485 MODULE = B      PACKAGE = B::PMOP               PREFIX = PMOP_
486
487 void
488 PMOP_pmreplroot(o)
489         B::PMOP         o
490         OP *            root = NO_INIT
491     CODE:
492         ST(0) = sv_newmortal();
493         root = o->op_pmreplroot;
494         /* OP_PUSHRE stores an SV* instead of an OP* in op_pmreplroot */
495         if (o->op_type == OP_PUSHRE) {
496             sv_setiv(newSVrv(ST(0), root ?
497                              svclassnames[SvTYPE((SV*)root)] : "B::SV"),
498                      (IV)root);
499         }
500         else {
501             sv_setiv(newSVrv(ST(0), cc_opclassname(root)), (IV)root);
502         }
503
504 B::OP
505 PMOP_pmreplstart(o)
506         B::PMOP         o
507
508 B::PMOP
509 PMOP_pmnext(o)
510         B::PMOP         o
511
512 B::SV
513 PMOP_pmshort(o)
514         B::PMOP         o
515
516 U16
517 PMOP_pmflags(o)
518         B::PMOP         o
519
520 U16
521 PMOP_pmpermflags(o)
522         B::PMOP         o
523
524 U8
525 PMOP_pmslen(o)
526         B::PMOP         o
527
528 void
529 PMOP_precomp(o)
530         B::PMOP         o
531         REGEXP *        rx = NO_INIT
532     CODE:
533         ST(0) = sv_newmortal();
534         rx = o->op_pmregexp;
535         if (rx)
536             sv_setpvn(ST(0), rx->precomp, rx->prelen);
537
538 #define SVOP_sv(o)      o->op_sv
539
540 MODULE = B      PACKAGE = B::SVOP               PREFIX = SVOP_
541
542
543 B::SV
544 SVOP_sv(o)
545         B::SVOP o
546
547 #define GVOP_gv(o)      o->op_gv
548
549 MODULE = B      PACKAGE = B::GVOP               PREFIX = GVOP_
550
551
552 B::GV
553 GVOP_gv(o)
554         B::GVOP o
555
556 MODULE = B      PACKAGE = B::PVOP               PREFIX = PVOP_
557
558 void
559 PVOP_pv(o)
560         B::PVOP o
561     CODE:
562         /*
563          * OP_TRANS uses op_pv to point to a table of 256 shorts
564          * whereas other PVOPs point to a null terminated string.
565          */
566         ST(0) = sv_2mortal(newSVpv(o->op_pv, (o->op_type == OP_TRANS) ?
567                                    256 * sizeof(short) : 0));
568
569 #define LOOP_redoop(o)  o->op_redoop
570 #define LOOP_nextop(o)  o->op_nextop
571 #define LOOP_lastop(o)  o->op_lastop
572
573 MODULE = B      PACKAGE = B::LOOP               PREFIX = LOOP_
574
575
576 B::OP
577 LOOP_redoop(o)
578         B::LOOP o
579
580 B::OP
581 LOOP_nextop(o)
582         B::LOOP o
583
584 B::OP
585 LOOP_lastop(o)
586         B::LOOP o
587
588 #define COP_label(o)    o->cop_label
589 #define COP_stash(o)    o->cop_stash
590 #define COP_filegv(o)   o->cop_filegv
591 #define COP_cop_seq(o)  o->cop_seq
592 #define COP_arybase(o)  o->cop_arybase
593 #define COP_line(o)     o->cop_line
594
595 MODULE = B      PACKAGE = B::COP                PREFIX = COP_
596
597 char *
598 COP_label(o)
599         B::COP  o
600
601 B::HV
602 COP_stash(o)
603         B::COP  o
604
605 B::GV
606 COP_filegv(o)
607         B::COP  o
608
609 U32
610 COP_cop_seq(o)
611         B::COP  o
612
613 I32
614 COP_arybase(o)
615         B::COP  o
616
617 U16
618 COP_line(o)
619         B::COP  o
620
621 MODULE = B      PACKAGE = B::SV         PREFIX = Sv
622
623 U32
624 SvREFCNT(sv)
625         B::SV   sv
626
627 U32
628 SvFLAGS(sv)
629         B::SV   sv
630
631 MODULE = B      PACKAGE = B::IV         PREFIX = Sv
632
633 IV
634 SvIV(sv)
635         B::IV   sv
636
637 IV
638 SvIVX(sv)
639         B::IV   sv
640
641 MODULE = B      PACKAGE = B::IV
642
643 #define needs64bits(sv) ((I32)SvIVX(sv) != SvIVX(sv))
644
645 int
646 needs64bits(sv)
647         B::IV   sv
648
649 void
650 packiv(sv)
651         B::IV   sv
652     CODE:
653         if (sizeof(IV) == 8) {
654             U32 wp[2];
655             IV iv = SvIVX(sv);
656             /*
657              * The following way of spelling 32 is to stop compilers on
658              * 32-bit architectures from moaning about the shift count
659              * being >= the width of the type. Such architectures don't
660              * reach this code anyway (unless sizeof(IV) > 8 but then
661              * everything else breaks too so I'm not fussed at the moment).
662              */
663             wp[0] = htonl(((U32)iv) >> (sizeof(IV)*4));
664             wp[1] = htonl(iv & 0xffffffff);
665             ST(0) = sv_2mortal(newSVpv((char *)wp, 8));
666         } else {
667             U32 w = htonl((U32)SvIVX(sv));
668             ST(0) = sv_2mortal(newSVpv((char *)&w, 4));
669         }
670
671 MODULE = B      PACKAGE = B::NV         PREFIX = Sv
672
673 double
674 SvNV(sv)
675         B::NV   sv
676
677 double
678 SvNVX(sv)
679         B::NV   sv
680
681 MODULE = B      PACKAGE = B::RV         PREFIX = Sv
682
683 B::SV
684 SvRV(sv)
685         B::RV   sv
686
687 MODULE = B      PACKAGE = B::PV         PREFIX = Sv
688
689 void
690 SvPV(sv)
691         B::PV   sv
692     CODE:
693         ST(0) = sv_newmortal();
694         sv_setpvn(ST(0), SvPVX(sv), SvCUR(sv));
695
696 MODULE = B      PACKAGE = B::PVMG       PREFIX = Sv
697
698 void
699 SvMAGIC(sv)
700         B::PVMG sv
701         MAGIC * mg = NO_INIT
702     PPCODE:
703         for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic)
704             XPUSHs(make_mg_object(sv_newmortal(), mg));
705
706 MODULE = B      PACKAGE = B::PVMG
707
708 B::HV
709 SvSTASH(sv)
710         B::PVMG sv
711
712 #define MgMOREMAGIC(mg) mg->mg_moremagic
713 #define MgPRIVATE(mg) mg->mg_private
714 #define MgTYPE(mg) mg->mg_type
715 #define MgFLAGS(mg) mg->mg_flags
716 #define MgOBJ(mg) mg->mg_obj
717
718 MODULE = B      PACKAGE = B::MAGIC      PREFIX = Mg     
719
720 B::MAGIC
721 MgMOREMAGIC(mg)
722         B::MAGIC        mg
723
724 U16
725 MgPRIVATE(mg)
726         B::MAGIC        mg
727
728 char
729 MgTYPE(mg)
730         B::MAGIC        mg
731
732 U8
733 MgFLAGS(mg)
734         B::MAGIC        mg
735
736 B::SV
737 MgOBJ(mg)
738         B::MAGIC        mg
739
740 void
741 MgPTR(mg)
742         B::MAGIC        mg
743     CODE:
744         ST(0) = sv_newmortal();
745         if (mg->mg_ptr)
746             sv_setpvn(ST(0), mg->mg_ptr, mg->mg_len);
747
748 MODULE = B      PACKAGE = B::PVLV       PREFIX = Lv
749
750 U32
751 LvTARGOFF(sv)
752         B::PVLV sv
753
754 U32
755 LvTARGLEN(sv)
756         B::PVLV sv
757
758 char
759 LvTYPE(sv)
760         B::PVLV sv
761
762 B::SV
763 LvTARG(sv)
764         B::PVLV sv
765
766 MODULE = B      PACKAGE = B::BM         PREFIX = Bm
767
768 I32
769 BmUSEFUL(sv)
770         B::BM   sv
771
772 U16
773 BmPREVIOUS(sv)
774         B::BM   sv
775
776 U8
777 BmRARE(sv)
778         B::BM   sv
779
780 void
781 BmTABLE(sv)
782         B::BM   sv
783         STRLEN  len = NO_INIT
784         char *  str = NO_INIT
785     CODE:
786         str = SvPV(sv, len);
787         /* Boyer-Moore table is just after string and its safety-margin \0 */
788         ST(0) = sv_2mortal(newSVpv(str + len + 1, 256));
789
790 MODULE = B      PACKAGE = B::GV         PREFIX = Gv
791
792 void
793 GvNAME(gv)
794         B::GV   gv
795     CODE:
796         ST(0) = sv_2mortal(newSVpv(GvNAME(gv), GvNAMELEN(gv)));
797
798 B::HV
799 GvSTASH(gv)
800         B::GV   gv
801
802 B::SV
803 GvSV(gv)
804         B::GV   gv
805
806 B::IO
807 GvIO(gv)
808         B::GV   gv
809
810 B::CV
811 GvFORM(gv)
812         B::GV   gv
813
814 B::AV
815 GvAV(gv)
816         B::GV   gv
817
818 B::HV
819 GvHV(gv)
820         B::GV   gv
821
822 B::GV
823 GvEGV(gv)
824         B::GV   gv
825
826 B::CV
827 GvCV(gv)
828         B::GV   gv
829
830 U32
831 GvCVGEN(gv)
832         B::GV   gv
833
834 U16
835 GvLINE(gv)
836         B::GV   gv
837
838 B::GV
839 GvFILEGV(gv)
840         B::GV   gv
841
842 MODULE = B      PACKAGE = B::GV
843
844 U32
845 GvREFCNT(gv)
846         B::GV   gv
847
848 U8
849 GvFLAGS(gv)
850         B::GV   gv
851
852 MODULE = B      PACKAGE = B::IO         PREFIX = Io
853
854 long
855 IoLINES(io)
856         B::IO   io
857
858 long
859 IoPAGE(io)
860         B::IO   io
861
862 long
863 IoPAGE_LEN(io)
864         B::IO   io
865
866 long
867 IoLINES_LEFT(io)
868         B::IO   io
869
870 char *
871 IoTOP_NAME(io)
872         B::IO   io
873
874 B::GV
875 IoTOP_GV(io)
876         B::IO   io
877
878 char *
879 IoFMT_NAME(io)
880         B::IO   io
881
882 B::GV
883 IoFMT_GV(io)
884         B::IO   io
885
886 char *
887 IoBOTTOM_NAME(io)
888         B::IO   io
889
890 B::GV
891 IoBOTTOM_GV(io)
892         B::IO   io
893
894 short
895 IoSUBPROCESS(io)
896         B::IO   io
897
898 MODULE = B      PACKAGE = B::IO
899
900 char
901 IoTYPE(io)
902         B::IO   io
903
904 U8
905 IoFLAGS(io)
906         B::IO   io
907
908 MODULE = B      PACKAGE = B::AV         PREFIX = Av
909
910 SSize_t
911 AvFILL(av)
912         B::AV   av
913
914 SSize_t
915 AvMAX(av)
916         B::AV   av
917
918 #define AvOFF(av) ((XPVAV*)SvANY(av))->xof_off
919
920 IV
921 AvOFF(av)
922         B::AV   av
923
924 void
925 AvARRAY(av)
926         B::AV   av
927     PPCODE:
928         if (AvFILL(av) >= 0) {
929             SV **svp = AvARRAY(av);
930             I32 i;
931             for (i = 0; i <= AvFILL(av); i++)
932                 XPUSHs(make_sv_object(sv_newmortal(), svp[i]));
933         }
934
935 MODULE = B      PACKAGE = B::AV
936
937 U8
938 AvFLAGS(av)
939         B::AV   av
940
941 MODULE = B      PACKAGE = B::CV         PREFIX = Cv
942
943 B::HV
944 CvSTASH(cv)
945         B::CV   cv
946
947 B::OP
948 CvSTART(cv)
949         B::CV   cv
950
951 B::OP
952 CvROOT(cv)
953         B::CV   cv
954
955 B::GV
956 CvGV(cv)
957         B::CV   cv
958
959 B::GV
960 CvFILEGV(cv)
961         B::CV   cv
962
963 long
964 CvDEPTH(cv)
965         B::CV   cv
966
967 B::AV
968 CvPADLIST(cv)
969         B::CV   cv
970
971 B::CV
972 CvOUTSIDE(cv)
973         B::CV   cv
974
975 void
976 CvXSUB(cv)
977         B::CV   cv
978     CODE:
979         ST(0) = sv_2mortal(newSViv((IV)CvXSUB(cv)));
980
981
982 void
983 CvXSUBANY(cv)
984         B::CV   cv
985     CODE:
986         ST(0) = sv_2mortal(newSViv(CvXSUBANY(cv).any_iv));
987
988 MODULE = B      PACKAGE = B::HV         PREFIX = Hv
989
990 STRLEN
991 HvFILL(hv)
992         B::HV   hv
993
994 STRLEN
995 HvMAX(hv)
996         B::HV   hv
997
998 I32
999 HvKEYS(hv)
1000         B::HV   hv
1001
1002 I32
1003 HvRITER(hv)
1004         B::HV   hv
1005
1006 char *
1007 HvNAME(hv)
1008         B::HV   hv
1009
1010 B::PMOP
1011 HvPMROOT(hv)
1012         B::HV   hv
1013
1014 void
1015 HvARRAY(hv)
1016         B::HV   hv
1017     PPCODE:
1018         if (HvKEYS(hv) > 0) {
1019             SV *sv;
1020             char *key;
1021             I32 len;
1022             (void)hv_iterinit(hv);
1023             EXTEND(sp, HvKEYS(hv) * 2);
1024             while (sv = hv_iternextsv(hv, &key, &len)) {
1025                 PUSHs(newSVpv(key, len));
1026                 PUSHs(make_sv_object(sv_newmortal(), sv));
1027             }
1028         }