1N/A/* B.xs
1N/A *
1N/A * Copyright (c) 1996 Malcolm Beattie
1N/A *
1N/A * You may distribute under the terms of either the GNU General Public
1N/A * License or the Artistic License, as specified in the README file.
1N/A *
1N/A */
1N/A
1N/A#define PERL_NO_GET_CONTEXT
1N/A#include "EXTERN.h"
1N/A#include "perl.h"
1N/A#include "XSUB.h"
1N/A
1N/A#ifdef PerlIO
1N/Atypedef PerlIO * InputStream;
1N/A#else
1N/Atypedef FILE * InputStream;
1N/A#endif
1N/A
1N/A
1N/Astatic char *svclassnames[] = {
1N/A "B::NULL",
1N/A "B::IV",
1N/A "B::NV",
1N/A "B::RV",
1N/A "B::PV",
1N/A "B::PVIV",
1N/A "B::PVNV",
1N/A "B::PVMG",
1N/A "B::BM",
1N/A "B::PVLV",
1N/A "B::AV",
1N/A "B::HV",
1N/A "B::CV",
1N/A "B::GV",
1N/A "B::FM",
1N/A "B::IO",
1N/A};
1N/A
1N/Atypedef enum {
1N/A OPc_NULL, /* 0 */
1N/A OPc_BASEOP, /* 1 */
1N/A OPc_UNOP, /* 2 */
1N/A OPc_BINOP, /* 3 */
1N/A OPc_LOGOP, /* 4 */
1N/A OPc_LISTOP, /* 5 */
1N/A OPc_PMOP, /* 6 */
1N/A OPc_SVOP, /* 7 */
1N/A OPc_PADOP, /* 8 */
1N/A OPc_PVOP, /* 9 */
1N/A OPc_LOOP, /* 10 */
1N/A OPc_COP /* 11 */
1N/A} opclass;
1N/A
1N/Astatic char *opclassnames[] = {
1N/A "B::NULL",
1N/A "B::OP",
1N/A "B::UNOP",
1N/A "B::BINOP",
1N/A "B::LOGOP",
1N/A "B::LISTOP",
1N/A "B::PMOP",
1N/A "B::SVOP",
1N/A "B::PADOP",
1N/A "B::PVOP",
1N/A "B::LOOP",
1N/A "B::COP"
1N/A};
1N/A
1N/Astatic size_t opsizes[] = {
1N/A 0,
1N/A sizeof(OP),
1N/A sizeof(UNOP),
1N/A sizeof(BINOP),
1N/A sizeof(LOGOP),
1N/A sizeof(LISTOP),
1N/A sizeof(PMOP),
1N/A sizeof(SVOP),
1N/A sizeof(PADOP),
1N/A sizeof(PVOP),
1N/A sizeof(LOOP),
1N/A sizeof(COP)
1N/A};
1N/A
1N/A#define MY_CXT_KEY "B::_guts" XS_VERSION
1N/A
1N/Atypedef struct {
1N/A int x_walkoptree_debug; /* Flag for walkoptree debug hook */
1N/A SV * x_specialsv_list[7];
1N/A} my_cxt_t;
1N/A
1N/ASTART_MY_CXT
1N/A
1N/A#define walkoptree_debug (MY_CXT.x_walkoptree_debug)
1N/A#define specialsv_list (MY_CXT.x_specialsv_list)
1N/A
1N/Astatic opclass
1N/Acc_opclass(pTHX_ OP *o)
1N/A{
1N/A if (!o)
1N/A return OPc_NULL;
1N/A
1N/A if (o->op_type == 0)
1N/A return (o->op_flags & OPf_KIDS) ? OPc_UNOP : OPc_BASEOP;
1N/A
1N/A if (o->op_type == OP_SASSIGN)
1N/A return ((o->op_private & OPpASSIGN_BACKWARDS) ? OPc_UNOP : OPc_BINOP);
1N/A
1N/A#ifdef USE_ITHREADS
1N/A if (o->op_type == OP_GV || o->op_type == OP_GVSV ||
1N/A o->op_type == OP_AELEMFAST || o->op_type == OP_RCATLINE)
1N/A return OPc_PADOP;
1N/A#endif
1N/A
1N/A switch (PL_opargs[o->op_type] & OA_CLASS_MASK) {
1N/A case OA_BASEOP:
1N/A return OPc_BASEOP;
1N/A
1N/A case OA_UNOP:
1N/A return OPc_UNOP;
1N/A
1N/A case OA_BINOP:
1N/A return OPc_BINOP;
1N/A
1N/A case OA_LOGOP:
1N/A return OPc_LOGOP;
1N/A
1N/A case OA_LISTOP:
1N/A return OPc_LISTOP;
1N/A
1N/A case OA_PMOP:
1N/A return OPc_PMOP;
1N/A
1N/A case OA_SVOP:
1N/A return OPc_SVOP;
1N/A
1N/A case OA_PADOP:
1N/A return OPc_PADOP;
1N/A
1N/A case OA_PVOP_OR_SVOP:
1N/A /*
1N/A * Character translations (tr///) are usually a PVOP, keeping a
1N/A * pointer to a table of shorts used to look up translations.
1N/A * Under utf8, however, a simple table isn't practical; instead,
1N/A * the OP is an SVOP, and the SV is a reference to a swash
1N/A * (i.e., an RV pointing to an HV).
1N/A */
1N/A return (o->op_private & (OPpTRANS_TO_UTF|OPpTRANS_FROM_UTF))
1N/A ? OPc_SVOP : OPc_PVOP;
1N/A
1N/A case OA_LOOP:
1N/A return OPc_LOOP;
1N/A
1N/A case OA_COP:
1N/A return OPc_COP;
1N/A
1N/A case OA_BASEOP_OR_UNOP:
1N/A /*
1N/A * UNI(OP_foo) in toke.c returns token UNI or FUNC1 depending on
1N/A * whether parens were seen. perly.y uses OPf_SPECIAL to
1N/A * signal whether a BASEOP had empty parens or none.
1N/A * Some other UNOPs are created later, though, so the best
1N/A * test is OPf_KIDS, which is set in newUNOP.
1N/A */
1N/A return (o->op_flags & OPf_KIDS) ? OPc_UNOP : OPc_BASEOP;
1N/A
1N/A case OA_FILESTATOP:
1N/A /*
1N/A * The file stat OPs are created via UNI(OP_foo) in toke.c but use
1N/A * the OPf_REF flag to distinguish between OP types instead of the
1N/A * usual OPf_SPECIAL flag. As usual, if OPf_KIDS is set, then we
1N/A * return OPc_UNOP so that walkoptree can find our children. If
1N/A * OPf_KIDS is not set then we check OPf_REF. Without OPf_REF set
1N/A * (no argument to the operator) it's an OP; with OPf_REF set it's
1N/A * an SVOP (and op_sv is the GV for the filehandle argument).
1N/A */
1N/A return ((o->op_flags & OPf_KIDS) ? OPc_UNOP :
1N/A#ifdef USE_ITHREADS
1N/A (o->op_flags & OPf_REF) ? OPc_PADOP : OPc_BASEOP);
1N/A#else
1N/A (o->op_flags & OPf_REF) ? OPc_SVOP : OPc_BASEOP);
1N/A#endif
1N/A case OA_LOOPEXOP:
1N/A /*
1N/A * next, last, redo, dump and goto use OPf_SPECIAL to indicate that a
1N/A * label was omitted (in which case it's a BASEOP) or else a term was
1N/A * seen. In this last case, all except goto are definitely PVOP but
1N/A * goto is either a PVOP (with an ordinary constant label), an UNOP
1N/A * with OPf_STACKED (with a non-constant non-sub) or an UNOP for
1N/A * OP_REFGEN (with goto &sub) in which case OPf_STACKED also seems to
1N/A * get set.
1N/A */
1N/A if (o->op_flags & OPf_STACKED)
1N/A return OPc_UNOP;
1N/A else if (o->op_flags & OPf_SPECIAL)
1N/A return OPc_BASEOP;
1N/A else
1N/A return OPc_PVOP;
1N/A }
1N/A warn("can't determine class of operator %s, assuming BASEOP\n",
1N/A PL_op_name[o->op_type]);
1N/A return OPc_BASEOP;
1N/A}
1N/A
1N/Astatic char *
1N/Acc_opclassname(pTHX_ OP *o)
1N/A{
1N/A return opclassnames[cc_opclass(aTHX_ o)];
1N/A}
1N/A
1N/Astatic SV *
1N/Amake_sv_object(pTHX_ SV *arg, SV *sv)
1N/A{
1N/A char *type = 0;
1N/A IV iv;
1N/A dMY_CXT;
1N/A
1N/A for (iv = 0; iv < sizeof(specialsv_list)/sizeof(SV*); iv++) {
1N/A if (sv == specialsv_list[iv]) {
1N/A type = "B::SPECIAL";
1N/A break;
1N/A }
1N/A }
1N/A if (!type) {
1N/A type = svclassnames[SvTYPE(sv)];
1N/A iv = PTR2IV(sv);
1N/A }
1N/A sv_setiv(newSVrv(arg, type), iv);
1N/A return arg;
1N/A}
1N/A
1N/Astatic SV *
1N/Amake_mg_object(pTHX_ SV *arg, MAGIC *mg)
1N/A{
1N/A sv_setiv(newSVrv(arg, "B::MAGIC"), PTR2IV(mg));
1N/A return arg;
1N/A}
1N/A
1N/Astatic SV *
1N/Acstring(pTHX_ SV *sv, bool perlstyle)
1N/A{
1N/A SV *sstr = newSVpvn("", 0);
1N/A STRLEN len;
1N/A char *s;
1N/A char escbuff[5]; /* to fit backslash, 3 octals + trailing \0 */
1N/A
1N/A if (!SvOK(sv))
1N/A sv_setpvn(sstr, "0", 1);
1N/A else if (perlstyle && SvUTF8(sv))
1N/A {
1N/A SV *tmpsv = sv_newmortal(); /* Temporary SV to feed sv_uni_display */
1N/A len = SvCUR(sv);
1N/A s = sv_uni_display(tmpsv, sv, 8*len, UNI_DISPLAY_QQ);
1N/A sv_setpv(sstr,"\"");
1N/A while (*s)
1N/A {
1N/A if (*s == '"')
1N/A sv_catpv(sstr, "\\\"");
1N/A else if (*s == '$')
1N/A sv_catpv(sstr, "\\$");
1N/A else if (*s == '@')
1N/A sv_catpv(sstr, "\\@");
1N/A else if (*s == '\\')
1N/A {
1N/A if (strchr("nrftax\\",*(s+1)))
1N/A sv_catpvn(sstr, s++, 2);
1N/A else
1N/A sv_catpv(sstr, "\\\\");
1N/A }
1N/A else /* should always be printable */
1N/A sv_catpvn(sstr, s, 1);
1N/A ++s;
1N/A }
1N/A sv_catpv(sstr, "\"");
1N/A return sstr;
1N/A }
1N/A else
1N/A {
1N/A /* XXX Optimise? */
1N/A s = SvPV(sv, len);
1N/A sv_catpv(sstr, "\"");
1N/A for (; len; len--, s++)
1N/A {
1N/A /* At least try a little for readability */
1N/A if (*s == '"')
1N/A sv_catpv(sstr, "\\\"");
1N/A else if (*s == '\\')
1N/A sv_catpv(sstr, "\\\\");
1N/A /* trigraphs - bleagh */
1N/A else if (!perlstyle && *s == '?' && len>=3 && s[1] == '?')
1N/A {
1N/A sprintf(escbuff, "\\%03o", '?');
1N/A sv_catpv(sstr, escbuff);
1N/A }
1N/A else if (perlstyle && *s == '$')
1N/A sv_catpv(sstr, "\\$");
1N/A else if (perlstyle && *s == '@')
1N/A sv_catpv(sstr, "\\@");
1N/A#ifdef EBCDIC
1N/A else if (isPRINT(*s))
1N/A#else
1N/A else if (*s >= ' ' && *s < 127)
1N/A#endif /* EBCDIC */
1N/A sv_catpvn(sstr, s, 1);
1N/A else if (*s == '\n')
1N/A sv_catpv(sstr, "\\n");
1N/A else if (*s == '\r')
1N/A sv_catpv(sstr, "\\r");
1N/A else if (*s == '\t')
1N/A sv_catpv(sstr, "\\t");
1N/A else if (*s == '\a')
1N/A sv_catpv(sstr, "\\a");
1N/A else if (*s == '\b')
1N/A sv_catpv(sstr, "\\b");
1N/A else if (*s == '\f')
1N/A sv_catpv(sstr, "\\f");
1N/A else if (!perlstyle && *s == '\v')
1N/A sv_catpv(sstr, "\\v");
1N/A else
1N/A {
1N/A /* Don't want promotion of a signed -1 char in sprintf args */
1N/A unsigned char c = (unsigned char) *s;
1N/A sprintf(escbuff, "\\%03o", c);
1N/A sv_catpv(sstr, escbuff);
1N/A }
1N/A /* XXX Add line breaks if string is long */
1N/A }
1N/A sv_catpv(sstr, "\"");
1N/A }
1N/A return sstr;
1N/A}
1N/A
1N/Astatic SV *
1N/Acchar(pTHX_ SV *sv)
1N/A{
1N/A SV *sstr = newSVpvn("'", 1);
1N/A STRLEN n_a;
1N/A char *s = SvPV(sv, n_a);
1N/A
1N/A if (*s == '\'')
1N/A sv_catpv(sstr, "\\'");
1N/A else if (*s == '\\')
1N/A sv_catpv(sstr, "\\\\");
1N/A#ifdef EBCDIC
1N/A else if (isPRINT(*s))
1N/A#else
1N/A else if (*s >= ' ' && *s < 127)
1N/A#endif /* EBCDIC */
1N/A sv_catpvn(sstr, s, 1);
1N/A else if (*s == '\n')
1N/A sv_catpv(sstr, "\\n");
1N/A else if (*s == '\r')
1N/A sv_catpv(sstr, "\\r");
1N/A else if (*s == '\t')
1N/A sv_catpv(sstr, "\\t");
1N/A else if (*s == '\a')
1N/A sv_catpv(sstr, "\\a");
1N/A else if (*s == '\b')
1N/A sv_catpv(sstr, "\\b");
1N/A else if (*s == '\f')
1N/A sv_catpv(sstr, "\\f");
1N/A else if (*s == '\v')
1N/A sv_catpv(sstr, "\\v");
1N/A else
1N/A {
1N/A /* no trigraph support */
1N/A char escbuff[5]; /* to fit backslash, 3 octals + trailing \0 */
1N/A /* Don't want promotion of a signed -1 char in sprintf args */
1N/A unsigned char c = (unsigned char) *s;
1N/A sprintf(escbuff, "\\%03o", c);
1N/A sv_catpv(sstr, escbuff);
1N/A }
1N/A sv_catpv(sstr, "'");
1N/A return sstr;
1N/A}
1N/A
1N/Avoid
1N/Awalkoptree(pTHX_ SV *opsv, char *method)
1N/A{
1N/A dSP;
1N/A OP *o, *kid;
1N/A dMY_CXT;
1N/A
1N/A if (!SvROK(opsv))
1N/A croak("opsv is not a reference");
1N/A opsv = sv_mortalcopy(opsv);
1N/A o = INT2PTR(OP*,SvIV((SV*)SvRV(opsv)));
1N/A if (walkoptree_debug) {
1N/A PUSHMARK(sp);
1N/A XPUSHs(opsv);
1N/A PUTBACK;
1N/A perl_call_method("walkoptree_debug", G_DISCARD);
1N/A }
1N/A PUSHMARK(sp);
1N/A XPUSHs(opsv);
1N/A PUTBACK;
1N/A perl_call_method(method, G_DISCARD);
1N/A if (o && (o->op_flags & OPf_KIDS)) {
1N/A for (kid = ((UNOP*)o)->op_first; kid; kid = kid->op_sibling) {
1N/A /* Use the same opsv. Rely on methods not to mess it up. */
1N/A sv_setiv(newSVrv(opsv, cc_opclassname(aTHX_ kid)), PTR2IV(kid));
1N/A walkoptree(aTHX_ opsv, method);
1N/A }
1N/A }
1N/A if (o && (cc_opclass(aTHX_ o) == OPc_PMOP)
1N/A && (kid = cPMOPo->op_pmreplroot))
1N/A {
1N/A sv_setiv(newSVrv(opsv, opclassnames[OPc_PMOP]), PTR2IV(kid));
1N/A walkoptree(aTHX_ opsv, method);
1N/A }
1N/A}
1N/A
1N/ASV **
1N/Aoplist(pTHX_ OP *o, SV **SP)
1N/A{
1N/A for(; o; o = o->op_next) {
1N/A SV *opsv;
1N/A if (o->op_seq == 0)
1N/A break;
1N/A o->op_seq = 0;
1N/A opsv = sv_newmortal();
1N/A sv_setiv(newSVrv(opsv, cc_opclassname(aTHX_ (OP*)o)), PTR2IV(o));
1N/A XPUSHs(opsv);
1N/A switch (o->op_type) {
1N/A case OP_SUBST:
1N/A SP = oplist(aTHX_ cPMOPo->op_pmreplstart, SP);
1N/A continue;
1N/A case OP_SORT:
1N/A if (o->op_flags & OPf_STACKED && o->op_flags & OPf_SPECIAL) {
1N/A OP *kid = cLISTOPo->op_first->op_sibling; /* pass pushmark */
1N/A kid = kUNOP->op_first; /* pass rv2gv */
1N/A kid = kUNOP->op_first; /* pass leave */
1N/A SP = oplist(aTHX_ kid->op_next, SP);
1N/A }
1N/A continue;
1N/A }
1N/A switch (PL_opargs[o->op_type] & OA_CLASS_MASK) {
1N/A case OA_LOGOP:
1N/A SP = oplist(aTHX_ cLOGOPo->op_other, SP);
1N/A break;
1N/A case OA_LOOP:
1N/A SP = oplist(aTHX_ cLOOPo->op_lastop, SP);
1N/A SP = oplist(aTHX_ cLOOPo->op_nextop, SP);
1N/A SP = oplist(aTHX_ cLOOPo->op_redoop, SP);
1N/A break;
1N/A }
1N/A }
1N/A return SP;
1N/A}
1N/A
1N/Atypedef OP *B__OP;
1N/Atypedef UNOP *B__UNOP;
1N/Atypedef BINOP *B__BINOP;
1N/Atypedef LOGOP *B__LOGOP;
1N/Atypedef LISTOP *B__LISTOP;
1N/Atypedef PMOP *B__PMOP;
1N/Atypedef SVOP *B__SVOP;
1N/Atypedef PADOP *B__PADOP;
1N/Atypedef PVOP *B__PVOP;
1N/Atypedef LOOP *B__LOOP;
1N/Atypedef COP *B__COP;
1N/A
1N/Atypedef SV *B__SV;
1N/Atypedef SV *B__IV;
1N/Atypedef SV *B__PV;
1N/Atypedef SV *B__NV;
1N/Atypedef SV *B__PVMG;
1N/Atypedef SV *B__PVLV;
1N/Atypedef SV *B__BM;
1N/Atypedef SV *B__RV;
1N/Atypedef SV *B__FM;
1N/Atypedef AV *B__AV;
1N/Atypedef HV *B__HV;
1N/Atypedef CV *B__CV;
1N/Atypedef GV *B__GV;
1N/Atypedef IO *B__IO;
1N/A
1N/Atypedef MAGIC *B__MAGIC;
1N/A
1N/AMODULE = B PACKAGE = B PREFIX = B_
1N/A
1N/APROTOTYPES: DISABLE
1N/A
1N/ABOOT:
1N/A{
1N/A HV *stash = gv_stashpvn("B", 1, TRUE);
1N/A AV *export_ok = perl_get_av("B::EXPORT_OK",TRUE);
1N/A MY_CXT_INIT;
1N/A specialsv_list[0] = Nullsv;
1N/A specialsv_list[1] = &PL_sv_undef;
1N/A specialsv_list[2] = &PL_sv_yes;
1N/A specialsv_list[3] = &PL_sv_no;
1N/A specialsv_list[4] = pWARN_ALL;
1N/A specialsv_list[5] = pWARN_NONE;
1N/A specialsv_list[6] = pWARN_STD;
1N/A#include "defsubs.h"
1N/A}
1N/A
1N/A#define B_main_cv() PL_main_cv
1N/A#define B_init_av() PL_initav
1N/A#define B_inc_gv() PL_incgv
1N/A#define B_check_av() PL_checkav_save
1N/A#define B_begin_av() PL_beginav_save
1N/A#define B_end_av() PL_endav
1N/A#define B_main_root() PL_main_root
1N/A#define B_main_start() PL_main_start
1N/A#define B_amagic_generation() PL_amagic_generation
1N/A#define B_defstash() PL_defstash
1N/A#define B_curstash() PL_curstash
1N/A#define B_dowarn() PL_dowarn
1N/A#define B_comppadlist() (PL_main_cv ? CvPADLIST(PL_main_cv) : CvPADLIST(PL_compcv))
1N/A#define B_sv_undef() &PL_sv_undef
1N/A#define B_sv_yes() &PL_sv_yes
1N/A#define B_sv_no() &PL_sv_no
1N/A#define B_formfeed() PL_formfeed
1N/A#ifdef USE_ITHREADS
1N/A#define B_regex_padav() PL_regex_padav
1N/A#endif
1N/A
1N/AB::AV
1N/AB_init_av()
1N/A
1N/AB::AV
1N/AB_check_av()
1N/A
1N/AB::AV
1N/AB_begin_av()
1N/A
1N/AB::AV
1N/AB_end_av()
1N/A
1N/AB::GV
1N/AB_inc_gv()
1N/A
1N/A#ifdef USE_ITHREADS
1N/A
1N/AB::AV
1N/AB_regex_padav()
1N/A
1N/A#endif
1N/A
1N/AB::CV
1N/AB_main_cv()
1N/A
1N/AB::OP
1N/AB_main_root()
1N/A
1N/AB::OP
1N/AB_main_start()
1N/A
1N/Along
1N/AB_amagic_generation()
1N/A
1N/AB::AV
1N/AB_comppadlist()
1N/A
1N/AB::SV
1N/AB_sv_undef()
1N/A
1N/AB::SV
1N/AB_sv_yes()
1N/A
1N/AB::SV
1N/AB_sv_no()
1N/A
1N/AB::HV
1N/AB_curstash()
1N/A
1N/AB::HV
1N/AB_defstash()
1N/A
1N/AU8
1N/AB_dowarn()
1N/A
1N/AB::SV
1N/AB_formfeed()
1N/A
1N/Avoid
1N/AB_warnhook()
1N/A CODE:
1N/A ST(0) = make_sv_object(aTHX_ sv_newmortal(), PL_warnhook);
1N/A
1N/Avoid
1N/AB_diehook()
1N/A CODE:
1N/A ST(0) = make_sv_object(aTHX_ sv_newmortal(), PL_diehook);
1N/A
1N/AMODULE = B PACKAGE = B
1N/A
1N/Avoid
1N/Awalkoptree(opsv, method)
1N/A SV * opsv
1N/A char * method
1N/A CODE:
1N/A walkoptree(aTHX_ opsv, method);
1N/A
1N/Aint
1N/Awalkoptree_debug(...)
1N/A CODE:
1N/A dMY_CXT;
1N/A RETVAL = walkoptree_debug;
1N/A if (items > 0 && SvTRUE(ST(1)))
1N/A walkoptree_debug = 1;
1N/A OUTPUT:
1N/A RETVAL
1N/A
1N/A#define address(sv) PTR2IV(sv)
1N/A
1N/AIV
1N/Aaddress(sv)
1N/A SV * sv
1N/A
1N/AB::SV
1N/Asvref_2object(sv)
1N/A SV * sv
1N/A CODE:
1N/A if (!SvROK(sv))
1N/A croak("argument is not a reference");
1N/A RETVAL = (SV*)SvRV(sv);
1N/A OUTPUT:
1N/A RETVAL
1N/A
1N/Avoid
1N/Aopnumber(name)
1N/Achar * name
1N/ACODE:
1N/A{
1N/A int i;
1N/A IV result = -1;
1N/A ST(0) = sv_newmortal();
1N/A if (strncmp(name,"pp_",3) == 0)
1N/A name += 3;
1N/A for (i = 0; i < PL_maxo; i++)
1N/A {
1N/A if (strcmp(name, PL_op_name[i]) == 0)
1N/A {
1N/A result = i;
1N/A break;
1N/A }
1N/A }
1N/A sv_setiv(ST(0),result);
1N/A}
1N/A
1N/Avoid
1N/Appname(opnum)
1N/A int opnum
1N/A CODE:
1N/A ST(0) = sv_newmortal();
1N/A if (opnum >= 0 && opnum < PL_maxo) {
1N/A sv_setpvn(ST(0), "pp_", 3);
1N/A sv_catpv(ST(0), PL_op_name[opnum]);
1N/A }
1N/A
1N/Avoid
1N/Ahash(sv)
1N/A SV * sv
1N/A CODE:
1N/A char *s;
1N/A STRLEN len;
1N/A U32 hash = 0;
1N/A char hexhash[19]; /* must fit "0xffffffffffffffff" plus trailing \0 */
1N/A s = SvPV(sv, len);
1N/A PERL_HASH(hash, s, len);
1N/A sprintf(hexhash, "0x%"UVxf, (UV)hash);
1N/A ST(0) = sv_2mortal(newSVpv(hexhash, 0));
1N/A
1N/A#define cast_I32(foo) (I32)foo
1N/AIV
1N/Acast_I32(i)
1N/A IV i
1N/A
1N/Avoid
1N/Aminus_c()
1N/A CODE:
1N/A PL_minus_c = TRUE;
1N/A
1N/Avoid
1N/Asave_BEGINs()
1N/A CODE:
1N/A PL_savebegin = TRUE;
1N/A
1N/ASV *
1N/Acstring(sv)
1N/A SV * sv
1N/A CODE:
1N/A RETVAL = cstring(aTHX_ sv, 0);
1N/A OUTPUT:
1N/A RETVAL
1N/A
1N/ASV *
1N/Aperlstring(sv)
1N/A SV * sv
1N/A CODE:
1N/A RETVAL = cstring(aTHX_ sv, 1);
1N/A OUTPUT:
1N/A RETVAL
1N/A
1N/ASV *
1N/Acchar(sv)
1N/A SV * sv
1N/A CODE:
1N/A RETVAL = cchar(aTHX_ sv);
1N/A OUTPUT:
1N/A RETVAL
1N/A
1N/Avoid
1N/Athreadsv_names()
1N/A PPCODE:
1N/A#ifdef USE_5005THREADS
1N/A int i;
1N/A STRLEN len = strlen(PL_threadsv_names);
1N/A
1N/A EXTEND(sp, len);
1N/A for (i = 0; i < len; i++)
1N/A PUSHs(sv_2mortal(newSVpvn(&PL_threadsv_names[i], 1)));
1N/A#endif
1N/A
1N/A
1N/A#define OP_next(o) o->op_next
1N/A#define OP_sibling(o) o->op_sibling
1N/A#define OP_desc(o) PL_op_desc[o->op_type]
1N/A#define OP_targ(o) o->op_targ
1N/A#define OP_type(o) o->op_type
1N/A#define OP_seq(o) o->op_seq
1N/A#define OP_flags(o) o->op_flags
1N/A#define OP_private(o) o->op_private
1N/A
1N/AMODULE = B PACKAGE = B::OP PREFIX = OP_
1N/A
1N/Asize_t
1N/AOP_size(o)
1N/A B::OP o
1N/A CODE:
1N/A RETVAL = opsizes[cc_opclass(aTHX_ o)];
1N/A OUTPUT:
1N/A RETVAL
1N/A
1N/AB::OP
1N/AOP_next(o)
1N/A B::OP o
1N/A
1N/AB::OP
1N/AOP_sibling(o)
1N/A B::OP o
1N/A
1N/Achar *
1N/AOP_name(o)
1N/A B::OP o
1N/A CODE:
1N/A RETVAL = PL_op_name[o->op_type];
1N/A OUTPUT:
1N/A RETVAL
1N/A
1N/A
1N/Avoid
1N/AOP_ppaddr(o)
1N/A B::OP o
1N/A PREINIT:
1N/A int i;
1N/A SV *sv = sv_newmortal();
1N/A CODE:
1N/A sv_setpvn(sv, "PL_ppaddr[OP_", 13);
1N/A sv_catpv(sv, PL_op_name[o->op_type]);
1N/A for (i=13; (STRLEN)i < SvCUR(sv); ++i)
1N/A SvPVX(sv)[i] = toUPPER(SvPVX(sv)[i]);
1N/A sv_catpv(sv, "]");
1N/A ST(0) = sv;
1N/A
1N/Achar *
1N/AOP_desc(o)
1N/A B::OP o
1N/A
1N/APADOFFSET
1N/AOP_targ(o)
1N/A B::OP o
1N/A
1N/AU16
1N/AOP_type(o)
1N/A B::OP o
1N/A
1N/AU16
1N/AOP_seq(o)
1N/A B::OP o
1N/A
1N/AU8
1N/AOP_flags(o)
1N/A B::OP o
1N/A
1N/AU8
1N/AOP_private(o)
1N/A B::OP o
1N/A
1N/Avoid
1N/AOP_oplist(o)
1N/A B::OP o
1N/A PPCODE:
1N/A SP = oplist(aTHX_ o, SP);
1N/A
1N/A#define UNOP_first(o) o->op_first
1N/A
1N/AMODULE = B PACKAGE = B::UNOP PREFIX = UNOP_
1N/A
1N/AB::OP
1N/AUNOP_first(o)
1N/A B::UNOP o
1N/A
1N/A#define BINOP_last(o) o->op_last
1N/A
1N/AMODULE = B PACKAGE = B::BINOP PREFIX = BINOP_
1N/A
1N/AB::OP
1N/ABINOP_last(o)
1N/A B::BINOP o
1N/A
1N/A#define LOGOP_other(o) o->op_other
1N/A
1N/AMODULE = B PACKAGE = B::LOGOP PREFIX = LOGOP_
1N/A
1N/AB::OP
1N/ALOGOP_other(o)
1N/A B::LOGOP o
1N/A
1N/AMODULE = B PACKAGE = B::LISTOP PREFIX = LISTOP_
1N/A
1N/AU32
1N/ALISTOP_children(o)
1N/A B::LISTOP o
1N/A OP * kid = NO_INIT
1N/A int i = NO_INIT
1N/A CODE:
1N/A i = 0;
1N/A for (kid = o->op_first; kid; kid = kid->op_sibling)
1N/A i++;
1N/A RETVAL = i;
1N/A OUTPUT:
1N/A RETVAL
1N/A
1N/A#define PMOP_pmreplroot(o) o->op_pmreplroot
1N/A#define PMOP_pmreplstart(o) o->op_pmreplstart
1N/A#define PMOP_pmnext(o) o->op_pmnext
1N/A#define PMOP_pmregexp(o) PM_GETRE(o)
1N/A#ifdef USE_ITHREADS
1N/A#define PMOP_pmoffset(o) o->op_pmoffset
1N/A#define PMOP_pmstashpv(o) o->op_pmstashpv
1N/A#else
1N/A#define PMOP_pmstash(o) o->op_pmstash
1N/A#endif
1N/A#define PMOP_pmflags(o) o->op_pmflags
1N/A#define PMOP_pmpermflags(o) o->op_pmpermflags
1N/A#define PMOP_pmdynflags(o) o->op_pmdynflags
1N/A
1N/AMODULE = B PACKAGE = B::PMOP PREFIX = PMOP_
1N/A
1N/Avoid
1N/APMOP_pmreplroot(o)
1N/A B::PMOP o
1N/A OP * root = NO_INIT
1N/A CODE:
1N/A ST(0) = sv_newmortal();
1N/A root = o->op_pmreplroot;
1N/A /* OP_PUSHRE stores an SV* instead of an OP* in op_pmreplroot */
1N/A if (o->op_type == OP_PUSHRE) {
1N/A#ifdef USE_ITHREADS
1N/A sv_setiv(ST(0), INT2PTR(PADOFFSET,root) );
1N/A#else
1N/A sv_setiv(newSVrv(ST(0), root ?
1N/A svclassnames[SvTYPE((SV*)root)] : "B::SV"),
1N/A PTR2IV(root));
1N/A#endif
1N/A }
1N/A else {
1N/A sv_setiv(newSVrv(ST(0), cc_opclassname(aTHX_ root)), PTR2IV(root));
1N/A }
1N/A
1N/AB::OP
1N/APMOP_pmreplstart(o)
1N/A B::PMOP o
1N/A
1N/AB::PMOP
1N/APMOP_pmnext(o)
1N/A B::PMOP o
1N/A
1N/A#ifdef USE_ITHREADS
1N/A
1N/AIV
1N/APMOP_pmoffset(o)
1N/A B::PMOP o
1N/A
1N/Achar*
1N/APMOP_pmstashpv(o)
1N/A B::PMOP o
1N/A
1N/A#else
1N/A
1N/AB::HV
1N/APMOP_pmstash(o)
1N/A B::PMOP o
1N/A
1N/A#endif
1N/A
1N/AU32
1N/APMOP_pmflags(o)
1N/A B::PMOP o
1N/A
1N/AU32
1N/APMOP_pmpermflags(o)
1N/A B::PMOP o
1N/A
1N/AU8
1N/APMOP_pmdynflags(o)
1N/A B::PMOP o
1N/A
1N/Avoid
1N/APMOP_precomp(o)
1N/A B::PMOP o
1N/A REGEXP * rx = NO_INIT
1N/A CODE:
1N/A ST(0) = sv_newmortal();
1N/A rx = PM_GETRE(o);
1N/A if (rx)
1N/A sv_setpvn(ST(0), rx->precomp, rx->prelen);
1N/A
1N/A#define SVOP_sv(o) cSVOPo->op_sv
1N/A#define SVOP_gv(o) ((GV*)cSVOPo->op_sv)
1N/A
1N/AMODULE = B PACKAGE = B::SVOP PREFIX = SVOP_
1N/A
1N/AB::SV
1N/ASVOP_sv(o)
1N/A B::SVOP o
1N/A
1N/AB::GV
1N/ASVOP_gv(o)
1N/A B::SVOP o
1N/A
1N/A#define PADOP_padix(o) o->op_padix
1N/A#define PADOP_sv(o) (o->op_padix ? PAD_SVl(o->op_padix) : Nullsv)
1N/A#define PADOP_gv(o) ((o->op_padix \
1N/A && SvTYPE(PAD_SVl(o->op_padix)) == SVt_PVGV) \
1N/A ? (GV*)PAD_SVl(o->op_padix) : Nullgv)
1N/A
1N/AMODULE = B PACKAGE = B::PADOP PREFIX = PADOP_
1N/A
1N/APADOFFSET
1N/APADOP_padix(o)
1N/A B::PADOP o
1N/A
1N/AB::SV
1N/APADOP_sv(o)
1N/A B::PADOP o
1N/A
1N/AB::GV
1N/APADOP_gv(o)
1N/A B::PADOP o
1N/A
1N/AMODULE = B PACKAGE = B::PVOP PREFIX = PVOP_
1N/A
1N/Avoid
1N/APVOP_pv(o)
1N/A B::PVOP o
1N/A CODE:
1N/A /*
1N/A * OP_TRANS uses op_pv to point to a table of 256 or >=258 shorts
1N/A * whereas other PVOPs point to a null terminated string.
1N/A */
1N/A if (o->op_type == OP_TRANS &&
1N/A (o->op_private & OPpTRANS_COMPLEMENT) &&
1N/A !(o->op_private & OPpTRANS_DELETE))
1N/A {
1N/A short* tbl = (short*)o->op_pv;
1N/A short entries = 257 + tbl[256];
1N/A ST(0) = sv_2mortal(newSVpv(o->op_pv, entries * sizeof(short)));
1N/A }
1N/A else if (o->op_type == OP_TRANS) {
1N/A ST(0) = sv_2mortal(newSVpv(o->op_pv, 256 * sizeof(short)));
1N/A }
1N/A else
1N/A ST(0) = sv_2mortal(newSVpv(o->op_pv, 0));
1N/A
1N/A#define LOOP_redoop(o) o->op_redoop
1N/A#define LOOP_nextop(o) o->op_nextop
1N/A#define LOOP_lastop(o) o->op_lastop
1N/A
1N/AMODULE = B PACKAGE = B::LOOP PREFIX = LOOP_
1N/A
1N/A
1N/AB::OP
1N/ALOOP_redoop(o)
1N/A B::LOOP o
1N/A
1N/AB::OP
1N/ALOOP_nextop(o)
1N/A B::LOOP o
1N/A
1N/AB::OP
1N/ALOOP_lastop(o)
1N/A B::LOOP o
1N/A
1N/A#define COP_label(o) o->cop_label
1N/A#define COP_stashpv(o) CopSTASHPV(o)
1N/A#define COP_stash(o) CopSTASH(o)
1N/A#define COP_file(o) CopFILE(o)
1N/A#define COP_filegv(o) CopFILEGV(o)
1N/A#define COP_cop_seq(o) o->cop_seq
1N/A#define COP_arybase(o) o->cop_arybase
1N/A#define COP_line(o) CopLINE(o)
1N/A#define COP_warnings(o) o->cop_warnings
1N/A#define COP_io(o) o->cop_io
1N/A
1N/AMODULE = B PACKAGE = B::COP PREFIX = COP_
1N/A
1N/Achar *
1N/ACOP_label(o)
1N/A B::COP o
1N/A
1N/Achar *
1N/ACOP_stashpv(o)
1N/A B::COP o
1N/A
1N/AB::HV
1N/ACOP_stash(o)
1N/A B::COP o
1N/A
1N/Achar *
1N/ACOP_file(o)
1N/A B::COP o
1N/A
1N/AB::GV
1N/ACOP_filegv(o)
1N/A B::COP o
1N/A
1N/A
1N/AU32
1N/ACOP_cop_seq(o)
1N/A B::COP o
1N/A
1N/AI32
1N/ACOP_arybase(o)
1N/A B::COP o
1N/A
1N/AU32
1N/ACOP_line(o)
1N/A B::COP o
1N/A
1N/AB::SV
1N/ACOP_warnings(o)
1N/A B::COP o
1N/A
1N/AB::SV
1N/ACOP_io(o)
1N/A B::COP o
1N/A
1N/AMODULE = B PACKAGE = B::SV
1N/A
1N/AU32
1N/ASvTYPE(sv)
1N/A B::SV sv
1N/A
1N/A#define object_2svref(sv) sv
1N/A#define SVREF SV *
1N/A
1N/ASVREF
1N/Aobject_2svref(sv)
1N/A B::SV sv
1N/A
1N/AMODULE = B PACKAGE = B::SV PREFIX = Sv
1N/A
1N/AU32
1N/ASvREFCNT(sv)
1N/A B::SV sv
1N/A
1N/AU32
1N/ASvFLAGS(sv)
1N/A B::SV sv
1N/A
1N/AU32
1N/ASvPOK(sv)
1N/A B::SV sv
1N/A
1N/AU32
1N/ASvROK(sv)
1N/A B::SV sv
1N/A
1N/AU32
1N/ASvMAGICAL(sv)
1N/A B::SV sv
1N/A
1N/AMODULE = B PACKAGE = B::IV PREFIX = Sv
1N/A
1N/AIV
1N/ASvIV(sv)
1N/A B::IV sv
1N/A
1N/AIV
1N/ASvIVX(sv)
1N/A B::IV sv
1N/A
1N/AUV
1N/ASvUVX(sv)
1N/A B::IV sv
1N/A
1N/A
1N/AMODULE = B PACKAGE = B::IV
1N/A
1N/A#define needs64bits(sv) ((I32)SvIVX(sv) != SvIVX(sv))
1N/A
1N/Aint
1N/Aneeds64bits(sv)
1N/A B::IV sv
1N/A
1N/Avoid
1N/Apackiv(sv)
1N/A B::IV sv
1N/A CODE:
1N/A if (sizeof(IV) == 8) {
1N/A U32 wp[2];
1N/A IV iv = SvIVX(sv);
1N/A /*
1N/A * The following way of spelling 32 is to stop compilers on
1N/A * 32-bit architectures from moaning about the shift count
1N/A * being >= the width of the type. Such architectures don't
1N/A * reach this code anyway (unless sizeof(IV) > 8 but then
1N/A * everything else breaks too so I'm not fussed at the moment).
1N/A */
1N/A#ifdef UV_IS_QUAD
1N/A wp[0] = htonl(((UV)iv) >> (sizeof(UV)*4));
1N/A#else
1N/A wp[0] = htonl(((U32)iv) >> (sizeof(UV)*4));
1N/A#endif
1N/A wp[1] = htonl(iv & 0xffffffff);
1N/A ST(0) = sv_2mortal(newSVpvn((char *)wp, 8));
1N/A } else {
1N/A U32 w = htonl((U32)SvIVX(sv));
1N/A ST(0) = sv_2mortal(newSVpvn((char *)&w, 4));
1N/A }
1N/A
1N/AMODULE = B PACKAGE = B::NV PREFIX = Sv
1N/A
1N/ANV
1N/ASvNV(sv)
1N/A B::NV sv
1N/A
1N/ANV
1N/ASvNVX(sv)
1N/A B::NV sv
1N/A
1N/AMODULE = B PACKAGE = B::RV PREFIX = Sv
1N/A
1N/AB::SV
1N/ASvRV(sv)
1N/A B::RV sv
1N/A
1N/AMODULE = B PACKAGE = B::PV PREFIX = Sv
1N/A
1N/Achar*
1N/ASvPVX(sv)
1N/A B::PV sv
1N/A
1N/AB::SV
1N/ASvRV(sv)
1N/A B::PV sv
1N/A CODE:
1N/A if( SvROK(sv) ) {
1N/A RETVAL = SvRV(sv);
1N/A }
1N/A else {
1N/A croak( "argument is not SvROK" );
1N/A }
1N/A OUTPUT:
1N/A RETVAL
1N/A
1N/Avoid
1N/ASvPV(sv)
1N/A B::PV sv
1N/A CODE:
1N/A ST(0) = sv_newmortal();
1N/A if( SvPOK(sv) ) {
1N/A sv_setpvn(ST(0), SvPVX(sv), SvCUR(sv));
1N/A SvFLAGS(ST(0)) |= SvUTF8(sv);
1N/A }
1N/A else {
1N/A /* XXX for backward compatibility, but should fail */
1N/A /* croak( "argument is not SvPOK" ); */
1N/A sv_setpvn(ST(0), NULL, 0);
1N/A }
1N/A
1N/Avoid
1N/ASvPVBM(sv)
1N/A B::PV sv
1N/A CODE:
1N/A ST(0) = sv_newmortal();
1N/A sv_setpvn(ST(0), SvPVX(sv),
1N/A SvCUR(sv) + (SvTYPE(sv) == SVt_PVBM ? 257 : 0));
1N/A
1N/A
1N/ASTRLEN
1N/ASvLEN(sv)
1N/A B::PV sv
1N/A
1N/ASTRLEN
1N/ASvCUR(sv)
1N/A B::PV sv
1N/A
1N/AMODULE = B PACKAGE = B::PVMG PREFIX = Sv
1N/A
1N/Avoid
1N/ASvMAGIC(sv)
1N/A B::PVMG sv
1N/A MAGIC * mg = NO_INIT
1N/A PPCODE:
1N/A for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic)
1N/A XPUSHs(make_mg_object(aTHX_ sv_newmortal(), mg));
1N/A
1N/AMODULE = B PACKAGE = B::PVMG
1N/A
1N/AB::HV
1N/ASvSTASH(sv)
1N/A B::PVMG sv
1N/A
1N/A#define MgMOREMAGIC(mg) mg->mg_moremagic
1N/A#define MgPRIVATE(mg) mg->mg_private
1N/A#define MgTYPE(mg) mg->mg_type
1N/A#define MgFLAGS(mg) mg->mg_flags
1N/A#define MgOBJ(mg) mg->mg_obj
1N/A#define MgLENGTH(mg) mg->mg_len
1N/A#define MgREGEX(mg) PTR2IV(mg->mg_obj)
1N/A
1N/AMODULE = B PACKAGE = B::MAGIC PREFIX = Mg
1N/A
1N/AB::MAGIC
1N/AMgMOREMAGIC(mg)
1N/A B::MAGIC mg
1N/A CODE:
1N/A if( MgMOREMAGIC(mg) ) {
1N/A RETVAL = MgMOREMAGIC(mg);
1N/A }
1N/A else {
1N/A XSRETURN_UNDEF;
1N/A }
1N/A OUTPUT:
1N/A RETVAL
1N/A
1N/AU16
1N/AMgPRIVATE(mg)
1N/A B::MAGIC mg
1N/A
1N/Achar
1N/AMgTYPE(mg)
1N/A B::MAGIC mg
1N/A
1N/AU8
1N/AMgFLAGS(mg)
1N/A B::MAGIC mg
1N/A
1N/AB::SV
1N/AMgOBJ(mg)
1N/A B::MAGIC mg
1N/A
1N/AIV
1N/AMgREGEX(mg)
1N/A B::MAGIC mg
1N/A CODE:
1N/A if( mg->mg_type == 'r' ) {
1N/A RETVAL = MgREGEX(mg);
1N/A }
1N/A else {
1N/A croak( "REGEX is only meaningful on r-magic" );
1N/A }
1N/A OUTPUT:
1N/A RETVAL
1N/A
1N/ASV*
1N/Aprecomp(mg)
1N/A B::MAGIC mg
1N/A CODE:
1N/A if (mg->mg_type == 'r') {
1N/A REGEXP* rx = (REGEXP*)mg->mg_obj;
1N/A if( rx )
1N/A RETVAL = newSVpvn( rx->precomp, rx->prelen );
1N/A }
1N/A else {
1N/A croak( "precomp is only meaningful on r-magic" );
1N/A }
1N/A OUTPUT:
1N/A RETVAL
1N/A
1N/AI32
1N/AMgLENGTH(mg)
1N/A B::MAGIC mg
1N/A
1N/Avoid
1N/AMgPTR(mg)
1N/A B::MAGIC mg
1N/A CODE:
1N/A ST(0) = sv_newmortal();
1N/A if (mg->mg_ptr){
1N/A if (mg->mg_len >= 0){
1N/A sv_setpvn(ST(0), mg->mg_ptr, mg->mg_len);
1N/A } else if (mg->mg_len == HEf_SVKEY) {
1N/A ST(0) = make_sv_object(aTHX_
1N/A sv_newmortal(), (SV*)mg->mg_ptr);
1N/A }
1N/A }
1N/A
1N/AMODULE = B PACKAGE = B::PVLV PREFIX = Lv
1N/A
1N/AU32
1N/ALvTARGOFF(sv)
1N/A B::PVLV sv
1N/A
1N/AU32
1N/ALvTARGLEN(sv)
1N/A B::PVLV sv
1N/A
1N/Achar
1N/ALvTYPE(sv)
1N/A B::PVLV sv
1N/A
1N/AB::SV
1N/ALvTARG(sv)
1N/A B::PVLV sv
1N/A
1N/AMODULE = B PACKAGE = B::BM PREFIX = Bm
1N/A
1N/AI32
1N/ABmUSEFUL(sv)
1N/A B::BM sv
1N/A
1N/AU16
1N/ABmPREVIOUS(sv)
1N/A B::BM sv
1N/A
1N/AU8
1N/ABmRARE(sv)
1N/A B::BM sv
1N/A
1N/Avoid
1N/ABmTABLE(sv)
1N/A B::BM sv
1N/A STRLEN len = NO_INIT
1N/A char * str = NO_INIT
1N/A CODE:
1N/A str = SvPV(sv, len);
1N/A /* Boyer-Moore table is just after string and its safety-margin \0 */
1N/A ST(0) = sv_2mortal(newSVpvn(str + len + 1, 256));
1N/A
1N/AMODULE = B PACKAGE = B::GV PREFIX = Gv
1N/A
1N/Avoid
1N/AGvNAME(gv)
1N/A B::GV gv
1N/A CODE:
1N/A ST(0) = sv_2mortal(newSVpvn(GvNAME(gv), GvNAMELEN(gv)));
1N/A
1N/Abool
1N/Ais_empty(gv)
1N/A B::GV gv
1N/A CODE:
1N/A RETVAL = GvGP(gv) == Null(GP*);
1N/A OUTPUT:
1N/A RETVAL
1N/A
1N/Avoid*
1N/AGvGP(gv)
1N/A B::GV gv
1N/A
1N/AB::HV
1N/AGvSTASH(gv)
1N/A B::GV gv
1N/A
1N/AB::SV
1N/AGvSV(gv)
1N/A B::GV gv
1N/A
1N/AB::IO
1N/AGvIO(gv)
1N/A B::GV gv
1N/A
1N/AB::FM
1N/AGvFORM(gv)
1N/A B::GV gv
1N/A CODE:
1N/A RETVAL = (SV*)GvFORM(gv);
1N/A OUTPUT:
1N/A RETVAL
1N/A
1N/AB::AV
1N/AGvAV(gv)
1N/A B::GV gv
1N/A
1N/AB::HV
1N/AGvHV(gv)
1N/A B::GV gv
1N/A
1N/AB::GV
1N/AGvEGV(gv)
1N/A B::GV gv
1N/A
1N/AB::CV
1N/AGvCV(gv)
1N/A B::GV gv
1N/A
1N/AU32
1N/AGvCVGEN(gv)
1N/A B::GV gv
1N/A
1N/AU32
1N/AGvLINE(gv)
1N/A B::GV gv
1N/A
1N/Achar *
1N/AGvFILE(gv)
1N/A B::GV gv
1N/A
1N/AB::GV
1N/AGvFILEGV(gv)
1N/A B::GV gv
1N/A
1N/AMODULE = B PACKAGE = B::GV
1N/A
1N/AU32
1N/AGvREFCNT(gv)
1N/A B::GV gv
1N/A
1N/AU8
1N/AGvFLAGS(gv)
1N/A B::GV gv
1N/A
1N/AMODULE = B PACKAGE = B::IO PREFIX = Io
1N/A
1N/Along
1N/AIoLINES(io)
1N/A B::IO io
1N/A
1N/Along
1N/AIoPAGE(io)
1N/A B::IO io
1N/A
1N/Along
1N/AIoPAGE_LEN(io)
1N/A B::IO io
1N/A
1N/Along
1N/AIoLINES_LEFT(io)
1N/A B::IO io
1N/A
1N/Achar *
1N/AIoTOP_NAME(io)
1N/A B::IO io
1N/A
1N/AB::GV
1N/AIoTOP_GV(io)
1N/A B::IO io
1N/A
1N/Achar *
1N/AIoFMT_NAME(io)
1N/A B::IO io
1N/A
1N/AB::GV
1N/AIoFMT_GV(io)
1N/A B::IO io
1N/A
1N/Achar *
1N/AIoBOTTOM_NAME(io)
1N/A B::IO io
1N/A
1N/AB::GV
1N/AIoBOTTOM_GV(io)
1N/A B::IO io
1N/A
1N/Ashort
1N/AIoSUBPROCESS(io)
1N/A B::IO io
1N/A
1N/Abool
1N/AIsSTD(io,name)
1N/A B::IO io
1N/A char* name
1N/A PREINIT:
1N/A PerlIO* handle = 0;
1N/A CODE:
1N/A if( strEQ( name, "stdin" ) ) {
1N/A handle = PerlIO_stdin();
1N/A }
1N/A else if( strEQ( name, "stdout" ) ) {
1N/A handle = PerlIO_stdout();
1N/A }
1N/A else if( strEQ( name, "stderr" ) ) {
1N/A handle = PerlIO_stderr();
1N/A }
1N/A else {
1N/A croak( "Invalid value '%s'", name );
1N/A }
1N/A RETVAL = handle == IoIFP(io);
1N/A OUTPUT:
1N/A RETVAL
1N/A
1N/AMODULE = B PACKAGE = B::IO
1N/A
1N/Achar
1N/AIoTYPE(io)
1N/A B::IO io
1N/A
1N/AU8
1N/AIoFLAGS(io)
1N/A B::IO io
1N/A
1N/AMODULE = B PACKAGE = B::AV PREFIX = Av
1N/A
1N/ASSize_t
1N/AAvFILL(av)
1N/A B::AV av
1N/A
1N/ASSize_t
1N/AAvMAX(av)
1N/A B::AV av
1N/A
1N/A#define AvOFF(av) ((XPVAV*)SvANY(av))->xof_off
1N/A
1N/AIV
1N/AAvOFF(av)
1N/A B::AV av
1N/A
1N/Avoid
1N/AAvARRAY(av)
1N/A B::AV av
1N/A PPCODE:
1N/A if (AvFILL(av) >= 0) {
1N/A SV **svp = AvARRAY(av);
1N/A I32 i;
1N/A for (i = 0; i <= AvFILL(av); i++)
1N/A XPUSHs(make_sv_object(aTHX_ sv_newmortal(), svp[i]));
1N/A }
1N/A
1N/Avoid
1N/AAvARRAYelt(av, idx)
1N/A B::AV av
1N/A int idx
1N/A PPCODE:
1N/A if (idx >= 0 && AvFILL(av) >= 0 && idx <= AvFILL(av))
1N/A XPUSHs(make_sv_object(aTHX_ sv_newmortal(), (AvARRAY(av)[idx])));
1N/A else
1N/A XPUSHs(make_sv_object(aTHX_ sv_newmortal(), NULL));
1N/A
1N/A
1N/AMODULE = B PACKAGE = B::AV
1N/A
1N/AU8
1N/AAvFLAGS(av)
1N/A B::AV av
1N/A
1N/AMODULE = B PACKAGE = B::FM PREFIX = Fm
1N/A
1N/AIV
1N/AFmLINES(form)
1N/A B::FM form
1N/A
1N/AMODULE = B PACKAGE = B::CV PREFIX = Cv
1N/A
1N/AU32
1N/ACvCONST(cv)
1N/A B::CV cv
1N/A
1N/AB::HV
1N/ACvSTASH(cv)
1N/A B::CV cv
1N/A
1N/AB::OP
1N/ACvSTART(cv)
1N/A B::CV cv
1N/A
1N/AB::OP
1N/ACvROOT(cv)
1N/A B::CV cv
1N/A
1N/AB::GV
1N/ACvGV(cv)
1N/A B::CV cv
1N/A
1N/Achar *
1N/ACvFILE(cv)
1N/A B::CV cv
1N/A
1N/Along
1N/ACvDEPTH(cv)
1N/A B::CV cv
1N/A
1N/AB::AV
1N/ACvPADLIST(cv)
1N/A B::CV cv
1N/A
1N/AB::CV
1N/ACvOUTSIDE(cv)
1N/A B::CV cv
1N/A
1N/AU32
1N/ACvOUTSIDE_SEQ(cv)
1N/A B::CV cv
1N/A
1N/Avoid
1N/ACvXSUB(cv)
1N/A B::CV cv
1N/A CODE:
1N/A ST(0) = sv_2mortal(newSViv(PTR2IV(CvXSUB(cv))));
1N/A
1N/A
1N/Avoid
1N/ACvXSUBANY(cv)
1N/A B::CV cv
1N/A CODE:
1N/A ST(0) = CvCONST(cv) ?
1N/A make_sv_object(aTHX_ sv_newmortal(),CvXSUBANY(cv).any_ptr) :
1N/A sv_2mortal(newSViv(CvXSUBANY(cv).any_iv));
1N/A
1N/AMODULE = B PACKAGE = B::CV
1N/A
1N/AU16
1N/ACvFLAGS(cv)
1N/A B::CV cv
1N/A
1N/AMODULE = B PACKAGE = B::CV PREFIX = cv_
1N/A
1N/AB::SV
1N/Acv_const_sv(cv)
1N/A B::CV cv
1N/A
1N/A
1N/AMODULE = B PACKAGE = B::HV PREFIX = Hv
1N/A
1N/ASTRLEN
1N/AHvFILL(hv)
1N/A B::HV hv
1N/A
1N/ASTRLEN
1N/AHvMAX(hv)
1N/A B::HV hv
1N/A
1N/AI32
1N/AHvKEYS(hv)
1N/A B::HV hv
1N/A
1N/AI32
1N/AHvRITER(hv)
1N/A B::HV hv
1N/A
1N/Achar *
1N/AHvNAME(hv)
1N/A B::HV hv
1N/A
1N/AB::PMOP
1N/AHvPMROOT(hv)
1N/A B::HV hv
1N/A
1N/Avoid
1N/AHvARRAY(hv)
1N/A B::HV hv
1N/A PPCODE:
1N/A if (HvKEYS(hv) > 0) {
1N/A SV *sv;
1N/A char *key;
1N/A I32 len;
1N/A (void)hv_iterinit(hv);
1N/A EXTEND(sp, HvKEYS(hv) * 2);
1N/A while ((sv = hv_iternextsv(hv, &key, &len))) {
1N/A PUSHs(newSVpvn(key, len));
1N/A PUSHs(make_sv_object(aTHX_ sv_newmortal(), sv));
1N/A }
1N/A }