PUT results from the CPAN

ALPM

view release on metacpan or search on metacpan

	char * dbpath
 PREINIT:
	alpm_errno_t err;
	ALPM_Handle h;
 CODE:
	h = alpm_initialize(root, dbpath, &err);
	if(h == NULL){
		croak("ALPM Error: %s", alpm_strerror(err));
	}
	RETVAL = h;
 OUTPUT:
	RETVAL

void
DESTROY(self)
	ALPM_Handle self;
 PREINIT:
	int ret;
 CODE:
	ret = alpm_release(self);
	if(ret == -1){

ALPM.xs view on Meta::CPAN

	}
	if(c & ALPM_CAPABILITY_SIGNATURES){
		XPUSHs(sv_2mortal(newSVpv("signatures", 0)));
	}

const char *
version(class)
	SV * class
 CODE:
	RETVAL = alpm_version();
 OUTPUT:
	RETVAL

const char *
strerror(self)
	ALPM_Handle self;
 CODE:
	RETVAL = alpm_strerror(alpm_errno(self));
 OUTPUT:
	RETVAL

int
errno(self)
	ALPM_Handle self
 CODE:
	RETVAL = alpm_errno(self);
 OUTPUT:
	RETVAL

ALPM_Package
find_satisfier(self, depstr, ...)
	SV * self
	const char * depstr
 PREINIT:
	alpm_list_t *pkgs;
	int i;
 CODE:
	i = 2;
	STACK2LIST(i, pkgs, p2c_pkg);
	RETVAL = alpm_find_satisfier(pkgs, depstr);
	alpm_list_free(pkgs);
 OUTPUT:
	RETVAL

ALPM_Package
find_dbs_satisfier(self, depstr, ...)
	ALPM_Handle self
	const char * depstr
 PREINIT:
	alpm_list_t *dbs;
	int i;
 CODE:
	i = 2;
	STACK2LIST(i, dbs, p2c_db);
	RETVAL = alpm_find_dbs_satisfier(self, dbs, depstr);
	alpm_list_free(dbs);
 OUTPUT:
	RETVAL

void
check_conflicts(self, ...)
	ALPM_Handle self
 PREINIT:
	alpm_list_t *L, *clist;
	int i;
 PPCODE:
	i = 1;

ALPM.xs view on Meta::CPAN

	const char * url
 PREINIT:
	char * path;
 CODE:
	path = alpm_fetch_pkgurl(self, url);
	if(path == NULL){
		RETVAL = &PL_sv_undef;
	}else{
		RETVAL = sv_2mortal(newSVpv(path, strlen(path)));
	}
 OUTPUT:
	RETVAL

## Why name this register_sync when there is no register_local? Redundant.

ALPM_SyncDB
register(self, name, ...)
	ALPM_Handle self
	const char * name
 PREINIT:
	alpm_siglevel_t siglvl;
 CODE:
	if(items >= 3){
		siglvl = p2c_siglevel(ST(2));
	}else{
		siglvl = ALPM_SIG_USE_DEFAULT;
	}
	RETVAL = alpm_register_syncdb(self, name, siglvl);
 OUTPUT:
	RETVAL

negative_is_error
unregister_all(self)
	ALPM_Handle self
 CODE:
	RETVAL = alpm_unregister_all_syncdbs(self);
 OUTPUT:
	RETVAL

# Packages created with load_pkgfile must be freed by the caller.
# Hence we use ALPM_PackageFree. NULL pointers are converted
# into undef by the typemap.

ALPM_PackageFree
load_pkgfile(self, filename, full, siglevel)
	ALPM_Handle self
	const char *filename
	int full
	ALPM_SigLevel siglevel
 CODE:
	RETVAL = NULL;
	alpm_pkg_load(self, filename, full, siglevel, &RETVAL);
 OUTPUT:
	RETVAL

int
vercmp(unused, a, b)
	SV * unused
	const char *a
	const char *b
 CODE:
	RETVAL = alpm_pkg_vercmp(a, b);
 OUTPUT:
	RETVAL

INCLUDE: xs/Options.xs

INCLUDE: xs/Package.xs

INCLUDE: xs/DB.xs

# INCLUDE: xs/Transaction.xs

cb.c view on Meta::CPAN

	SAVETMPS;

	/* We can't use sv_vsetpvfn because it doesn't like j's: %jd or %ji, etc... */
	svlvl = sv_2mortal(newSVpv(str, 0));
	vsnprintf(buf, 255, fmt, args);
	svmsg = sv_2mortal(newSVpv(buf, 0));
	
	PUSHMARK(SP);
	XPUSHs(svlvl);
	XPUSHs(svmsg);
	PUTBACK;

	call_sv(logcb_ref, G_DISCARD);

	FREETMPS;
	LEAVE;
	return;
}

void
c2p_dlcb(const char * name, off_t curr, off_t total)

cb.c view on Meta::CPAN

	ENTER;
	SAVETMPS;
	svname = sv_2mortal(newSVpv(name, 0));
	svcurr = sv_2mortal(newSViv(curr));
	svtotal = sv_2mortal(newSViv(total));

	PUSHMARK(SP);
	XPUSHs(svname);
	XPUSHs(svcurr);
	XPUSHs(svtotal);
	PUTBACK;
	call_sv(dlcb_ref, G_DISCARD);

	FREETMPS;
	LEAVE;
	return;
}

int
c2p_fetchcb(const char * url, const char * dest, int force)
{

cb.c view on Meta::CPAN

	}

	ENTER;
	SAVETMPS;

	PUSHMARK(SP);
	EXTEND(SP, 3);
	PUSHs(sv_2mortal(newSVpv(url, 0)));
	PUSHs(sv_2mortal(newSVpv(dest, 0)));
	PUSHs(sv_2mortal(newSViv(force)));
	PUTBACK;

	ret = 0;
	if(call_sv(fetchcb_ref, G_SCALAR | G_EVAL) == 1){
		svret = POPs;
		if(SvTRUE(ERRSV)){
			/* the callback died, return an error to libalpm */
			ret = -1;
		}else{
			ret = (SvTRUE(svret) ? 1 : 0);
		}

cb.c view on Meta::CPAN

	dSP;
	if(!totaldlcb_ref){
		return;
	}
	ENTER;
	SAVETMPS;

	PUSHMARK(SP);
	EXTEND(SP, 1);
	PUSHs(sv_2mortal(newSViv(total)));
	PUTBACK;
	call_sv(totaldlcb_ref, G_DISCARD);

	FREETMPS;
	LEAVE;
	return;
	
}

ppport.h view on Meta::CPAN

PTR2ul|5.007001||p
PTRV|5.006000||p
PUSHMARK|||
PUSH_MULTICALL||5.011000|
PUSHi|||
PUSHmortal|5.009002||p
PUSHn|||
PUSHp|||
PUSHs|||
PUSHu|5.004000||p
PUTBACK|||
PerlIO_clearerr||5.007003|
PerlIO_close||5.007003|
PerlIO_context_layers||5.009004|
PerlIO_eof||5.007003|
PerlIO_error||5.007003|
PerlIO_fileno||5.007003|
PerlIO_fill||5.007003|
PerlIO_flush||5.007003|
PerlIO_get_base||5.007003|
PerlIO_get_bufsiz||5.007003|

ppport.h view on Meta::CPAN

{
    dSP;
    SV* sv = newSVpv(p, 0);

    PUSHMARK(sp);
    eval_sv(sv, G_SCALAR);
    SvREFCNT_dec(sv);

    SPAGAIN;
    sv = POPs;
    PUTBACK;

    if (croak_on_error && SvTRUE(GvSV(errgv)))
	croak(SvPVx(GvSV(errgv), na));

    return sv;
}

#endif
#endif

typemap view on Meta::CPAN


PackageList		L_PACKAGE
DependList		L_DEPEND
StringList		L_STRING
StringListFree		L_STRINGFREE

alpm_pkgreason_t	T_PKGREASON
off_t			T_INT

#--------------------
# INPUT # Perl ==> C
#--------------------

INPUT

T_ALPM_HANDLE
	if(sv_derived_from($arg, \"ALPM\")){
		$var = INT2PTR($type, SvIV((SV *)SvRV($arg)));
	}else{
		croak(\"error: expected an ALPM object\");
	}

T_ALPM_DB
	if(sv_derived_from($arg, \"ALPM::DB\")){

typemap view on Meta::CPAN

T_SIGLEVEL
	$var = p2c_siglevel($arg);

T_DEPEND
	$var = p2c_depend($arg);

T_PKGREASON
	$var = p2c_pkgreason($arg);

#---------------------
# OUTPUT # C ==> Perl
#---------------------

OUTPUT

# The handle should never be NULL. This is the only error condition
# but hopefully doesn't affect us. However, the string is sometimes NULL
# so we should convert it to undef.
T_STROPT
	if($var == NULL){
		$arg = &PL_sv_undef;
	}else{
		$arg = newSVpv($var, 0);
	}

xs/DB.xs view on Meta::CPAN

		pkgarr = list2av(grp->packages, c2p_pkg);
		XPUSHs(sv_2mortal(newRV_noinc((SV*)pkgarr)));
		grps = alpm_list_next(grps);
	}

const char *
name(db)
	ALPM_DB db
 CODE:
	RETVAL = alpm_db_get_name(db);
 OUTPUT:
	RETVAL

SV *
find(db, name)
	ALPM_DB db
	const char *name
 PREINIT:
	ALPM_Package pkg;
 CODE:
	pkg = alpm_db_get_pkg(db, name);
	RETVAL = (pkg == NULL ? &PL_sv_undef
		: c2p_pkg(pkg));
 OUTPUT:
	RETVAL

void
find_group(db, name)
	ALPM_DB db
	const char *name
 PREINIT:
	alpm_group_t *grp;
	alpm_list_t *pkgs;
 PPCODE:

xs/DB.xs view on Meta::CPAN


MODULE = ALPM   PACKAGE = ALPM::DB::Local

negative_is_error
set_install_reason(self, pkg, rsn)
	ALPM_LocalDB self
	ALPM_Package pkg
	alpm_pkgreason_t rsn
 CODE:
	RETVAL = alpm_pkg_set_reason(pkg, rsn);
 OUTPUT:
	RETVAL

#-----------------------------
# PUBLIC SYNC DATABASE METHODS
#-----------------------------

MODULE = ALPM   PACKAGE = ALPM::DB::Sync

int
update(db)

xs/DB.xs view on Meta::CPAN

 PREINIT:
	int ret;
 CODE:
	ret = alpm_db_update(0, db);
	switch(ret){
	case 0: RETVAL = 1; break;
	case 1: RETVAL = -1; break; /* DB did not need to be updated */
	case -1: RETVAL = 0; break;
	default: croak("Unrecognized return value of alpm_db_update");
	}
 OUTPUT:
	RETVAL

negative_is_error
force_update(db)
	ALPM_SyncDB db
 CODE:
	RETVAL = alpm_db_update(1, db);
 OUTPUT:
	RETVAL

ALPM_SigLevel
siglvl(db)
	ALPM_SyncDB db
 CODE:
	RETVAL = alpm_db_get_siglevel(db);
 OUTPUT:
	RETVAL

MODULE = ALPM   PACKAGE = ALPM::DB::Sync    PREFIX = alpm_db_

negative_is_error
alpm_db_unregister(self)
	ALPM_SyncDB self

negative_is_error
alpm_db_add_server(self, url)

xs/DB.xs view on Meta::CPAN

negative_is_error
alpm_db_set_servers(self, ...)
	ALPM_SyncDB self
 PREINIT:
	alpm_list_t *L;
	int i;
 CODE:
	i = 1;
	STACK2LIST(i, L, p2c_str);
	RETVAL = alpm_db_set_servers(self, L);
 OUTPUT:
	RETVAL

MODULE = ALPM	PACKAGE = ALPM::DB::Sync	PREFIX = alpm_db_get_

int
alpm_db_get_valid(db)
	ALPM_SyncDB db

xs/Options.xs view on Meta::CPAN

MODULE = ALPM	PACKAGE = ALPM

## CALLBACKS

SV*
get_logcb(...)
 CODE:
	RETVAL = (logcb_ref ? newSVsv(logcb_ref) : &PL_sv_undef);
 OUTPUT:
	RETVAL

SV*
get_dlcb(...)
 CODE:
	RETVAL = (dlcb_ref ? newSVsv(dlcb_ref) : &PL_sv_undef);
 OUTPUT:
	RETVAL

SV*
get_fetchcb(...)
 CODE:
	RETVAL = (fetchcb_ref ? newSVsv(fetchcb_ref) : &PL_sv_undef);
 OUTPUT:
	RETVAL

SV*
get_totaldlcb(...)
 CODE:
	RETVAL = (totaldlcb_ref ? newSVsv(totaldlcb_ref) : &PL_sv_undef);
 OUTPUT:
	RETVAL

MODULE = ALPM	PACKAGE = ALPM	PREFIX = alpm_option_

void
alpm_option_set_logcb(self, cb)
	ALPM_Handle self
	SV * cb
 CODE:
	DEFSETCB(log, self, cb)

xs/Options.xs view on Meta::CPAN

alpm_option_set_cachedirs(self, ...)
	ALPM_Handle self
 PREINIT:
	alpm_list_t *lst;
	int i;
 CODE:
	i = 1;
	STACK2LIST(i, lst, p2c_str);
	RETVAL = alpm_option_set_cachedirs(self, lst);
	ZAPLIST(lst, free);
 OUTPUT:
	RETVAL

SetOption
alpm_option_set_noupgrades(self, ...)
	ALPM_Handle self
 PREINIT:
	alpm_list_t *lst;
	int i;
 CODE:
	i = 1;
	STACK2LIST(i, lst, p2c_str);
	RETVAL = alpm_option_set_noupgrades(self, lst);
	ZAPLIST(lst, free);
 OUTPUT:
	RETVAL

SetOption
alpm_option_set_noextracts(self, ...)
	ALPM_Handle self
 PREINIT:
	alpm_list_t *lst;
	int i;
 CODE:
	i = 1;
	STACK2LIST(i, lst, p2c_str);
	RETVAL = alpm_option_set_noextracts(self, lst);
	ZAPLIST(lst, free);
 OUTPUT:
	RETVAL

SetOption
alpm_option_set_ignorepkgs(self, ...)
	ALPM_Handle self
 PREINIT:
	alpm_list_t *lst;
	int i;
 CODE:
	i = 1;
	STACK2LIST(i, lst, p2c_str);
	RETVAL = alpm_option_set_ignorepkgs(self, lst);
	ZAPLIST(lst, free);
 OUTPUT:
	RETVAL

SetOption
alpm_option_set_ignoregroups(self, ...)
	ALPM_Handle self
 PREINIT:
	alpm_list_t *lst;
	int i;
 CODE:
	i = 1;
	STACK2LIST(i, lst, p2c_str);
	RETVAL = alpm_option_set_ignoregroups(self, lst);
	ZAPLIST(lst, free);
 OUTPUT:
	RETVAL

# Use IntOption to return the number of items removed (0 or 1).

IntOption
option_stringlist_remove(self, badstring)
	ALPM_Handle self
	const char * badstring
INTERFACE:
	alpm_option_remove_cachedir

xs/Options.xs view on Meta::CPAN


SetOption
alpm_option_set_assumeinstalled(self, ...)
	ALPM_Handle self
 PREINIT:
	alpm_list_t *lst = NULL;
	int i = 1;
 CODE:
	STACK2LIST(i, lst, p2c_depend);
	RETVAL = alpm_option_set_assumeinstalled(self, lst);
 OUTPUT:
	RETVAL

MODULE = ALPM	PACKAGE = ALPM	PREFIX = alpm_option_

# Why have get_localdb when there is no set_localdb? s/get_//;

ALPM_LocalDB
localdb(self)
	ALPM_Handle self
 CODE:
	RETVAL = alpm_get_localdb(self);
 OUTPUT:
	RETVAL

# Ditto.

void
syncdbs(self)
	ALPM_Handle self
 PREINIT:
	alpm_list_t *lst;
 PPCODE:
	lst = alpm_get_syncdbs(self);
	if(lst == NULL && alpm_errno(self)) alpm_croak(self);
	LIST2STACK(lst, c2p_syncdb);

ALPM_SigLevel
get_defsiglvl(self)
	ALPM_Handle self
 CODE:
	RETVAL = alpm_option_get_default_siglevel(self);
 OUTPUT:
	RETVAL

SetOption
set_defsiglvl(self, siglvl)
	ALPM_Handle self
	SV* siglvl
 CODE:
	if(strcmp(SvPV_nolen(siglvl), "default") == 0){
		croak("Default signature level cannot itself be set to default. You hear the sound of one hand clapping");
	}else{
		RETVAL = alpm_option_set_default_siglevel(self, p2c_siglevel(siglvl));
	}
 OUTPUT:
	RETVAL

# EOF

xs/Package.xs view on Meta::CPAN

# PUBLIC PACKAGE METHODS
#-----------------------

MODULE = ALPM	PACKAGE = ALPM::Package

const char *
signature(pkg)
	ALPM_Package pkg
 CODE:
	RETVAL = alpm_pkg_get_base64_sig(pkg);
 OUTPUT:
	RETVAL

SV *
changelog(pkg)
	ALPM_Package pkg
 PREINIT:
	void *fp;
	char buffer[128];
	size_t bytes_read;
	SV *changelog_txt;

xs/Package.xs view on Meta::CPAN

		while(1){
			bytes_read = alpm_pkg_changelog_read((void *)buffer, 128,
												  pkg, fp);
			/*fprintf(stderr,"DEBUG: read %d bytes of changelog\n", */
			/*		  bytes_read); */
			if(bytes_read == 0) break;
			sv_catpvn(changelog_txt, buffer, bytes_read);
		}
		alpm_pkg_changelog_close(pkg, fp);
	}
 OUTPUT:
	RETVAL

MODULE=ALPM    PACKAGE=ALPM::Package    PREFIX=alpm_pkg_compute_

StringListFree
pkg_compute(pkg)
	ALPM_Package pkg
 INTERFACE:
	alpm_pkg_compute_requiredby
	alpm_pkg_compute_optionalfor

( run in 0.476 second using v1.01-cache-2.11-cpan-4e96b696675 )