view release on metacpan or  search on metacpan

RPM/Header.xs  view on Meta::CPAN

        RETVAL = rpmhdr_TIEHASH_new(aTHX);
    else if (SvPOK(source))
        RETVAL = rpmhdr_TIEHASH_file(aTHX_ SvPV_nolen(source));
    else
        RETVAL = rpmhdr_TIEHASH_fd(aTHX_ PerlIO_fileno(IoIFP(sv_2io(source))));
    OUTPUT:
    RETVAL

SV*
rpmhdr_FETCH(self, tag)
    RPM::Header self;
    RPM_Tag tag;
    PROTOTYPE: $$
    CODE:
    RETVAL = rpmhdr_FETCH(aTHX_ self, tag);
    OUTPUT:
    RETVAL

int
rpmhdr_STORE(self, tag, value)
    RPM::Header self;
    RPM_Tag tag;
    SV* value;
    PROTOTYPE: $$$
    CODE:
    RETVAL = rpmhdr_STORE(aTHX_ self, tag, value);
    OUTPUT:
    RETVAL

int
rpmhdr_DELETE(self, tag)
    RPM::Header self;
    RPM_Tag tag;
    PROTOTYPE: $$
    CODE:
    RETVAL = rpmhdr_DELETE(aTHX_ self, tag);
    OUTPUT:
    RETVAL

void
rpmhdr_CLEAR(self)
    RPM::Header self;
    PROTOTYPE: $
    CODE:
    rpmhdr_CLEAR(aTHX_ self);

bool
rpmhdr_EXISTS(self, tag)
    RPM::Header self;
    RPM_Tag tag;
    PROTOTYPE: $$
    CODE:
    RETVAL = rpmhdr_EXISTS(aTHX_ self, tag);
    OUTPUT:
    RETVAL

void
rpmhdr_FIRSTKEY(self)
    RPM::Header self;
    PROTOTYPE: $
    PPCODE:
    {
        RPM_Tag tag;
        SV* value;

        if (rpmhdr_FIRSTKEY(aTHX_ self, &tag, &value))
        {
            XPUSHs(sv_2mortal(value));
            XPUSHs(sv_2mortal(rpmtag_iv2sv(aTHX_ tag)));
        }

    }

void
rpmhdr_NEXTKEY(self, prev_tag=0)
    RPM::Header self;
    RPM_Tag prev_tag;
    PROTOTYPE: $;$
    PPCODE:
    {
        RPM_Tag tag;
        SV* value;

        if (rpmhdr_NEXTKEY(aTHX_ self, prev_tag, &tag, &value))
        {
            XPUSHs(sv_2mortal(value));
            XPUSHs(sv_2mortal(rpmtag_iv2sv(aTHX_ tag)));
        }
    }

void
rpmhdr_DESTROY(self)
    RPM::Header self;
    PROTOTYPE: $
    CODE:
    rpmhdr_DESTROY(aTHX_ self);

unsigned int
rpmhdr_size(self)
    RPM::Header self;
    PROTOTYPE: $
    CODE:
    RETVAL = rpmhdr_size(aTHX_ self);
    OUTPUT:
    RETVAL

int
rpmhdr_tagtype(self, tag)
    RPM::Header self;
    RPM_Tag tag;
    PROTOTYPE: $$
    CODE:
    RETVAL = rpmhdr_tagtype(aTHX_ self, tag);
    OUTPUT:
    RETVAL

int
rpmhdr_write(self, gv, magicp=0)
    RPM::Header self;
    SV* gv;
    SV* magicp;
    PROTOTYPE: $$;$
    CODE:
    {
        int flag;

        if (magicp && SvIOK(magicp))
            flag = SvIV(magicp);
        else
            flag = HEADER_MAGIC_YES;

        RETVAL = rpmhdr_write(aTHX_ self, gv, flag);
    }
    OUTPUT:
    RETVAL

bool
rpmhdr_is_source(self)
    RPM::Header self;
    PROTOTYPE: $
    CODE:
    RETVAL = self->isSource;
    OUTPUT:
    RETVAL

int
rpmhdr_cmpver(self, other)
    RPM::Header self;
    RPM::Header other;
    PROTOTYPE: $$
    CODE:
    RETVAL = rpmhdr_cmpver(aTHX_ self, other);
    OUTPUT:
    RETVAL

void
rpmhdr_NVR(self)
    RPM::Header self;
    PROTOTYPE: $
    PPCODE:
    {
        RPM_Header* hdr = self;

        if (hdr->name)
        {
            XPUSHs(sv_2mortal(newSVpv((char *)hdr->name, 0)));
            XPUSHs(sv_2mortal(newSVpv((char *)hdr->version, 0)));
            XPUSHs(sv_2mortal(newSVpv((char *)hdr->release, 0)));
        }
    }

bool
rpmhdr_scalar_tag(self, tag)
    SV* self;
    RPM_Tag tag;
    PROTOTYPE: $$
    CODE:
    (void) self;
    RETVAL = scalar_tag(tag);
    OUTPUT:
    RETVAL

const char *
rpmhdr_source_name(self)
    RPM::Header self;
    PROTOTYPE: $
    CODE:
    RETVAL = self->source_name;
    OUTPUT:
    RETVAL

void
rpmhdr_dump(self, fh=stdout)
    RPM::Header self;
    FILE * fh;
    PROTOTYPE: $;$
    CODE:
    headerDump(self->hdr, fh, HEADER_DUMP_INLINE, rpmTagTable);