moparisthebest
/
pacman
mirror of https://github.com/moparisthebest/pacman
1
0
Fork 0
Code Issues Releases Wiki Activity

Style change: return(x) --> return x 

This was discussed and more or less agreed upon on the mailing list. A
huge checkin, but if we just do it and let people adjust the pain will
end soon enough. Rebasing should be relatively straighforward for anyone
that sees conflicts; just be sure you use the new return style if
possible.

The following semantic patch was used to do the change, along with some
hand-massaging in order to preserve parenthesis where appropriate:

The semantic match that finds this problem is as follows, although some
hand-massaging was done in order to keep parenthesis where appropriate:
(http://coccinelle.lip6.fr/)

// <smpl>
@@
expression a;
@@
- return(a);
+ return a;

// </smpl>

A macros_file was also provided with the following content:

Additional steps taken, mainly for ASSERT() macros:
$ sed -i -e 's#return(NULL)#return NULL#' lib/libalpm/*.c
$ sed -i -e 's#return(-1)#return -1#' lib/libalpm/*.c

Signed-off-by: Dan McGee <dan@archlinux.org>
This commit is contained in:
Dan McGee 2011-03-20 19:45:57 -05:00
parent 0cf05c77ad
commit 0303b26b1e
43 changed files with 726 additions and 725 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
HACKING
View File

@ -35,7 +35,7 @@ while(it) {
if(fn) {
fn(it->data);
} else {
return(1);
return 1;
}
free(it);
it = ptr;
@ -67,11 +67,11 @@ alpm_list_t *alpm_list_add(alpm_list_t *list, void *data)
NOT
// This is a comment
5. Return statements should be written like a function call.
5. Return statements should *not* be written like function calls.
return(0);
NOT
return 0;
NOT
return(0);
6. The sizeof() operator should accept a type, not a value. (TODO: in certain
cases, it may be better- should this be a set guideline? Read "The Practice

34
lib/libalpm/add.c
View File

@ -91,7 +91,7 @@ int SYMEXPORT alpm_add_pkg(pmpkg_t *pkg)
/* with the NEEDED flag, packages up to date are not reinstalled */
_alpm_log(PM_LOG_WARNING, _("%s-%s is up to date -- skipping\n"),
localpkgname, localpkgver);
return(0);
return 0;
} else {
_alpm_log(PM_LOG_WARNING, _("%s-%s is up to date -- reinstalling\n"),
localpkgname, localpkgver);
@ -109,7 +109,7 @@ int SYMEXPORT alpm_add_pkg(pmpkg_t *pkg)
pkgname, pkgver);
trans->add = alpm_list_add(trans->add, pkg);
return(0);
return 0;
}
static int perform_extraction(struct archive *archive,
@ -132,9 +132,9 @@ static int perform_extraction(struct archive *archive,
origname, archive_error_string(archive));
alpm_logaction("error: could not extract %s (%s)\n",
origname, archive_error_string(archive));
return(1);
return 1;
}
return(0);
return 0;
}
static int extract_single_file(struct archive *archive,
@ -169,7 +169,7 @@ static int extract_single_file(struct archive *archive,
* already been handled (for future possibilities) */
_alpm_log(PM_LOG_DEBUG, "skipping extraction of '%s'\n", entryname);
archive_read_data_skip(archive);
return(0);
return 0;
} else {
/* build the new entryname relative to handle->root */
snprintf(filename, PATH_MAX, "%s%s", handle->root, entryname);
@ -182,7 +182,7 @@ static int extract_single_file(struct archive *archive,
alpm_logaction("note: %s is in NoExtract, skipping extraction\n",
entryname);
archive_read_data_skip(archive);
return(0);
return 0;
}
/* Check for file existence. This is one of the more crucial parts
@ -226,13 +226,13 @@ static int extract_single_file(struct archive *archive,
_alpm_log(PM_LOG_DEBUG, "extract: skipping dir extraction of %s\n",
entryname);
archive_read_data_skip(archive);
return(0);
return 0;
} else {
/* case 10/11: trying to overwrite dir with file/symlink, don't allow it */
_alpm_log(PM_LOG_ERROR, _("extract: not overwriting dir with file %s\n"),
entryname);
archive_read_data_skip(archive);
return(1);
return 1;
}
} else if(S_ISLNK(lsbuf.st_mode) && S_ISDIR(entrymode)) {
/* case 9: existing symlink, dir in package */
@ -241,13 +241,13 @@ static int extract_single_file(struct archive *archive,
_alpm_log(PM_LOG_DEBUG, "extract: skipping symlink overwrite of %s\n",
entryname);
archive_read_data_skip(archive);
return(0);
return 0;
} else {
/* this is BAD. symlink was not to a directory */
_alpm_log(PM_LOG_ERROR, _("extract: symlink %s does not point to dir\n"),
entryname);
archive_read_data_skip(archive);
return(1);
return 1;
}
} else if(S_ISREG(lsbuf.st_mode) && S_ISDIR(entrymode)) {
/* case 6: trying to overwrite file with dir */
@ -299,7 +299,7 @@ static int extract_single_file(struct archive *archive,
/* error */
FREE(hash_orig);
FREE(entryname_orig);
return(1);
return 1;
}
hash_local = alpm_compute_md5sum(filename);
@ -442,7 +442,7 @@ static int extract_single_file(struct archive *archive,
if(ret == 1) {
/* error */
FREE(entryname_orig);
return(1);
return 1;
}
/* calculate an hash if this is in newpkg's backup */
@ -469,7 +469,7 @@ static int extract_single_file(struct archive *archive,
}
}
FREE(entryname_orig);
return(errors);
return errors;
}
static int commit_single_pkg(pmpkg_t *newpkg, size_t pkg_current,
@ -705,7 +705,7 @@ static int commit_single_pkg(pmpkg_t *newpkg, size_t pkg_current,
cleanup:
_alpm_pkg_free(oldpkg);
return(ret);
return ret;
}
int _alpm_upgrade_packages(pmtrans_t *trans, pmdb_t *db)
@ -720,7 +720,7 @@ int _alpm_upgrade_packages(pmtrans_t *trans, pmdb_t *db)
ASSERT(db != NULL, RET_ERR(PM_ERR_DB_NULL, -1));
if(trans->add == NULL) {
return(0);
return 0;
}
pkg_count = alpm_list_count(trans->add);
@ -729,7 +729,7 @@ int _alpm_upgrade_packages(pmtrans_t *trans, pmdb_t *db)
/* loop through our package list adding/upgrading one at a time */
for(targ = trans->add; targ; targ = targ->next) {
if(handle->trans->state == STATE_INTERRUPTED) {
return(ret);
return ret;
}
pmpkg_t *newpkg = (pmpkg_t *)targ->data;
@ -750,7 +750,7 @@ int _alpm_upgrade_packages(pmtrans_t *trans, pmdb_t *db)
_alpm_ldconfig(handle->root);
}
return(ret);
return ret;
}
/* vim: set ts=2 sw=2 noet: */

10
lib/libalpm/alpm.c
View File

@ -57,7 +57,7 @@ int SYMEXPORT alpm_initialize(void)
/* error code should be set */
_alpm_handle_free(handle);
handle = NULL;
return(-1);
return -1;
}
#ifdef ENABLE_NLS
@ -69,7 +69,7 @@ int SYMEXPORT alpm_initialize(void)
handle->curl = curl_easy_init();
#endif
return(0);
return 0;
}
/** Release the library. This should be the last alpm call you make.
@ -82,7 +82,7 @@ int SYMEXPORT alpm_release(void)
ASSERT(handle != NULL, RET_ERR(PM_ERR_HANDLE_NULL, -1));
if(alpm_db_unregister_all() == -1) {
return(-1);
return -1;
}
_alpm_handle_free(handle);
@ -92,7 +92,7 @@ int SYMEXPORT alpm_release(void)
curl_global_cleanup();
#endif
return(0);
return 0;
}
/** @} */
@ -103,7 +103,7 @@ int SYMEXPORT alpm_release(void)
/* Get the version of library */
const char SYMEXPORT *alpm_version(void) {
return(LIB_VERSION);
return LIB_VERSION;
}
/* vim: set ts=2 sw=2 noet: */

87
lib/libalpm/alpm_list.c
View File

@ -92,7 +92,7 @@ alpm_list_t SYMEXPORT *alpm_list_add(alpm_list_t *list, void *data)
ptr = calloc(1, sizeof(alpm_list_t));
if(ptr == NULL) {
return(list);
return list;
}
ptr->data = data;
@ -101,7 +101,7 @@ alpm_list_t SYMEXPORT *alpm_list_add(alpm_list_t *list, void *data)
/* Special case: the input list is empty */
if(list == NULL) {
ptr->prev = ptr;
return(ptr);
return ptr;
}
lp = alpm_list_last(list);
@ -109,7 +109,7 @@ alpm_list_t SYMEXPORT *alpm_list_add(alpm_list_t *list, void *data)
ptr->prev = lp;
list->prev = ptr;
return(list);
return list;
}
/**
@ -124,13 +124,13 @@ alpm_list_t SYMEXPORT *alpm_list_add(alpm_list_t *list, void *data)
alpm_list_t SYMEXPORT *alpm_list_add_sorted(alpm_list_t *list, void *data, alpm_list_fn_cmp fn)
{
if(!fn || !list) {
return(alpm_list_add(list, data));
return alpm_list_add(list, data);
} else {
alpm_list_t *add = NULL, *prev = NULL, *next = list;
add = calloc(1, sizeof(alpm_list_t));
if(add == NULL) {
return(list);
return list;
}
add->data = data;
@ -146,19 +146,19 @@ alpm_list_t SYMEXPORT *alpm_list_add_sorted(alpm_list_t *list, void *data, alpm_
add->prev = list->prev; /* list != NULL */
add->next = list;
list->prev = add;
return(add);
return add;
} else if(next == NULL) { /* another special case: add last element */
add->prev = prev;
add->next = NULL;
prev->next = add;
list->prev = add;
return(list);
return list;
} else {
add->prev = prev;
add->next = next;
next->prev = add;
prev->next = add;
return(list);
return list;
}
}
}
@ -179,10 +179,10 @@ alpm_list_t SYMEXPORT *alpm_list_join(alpm_list_t *first, alpm_list_t *second)
alpm_list_t *tmp;
if (first == NULL) {
return(second);
return second;
}
if (second == NULL) {
return(first);
return first;
}
/* tmp is the last element of the first list */
tmp = first->prev;
@ -193,7 +193,7 @@ alpm_list_t SYMEXPORT *alpm_list_join(alpm_list_t *first, alpm_list_t *second)
/* set the back reference to the tail */
second->prev = tmp;
return(first);
return first;
}
/**
@ -257,7 +257,7 @@ alpm_list_t SYMEXPORT *alpm_list_mmerge(alpm_list_t *left, alpm_list_t *right, a
}
newlist->prev = lp;
return(newlist);
return newlist;
}
/**
@ -282,7 +282,7 @@ alpm_list_t SYMEXPORT *alpm_list_msort(alpm_list_t *list, size_t n, alpm_list_fn
right = alpm_list_msort(right, n - (n/2), fn);
list = alpm_list_mmerge(left, right, fn);
}
return(list);
return list;
}
/**
@ -298,7 +298,7 @@ alpm_list_t SYMEXPORT *alpm_list_remove_item(alpm_list_t *haystack,
alpm_list_t *item)
{
if(haystack == NULL || item == NULL) {
return(haystack);
return haystack;
}
if(item == haystack) {
@ -328,7 +328,7 @@ alpm_list_t SYMEXPORT *alpm_list_remove_item(alpm_list_t *haystack,
}
}
return(haystack);
return haystack;
}
@ -352,7 +352,7 @@ alpm_list_t SYMEXPORT *alpm_list_remove(alpm_list_t *haystack,
}
if(needle == NULL) {
return(haystack);
return haystack;
}
while(i) {
@ -373,7 +373,7 @@ alpm_list_t SYMEXPORT *alpm_list_remove(alpm_list_t *haystack,
}
}
return(haystack);
return haystack;
}
/**
@ -388,8 +388,8 @@ alpm_list_t SYMEXPORT *alpm_list_remove(alpm_list_t *haystack,
alpm_list_t SYMEXPORT *alpm_list_remove_str(alpm_list_t *haystack,
const char *needle, char **data)
{
return(alpm_list_remove(haystack, (const void *)needle,
(alpm_list_fn_cmp)strcmp, (void **)data));
return alpm_list_remove(haystack, (const void *)needle,
(alpm_list_fn_cmp)strcmp, (void **)data);
}
/**
@ -411,7 +411,7 @@ alpm_list_t SYMEXPORT *alpm_list_remove_dupes(const alpm_list_t *list)
}
lp = lp->next;
}
return(newlist);
return newlist;
}
/**
@ -429,7 +429,7 @@ alpm_list_t SYMEXPORT *alpm_list_strdup(const alpm_list_t *list)
newlist = alpm_list_add(newlist, strdup(lp->data));
lp = lp->next;
}
return(newlist);
return newlist;
}
/**
@ -447,7 +447,7 @@ alpm_list_t SYMEXPORT *alpm_list_copy(const alpm_list_t *list)
newlist = alpm_list_add(newlist, lp->data);
lp = lp->next;
}
return(newlist);
return newlist;
}
/**
@ -473,7 +473,7 @@ alpm_list_t SYMEXPORT *alpm_list_copy_data(const alpm_list_t *list,
lp = lp->next;
}
}
return(newlist);
return newlist;
}
/**
@ -489,7 +489,7 @@ alpm_list_t SYMEXPORT *alpm_list_reverse(alpm_list_t *list)
alpm_list_t *newlist = NULL, *backup;
if(list == NULL) {
return(NULL);
return NULL;
}
lp = alpm_list_last(list);
@ -502,7 +502,7 @@ alpm_list_t SYMEXPORT *alpm_list_reverse(alpm_list_t *list)
lp = lp->prev;
}
list->prev = backup; /* restore tail pointer */
return(newlist);
return newlist;
}
/* Accessors */
@ -517,9 +517,9 @@ alpm_list_t SYMEXPORT *alpm_list_reverse(alpm_list_t *list)
inline alpm_list_t SYMEXPORT *alpm_list_first(const alpm_list_t *list)
{
if(list) {
return((alpm_list_t*)list);
return (alpm_list_t *)list;
} else {
return(NULL);
return NULL;
}
}
@ -537,7 +537,7 @@ alpm_list_t SYMEXPORT *alpm_list_nth(const alpm_list_t *list, size_t n)
while(n--) {
i = i->next;
}
return((alpm_list_t*)i);
return (alpm_list_t *)i;
}
/**
@ -550,9 +550,9 @@ alpm_list_t SYMEXPORT *alpm_list_nth(const alpm_list_t *list, size_t n)
inline alpm_list_t SYMEXPORT *alpm_list_next(const alpm_list_t *node)
{
if(node) {
return(node->next);
return node->next;
} else {
return(NULL);
return NULL;
}
}
@ -566,9 +566,9 @@ inline alpm_list_t SYMEXPORT *alpm_list_next(const alpm_list_t *node)
alpm_list_t SYMEXPORT *alpm_list_last(const alpm_list_t *list)
{
if(list) {
return(list->prev);
return list->prev;
} else {
return(NULL);
return NULL;
}
}
@ -581,8 +581,8 @@ alpm_list_t SYMEXPORT *alpm_list_last(const alpm_list_t *list)
*/
void SYMEXPORT *alpm_list_getdata(const alpm_list_t *node)
{
if(node == NULL) return(NULL);
return(node->data);
if(node == NULL) return NULL;
return node->data;
}
/* Misc */
@ -602,7 +602,7 @@ size_t SYMEXPORT alpm_list_count(const alpm_list_t *list)
++i;
lp = lp->next;
}
return(i);
return i;
}
/**
@ -620,17 +620,17 @@ void SYMEXPORT *alpm_list_find(const alpm_list_t *haystack, const void *needle,
const alpm_list_t *lp = haystack;
while(lp) {
if(lp->data && fn(lp->data, needle) == 0) {
return(lp->data);
return lp->data;
}
lp = lp->next;
}
return(NULL);
return NULL;
}
/* trivial helper function for alpm_list_find_ptr */
static int ptr_cmp(const void *p, const void *q)
{
return(p != q);
return (p != q);
}
/**
@ -643,9 +643,10 @@ static int ptr_cmp(const void *p, const void *q)
*
* @return `needle` if found, NULL otherwise
*/
void SYMEXPORT *alpm_list_find_ptr(const alpm_list_t *haystack, const void *needle)
void SYMEXPORT *alpm_list_find_ptr(const alpm_list_t *haystack,
const void *needle)
{
return(alpm_list_find(haystack, needle, ptr_cmp));
return alpm_list_find(haystack, needle, ptr_cmp);
}
/**
@ -659,8 +660,8 @@ void SYMEXPORT *alpm_list_find_ptr(const alpm_list_t *haystack, const void *need
char SYMEXPORT *alpm_list_find_str(const alpm_list_t *haystack,
const char *needle)
{
return((char *)alpm_list_find(haystack, (const void*)needle,
(alpm_list_fn_cmp)strcmp));
return (char *)alpm_list_find(haystack, (const void *)needle,
(alpm_list_fn_cmp)strcmp);
}
/**
@ -745,7 +746,7 @@ alpm_list_t SYMEXPORT *alpm_list_diff(const alpm_list_t *lhs,
alpm_list_free(left);
alpm_list_free(right);
return(ret);
return ret;
}
/** @} */

14
lib/libalpm/backup.c
View File

@ -47,7 +47,7 @@ static int backup_split(const char *string, char **file, char **hash)
/* don't need our dup as the fname wasn't requested, so free it */
FREE(str);
}
return(0);
return 0;
}
*ptr = '\0';
ptr++;
@ -59,21 +59,21 @@ static int backup_split(const char *string, char **file, char **hash)
*hash = strdup(ptr);
}
FREE(str);
return(1);
return 1;
}
char *_alpm_backup_file(const char *string)
{
char *file = NULL;
backup_split(string, &file, NULL);
return(file);
return file;
}
char *_alpm_backup_hash(const char *string)
{
char *hash = NULL;
backup_split(string, NULL, &hash);
return(hash);
return hash;
}
/* Look for a filename in a pmpkg_t.backup list. If we find it,
@ -86,7 +86,7 @@ char *_alpm_needbackup(const char *file, const alpm_list_t *backup)
ALPM_LOG_FUNC;
if(file == NULL || backup == NULL) {
return(NULL);
return NULL;
}
/* run through the backup list and parse out the hash for our file */
@ -101,13 +101,13 @@ char *_alpm_needbackup(const char *file, const alpm_list_t *backup)
}
if(strcmp(file, filename) == 0) {
FREE(filename);
return(hash);
return hash;
}
FREE(filename);
FREE(hash);
}
return(NULL);
return NULL;
}
/* vim: set ts=2 sw=2 noet: */

70
lib/libalpm/be_local.c
View File

@ -51,8 +51,8 @@
#define LAZY_LOAD(info, errret) \
do { \
ALPM_LOG_FUNC; \
ASSERT(handle != NULL, return(errret)); \
ASSERT(pkg != NULL, return(errret)); \
ASSERT(handle != NULL, return (errret)); \
ASSERT(pkg != NULL, return (errret)); \
if(pkg->origin != PKG_FROM_FILE && !(pkg->infolevel & info)) { \
_alpm_local_db_read(pkg->origin_data.db, pkg, info); \
} \
@ -73,13 +73,13 @@ static const char *_cache_get_filename(pmpkg_t *pkg)
static const char *_cache_get_name(pmpkg_t *pkg)
{
ASSERT(pkg != NULL, return(NULL));
ASSERT(pkg != NULL, return NULL);
return pkg->name;
}
static const char *_cache_get_version(pmpkg_t *pkg)
{
ASSERT(pkg != NULL, return(NULL));
ASSERT(pkg != NULL, return NULL);
return pkg->version;
}
@ -160,8 +160,8 @@ static int _cache_has_scriptlet(pmpkg_t *pkg)
ALPM_LOG_FUNC;
/* Sanity checks */
ASSERT(handle != NULL, return(-1));
ASSERT(pkg != NULL, return(-1));
ASSERT(handle != NULL, return -1);
ASSERT(pkg != NULL, return -1);
if(!(pkg->infolevel & INFRQ_SCRIPTLET)) {
_alpm_local_db_read(pkg->origin_data.db, pkg, INFRQ_SCRIPTLET);
@ -210,8 +210,8 @@ static alpm_list_t *_cache_get_files(pmpkg_t *pkg)
ALPM_LOG_FUNC;
/* Sanity checks */
ASSERT(handle != NULL, return(NULL));
ASSERT(pkg != NULL, return(NULL));
ASSERT(handle != NULL, return NULL);
ASSERT(pkg != NULL, return NULL);
if(pkg->origin == PKG_FROM_LOCALDB
&& !(pkg->infolevel & INFRQ_FILES)) {
@ -225,8 +225,8 @@ static alpm_list_t *_cache_get_backup(pmpkg_t *pkg)
ALPM_LOG_FUNC;
/* Sanity checks */
ASSERT(handle != NULL, return(NULL));
ASSERT(pkg != NULL, return(NULL));
ASSERT(handle != NULL, return NULL);
ASSERT(pkg != NULL, return NULL);
if(pkg->origin == PKG_FROM_LOCALDB
&& !(pkg->infolevel & INFRQ_FILES)) {
@ -246,8 +246,8 @@ static void *_cache_changelog_open(pmpkg_t *pkg)
ALPM_LOG_FUNC;
/* Sanity checks */
ASSERT(handle != NULL, return(NULL));
ASSERT(pkg != NULL, return(NULL));
ASSERT(handle != NULL, return NULL);
ASSERT(pkg != NULL, return NULL);
char clfile[PATH_MAX];
snprintf(clfile, PATH_MAX, "%s/%s/%s-%s/changelog",
@ -270,13 +270,13 @@ static void *_cache_changelog_open(pmpkg_t *pkg)
static size_t _cache_changelog_read(void *ptr, size_t size,
const pmpkg_t *pkg, const void *fp)
{
return ( fread(ptr, 1, size, (FILE*)fp) );
return fread(ptr, 1, size, (FILE *)fp);
}
/*
static int _cache_changelog_feof(const pmpkg_t *pkg, void *fp)
{
return( feof((FILE*)fp) );
return feof((FILE*)fp);
}
*/
@ -289,7 +289,7 @@ static int _cache_changelog_feof(const pmpkg_t *pkg, void *fp)
*/
static int _cache_changelog_close(const pmpkg_t *pkg, void *fp)
{
return( fclose((FILE*)fp) );
return fclose((FILE *)fp);
}
@ -345,14 +345,14 @@ static int checkdbdir(pmdb_t *db)
RET_ERR(PM_ERR_SYSTEM, -1);
}
}
return(0);
return 0;
}
static int is_dir(const char *path, struct dirent *entry)
{
#ifdef HAVE_STRUCT_DIRENT_D_TYPE
if(entry->d_type != DT_UNKNOWN) {
return(entry->d_type == DT_DIR);
return (entry->d_type == DT_DIR);
}
#endif
{
@ -362,11 +362,11 @@ static int is_dir(const char *path, struct dirent *entry)
snprintf(buffer, PATH_MAX, "%s/%s", path, entry->d_name);
if (!stat(buffer, &sbuf)) {
return(S_ISDIR(sbuf.st_mode));
return S_ISDIR(sbuf.st_mode);
}
}
return(0);
return 0;
}
static int local_db_populate(pmdb_t *db)
@ -390,7 +390,7 @@ static int local_db_populate(pmdb_t *db)
if(dbdir == NULL) {
if(errno == ENOENT) {
/* no database existing yet is not an error */
return(0);
return 0;
}
RET_ERR(PM_ERR_DB_OPEN, -1);
}
@ -476,7 +476,7 @@ static int local_db_populate(pmdb_t *db)
if(count > 0) {
db->pkgcache->list = alpm_list_msort(db->pkgcache->list, (size_t)count, _alpm_pkg_cmp);
}
return(count);
return count;
}
/* Note: the return value must be freed by the caller */
@ -490,7 +490,7 @@ static char *get_pkgpath(pmdb_t *db, pmpkg_t *info)
len = strlen(dbpath) + strlen(info->name) + strlen(info->version) + 3;
MALLOC(pkgpath, len, RET_ERR(PM_ERR_MEMORY, NULL));
sprintf(pkgpath, "%s%s-%s/", dbpath, info->name, info->version);
return(pkgpath);
return pkgpath;
}
@ -509,14 +509,14 @@ int _alpm_local_db_read(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq)
if(info == NULL || info->name == NULL || info->version == NULL) {
_alpm_log(PM_LOG_DEBUG, "invalid package entry provided to _alpm_local_db_read, skipping\n");
return(-1);
return -1;
}
if(info->origin != PKG_FROM_LOCALDB) {
_alpm_log(PM_LOG_DEBUG,
"request to read info for a non-local package '%s', skipping...\n",
info->name);
return(-1);
return -1;
}
/* bitmask logic here:
@ -526,7 +526,7 @@ int _alpm_local_db_read(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq)
* == to inforeq? nope, we need to load more info. */
if((info->infolevel & inforeq) == inforeq) {
/* already loaded all of this info, do nothing */
return(0);
return 0;
}
_alpm_log(PM_LOG_FUNCTION, "loading package data for %s : level=0x%x\n",
info->name, inforeq);
@ -706,14 +706,14 @@ int _alpm_local_db_read(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq)
info->infolevel |= inforeq;
free(pkgpath);
return(0);
return 0;
error:
free(pkgpath);
if(fp) {
fclose(fp);
}
return(-1);
return -1;
}
int _alpm_local_db_prepare(pmdb_t *db, pmpkg_t *info)
@ -723,7 +723,7 @@ int _alpm_local_db_prepare(pmdb_t *db, pmpkg_t *info)
char *pkgpath = NULL;
if(checkdbdir(db) != 0) {
return(-1);
return -1;
}
oldmask = umask(0000);
@ -737,7 +737,7 @@ int _alpm_local_db_prepare(pmdb_t *db, pmpkg_t *info)
free(pkgpath);
umask(oldmask);
return(retval);
return retval;
}
int _alpm_local_db_write(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq)
@ -752,7 +752,7 @@ int _alpm_local_db_write(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq)
ALPM_LOG_FUNC;
if(db == NULL || info == NULL) {
return(-1);
return -1;
}
pkgpath = get_pkgpath(db, info);
@ -761,7 +761,7 @@ int _alpm_local_db_write(pmdb_t *db, pmpkg_t *info, pmdbinfrq_t inforeq)
oldmask = umask(0022);
if(strcmp(db->treename, "local") != 0) {
return(-1);
return -1;
}
/* DESC */
@ -904,7 +904,7 @@ cleanup:
fclose(fp);
}
return(retval);
return retval;
}
int _alpm_local_db_remove(pmdb_t *db, pmpkg_t *info)
@ -925,7 +925,7 @@ int _alpm_local_db_remove(pmdb_t *db, pmpkg_t *info)
if(ret != 0) {
ret = -1;
}
return(ret);
return ret;
}
static int local_db_version(pmdb_t *db)
@ -977,7 +977,7 @@ done:
}
_alpm_log(PM_LOG_DEBUG, "local database version %d\n", version);
return(version);
return version;
}
struct db_operations local_db_ops = {
@ -1001,7 +1001,7 @@ pmdb_t *_alpm_db_register_local(void)
}
handle->db_local = db;
return(db);
return db;
}
/* vim: set ts=2 sw=2 noet: */

26
lib/libalpm/be_package.c
View File

@ -47,7 +47,7 @@ static void *_package_changelog_open(pmpkg_t *pkg)
{
ALPM_LOG_FUNC;
ASSERT(pkg != NULL, return(NULL));
ASSERT(pkg != NULL, return NULL);
struct archive *archive = NULL;
struct archive_entry *entry;
@ -69,14 +69,14 @@ static void *_package_changelog_open(pmpkg_t *pkg)
const char *entry_name = archive_entry_pathname(entry);
if(strcmp(entry_name, ".CHANGELOG") == 0) {
return(archive);
return archive;
}
}
/* we didn't find a changelog */
archive_read_finish(archive);
errno = ENOENT;
return(NULL);
return NULL;
}
/**
@ -95,9 +95,9 @@ static size_t _package_changelog_read(void *ptr, size_t size,
/* Report error (negative values) */
if(sret < 0) {
pm_errno = PM_ERR_LIBARCHIVE;
return(0);
return 0;
} else {
return((size_t)sret);
return (size_t)sret;
}
}
@ -105,7 +105,7 @@ static size_t _package_changelog_read(void *ptr, size_t size,
static int _package_changelog_feof(const pmpkg_t *pkg, void *fp)
{
// note: this doesn't quite work, no feof in libarchive
return( archive_read_data((struct archive*)fp, NULL, 0) );
return archive_read_data((struct archive*)fp, NULL, 0);
}
*/
@ -118,7 +118,7 @@ static int _package_changelog_feof(const pmpkg_t *pkg, void *fp)
*/
static int _package_changelog_close(const pmpkg_t *pkg, void *fp)
{
return( archive_read_finish((struct archive *)fp) );
return archive_read_finish((struct archive *)fp);
}
/** Package file operations struct accessor. We implement this as a method
@ -137,7 +137,7 @@ static struct pkg_operations *get_file_pkg_ops(void)
file_pkg_ops.changelog_close = _package_changelog_close;
file_pkg_ops_initialized = 1;
}
return(&file_pkg_ops);
return &file_pkg_ops;
}
/**
@ -226,7 +226,7 @@ static int parse_descfile(struct archive *a, pmpkg_t *newpkg)
line[0] = '\0';
}
return(0);
return 0;
}
/**
@ -356,7 +356,7 @@ static pmpkg_t *pkg_load(const char *pkgfile, int full)
newpkg->infolevel = INFRQ_BASE | INFRQ_DESC;
}
return(newpkg);
return newpkg;
pkg_invalid:
pm_errno = PM_ERR_PKG_INVALID;
@ -364,7 +364,7 @@ error:
_alpm_pkg_free(newpkg);
archive_read_finish(archive);
return(NULL);
return NULL;
}
/** Create a package from a file.
@ -389,10 +389,10 @@ int SYMEXPORT alpm_pkg_load(const char *filename, int full, pmpkg_t **pkg)
*pkg = pkg_load(filename, full);
if(*pkg == NULL) {
/* pm_errno is set by pkg_load */
return(-1);
return -1;
}
return(0);
return 0;
}
/* vim: set ts=2 sw=2 noet: */

20
lib/libalpm/be_sync.c
View File

@ -133,17 +133,17 @@ int SYMEXPORT alpm_db_update(int force, pmdb_t *db)
if(ret == 1) {
/* files match, do nothing */
pm_errno = 0;
return(1);
return 1;
} else if(ret == -1) {
/* pm_errno was set by the download code */
_alpm_log(PM_LOG_DEBUG, "failed to sync db: %s\n", alpm_strerrorlast());
return(-1);
return -1;
}
/* Cache needs to be rebuilt */
_alpm_db_free_pkgcache(db);
return(0);
return 0;
}
/* Forward decl so I don't reorganize the whole file right now */
@ -204,7 +204,7 @@ static size_t estimate_package_count(struct stat *st, struct archive *archive)
/* assume it is at least somewhat compressed */
per_package = 200;
}
return((size_t)(st->st_size / per_package) + 1);
return (size_t)((st->st_size / per_package) + 1);
}
static int sync_db_populate(pmdb_t *db)
@ -294,7 +294,7 @@ static int sync_db_populate(pmdb_t *db)
}
archive_read_finish(archive);
return(count);
return count;
}
#define READ_NEXT(s) do { \
@ -334,7 +334,7 @@ static int sync_db_read(pmdb_t *db, struct archive *archive,
}
if(entryname == NULL) {
_alpm_log(PM_LOG_DEBUG, "invalid archive entry provided to _alpm_sync_db_read, skipping\n");
return(-1);
return -1;
}
_alpm_log(PM_LOG_FUNCTION, "loading package data from archive entry %s\n",
@ -365,7 +365,7 @@ static int sync_db_read(pmdb_t *db, struct archive *archive,
if(pkg == NULL) {
_alpm_log(PM_LOG_DEBUG, "package %s not found in %s sync database",
pkgname, db->treename);
return(-1);
return -1;
}
if(strcmp(filename, "desc") == 0 || strcmp(filename, "depends") == 0
@ -452,12 +452,12 @@ static int sync_db_read(pmdb_t *db, struct archive *archive,
error:
FREE(pkgname);
/* TODO: return 0 always? */
return(0);
return 0;
}
static int sync_db_version(pmdb_t *db)
{
return(2);
return 2;
}
struct db_operations sync_db_ops = {
@ -490,7 +490,7 @@ pmdb_t *_alpm_db_register_sync(const char *treename)
db->ops = &sync_db_ops;
handle->dbs_sync = alpm_list_add(handle->dbs_sync, db);
return(db);
return db;
}

62
lib/libalpm/conflict.c
View File

@ -53,7 +53,7 @@ pmconflict_t *_alpm_conflict_new(const char *package1, const char *package2,
STRDUP(conflict->package2, package2, RET_ERR(PM_ERR_MEMORY, NULL));
STRDUP(conflict->reason, reason, RET_ERR(PM_ERR_MEMORY, NULL));
return(conflict);
return conflict;
}
void _alpm_conflict_free(pmconflict_t *conflict)
@ -73,7 +73,7 @@ pmconflict_t *_alpm_conflict_dup(const pmconflict_t *conflict)
STRDUP(newconflict->package2, conflict->package2, RET_ERR(PM_ERR_MEMORY, NULL));
STRDUP(newconflict->reason, conflict->reason, RET_ERR(PM_ERR_MEMORY, NULL));
return(newconflict);
return newconflict;
}
static int conflict_isin(pmconflict_t *needle, alpm_list_t *haystack)
@ -90,11 +90,11 @@ static int conflict_isin(pmconflict_t *needle, alpm_list_t *haystack)
const char *cpkg2 = conflict->package2;
if((strcmp(cpkg1, npkg1) == 0 && strcmp(cpkg2, npkg2) == 0)
|| (strcmp(cpkg1, npkg2) == 0 && strcmp(cpkg2, npkg1) == 0)) {
return(1);
return 1;
}
}
return(0);
return 0;
}
/** Adds the pkg1/pkg2 conflict to the baddeps list
@ -173,7 +173,7 @@ alpm_list_t *_alpm_innerconflicts(alpm_list_t *packages)
_alpm_log(PM_LOG_DEBUG, "check targets vs targets\n");
check_conflict(packages, packages, &baddeps, 0);
return(baddeps);
return baddeps;
}
/* Check for target vs (db - target) conflicts
@ -187,7 +187,7 @@ alpm_list_t *_alpm_outerconflicts(pmdb_t *db, alpm_list_t *packages)
ALPM_LOG_FUNC;
if(db == NULL) {
return(NULL);
return NULL;
}
alpm_list_t *dblist = alpm_list_diff(_alpm_db_get_pkgcache(db),
@ -200,7 +200,7 @@ alpm_list_t *_alpm_outerconflicts(pmdb_t *db, alpm_list_t *packages)
check_conflict(dblist, packages, &baddeps, -1);
alpm_list_free(dblist);
return(baddeps);
return baddeps;
}
/** Check the package conflicts in a database
@ -209,7 +209,7 @@ alpm_list_t *_alpm_outerconflicts(pmdb_t *db, alpm_list_t *packages)
* @return an alpm_list_t of pmconflict_t
*/
alpm_list_t SYMEXPORT *alpm_checkconflicts(alpm_list_t *pkglist) {
return(_alpm_innerconflicts(pkglist));
return _alpm_innerconflicts(pkglist);
}
/* Returns a alpm_list_t* of file conflicts.
@ -246,7 +246,7 @@ static alpm_list_t *chk_fileconflicts(alpm_list_t *filesA, alpm_list_t *filesB)
}
}
return(ret);
return ret;
}
/* Returns a alpm_list_t* of files that are in filesA but *NOT* in filesB
@ -293,7 +293,7 @@ static alpm_list_t *chk_filedifference(alpm_list_t *filesA, alpm_list_t *filesB)
pA = pA->next;
}
return(ret);
return ret;
}
/* Adds pmfileconflict_t to a conflicts list. Pass the conflicts list, type (either
@ -321,7 +321,7 @@ static alpm_list_t *add_fileconflict(alpm_list_t *conflicts,
_alpm_log(PM_LOG_DEBUG, "found file conflict %s, packages %s and %s\n",
filestr, name1, name2 ? name2 : "(filesystem)");
return(conflicts);
return conflicts;
}
void _alpm_fileconflict_free(pmfileconflict_t *conflict)
@ -345,7 +345,7 @@ static int dir_belongsto_pkg(char *dirpath, pmpkg_t *pkg)
snprintf(abspath, PATH_MAX, "%s%s", handle->root, dirpath);
dir = opendir(abspath);
if(dir == NULL) {
return(1);
return 1;
}
while((ent = readdir(dir)) != NULL) {
const char *name = ent->d_name;
@ -363,19 +363,19 @@ static int dir_belongsto_pkg(char *dirpath, pmpkg_t *pkg)
continue;
} else {
closedir(dir);
return(0);
return 0;
}
} else {
if(alpm_list_find_str(alpm_pkg_get_files(pkg), path)) {
continue;
} else {
closedir(dir);
return(0);
return 0;
}
}
}
closedir(dir);
return(1);
return 1;
}
/* Find file conflicts that may occur during the transaction with two checks:
@ -391,7 +391,7 @@ alpm_list_t *_alpm_db_find_fileconflicts(pmdb_t *db, pmtrans_t *trans,
ALPM_LOG_FUNC;
if(db == NULL || upgrade == NULL || trans == NULL) {
return(NULL);
return NULL;
}
/* TODO this whole function needs a huge change, which hopefully will
@ -540,7 +540,7 @@ alpm_list_t *_alpm_db_find_fileconflicts(pmdb_t *db, pmtrans_t *trans,
PROGRESS(trans, PM_TRANS_PROGRESS_CONFLICTS_START, "", 100,
numtargs, current);
return(conflicts);
return conflicts;
}
const char SYMEXPORT *alpm_conflict_get_package1(pmconflict_t *conflict)
@ -548,8 +548,8 @@ const char SYMEXPORT *alpm_conflict_get_package1(pmconflict_t *conflict)
ALPM_LOG_FUNC;
/* Sanity checks */
ASSERT(handle != NULL, return(NULL));
ASSERT(conflict != NULL, return(NULL));
ASSERT(handle != NULL, return NULL);
ASSERT(conflict != NULL, return NULL);
return conflict->package1;
}
@ -559,8 +559,8 @@ const char SYMEXPORT *alpm_conflict_get_package2(pmconflict_t *conflict)
ALPM_LOG_FUNC;
/* Sanity checks */
ASSERT(handle != NULL, return(NULL));
ASSERT(conflict != NULL, return(NULL));
ASSERT(handle != NULL, return NULL);
ASSERT(conflict != NULL, return NULL);
return conflict->package2;
}
@ -570,8 +570,8 @@ const char SYMEXPORT *alpm_conflict_get_reason(pmconflict_t *conflict)
ALPM_LOG_FUNC;
/* Sanity checks */
ASSERT(handle != NULL, return(NULL));
ASSERT(conflict != NULL, return(NULL));
ASSERT(handle != NULL, return NULL);
ASSERT(conflict != NULL, return NULL);
return conflict->reason;
}
@ -581,8 +581,8 @@ const char SYMEXPORT *alpm_fileconflict_get_target(pmfileconflict_t *conflict)
ALPM_LOG_FUNC;
/* Sanity checks */
ASSERT(handle != NULL, return(NULL));
ASSERT(conflict != NULL, return(NULL));
ASSERT(handle != NULL, return NULL);
ASSERT(conflict != NULL, return NULL);
return conflict->target;
}
@ -592,8 +592,8 @@ pmfileconflicttype_t SYMEXPORT alpm_fileconflict_get_type(pmfileconflict_t *conf
ALPM_LOG_FUNC;
/* Sanity checks */
ASSERT(handle != NULL, return(-1));
ASSERT(conflict != NULL, return(-1));
ASSERT(handle != NULL, return -1);
ASSERT(conflict != NULL, return -1);
return conflict->type;
}
@ -603,8 +603,8 @@ const char SYMEXPORT *alpm_fileconflict_get_file(pmfileconflict_t *conflict)
ALPM_LOG_FUNC;
/* Sanity checks */
ASSERT(handle != NULL, return(NULL));
ASSERT(conflict != NULL, return(NULL));
ASSERT(handle != NULL, return NULL);
ASSERT(conflict != NULL, return NULL);
return conflict->file;
}
@ -614,8 +614,8 @@ const char SYMEXPORT *alpm_fileconflict_get_ctarget(pmfileconflict_t *conflict)
ALPM_LOG_FUNC;
/* Sanity checks */
ASSERT(handle != NULL, return(NULL));
ASSERT(conflict != NULL, return(NULL));
ASSERT(handle != NULL, return NULL);
ASSERT(conflict != NULL, return NULL);
return conflict->ctarget;
}

120
lib/libalpm/db.c
View File

@ -61,7 +61,7 @@ pmdb_t SYMEXPORT *alpm_db_register_sync(const char *treename)
/* Do not register a database if a transaction is on-going */
ASSERT(handle->trans == NULL, RET_ERR(PM_ERR_TRANS_NOT_NULL, NULL));
return(_alpm_db_register_sync(treename));
return _alpm_db_register_sync(treename);
}
/* Helper function for alpm_db_unregister{_all} */
@ -104,7 +104,7 @@ int SYMEXPORT alpm_db_unregister_all(void)
i->data = NULL;
}
FREELIST(handle->dbs_sync);
return(0);
return 0;
}
/** Unregister a package database
@ -144,7 +144,7 @@ int SYMEXPORT alpm_db_unregister(pmdb_t *db)
}
db->ops->unregister(db);
return(0);
return 0;
}
/** Set the serverlist of a database.
@ -191,7 +191,7 @@ int SYMEXPORT alpm_db_setserver(pmdb_t *db, const char *url)
_alpm_log(PM_LOG_DEBUG, "serverlist flushed for '%s'\n", db->treename);
}
return(0);
return 0;
}
/** Get the name of a package database
@ -203,8 +203,8 @@ const char SYMEXPORT *alpm_db_get_name(const pmdb_t *db)
ALPM_LOG_FUNC;
/* Sanity checks */
ASSERT(handle != NULL, return(NULL));
ASSERT(db != NULL, return(NULL));
ASSERT(handle != NULL, return NULL);
ASSERT(db != NULL, return NULL);
return db->treename;
}
@ -220,13 +220,13 @@ const char SYMEXPORT *alpm_db_get_url(const pmdb_t *db)
ALPM_LOG_FUNC;
/* Sanity checks */
ASSERT(handle != NULL, return(NULL));
ASSERT(db != NULL, return(NULL));
ASSERT(db->servers != NULL, return(NULL));
ASSERT(handle != NULL, return NULL);
ASSERT(db != NULL, return NULL);
ASSERT(db->servers != NULL, return NULL);
url = (char*)db->servers->data;
return(url);
return url;
}
@ -240,11 +240,11 @@ pmpkg_t SYMEXPORT *alpm_db_get_pkg(pmdb_t *db, const char *name)
ALPM_LOG_FUNC;
/* Sanity checks */
ASSERT(handle != NULL, return(NULL));
ASSERT(db != NULL, return(NULL));
ASSERT(name != NULL && strlen(name) != 0, return(NULL));
ASSERT(handle != NULL, return NULL);
ASSERT(db != NULL, return NULL);
ASSERT(name != NULL && strlen(name) != 0, return NULL);
return(_alpm_db_get_pkgfromcache(db, name));
return _alpm_db_get_pkgfromcache(db, name);
}
/** Get the package cache of a package database
@ -256,10 +256,10 @@ alpm_list_t SYMEXPORT *alpm_db_get_pkgcache(pmdb_t *db)
ALPM_LOG_FUNC;
/* Sanity checks */
ASSERT(handle != NULL, return(NULL));
ASSERT(db != NULL, return(NULL));
ASSERT(handle != NULL, return NULL);
ASSERT(db != NULL, return NULL);
return(_alpm_db_get_pkgcache(db));
return _alpm_db_get_pkgcache(db);
}
/** Get a group entry from a package database
@ -272,11 +272,11 @@ pmgrp_t SYMEXPORT *alpm_db_readgrp(pmdb_t *db, const char *name)
ALPM_LOG_FUNC;
/* Sanity checks */
ASSERT(handle != NULL, return(NULL));
ASSERT(db != NULL, return(NULL));
ASSERT(name != NULL && strlen(name) != 0, return(NULL));
ASSERT(handle != NULL, return NULL);
ASSERT(db != NULL, return NULL);
ASSERT(name != NULL && strlen(name) != 0, return NULL);
return(_alpm_db_get_grpfromcache(db, name));
return _alpm_db_get_grpfromcache(db, name);
}
/** Get the group cache of a package database
@ -288,10 +288,10 @@ alpm_list_t SYMEXPORT *alpm_db_get_grpcache(pmdb_t *db)
ALPM_LOG_FUNC;
/* Sanity checks */
ASSERT(handle != NULL, return(NULL));
ASSERT(db != NULL, return(NULL));
ASSERT(handle != NULL, return NULL);
ASSERT(db != NULL, return NULL);
return(_alpm_db_get_grpcache(db));
return _alpm_db_get_grpcache(db);
}
/** Searches a database
@ -304,10 +304,10 @@ alpm_list_t SYMEXPORT *alpm_db_search(pmdb_t *db, const alpm_list_t* needles)
ALPM_LOG_FUNC;
/* Sanity checks */
ASSERT(handle != NULL, return(NULL));
ASSERT(db != NULL, return(NULL));
ASSERT(handle != NULL, return NULL);
ASSERT(db != NULL, return NULL);
return(_alpm_db_search(db, needles));
return _alpm_db_search(db, needles);
}
/** Set install reason for a package in db
@ -332,16 +332,16 @@ int SYMEXPORT alpm_db_set_pkgreason(pmdb_t *db, const char *name, pmpkgreason_t
_alpm_log(PM_LOG_DEBUG, "setting install reason %u for %s/%s\n", reason, db->treename, name);
if(alpm_pkg_get_reason(pkg) == reason) {
/* we are done */
return(0);
return 0;
}
/* set reason (in pkgcache) */
pkg->reason = reason;
/* write DESC */
if(_alpm_local_db_write(db, pkg, INFRQ_DESC)) {
return(-1);
return -1;
}
return(0);
return 0;
}
/** @} */
@ -356,7 +356,7 @@ pmdb_t *_alpm_db_new(const char *treename, int is_local)
STRDUP(db->treename, treename, RET_ERR(PM_ERR_MEMORY, NULL));
db->is_local = is_local;
return(db);
return db;
}
void _alpm_db_free(pmdb_t *db)
@ -377,7 +377,7 @@ void _alpm_db_free(pmdb_t *db)
const char *_alpm_db_path(pmdb_t *db)
{
if(!db) {
return(NULL);
return NULL;
}
if(!db->_path) {
const char *dbpath;
@ -402,22 +402,22 @@ const char *_alpm_db_path(pmdb_t *db)
_alpm_log(PM_LOG_DEBUG, "database path for tree %s set to %s\n",
db->treename, db->_path);
}
return(db->_path);
return db->_path;
}
int _alpm_db_version(pmdb_t *db)
{
if(!db) {
return(-1);
return -1;
}
return(db->ops->version(db));
return db->ops->version(db);
}
int _alpm_db_cmp(const void *d1, const void *d2)
{
pmdb_t *db1 = (pmdb_t *)d1;
pmdb_t *db2 = (pmdb_t *)d2;
return(strcmp(db1->treename, db2->treename));
return strcmp(db1->treename, db2->treename);
}
alpm_list_t *_alpm_db_search(pmdb_t *db, const alpm_list_t *needles)
@ -493,7 +493,7 @@ alpm_list_t *_alpm_db_search(pmdb_t *db, const alpm_list_t *needles)
regfree(&reg);
}
return(ret);
return ret;
}
/* Returns a new package cache from db.
@ -504,7 +504,7 @@ int _alpm_db_load_pkgcache(pmdb_t *db)
ALPM_LOG_FUNC;
if(db == NULL) {
return(-1);
return -1;
}
_alpm_db_free_pkgcache(db);
@ -513,11 +513,11 @@ int _alpm_db_load_pkgcache(pmdb_t *db)
if(db->ops->populate(db) == -1) {
_alpm_log(PM_LOG_DEBUG,
"failed to load package cache for repository '%s'\n", db->treename);
return(-1);
return -1;
}
db->pkgcache_loaded = 1;
return(0);
return 0;
}
void _alpm_db_free_pkgcache(pmdb_t *db)
@ -544,7 +544,7 @@ pmpkghash_t *_alpm_db_get_pkgcache_hash(pmdb_t *db)
ALPM_LOG_FUNC;
if(db == NULL) {
return(NULL);
return NULL;
}
if(!db->pkgcache_loaded) {
@ -556,7 +556,7 @@ pmpkghash_t *_alpm_db_get_pkgcache_hash(pmdb_t *db)
_alpm_log(PM_LOG_DEBUG, "warning: pkgcache is NULL for db '%s'\n", db->treename);
}
return(db->pkgcache);
return db->pkgcache;
}
alpm_list_t *_alpm_db_get_pkgcache(pmdb_t *db)
@ -566,10 +566,10 @@ alpm_list_t *_alpm_db_get_pkgcache(pmdb_t *db)
pmpkghash_t *hash = _alpm_db_get_pkgcache_hash(db);
if(hash == NULL) {
return(NULL);
return NULL;
}
return(hash->list);
return hash->list;
}
/* "duplicate" pkg then add it to pkgcache */
@ -580,12 +580,12 @@ int _alpm_db_add_pkgincache(pmdb_t *db, pmpkg_t *pkg)
ALPM_LOG_FUNC;
if(db == NULL || !db->pkgcache_loaded || pkg == NULL) {
return(-1);
return -1;
}
newpkg = _alpm_pkg_dup(pkg);
if(newpkg == NULL) {
return(-1);
return -1;
}
_alpm_log(PM_LOG_DEBUG, "adding entry '%s' in '%s' cache\n",
@ -594,7 +594,7 @@ int _alpm_db_add_pkgincache(pmdb_t *db, pmpkg_t *pkg)
_alpm_db_free_grpcache(db);
return(0);
return 0;
}
int _alpm_db_remove_pkgfromcache(pmdb_t *db, pmpkg_t *pkg)
@ -604,7 +604,7 @@ int _alpm_db_remove_pkgfromcache(pmdb_t *db, pmpkg_t *pkg)
ALPM_LOG_FUNC;
if(db == NULL || !db->pkgcache_loaded || pkg == NULL) {
return(-1);
return -1;
}
_alpm_log(PM_LOG_DEBUG, "removing entry '%s' from '%s' cache\n",
@ -615,14 +615,14 @@ int _alpm_db_remove_pkgfromcache(pmdb_t *db, pmpkg_t *pkg)
/* package not found */
_alpm_log(PM_LOG_DEBUG, "cannot remove entry '%s' from '%s' cache: not found\n",
alpm_pkg_get_name(pkg), db->treename);
return(-1);
return -1;
}
_alpm_pkg_free(data);
_alpm_db_free_grpcache(db);
return(0);
return 0;
}
pmpkg_t *_alpm_db_get_pkgfromcache(pmdb_t *db, const char *target)
@ -630,17 +630,17 @@ pmpkg_t *_alpm_db_get_pkgfromcache(pmdb_t *db, const char *target)
ALPM_LOG_FUNC;
if(db == NULL) {
return(NULL);
return NULL;
}
pmpkghash_t *pkgcache = _alpm_db_get_pkgcache_hash(db);
if(!pkgcache) {
_alpm_log(PM_LOG_DEBUG, "warning: failed to get '%s' from NULL pkgcache\n",
target);
return(NULL);
return NULL;
}
return(_alpm_pkghash_find(pkgcache, target));
return _alpm_pkghash_find(pkgcache, target);
}
/* Returns a new group cache from db.
@ -652,7 +652,7 @@ int _alpm_db_load_grpcache(pmdb_t *db)
ALPM_LOG_FUNC;
if(db == NULL) {
return(-1);
return -1;
}
_alpm_log(PM_LOG_DEBUG, "loading group cache for repository '%s'\n",
@ -690,7 +690,7 @@ int _alpm_db_load_grpcache(pmdb_t *db)
}
db->grpcache_loaded = 1;
return(0);
return 0;
}
void _alpm_db_free_grpcache(pmdb_t *db)
@ -719,14 +719,14 @@ alpm_list_t *_alpm_db_get_grpcache(pmdb_t *db)
ALPM_LOG_FUNC;
if(db == NULL) {
return(NULL);
return NULL;
}
if(!db->grpcache_loaded) {
_alpm_db_load_grpcache(db);
}
return(db->grpcache);
return db->grpcache;
}
pmgrp_t *_alpm_db_get_grpfromcache(pmdb_t *db, const char *target)
@ -736,18 +736,18 @@ pmgrp_t *_alpm_db_get_grpfromcache(pmdb_t *db, const char *target)
ALPM_LOG_FUNC;
if(db == NULL || target == NULL || strlen(target) == 0) {
return(NULL);
return NULL;
}
for(i = _alpm_db_get_grpcache(db); i; i = i->next) {
pmgrp_t *info = i->data;
if(strcmp(info->name, target) == 0) {
return(info);
return info;
}
}
return(NULL);
return NULL;
}
/* vim: set ts=2 sw=2 noet: */

36
lib/libalpm/delta.c
View File

@ -41,32 +41,32 @@
const char SYMEXPORT *alpm_delta_get_from(pmdelta_t *delta)
{
ASSERT(delta != NULL, return(NULL));
return(delta->from);
ASSERT(delta != NULL, return NULL);
return delta->from;
}
const char SYMEXPORT *alpm_delta_get_to(pmdelta_t *delta)
{
ASSERT(delta != NULL, return(NULL));
return(delta->to);
ASSERT(delta != NULL, return NULL);
return delta->to;
}
const char SYMEXPORT *alpm_delta_get_filename(pmdelta_t *delta)
{
ASSERT(delta != NULL, return(NULL));
return(delta->delta);
ASSERT(delta != NULL, return NULL);
return delta->delta;
}
const char SYMEXPORT *alpm_delta_get_md5sum(pmdelta_t *delta)
{
ASSERT(delta != NULL, return(NULL));
return(delta->delta_md5);
ASSERT(delta != NULL, return NULL);
return delta->delta_md5;
}
off_t SYMEXPORT alpm_delta_get_size(pmdelta_t *delta)
{
ASSERT(delta != NULL, return(-1));
return(delta->delta_size);
ASSERT(delta != NULL, return -1);
return delta->delta_size;
}
/** @} */
@ -108,7 +108,7 @@ static alpm_list_t *graph_init(alpm_list_t *deltas, int reverse)
}
v_i->childptr = v_i->children;
}
return(vertices);
return vertices;
}
static void graph_init_size(alpm_list_t *vertices)
@ -205,7 +205,7 @@ static off_t shortest_path(alpm_list_t *vertices, const char *to, alpm_list_t **
*path = alpm_list_reverse(rpath);
alpm_list_free(rpath);
return(bestsize);
return bestsize;
}
/** Calculates the shortest path from one version to another.
@ -229,7 +229,7 @@ off_t _alpm_shortest_delta_path(alpm_list_t *deltas,
if(deltas == NULL) {
*path = NULL;
return(bestsize);
return bestsize;
}
_alpm_log(PM_LOG_DEBUG, "started delta shortest-path search for '%s'\n", to);
@ -245,7 +245,7 @@ off_t _alpm_shortest_delta_path(alpm_list_t *deltas,
alpm_list_free(vertices);
*path = bestpath;
return(bestsize);
return bestsize;
}
static alpm_list_t *find_unused(alpm_list_t *deltas, const char *to, off_t quota)
@ -273,7 +273,7 @@ static alpm_list_t *find_unused(alpm_list_t *deltas, const char *to, off_t quota
}
alpm_list_free_inner(vertices, _alpm_graph_free);
alpm_list_free(vertices);
return(unused);
return unused;
}
alpm_list_t SYMEXPORT *alpm_pkg_unused_deltas(pmpkg_t *pkg)
@ -283,7 +283,7 @@ alpm_list_t SYMEXPORT *alpm_pkg_unused_deltas(pmpkg_t *pkg)
alpm_pkg_get_deltas(pkg),
alpm_pkg_get_filename(pkg),
pkgsize * MAX_DELTA_RATIO);
return(unused);
return unused;
}
@ -308,7 +308,7 @@ pmdelta_t *_alpm_delta_parse(char *line)
if(regexec(&reg, line, 0, 0, 0) != 0) {
/* delta line is invalid, return NULL */
regfree(&reg);
return(NULL);
return NULL;
}
regfree(&reg);
@ -339,7 +339,7 @@ pmdelta_t *_alpm_delta_parse(char *line)
_alpm_log(PM_LOG_DEBUG, "delta : %s %s '%jd'\n", delta->from, delta->to, (intmax_t)delta->delta_size);
return(delta);
return delta;
}
void _alpm_delta_free(pmdelta_t *delta)

88
lib/libalpm/deps.c
View File

@ -56,7 +56,7 @@ pmdepmissing_t *_alpm_depmiss_new(const char *target, pmdepend_t *dep,
miss->depend = _alpm_dep_dup(dep);
STRDUP(miss->causingpkg, causingpkg, RET_ERR(PM_ERR_MEMORY, NULL));
return(miss);
return miss;
}
void _alpm_depmiss_free(pmdepmissing_t *miss)
@ -98,7 +98,7 @@ static alpm_list_t *dep_graph_init(alpm_list_t *targets)
}
vertex_i->childptr = vertex_i->children;
}
return(vertices);
return vertices;
}
/* Re-order a list of target packages with respect to their dependencies.
@ -125,7 +125,7 @@ alpm_list_t *_alpm_sortbydeps(alpm_list_t *targets, int reverse)
ALPM_LOG_FUNC;
if(targets == NULL) {
return(NULL);
return NULL;
}
_alpm_log(PM_LOG_DEBUG, "started sorting dependencies\n");
@ -189,7 +189,7 @@ alpm_list_t *_alpm_sortbydeps(alpm_list_t *targets, int reverse)
alpm_list_free_inner(vertices, _alpm_graph_free);
alpm_list_free(vertices);
return(newtargs);
return newtargs;
}
pmpkg_t *_alpm_find_dep_satisfier(alpm_list_t *pkgs, pmdepend_t *dep)
@ -199,10 +199,10 @@ pmpkg_t *_alpm_find_dep_satisfier(alpm_list_t *pkgs, pmdepend_t *dep)
for(i = pkgs; i; i = alpm_list_next(i)) {
pmpkg_t *pkg = i->data;
if(_alpm_depcmp_tolerant(pkg, dep)) {
return(pkg);
return pkg;
}
}
return(NULL);
return NULL;
}
/** Find a package satisfying a specified dependency.
@ -216,7 +216,7 @@ pmpkg_t SYMEXPORT *alpm_find_satisfier(alpm_list_t *pkgs, const char *depstring)
pmdepend_t *dep = _alpm_splitdep(depstring);
pmpkg_t *pkg = _alpm_find_dep_satisfier(pkgs, dep);
_alpm_dep_free(dep);
return(pkg);
return pkg;
}
/** Checks dependencies and returns missing ones in a list.
@ -300,7 +300,7 @@ alpm_list_t SYMEXPORT *alpm_checkdeps(alpm_list_t *pkglist, int reversedeps,
alpm_list_free(modified);
alpm_list_free(dblist);
return(baddeps);
return baddeps;
}
static int dep_vercmp(const char *version1, pmdepmod_t mod,
@ -321,7 +321,7 @@ static int dep_vercmp(const char *version1, pmdepmod_t mod,
default: equal = 1; break;
}
}
return(equal);
return equal;
}
/* nodepversion: skip version checking */
@ -345,7 +345,7 @@ static int _depcmp(pmpkg_t *pkg, pmdepend_t *dep, int nodepversion)
satisfy = (strcmp(pkg->name, dep->name) == 0
&& dep_vercmp(pkg->version, depmod, dep->version));
if(satisfy) {
return(satisfy);
return satisfy;
}
}
@ -371,7 +371,7 @@ static int _depcmp(pmpkg_t *pkg, pmdepend_t *dep, int nodepversion)
}
}
return(satisfy);
return satisfy;
}
/* tolerant : respects NODEPVERSION flag */
@ -384,13 +384,13 @@ int _alpm_depcmp_tolerant(pmpkg_t *pkg, pmdepend_t *dep)
nodepversion = flags & PM_TRANS_FLAG_NODEPVERSION;
}
return(_depcmp(pkg, dep, nodepversion));
return _depcmp(pkg, dep, nodepversion);
}
/* strict : ignores NODEPVERSION flag */
int _alpm_depcmp(pmpkg_t *pkg, pmdepend_t *dep)
{
return(_depcmp(pkg, dep, 0));
return _depcmp(pkg, dep, 0);
}
pmdepend_t *_alpm_splitdep(const char *depstring)
@ -399,7 +399,7 @@ pmdepend_t *_alpm_splitdep(const char *depstring)
const char *ptr, *version = NULL;
if(depstring == NULL) {
return(NULL);
return NULL;
}
CALLOC(depend, 1, sizeof(pmdepend_t), RET_ERR(PM_ERR_MEMORY, NULL));
@ -435,7 +435,7 @@ pmdepend_t *_alpm_splitdep(const char *depstring)
STRDUP(depend->version, version, RET_ERR(PM_ERR_MEMORY, NULL));
}
return(depend);
return depend;
}
pmdepend_t *_alpm_dep_dup(const pmdepend_t *dep)
@ -448,7 +448,7 @@ pmdepend_t *_alpm_dep_dup(const pmdepend_t *dep)
STRDUP(newdep->version, dep->version, RET_ERR(PM_ERR_MEMORY, NULL));
newdep->mod = dep->mod;
return(newdep);
return newdep;
}
/* These parameters are messy. We check if this package, given a list of
@ -461,7 +461,7 @@ static int can_remove_package(pmdb_t *db, pmpkg_t *pkg, alpm_list_t *targets,
alpm_list_t *i;
if(_alpm_pkg_find(targets, alpm_pkg_get_name(pkg))) {
return(0);
return 0;
}
if(!include_explicit) {
@ -469,7 +469,7 @@ static int can_remove_package(pmdb_t *db, pmpkg_t *pkg, alpm_list_t *targets,
if(alpm_pkg_get_reason(pkg) == PM_PKG_REASON_EXPLICIT) {
_alpm_log(PM_LOG_DEBUG, "excluding %s -- explicitly installed\n",
alpm_pkg_get_name(pkg));
return(0);
return 0;
}
}
@ -483,12 +483,12 @@ static int can_remove_package(pmdb_t *db, pmpkg_t *pkg, alpm_list_t *targets,
for(i = _alpm_db_get_pkgcache(db); i; i = i->next) {
pmpkg_t *lpkg = i->data;
if(_alpm_dep_edge(lpkg, pkg) && !_alpm_pkg_find(targets, lpkg->name)) {
return(0);
return 0;
}
}
/* it's ok to remove */
return(1);
return 1;
}
/**
@ -539,13 +539,13 @@ pmpkg_t SYMEXPORT *alpm_find_dbs_satisfier(alpm_list_t *dbs, const char *depstri
pmdepend_t *dep;
pmpkg_t *pkg;
ASSERT(dbs, return(NULL));
ASSERT(dbs, return NULL);
dep = _alpm_splitdep(depstring);
ASSERT(dep, return(NULL));
ASSERT(dep, return NULL);
pkg = _alpm_resolvedep(dep, dbs, NULL, 1);
_alpm_dep_free(dep);
return(pkg);
return pkg;
}
/**
@ -586,7 +586,7 @@ pmpkg_t *_alpm_resolvedep(pmdepend_t *dep, alpm_list_t *dbs,
continue;
}
}
return(pkg);
return pkg;
}
}
/* 2. satisfiers (skip literals here) */
@ -621,7 +621,7 @@ pmpkg_t *_alpm_resolvedep(pmdepend_t *dep, alpm_list_t *dbs,
pmpkg_t *pkg = i->data;
if (_alpm_pkghash_find(_alpm_db_get_pkgcache_hash(handle->db_local), pkg->name)) {
alpm_list_free(providers);
return(pkg);
return pkg;
}
}
count = alpm_list_count(providers);
@ -636,7 +636,7 @@ pmpkg_t *_alpm_resolvedep(pmdepend_t *dep, alpm_list_t *dbs,
if(index >= 0 && index < count) {
pmpkg_t *pkg = alpm_list_getdata(alpm_list_nth(providers, index));
alpm_list_free(providers);
return(pkg);
return pkg;
}
alpm_list_free(providers);
providers = NULL;
@ -647,7 +647,7 @@ pmpkg_t *_alpm_resolvedep(pmdepend_t *dep, alpm_list_t *dbs,
} else {
pm_errno = PM_ERR_PKG_NOT_FOUND;
}
return(NULL);
return NULL;
}
/* Computes resolvable dependencies for a given package and adds that package
@ -682,7 +682,7 @@ int _alpm_resolvedeps(alpm_list_t *localpkgs, alpm_list_t *dbs_sync, pmpkg_t *pk
ALPM_LOG_FUNC;
if(_alpm_pkg_find(*packages, pkg->name) != NULL) {
return(0);
return 0;
}
/* Create a copy of the packages list, so that it can be restored
@ -743,7 +743,7 @@ int _alpm_resolvedeps(alpm_list_t *localpkgs, alpm_list_t *dbs_sync, pmpkg_t *pk
alpm_list_free(packages_copy);
}
_alpm_log(PM_LOG_DEBUG, "finished resolving dependencies\n");
return(ret);
return ret;
}
/* Does pkg1 depend on pkg2, ie. does pkg2 satisfy a dependency of pkg1? */
@ -752,10 +752,10 @@ int _alpm_dep_edge(pmpkg_t *pkg1, pmpkg_t *pkg2)
alpm_list_t *i;
for(i = alpm_pkg_get_depends(pkg1); i; i = i->next) {
if(_alpm_depcmp_tolerant(pkg2, i->data)) {
return(1);
return 1;
}
}
return(0);
return 0;
}
const char SYMEXPORT *alpm_miss_get_target(const pmdepmissing_t *miss)
@ -763,9 +763,9 @@ const char SYMEXPORT *alpm_miss_get_target(const pmdepmissing_t *miss)
ALPM_LOG_FUNC;
/* Sanity checks */
ASSERT(miss != NULL, return(NULL));
ASSERT(miss != NULL, return NULL);
return(miss->target);
return miss->target;
}
const char SYMEXPORT *alpm_miss_get_causingpkg(const pmdepmissing_t *miss)
@ -773,7 +773,7 @@ const char SYMEXPORT *alpm_miss_get_causingpkg(const pmdepmissing_t *miss)
ALPM_LOG_FUNC;
/* Sanity checks */
ASSERT(miss != NULL, return(NULL));
ASSERT(miss != NULL, return NULL);
return miss->causingpkg;
}
@ -783,9 +783,9 @@ pmdepend_t SYMEXPORT *alpm_miss_get_dep(pmdepmissing_t *miss)
ALPM_LOG_FUNC;
/* Sanity checks */
ASSERT(miss != NULL, return(NULL));
ASSERT(miss != NULL, return NULL);
return(miss->depend);
return miss->depend;
}
pmdepmod_t SYMEXPORT alpm_dep_get_mod(const pmdepend_t *dep)
@ -793,9 +793,9 @@ pmdepmod_t SYMEXPORT alpm_dep_get_mod(const pmdepend_t *dep)
ALPM_LOG_FUNC;
/* Sanity checks */
ASSERT(dep != NULL, return(-1));
ASSERT(dep != NULL, return -1);
return(dep->mod);
return dep->mod;
}
const char SYMEXPORT *alpm_dep_get_name(const pmdepend_t *dep)
@ -803,9 +803,9 @@ const char SYMEXPORT *alpm_dep_get_name(const pmdepend_t *dep)
ALPM_LOG_FUNC;
/* Sanity checks */
ASSERT(dep != NULL, return(NULL));
ASSERT(dep != NULL, return NULL);
return(dep->name);
return dep->name;
}
const char SYMEXPORT *alpm_dep_get_version(const pmdepend_t *dep)
@ -813,9 +813,9 @@ const char SYMEXPORT *alpm_dep_get_version(const pmdepend_t *dep)
ALPM_LOG_FUNC;
/* Sanity checks */
ASSERT(dep != NULL, return(NULL));
ASSERT(dep != NULL, return NULL);
return(dep->version);
return dep->version;
}
/** Reverse of splitdep; make a dep string from a pmdepend_t struct.
@ -831,7 +831,7 @@ char SYMEXPORT *alpm_dep_compute_string(const pmdepend_t *dep)
ALPM_LOG_FUNC;
/* Sanity checks */
ASSERT(dep != NULL, return(NULL));
ASSERT(dep != NULL, return NULL);
if(dep->name) {
name = dep->name;
@ -876,6 +876,6 @@ char SYMEXPORT *alpm_dep_compute_string(const pmdepend_t *dep)
MALLOC(str, len, RET_ERR(PM_ERR_MEMORY, NULL));
snprintf(str, len, "%s%s%s", name, opr, ver);
return(str);
return str;
}
/* vim: set ts=2 sw=2 noet: */

22
lib/libalpm/diskspace.c
View File

@ -56,7 +56,7 @@ static int mount_point_cmp(const void *p1, const void *p2)
const alpm_mountpoint_t *mp1 = p1;
const alpm_mountpoint_t *mp2 = p2;
/* the negation will sort all mountpoints before their parent */
return(-strcmp(mp1->mount_dir, mp2->mount_dir));
return -strcmp(mp1->mount_dir, mp2->mount_dir);
}
static alpm_list_t *mount_point_list(void)
@ -72,7 +72,7 @@ static alpm_list_t *mount_point_list(void)
fp = setmntent(MOUNTED, "r");
if (fp == NULL) {
return(NULL);
return NULL;
}
while((mnt = getmntent(fp))) {
@ -104,7 +104,7 @@ static alpm_list_t *mount_point_list(void)
entries = getmntinfo(&fsp, MNT_NOWAIT);
if (entries < 0) {
return(NULL);
return NULL;
}
for(; entries-- > 0; fsp++) {
@ -128,7 +128,7 @@ static alpm_list_t *mount_point_list(void)
mp = ptr->data;
_alpm_log(PM_LOG_DEBUG, "mountpoint: %s\n", mp->mount_dir);
}
return(mount_points);
return mount_points;
}
static alpm_mountpoint_t *match_mount_point(const alpm_list_t *mount_points,
@ -140,12 +140,12 @@ static alpm_mountpoint_t *match_mount_point(const alpm_list_t *mount_points,
alpm_mountpoint_t *data = mp->data;
if(strncmp(data->mount_dir, real_path, data->mount_dir_len) == 0) {
return(data);
return data;
}
}
/* should not get here... */
return(NULL);
return NULL;
}
static int calculate_removed_size(const alpm_list_t *mount_points,
@ -182,7 +182,7 @@ static int calculate_removed_size(const alpm_list_t *mount_points,
mp->used |= USED_REMOVE;
}
return(0);
return 0;
}
static int calculate_installed_size(const alpm_list_t *mount_points,
@ -254,7 +254,7 @@ static int calculate_installed_size(const alpm_list_t *mount_points,
archive_read_finish(archive);
cleanup:
return(ret);
return ret;
}
int _alpm_check_diskspace(pmtrans_t *trans, pmdb_t *db_local)
@ -269,13 +269,13 @@ int _alpm_check_diskspace(pmtrans_t *trans, pmdb_t *db_local)
mount_points = mount_point_list();
if(mount_points == NULL) {
_alpm_log(PM_LOG_ERROR, _("could not determine filesystem mount points\n"));
return(-1);
return -1;
}
root_mp = match_mount_point(mount_points, handle->root);
if(root_mp == NULL) {
_alpm_log(PM_LOG_ERROR, _("could not determine root mount point %s\n"),
handle->root);
return(-1);
return -1;
}
replaces = alpm_list_count(trans->remove);
@ -352,7 +352,7 @@ int _alpm_check_diskspace(pmtrans_t *trans, pmdb_t *db_local)
RET_ERR(PM_ERR_DISK_SPACE, -1);
}
return(0);
return 0;
}
/* vim: set ts=2 sw=2 noet: */

32
lib/libalpm/dload.c
View File

@ -49,7 +49,7 @@ static char *get_filename(const char *url) {
if(filename != NULL) {
filename++;
}
return(filename);
return filename;
}
#ifdef HAVE_LIBCURL
@ -61,7 +61,7 @@ static char *get_destfile(const char *path, const char *filename)
CALLOC(destfile, len, sizeof(char), RET_ERR(PM_ERR_MEMORY, NULL));
snprintf(destfile, len, "%s%s", path, filename);
return(destfile);
return destfile;
}
static char *get_tempfile(const char *path, const char *filename)
@ -72,7 +72,7 @@ static char *get_tempfile(const char *path, const char *filename)
CALLOC(tempfile, len, sizeof(char), RET_ERR(PM_ERR_MEMORY, NULL));
snprintf(tempfile, len, "%s%s.part", path, filename);
return(tempfile);
return tempfile;
}
#define check_stop() if(dload_interrupted) { ret = -1; goto cleanup; }
@ -93,18 +93,18 @@ static int curl_progress(void *filename, double dltotal, double dlnow,
(void)ulnow;
if(dltotal == 0 || prevprogress == dltotal) {
return(0);
return 0;
}
if(dload_interrupted) {
return(1);
return 1;
}
handle->dlcb((const char*)filename, (long)dlnow, (long)dltotal);
prevprogress = dlnow;
return(0);
return 0;
}
static int curl_gethost(const char *url, char *buffer)
@ -117,19 +117,19 @@ static int curl_gethost(const char *url, char *buffer)
} else {
p = strstr(url, "//");
if(!p) {
return(1);
return 1;
}
p += 2; /* jump over the found // */
hostlen = strcspn(p, "/");
if(hostlen > 255) {
/* buffer overflow imminent */
_alpm_log(PM_LOG_ERROR, _("buffer overflow detected"));
return(1);
return 1;
}
snprintf(buffer, hostlen + 1, "%s", p);
}
return(0);
return 0;
}
static int curl_download_internal(const char *url, const char *localpath,
@ -292,7 +292,7 @@ cleanup:
raise(SIGINT);
}
return(ret);
return ret;
}
#endif
@ -301,7 +301,7 @@ static int download(const char *url, const char *localpath,
{
if(handle->fetchcb == NULL) {
#ifdef HAVE_LIBCURL
return(curl_download_internal(url, localpath, force));
return curl_download_internal(url, localpath, force);
#else
RET_ERR(PM_ERR_EXTERNAL_DOWNLOAD, -1);
#endif
@ -310,7 +310,7 @@ static int download(const char *url, const char *localpath,
if(ret == -1) {
RET_ERR(PM_ERR_EXTERNAL_DOWNLOAD, -1);
}
return(ret);
return ret;
}
}
@ -348,7 +348,7 @@ int _alpm_download_single_file(const char *filename,
}
}
return(ret);
return ret;
}
int _alpm_download_files(alpm_list_t *files,
@ -365,7 +365,7 @@ int _alpm_download_files(alpm_list_t *files,
}
}
return(ret);
return ret;
}
/** Fetch a remote pkg.
@ -390,13 +390,13 @@ char SYMEXPORT *alpm_fetch_pkgurl(const char *url)
ret = download(url, cachedir, 0);
if(ret == -1) {
_alpm_log(PM_LOG_WARNING, _("failed to download %s\n"), url);
return(NULL);
return NULL;
}
_alpm_log(PM_LOG_DEBUG, "successfully downloaded %s\n", url);
/* we should be able to find the file the second time around */
filepath = _alpm_filecache_find(filename);
return(filepath);
return filepath;
}
/* vim: set ts=2 sw=2 noet: */

2
lib/libalpm/error.c
View File

@ -142,7 +142,7 @@ const char SYMEXPORT *alpm_strerror(int err)
return _("libarchive error");
case PM_ERR_LIBCURL:
#ifdef HAVE_LIBCURL
return(curl_easy_strerror(handle->curlerr));
return curl_easy_strerror(handle->curlerr);
#else
/* obviously shouldn't get here... */
return _("download library error");

2
lib/libalpm/graph.h
View File

@ -38,7 +38,7 @@ static pmgraph_t *_alpm_graph_new(void)
pmgraph_t *graph = NULL;
CALLOC(graph, 1, sizeof(pmgraph_t), RET_ERR(PM_ERR_MEMORY, NULL));
return(graph);
return graph;
}
static void _alpm_graph_free(void *data)

6
lib/libalpm/group.c
View File

@ -40,7 +40,7 @@ pmgrp_t *_alpm_grp_new(const char *name)
CALLOC(grp, 1, sizeof(pmgrp_t), RET_ERR(PM_ERR_MEMORY, NULL));
STRDUP(grp->name, name, RET_ERR(PM_ERR_MEMORY, NULL));
return(grp);
return grp;
}
void _alpm_grp_free(pmgrp_t *grp)
@ -62,7 +62,7 @@ const char SYMEXPORT *alpm_grp_get_name(const pmgrp_t *grp)
ALPM_LOG_FUNC;
/* Sanity checks */
ASSERT(grp != NULL, return(NULL));
ASSERT(grp != NULL, return NULL);
return grp->name;
}
@ -72,7 +72,7 @@ alpm_list_t SYMEXPORT *alpm_grp_get_pkgs(const pmgrp_t *grp)
ALPM_LOG_FUNC;
/* Sanity checks */
ASSERT(grp != NULL, return(NULL));
ASSERT(grp != NULL, return NULL);
return grp->packages;
}

44
lib/libalpm/handle.c
View File

@ -50,7 +50,7 @@ pmhandle_t *_alpm_handle_new()
CALLOC(handle, 1, sizeof(pmhandle_t), RET_ERR(PM_ERR_MEMORY, NULL));
return(handle);
return handle;
}
void _alpm_handle_free(pmhandle_t *handle)
@ -310,18 +310,18 @@ int SYMEXPORT alpm_option_set_root(const char *root)
if(!root) {
pm_errno = PM_ERR_WRONG_ARGS;
return(-1);
return -1;
}
if(stat(root, &st) == -1 || !S_ISDIR(st.st_mode)) {
pm_errno = PM_ERR_NOT_A_DIR;
return(-1);
return -1;
}
realroot = calloc(PATH_MAX+1, sizeof(char));
if(!realpath(root, realroot)) {
FREE(realroot);
pm_errno = PM_ERR_NOT_A_DIR;
return(-1);
return -1;
}
/* verify root ends in a '/' */
@ -337,7 +337,7 @@ int SYMEXPORT alpm_option_set_root(const char *root)
handle->root[rootlen-1] = '/';
FREE(realroot);
_alpm_log(PM_LOG_DEBUG, "option 'root' = %s\n", handle->root);
return(0);
return 0;
}
int SYMEXPORT alpm_option_set_dbpath(const char *dbpath)
@ -350,11 +350,11 @@ int SYMEXPORT alpm_option_set_dbpath(const char *dbpath)
if(!dbpath) {
pm_errno = PM_ERR_WRONG_ARGS;
return(-1);
return -1;
}
if(stat(dbpath, &st) == -1 || !S_ISDIR(st.st_mode)) {
pm_errno = PM_ERR_NOT_A_DIR;
return(-1);
return -1;
}
/* verify dbpath ends in a '/' */
dbpathlen = strlen(dbpath);
@ -376,7 +376,7 @@ int SYMEXPORT alpm_option_set_dbpath(const char *dbpath)
handle->lockfile = calloc(lockfilelen, sizeof(char));
snprintf(handle->lockfile, lockfilelen, "%s%s", handle->dbpath, lf);
_alpm_log(PM_LOG_DEBUG, "option 'lockfile' = %s\n", handle->lockfile);
return(0);
return 0;
}
int SYMEXPORT alpm_option_add_cachedir(const char *cachedir)
@ -388,7 +388,7 @@ int SYMEXPORT alpm_option_add_cachedir(const char *cachedir)
if(!cachedir) {
pm_errno = PM_ERR_WRONG_ARGS;
return(-1);
return -1;
}
/* don't stat the cachedir yet, as it may not even be needed. we can
* fail later if it is needed and the path is invalid. */
@ -403,7 +403,7 @@ int SYMEXPORT alpm_option_add_cachedir(const char *cachedir)
newcachedir[cachedirlen-1] = '/';
handle->cachedirs = alpm_list_add(handle->cachedirs, newcachedir);
_alpm_log(PM_LOG_DEBUG, "option 'cachedir' = %s\n", newcachedir);
return(0);
return 0;
}
void SYMEXPORT alpm_option_set_cachedirs(alpm_list_t *cachedirs)
@ -429,9 +429,9 @@ int SYMEXPORT alpm_option_remove_cachedir(const char *cachedir)
FREE(newcachedir);
if(vdata != NULL) {
FREE(vdata);
return(1);
return 1;
}
return(0);
return 0;
}
int SYMEXPORT alpm_option_set_logfile(const char *logfile)
@ -442,7 +442,7 @@ int SYMEXPORT alpm_option_set_logfile(const char *logfile)
if(!logfile) {
pm_errno = PM_ERR_WRONG_ARGS;
return(-1);
return -1;
}
handle->logfile = strdup(logfile);
@ -457,7 +457,7 @@ int SYMEXPORT alpm_option_set_logfile(const char *logfile)
handle->logstream = NULL;
}
_alpm_log(PM_LOG_DEBUG, "option 'logfile' = %s\n", handle->logfile);
return(0);
return 0;
}
void SYMEXPORT alpm_option_set_usesyslog(int usesyslog)
@ -482,9 +482,9 @@ int SYMEXPORT alpm_option_remove_noupgrade(const char *pkg)
handle->noupgrade = alpm_list_remove_str(handle->noupgrade, pkg, &vdata);
if(vdata != NULL) {
FREE(vdata);
return(1);
return 1;
}
return(0);
return 0;
}
void SYMEXPORT alpm_option_add_noextract(const char *pkg)
@ -504,9 +504,9 @@ int SYMEXPORT alpm_option_remove_noextract(const char *pkg)
handle->noextract = alpm_list_remove_str(handle->noextract, pkg, &vdata);
if(vdata != NULL) {
FREE(vdata);
return(1);
return 1;
}
return(0);
return 0;
}
void SYMEXPORT alpm_option_add_ignorepkg(const char *pkg)
@ -526,9 +526,9 @@ int SYMEXPORT alpm_option_remove_ignorepkg(const char *pkg)
handle->ignorepkg = alpm_list_remove_str(handle->ignorepkg, pkg, &vdata);
if(vdata != NULL) {
FREE(vdata);
return(1);
return 1;
}
return(0);
return 0;
}
void SYMEXPORT alpm_option_add_ignoregrp(const char *grp)
@ -548,9 +548,9 @@ int SYMEXPORT alpm_option_remove_ignoregrp(const char *grp)
handle->ignoregrp = alpm_list_remove_str(handle->ignoregrp, grp, &vdata);
if(vdata != NULL) {
FREE(vdata);
return(1);
return 1;
}
return(0);
return 0;
}
void SYMEXPORT alpm_option_set_arch(const char *arch)

4
lib/libalpm/log.c
View File

@ -64,7 +64,7 @@ int SYMEXPORT alpm_logaction(const char *fmt, ...)
} else {
pm_errno = PM_ERR_SYSTEM;
}
return(-1);
return -1;
}
}
@ -83,7 +83,7 @@ int SYMEXPORT alpm_logaction(const char *fmt, ...)
* kpacman: "KPACMAN"
* This would allow us to share the log file between several frontends
* and know who does what */
return(ret);
return ret;
}
/** @} */

32
lib/libalpm/package.c
View File

@ -61,7 +61,7 @@ int SYMEXPORT alpm_pkg_free(pmpkg_t *pkg)
_alpm_pkg_free(pkg);
}
return(0);
return 0;
}
/** Check the integrity (with md5) of a package from the sync cache.
@ -84,13 +84,13 @@ int SYMEXPORT alpm_pkg_checkmd5sum(pmpkg_t *pkg)
retval = _alpm_test_md5sum(fpath, alpm_pkg_get_md5sum(pkg));
if(retval == 0) {
return(0);
return 0;
} else if (retval == 1) {
pm_errno = PM_ERR_PKG_INVALID;
retval = -1;
}
return(retval);
return retval;
}
/* Default package accessor functions. These will get overridden by any
@ -274,10 +274,10 @@ alpm_list_t SYMEXPORT *alpm_pkg_get_backup(pmpkg_t *pkg)
pmdb_t SYMEXPORT *alpm_pkg_get_db(pmpkg_t *pkg)
{
/* Sanity checks */
ASSERT(pkg != NULL, return(NULL));
ASSERT(pkg->origin != PKG_FROM_FILE, return(NULL));
ASSERT(pkg != NULL, return NULL);
ASSERT(pkg->origin != PKG_FROM_FILE, return NULL);
return(pkg->origin_data.db);
return pkg->origin_data.db;
}
/**
@ -381,7 +381,7 @@ alpm_list_t SYMEXPORT *alpm_pkg_compute_requiredby(pmpkg_t *pkg)
}
}
}
return(reqs);
return reqs;
}
/** @} */
@ -394,7 +394,7 @@ pmpkg_t *_alpm_pkg_new(void)
CALLOC(pkg, 1, sizeof(pmpkg_t), RET_ERR(PM_ERR_MEMORY, NULL));
return(pkg);
return pkg;
}
pmpkg_t *_alpm_pkg_dup(pmpkg_t *pkg)
@ -445,7 +445,7 @@ pmpkg_t *_alpm_pkg_dup(pmpkg_t *pkg)
}
newpkg->infolevel = pkg->infolevel;
return(newpkg);
return newpkg;
}
void _alpm_pkg_free(pmpkg_t *pkg)
@ -522,7 +522,7 @@ int _alpm_pkg_cmp(const void *p1, const void *p2)
{
pmpkg_t *pkg1 = (pmpkg_t *)p1;
pmpkg_t *pkg2 = (pmpkg_t *)p2;
return(strcoll(pkg1->name, pkg2->name));
return strcoll(pkg1->name, pkg2->name);
}
/* Test for existence of a package in a alpm_list_t*
@ -536,7 +536,7 @@ pmpkg_t *_alpm_pkg_find(alpm_list_t *haystack, const char *needle)
ALPM_LOG_FUNC;
if(needle == NULL || haystack == NULL) {
return(NULL);
return NULL;
}
needle_hash = _alpm_hash_sdbm(needle);
@ -552,11 +552,11 @@ pmpkg_t *_alpm_pkg_find(alpm_list_t *haystack, const char *needle)
/* finally: we had hash match, verify string match */
if(strcmp(info->name, needle) == 0) {
return(info);
return info;
}
}
}
return(NULL);
return NULL;
}
/** Test if a package should be ignored.
@ -574,18 +574,18 @@ int _alpm_pkg_should_ignore(pmpkg_t *pkg)
/* first see if the package is ignored */
if(alpm_list_find_str(handle->ignorepkg, alpm_pkg_get_name(pkg))) {
return(1);
return 1;
}
/* next see if the package is in a group that is ignored */
for(groups = handle->ignoregrp; groups; groups = alpm_list_next(groups)) {
char *grp = (char *)alpm_list_getdata(groups);
if(alpm_list_find_str(alpm_pkg_get_groups(pkg), grp)) {
return(1);
return 1;
}
}
return(0);
return 0;
}
/* vim: set ts=2 sw=2 noet: */

34
lib/libalpm/pkghash.c
View File

@ -72,13 +72,13 @@ pmpkghash_t *_alpm_pkghash_create(size_t size)
if(hash->buckets < size) {
_alpm_log(PM_LOG_ERROR, _("database larger than maximum size\n"));
free(hash);
return(NULL);
return NULL;
}
CALLOC(hash->hash_table, hash->buckets, sizeof(alpm_list_t*), \
free(hash); RET_ERR(PM_ERR_MEMORY, NULL));
return(hash);
return hash;
}
static size_t get_hash_position(unsigned long name_hash, pmpkghash_t *hash)
@ -93,7 +93,7 @@ static size_t get_hash_position(unsigned long name_hash, pmpkghash_t *hash)
position = (position + 1) % hash->buckets;
}
return(position);
return position;
}
/* Expand the hash table size to the next increment and rebin the entries */
@ -124,7 +124,7 @@ static pmpkghash_t *rehash(pmpkghash_t *oldhash)
newhash = _alpm_pkghash_create(newsize);
if(newhash == NULL) {
/* creation of newhash failed, stick with old one... */
return(oldhash);
return oldhash;
}
newhash->list = oldhash->list;
@ -145,7 +145,7 @@ static pmpkghash_t *rehash(pmpkghash_t *oldhash)
_alpm_pkghash_free(oldhash);
return(newhash);
return newhash;
}
static pmpkghash_t *pkghash_add_pkg(pmpkghash_t *hash, pmpkg_t *pkg, int sorted)
@ -154,7 +154,7 @@ static pmpkghash_t *pkghash_add_pkg(pmpkghash_t *hash, pmpkg_t *pkg, int sorted)
size_t position;
if(pkg == NULL || hash == NULL) {
return(hash);
return hash;
}
if((hash->entries + 1) / MAX_HASH_LOAD > hash->buckets) {
@ -165,7 +165,7 @@ static pmpkghash_t *pkghash_add_pkg(pmpkghash_t *hash, pmpkg_t *pkg, int sorted)
ptr = calloc(1, sizeof(alpm_list_t));
if(ptr == NULL) {
return(hash);
return hash;
}
ptr->data = pkg;
@ -180,17 +180,17 @@ static pmpkghash_t *pkghash_add_pkg(pmpkghash_t *hash, pmpkg_t *pkg, int sorted)
}
hash->entries += 1;
return(hash);
return hash;
}
pmpkghash_t *_alpm_pkghash_add(pmpkghash_t *hash, pmpkg_t *pkg)
{
return(pkghash_add_pkg(hash, pkg, 0));
return pkghash_add_pkg(hash, pkg, 0);
}
pmpkghash_t *_alpm_pkghash_add_sorted(pmpkghash_t *hash, pmpkg_t *pkg)
{
return(pkghash_add_pkg(hash, pkg, 1));
return pkghash_add_pkg(hash, pkg, 1);
}
static size_t move_one_entry(pmpkghash_t *hash, size_t start, size_t end)
@ -218,7 +218,7 @@ static size_t move_one_entry(pmpkghash_t *hash, size_t start, size_t end)
* e.g. (47 + 0 - 1) % 47 == 46 */
end = (hash->buckets + end - 1) % hash->buckets;
}
return(end);
return end;
}
/**
@ -241,7 +241,7 @@ pmpkghash_t *_alpm_pkghash_remove(pmpkghash_t *hash, pmpkg_t *pkg,
}
if(pkg == NULL || hash == NULL) {
return(hash);
return hash;
}
position = pkg->name_hash % hash->buckets;
@ -278,13 +278,13 @@ pmpkghash_t *_alpm_pkghash_remove(pmpkghash_t *hash, pmpkg_t *pkg,
position = prev;
}
return(hash);
return hash;
}
position = (position + 1) % hash->buckets;
}
return(hash);
return hash;
}
void _alpm_pkghash_free(pmpkghash_t *hash)
@ -308,7 +308,7 @@ pmpkg_t *_alpm_pkghash_find(pmpkghash_t *hash, const char *name)
ALPM_LOG_FUNC;
if(name == NULL || hash == NULL) {
return(NULL);
return NULL;
}
name_hash = _alpm_hash_sdbm(name);
@ -319,13 +319,13 @@ pmpkg_t *_alpm_pkghash_find(pmpkghash_t *hash, const char *name)
pmpkg_t *info = lp->data;
if(info->name_hash == name_hash && strcmp(info->name, name) == 0) {
return(info);
return info;
}
position = (position + 1) % hash->buckets;
}
return(NULL);
return NULL;
}
/* vim: set ts=2 sw=2 noet: */

16
lib/libalpm/remove.c
View File

@ -69,7 +69,7 @@ int SYMEXPORT alpm_remove_pkg(pmpkg_t *pkg)
_alpm_log(PM_LOG_DEBUG, "adding %s in the target list\n", pkgname);
trans->remove = alpm_list_add(trans->remove, _alpm_pkg_dup(pkg));
return(0);
return 0;
}
static void remove_prepare_cascade(pmtrans_t *trans, pmdb_t *db,
@ -185,7 +185,7 @@ int _alpm_remove_prepare(pmtrans_t *trans, pmdb_t *db, alpm_list_t **data)
EVENT(trans, PM_TRANS_EVT_CHECKDEPS_DONE, NULL, NULL);
}
return(0);
return 0;
}
static int can_remove_file(const char *path, alpm_list_t *skip)
@ -196,7 +196,7 @@ static int can_remove_file(const char *path, alpm_list_t *skip)
if(alpm_list_find_str(skip, file)) {
/* return success because we will never actually remove this file */
return(1);
return 1;
}
/* If we fail write permissions due to a read-only filesystem, abort.
* Assume all other possible failures are covered somewhere else */
@ -206,11 +206,11 @@ static int can_remove_file(const char *path, alpm_list_t *skip)
* it - ignore "chmod -w" simple permission failures */
_alpm_log(PM_LOG_ERROR, _("cannot remove file '%s': %s\n"),
file, strerror(errno));
return(0);
return 0;
}
}
return(1);
return 1;
}
/* Helper function for iterating through a package's file and deleting them
@ -351,7 +351,7 @@ db:
pkgname);
}
return(0);
return 0;
}
int _alpm_remove_packages(pmtrans_t *trans, pmdb_t *db)
@ -375,7 +375,7 @@ int _alpm_remove_packages(pmtrans_t *trans, pmdb_t *db)
size_t targcount = alpm_list_count(targ);
if(handle->trans->state == STATE_INTERRUPTED) {
return(0);
return 0;
}
/* get the name now so we can use it after package is removed */
@ -457,7 +457,7 @@ int _alpm_remove_packages(pmtrans_t *trans, pmdb_t *db)
/* run ldconfig if it exists */
_alpm_ldconfig(handle->root);
return(0);
return 0;
}
/* vim: set ts=2 sw=2 noet: */

28
lib/libalpm/sync.c
View File

@ -56,7 +56,7 @@
*/
pmpkg_t SYMEXPORT *alpm_sync_newversion(pmpkg_t *pkg, alpm_list_t *dbs_sync)
{
ASSERT(pkg != NULL, return(NULL));
ASSERT(pkg != NULL, return NULL);
alpm_list_t *i;
pmpkg_t *spkg = NULL;
@ -68,7 +68,7 @@ pmpkg_t SYMEXPORT *alpm_sync_newversion(pmpkg_t *pkg, alpm_list_t *dbs_sync)
if(spkg == NULL) {
_alpm_log(PM_LOG_DEBUG, "'%s' not found in sync db => no upgrade\n",
alpm_pkg_get_name(pkg));
return(NULL);
return NULL;
}
/* compare versions and see if spkg is an upgrade */
@ -76,10 +76,10 @@ pmpkg_t SYMEXPORT *alpm_sync_newversion(pmpkg_t *pkg, alpm_list_t *dbs_sync)
_alpm_log(PM_LOG_DEBUG, "new version of '%s' found (%s => %s)\n",
alpm_pkg_get_name(pkg), alpm_pkg_get_version(pkg),
alpm_pkg_get_version(spkg));
return(spkg);
return spkg;
}
/* spkg is not an upgrade */
return(NULL);
return NULL;
}
/** Search for packages to upgrade and add them to the transaction.
@ -199,7 +199,7 @@ int SYMEXPORT alpm_sync_sysupgrade(int enable_downgrade)
}
}
return(0);
return 0;
}
/** Find group members across a list of databases.
@ -241,7 +241,7 @@ alpm_list_t SYMEXPORT *alpm_find_grp_pkgs(alpm_list_t *dbs,
}
}
alpm_list_free(ignorelist);
return(pkgs);
return pkgs;
}
/** Compute the size of the files that will be downloaded to install a
@ -257,7 +257,7 @@ static int compute_download_size(pmpkg_t *newpkg)
if(newpkg->origin != PKG_FROM_SYNCDB) {
newpkg->infolevel |= INFRQ_DSIZE;
newpkg->download_size = 0;
return(0);
return 0;
}
fname = alpm_pkg_get_filename(newpkg);
@ -294,7 +294,7 @@ static int compute_download_size(pmpkg_t *newpkg)
newpkg->infolevel |= INFRQ_DSIZE;
newpkg->download_size = size;
return(0);
return 0;
}
int _alpm_sync_prepare(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t *dbs_sync, alpm_list_t **data)
@ -544,7 +544,7 @@ cleanup:
alpm_list_free(unresolvable);
alpm_list_free(remove);
return(ret);
return ret;
}
/** Returns the size of the files that will be downloaded to install a
@ -557,13 +557,13 @@ off_t SYMEXPORT alpm_pkg_download_size(pmpkg_t *newpkg)
if(!(newpkg->infolevel & INFRQ_DSIZE)) {
compute_download_size(newpkg);
}
return(newpkg->download_size);
return newpkg->download_size;
}
static int endswith(const char *filename, const char *extension)
{
const char *s = filename + strlen(filename) - strlen(extension);
return(strcmp(s, extension) == 0);
return strcmp(s, extension) == 0;
}
/** Applies delta files to create an upgraded package file.
@ -649,7 +649,7 @@ static int apply_deltas(pmtrans_t *trans)
}
}
return(ret);
return ret;
}
/** Compares the md5sum of a file to the expected value.
@ -684,7 +684,7 @@ static int test_md5sum(pmtrans_t *trans, const char *filename,
FREE(filepath);
return(ret);
return ret;
}
int _alpm_sync_commit(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t **data)
@ -928,7 +928,7 @@ int _alpm_sync_commit(pmtrans_t *trans, pmdb_t *db_local, alpm_list_t **data)
error:
FREELIST(files);
alpm_list_free(deltas);
return(ret);
return ret;
}
/* vim: set ts=2 sw=2 noet: */

62
lib/libalpm/trans.c
View File

@ -66,7 +66,7 @@ static int make_lock(pmhandle_t *handle)
}
if(_alpm_makepath(dir)) {
FREE(dir);
return(-1);
return -1;
}
FREE(dir);
@ -79,9 +79,9 @@ static int make_lock(pmhandle_t *handle)
fflush(f);
fsync(fd);
handle->lckstream = f;
return(0);
return 0;
}
return(-1);
return -1;
}
/* Remove a lock file */
@ -92,9 +92,9 @@ static int remove_lock(pmhandle_t *handle)
handle->lckstream = NULL;
}
if(unlink(handle->lockfile) == -1 && errno != ENOENT) {
return(-1);
return -1;
}
return(0);
return 0;
}
/** Initialize the transaction.
@ -148,7 +148,7 @@ int SYMEXPORT alpm_trans_init(pmtransflag_t flags,
handle->trans = trans;
return(0);
return 0;
}
static alpm_list_t *check_arch(alpm_list_t *pkgs)
@ -158,7 +158,7 @@ static alpm_list_t *check_arch(alpm_list_t *pkgs)
const char *arch = alpm_option_get_arch();
if(!arch) {
return(NULL);
return NULL;
}
for(i = pkgs; i; i = i->next) {
pmpkg_t *pkg = i->data;
@ -173,7 +173,7 @@ static alpm_list_t *check_arch(alpm_list_t *pkgs)
invalid = alpm_list_add(invalid, string);
}
}
return(invalid);
return invalid;
}
/** Prepare a transaction.
@ -198,7 +198,7 @@ int SYMEXPORT alpm_trans_prepare(alpm_list_t **data)
/* If there's nothing to do, return without complaining */
if(trans->add == NULL && trans->remove == NULL) {
return(0);
return 0;
}
alpm_list_t *invalid = check_arch(trans->add);
@ -212,18 +212,18 @@ int SYMEXPORT alpm_trans_prepare(alpm_list_t **data)
if(trans->add == NULL) {
if(_alpm_remove_prepare(trans, handle->db_local, data) == -1) {
/* pm_errno is set by _alpm_remove_prepare() */
return(-1);
return -1;
}
} else {
if(_alpm_sync_prepare(trans, handle->db_local, handle->dbs_sync, data) == -1) {
/* pm_errno is set by _alpm_sync_prepare() */
return(-1);
return -1;
}
}
trans->state = STATE_PREPARED;
return(0);
return 0;
}
/** Commit a transaction.
@ -249,7 +249,7 @@ int SYMEXPORT alpm_trans_commit(alpm_list_t **data)
/* If there's nothing to do, return without complaining */
if(trans->add == NULL && trans->remove == NULL) {
return(0);
return 0;
}
trans->state = STATE_COMMITING;
@ -257,18 +257,18 @@ int SYMEXPORT alpm_trans_commit(alpm_list_t **data)
if(trans->add == NULL) {
if(_alpm_remove_packages(trans, handle->db_local) == -1) {
/* pm_errno is set by _alpm_remove_commit() */
return(-1);
return -1;
}
} else {
if(_alpm_sync_commit(trans, handle->db_local, data) == -1) {
/* pm_errno is set by _alpm_sync_commit() */
return(-1);
return -1;
}
}
trans->state = STATE_COMMITED;
return(0);
return 0;
}
/** Interrupt a transaction.
@ -290,7 +290,7 @@ int SYMEXPORT alpm_trans_interrupt(void)
trans->state = STATE_INTERRUPTED;
return(0);
return 0;
}
/** Release a transaction.
@ -324,7 +324,7 @@ int SYMEXPORT alpm_trans_release(void)
}
}
return(0);
return 0;
}
/** @} */
@ -338,7 +338,7 @@ pmtrans_t *_alpm_trans_new(void)
CALLOC(trans, 1, sizeof(pmtrans_t), RET_ERR(PM_ERR_MEMORY, NULL));
trans->state = STATE_IDLE;
return(trans);
return trans;
}
void _alpm_trans_free(pmtrans_t *trans)
@ -367,7 +367,7 @@ static int grep(const char *fn, const char *needle)
FILE *fp;
if((fp = fopen(fn, "r")) == NULL) {
return(0);
return 0;
}
while(!feof(fp)) {
char line[1024];
@ -378,11 +378,11 @@ static int grep(const char *fn, const char *needle)
* ends up being split across line reads */
if(strstr(line, needle)) {
fclose(fp);
return(1);
return 1;
}
}
fclose(fp);
return(0);
return 0;
}
int _alpm_runscriptlet(const char *root, const char *installfn,
@ -402,7 +402,7 @@ int _alpm_runscriptlet(const char *root, const char *installfn,
if(access(installfn, R_OK)) {
/* not found */
_alpm_log(PM_LOG_DEBUG, "scriptlet '%s' not found\n", installfn);
return(0);
return 0;
}
/* creates a directory in $root/tmp/ for copying/extracting the scriptlet */
@ -413,7 +413,7 @@ int _alpm_runscriptlet(const char *root, const char *installfn,
snprintf(tmpdir, PATH_MAX, "%stmp/alpm_XXXXXX", root);
if(mkdtemp(tmpdir) == NULL) {
_alpm_log(PM_LOG_ERROR, _("could not create temp directory\n"));
return(1);
return 1;
} else {
clean_tmpdir = 1;
}
@ -459,14 +459,14 @@ cleanup:
_alpm_log(PM_LOG_WARNING, _("could not remove tmpdir %s\n"), tmpdir);
}
return(retval);
return retval;
}
int SYMEXPORT alpm_trans_get_flags()
{
/* Sanity checks */
ASSERT(handle != NULL, return(-1));
ASSERT(handle->trans != NULL, return(-1));
ASSERT(handle != NULL, return -1);
ASSERT(handle->trans != NULL, return -1);
return handle->trans->flags;
}
@ -474,8 +474,8 @@ int SYMEXPORT alpm_trans_get_flags()
alpm_list_t SYMEXPORT * alpm_trans_get_add()
{
/* Sanity checks */
ASSERT(handle != NULL, return(NULL));
ASSERT(handle->trans != NULL, return(NULL));
ASSERT(handle != NULL, return NULL);
ASSERT(handle->trans != NULL, return NULL);
return handle->trans->add;
}
@ -483,8 +483,8 @@ alpm_list_t SYMEXPORT * alpm_trans_get_add()
alpm_list_t SYMEXPORT * alpm_trans_get_remove()
{
/* Sanity checks */
ASSERT(handle != NULL, return(NULL));
ASSERT(handle->trans != NULL, return(NULL));
ASSERT(handle != NULL, return NULL);
ASSERT(handle->trans != NULL, return NULL);
return handle->trans->remove;
}

88
lib/libalpm/util.c
View File

@ -86,7 +86,7 @@ char* strsep(char** str, const char* delims)
int _alpm_makepath(const char *path)
{
return(_alpm_makepath_mode(path, 0755));
return _alpm_makepath_mode(path, 0755);
}
/* does the same thing as 'mkdir -p' */
@ -122,7 +122,7 @@ int _alpm_makepath_mode(const char *path, mode_t mode)
free(orig);
free(incr);
umask(oldmask);
return(ret);
return ret;
}
#define CPBUFSIZE 8 * 1024
@ -136,12 +136,12 @@ int _alpm_copyfile(const char *src, const char *dest)
in = fopen(src, "rb");
if(in == NULL) {
return(1);
return 1;
}
out = fopen(dest, "wb");
if(out == NULL) {
fclose(in);
return(1);
return 1;
}
CALLOC(buf, (size_t)CPBUFSIZE, (size_t)1, ret = 1; goto cleanup;);
@ -174,7 +174,7 @@ cleanup:
fclose(in);
fclose(out);
FREE(buf);
return(ret);
return ret;
}
/* Trim whitespace and newlines from a string
@ -185,7 +185,7 @@ char *_alpm_strtrim(char *str)
if(*str == '\0') {
/* string is empty, so we're done. */
return(str);
return str;
}
while(isspace((unsigned char)*pch)) {
@ -197,7 +197,7 @@ char *_alpm_strtrim(char *str)
/* check if there wasn't anything but whitespace in the string. */
if(*str == '\0') {
return(str);
return str;
}
pch = (str + (strlen(str) - 1));
@ -206,7 +206,7 @@ char *_alpm_strtrim(char *str)
}
*++pch = '\0';
return(str);
return str;
}
/* Compression functions */
@ -224,12 +224,12 @@ int _alpm_unpack_single(const char *archive, const char *prefix, const char *fn)
alpm_list_t *list = NULL;
int ret = 0;
if(fn == NULL) {
return(1);
return 1;
}
list = alpm_list_add(list, (void *)fn);
ret = _alpm_unpack(archive, prefix, list, 1);
alpm_list_free(list);
return(ret);
return ret;
}
/**
@ -340,7 +340,7 @@ cleanup:
if(restore_cwd && chdir(cwd) != 0) {
_alpm_log(PM_LOG_ERROR, _("could not change directory to %s (%s)\n"), cwd, strerror(errno));
}
return(ret);
return ret;
}
/* does the same thing as 'rm -rf' */
@ -355,18 +355,18 @@ int _alpm_rmrf(const char *path)
if(_alpm_lstat(path, &st) == 0) {
if(!S_ISDIR(st.st_mode)) {
if(!unlink(path)) {
return(0);
return 0;
} else {
if(errno == ENOENT) {
return(0);
return 0;
} else {
return(1);
return 1;
}
}
} else {
dirp = opendir(path);
if(!dirp) {
return(1);
return 1;
}
for(dp = readdir(dirp); dp != NULL; dp = readdir(dirp)) {
if(dp->d_ino) {
@ -381,9 +381,9 @@ int _alpm_rmrf(const char *path)
errflag++;
}
}
return(errflag);
return errflag;
}
return(0);
return 0;
}
int _alpm_logaction(int usesyslog, FILE *f, const char *fmt, va_list args)
@ -414,7 +414,7 @@ int _alpm_logaction(int usesyslog, FILE *f, const char *fmt, va_list args)
fflush(f);
}
return(ret);
return ret;
}
int _alpm_run_chroot(const char *root, const char *path, char *const argv[])
@ -531,7 +531,7 @@ cleanup:
_alpm_log(PM_LOG_ERROR, _("could not change directory to %s (%s)\n"), cwd, strerror(errno));
}
return(retval);
return retval;
}
int _alpm_ldconfig(const char *root)
@ -549,14 +549,14 @@ int _alpm_ldconfig(const char *root)
}
}
return(0);
return 0;
}
/* Helper function for comparing strings using the
* alpm "compare func" signature */
int _alpm_str_cmp(const void *s1, const void *s2)
{
return(strcmp(s1, s2));
return strcmp(s1, s2);
}
/** Find a filename in a registered alpm cachedir.
@ -577,7 +577,7 @@ char *_alpm_filecache_find(const char* filename)
if(stat(path, &buf) == 0 && S_ISREG(buf.st_mode)) {
retpath = strdup(path);
_alpm_log(PM_LOG_DEBUG, "found cached pkg: %s\n", retpath);
return(retpath);
return retpath;
}
}
/* package wasn't found in any cachedir */
@ -603,11 +603,11 @@ const char *_alpm_filecache_setup(void)
cachedir);
if(_alpm_makepath(cachedir) == 0) {
_alpm_log(PM_LOG_DEBUG, "using cachedir: %s\n", cachedir);
return(cachedir);
return cachedir;
}
} else if(S_ISDIR(buf.st_mode) && (buf.st_mode & S_IWUSR)) {
_alpm_log(PM_LOG_DEBUG, "using cachedir: %s\n", cachedir);
return(cachedir);
return cachedir;
}
}
@ -616,7 +616,7 @@ const char *_alpm_filecache_setup(void)
alpm_option_set_cachedirs(tmp);
_alpm_log(PM_LOG_DEBUG, "using cachedir: %s", "/tmp/\n");
_alpm_log(PM_LOG_WARNING, _("couldn't create package cache, using /tmp instead\n"));
return(alpm_list_getdata(tmp));
return alpm_list_getdata(tmp);
}
/** lstat wrapper that treats /path/dirsymlink/ the same as /path/dirsymlink.
@ -640,7 +640,7 @@ int _alpm_lstat(const char *path, struct stat *buf)
ret = lstat(newpath, buf);
FREE(newpath);
return(ret);
return ret;
}
#ifdef HAVE_LIBSSL
@ -651,11 +651,11 @@ static int md5_file(const char *path, unsigned char output[16])
MD5_CTX ctx;
unsigned char *buf;
CALLOC(buf, 8192, sizeof(unsigned char), return(1));
CALLOC(buf, 8192, sizeof(unsigned char), RET_ERR(PM_ERR_MEMORY, 1));
if((f = fopen(path, "rb")) == NULL) {
free(buf);
return(1);
return 1;
}
MD5_Init(&ctx);
@ -671,11 +671,11 @@ static int md5_file(const char *path, unsigned char output[16])
if(ferror(f) != 0) {
fclose(f);
return(2);
return 2;
}
fclose(f);
return(0);
return 0;
}
#endif
@ -692,7 +692,7 @@ char SYMEXPORT *alpm_compute_md5sum(const char *filename)
ALPM_LOG_FUNC;
ASSERT(filename != NULL, return(NULL));
ASSERT(filename != NULL, return NULL);
/* allocate 32 chars plus 1 for null */
md5sum = calloc(33, sizeof(char));
@ -711,7 +711,7 @@ char SYMEXPORT *alpm_compute_md5sum(const char *filename)
md5sum[32] = '\0';
_alpm_log(PM_LOG_DEBUG, "md5(%s) = %s\n", filename, md5sum);
return(md5sum);
return md5sum;
}
int _alpm_test_md5sum(const char *filepath, const char *md5sum)
@ -730,7 +730,7 @@ int _alpm_test_md5sum(const char *filepath, const char *md5sum)
}
FREE(md5sum2);
return(ret);
return ret;
}
/* Note: does NOT handle sparse files on purpose for speed. */
@ -800,7 +800,7 @@ int _alpm_archive_fgets(struct archive *a, struct archive_read_buffer *b)
b->line_offset[len] = '\0';
b->block_offset = ++i;
/* this is the main return point; from here you can read b->line */
return(ARCHIVE_OK);
return ARCHIVE_OK;
} else {
/* we've looked through the whole block but no newline, copy it */
size_t len = (size_t)(b->block + b->block_size - b->block_offset);
@ -815,7 +815,7 @@ cleanup:
int ret = b->ret;
FREE(b->line);
memset(b, 0, sizeof(b));
return(ret);
return ret;
}
}
@ -829,7 +829,7 @@ int _alpm_splitname(const char *target, pmpkg_t *pkg)
const char *version, *end;
if(target == NULL || pkg == NULL) {
return(-1);
return -1;
}
end = target + strlen(target);
@ -843,7 +843,7 @@ int _alpm_splitname(const char *target, pmpkg_t *pkg)
for(version = end - 1; *version && *version != '-'; version--);
for(version = version - 1; *version && *version != '-'; version--);
if(*version != '-' || version == target) {
return(-1);
return -1;
}
/* copy into fields and return */
@ -861,7 +861,7 @@ int _alpm_splitname(const char *target, pmpkg_t *pkg)
STRNDUP(pkg->name, target, version - target, RET_ERR(PM_ERR_MEMORY, -1));
pkg->name_hash = _alpm_hash_sdbm(pkg->name);
return(0);
return 0;
}
/**
@ -876,13 +876,13 @@ unsigned long _alpm_hash_sdbm(const char *str)
int c;
if(!str) {
return(hash);
return hash;
}
while((c = *str++)) {
hash = c + (hash << 6) + (hash << 16) - hash;
}
return(hash);
return hash;
}
long _alpm_parsedate(const char *line)
@ -893,9 +893,9 @@ long _alpm_parsedate(const char *line)
setlocale(LC_TIME, "C");
strptime(line, "%a %b %e %H:%M:%S %Y", &tmp_tm);
setlocale(LC_TIME, "");
return(mktime(&tmp_tm));
return mktime(&tmp_tm);
}
return(atol(line));
return atol(line);
}
#ifndef HAVE_STRNDUP
@ -904,7 +904,7 @@ static size_t strnlen(const char *s, size_t max)
{
register const char *p;
for(p = s; *p && max--; ++p);
return(p - s);
return (p - s);
}
char *strndup(const char *s, size_t n)
@ -916,7 +916,7 @@ char *strndup(const char *s, size_t n)
return NULL;
new[len] = '\0';
return (char *) memcpy(new, s, len);
return (char *)memcpy(new, s, len);
}
#endif

2
lib/libalpm/util.h
View File

@ -59,7 +59,7 @@
#define RET_ERR(err, ret) do { pm_errno = (err); \
_alpm_log(PM_LOG_DEBUG, "returning error %d from %s : %s\n", err, __func__, alpm_strerrorlast()); \
return(ret); } while(0)
return (ret); } while(0)
/**
* Used as a buffer/state holder for _alpm_archive_fgets().

14
lib/libalpm/version.c
View File

@ -93,7 +93,7 @@ static int rpmvercmp(const char *a, const char *b)
int ret = 0;
/* easy comparison to see if versions are identical */
if(strcmp(a, b) == 0) return(0);
if(strcmp(a, b) == 0) return 0;
str1 = strdup(a);
str2 = strdup(b);
@ -209,7 +209,7 @@ static int rpmvercmp(const char *a, const char *b)
cleanup:
free(str1);
free(str2);
return(ret);
return ret;
}
/** Compare two version strings and determine which one is 'newer'.
@ -235,15 +235,15 @@ int SYMEXPORT alpm_pkg_vercmp(const char *a, const char *b)
/* ensure our strings are not null */
if(!a && !b) {
return(0);
return 0;
} else if(!a) {
return(-1);
return -1;
} else if(!b) {
return(1);
return 1;
}
/* another quick shortcut- if full version specs are equal */
if(strcmp(a, b) == 0) {
return(0);
return 0;
}
/* Parse both versions into [epoch:]version[-release] triplets. We probably
@ -266,7 +266,7 @@ int SYMEXPORT alpm_pkg_vercmp(const char *a, const char *b)
free(full1);
free(full2);
return(ret);
return ret;
}
/* vim: set ts=2 sw=2 noet: */

2
src/pacman/callback.c
View File

@ -81,7 +81,7 @@ static double get_update_timediff(int first_call)
}
}
return(retval);
return retval;
}
/* refactored from cb_trans_progress */

8
src/pacman/conf.c
View File

@ -38,7 +38,7 @@ config_t *config_new(void)
pm_fprintf(stderr, PM_LOG_ERROR,
_("malloc failure: could not allocate %zd bytes\n"),
sizeof(config_t));
return(NULL);
return NULL;
}
/* defaults which may get overridden later */
newconfig->op = PM_OP_MAIN;
@ -46,13 +46,13 @@ config_t *config_new(void)
/* CONFFILE is defined at compile-time */
newconfig->configfile = strdup(CONFFILE);
return(newconfig);
return newconfig;
}
int config_free(config_t *oldconfig)
{
if(oldconfig == NULL) {
return(-1);
return -1;
}
FREELIST(oldconfig->holdpkg);
@ -66,7 +66,7 @@ int config_free(config_t *oldconfig)
free(oldconfig);
oldconfig = NULL;
return(0);
return 0;
}
/* vim: set ts=2 sw=2 noet: */

10
src/pacman/database.c
View File

@ -47,7 +47,7 @@ int pacman_database(alpm_list_t *targets)
if(targets == NULL) {
pm_printf(PM_LOG_ERROR, _("no targets specified (use -h for help)\n"));
return(1);
return 1;
}
if(config->flags & PM_TRANS_FLAG_ALLDEPS) { /* --asdeps */
@ -56,12 +56,12 @@ int pacman_database(alpm_list_t *targets)
reason = PM_PKG_REASON_EXPLICIT;
} else {
pm_printf(PM_LOG_ERROR, _("no install reason specified (use -h for help)\n"));
return(1);
return 1;
}
/* Lock database */
if(trans_init(0) == -1) {
return(1);
return 1;
}
db_local = alpm_option_get_localdb();
@ -82,9 +82,9 @@ int pacman_database(alpm_list_t *targets)
/* Unlock database */
if(trans_release() == -1) {
return(1);
return 1;
}
return(retval);
return retval;
}
/* vim: set ts=2 sw=2 noet: */

4
src/pacman/deptest.c
View File

@ -47,7 +47,7 @@ int pacman_deptest(alpm_list_t *targets)
}
if(deps == NULL) {
return(0);
return 0;
}
for(i = deps; i; i = alpm_list_next(i)) {
@ -56,7 +56,7 @@ int pacman_deptest(alpm_list_t *targets)
printf("%s\n", dep);
}
alpm_list_free(deps);
return(127);
return 127;
}
/* vim: set ts=2 sw=2 noet: */

4
src/pacman/package.c
View File

@ -173,7 +173,7 @@ static const char *get_backup_file_status(const char *root,
if(md5sum == NULL) {
pm_fprintf(stderr, PM_LOG_ERROR,
_("could not calculate checksums for %s\n"), path);
return(NULL);
return NULL;
}
/* if checksums don't match, file has been modified */
@ -195,7 +195,7 @@ static const char *get_backup_file_status(const char *root,
ret = "UNKNOWN";
}
}
return(ret);
return ret;
}
/* Display list of backup files and their modification states

102
src/pacman/pacman.c
View File

@ -66,9 +66,9 @@ static int options_cmp(const void *p1, const void *p2)
const char *s1 = p1;
const char *s2 = p2;
if(s1 == s2) return(0);
if(!s1) return(-1);
if(!s2) return(1);
if(s1 == s2) return 0;
if(!s1) return -1;
if(!s2) return 1;
/* First skip all spaces in both strings */
while(isspace((unsigned char)*s1)) {
s1++;
@ -87,15 +87,15 @@ static int options_cmp(const void *p1, const void *p2)
s2++;
} else if(*s2 == '-') {
/* s1 short, s2 long */
return(-1);
return -1;
} else if(*s1 == '-') {
/* s1 long, s2 short */
return(1);
return 1;
}
/* two short -> strcmp */
}
return(strcmp(s1, s2));
return strcmp(s1, s2);
}
/** Display usage/syntax for the specified operation.
@ -297,7 +297,7 @@ static ssize_t xwrite(int fd, const void *buf, size_t count)
do {
ret = write(fd, buf, count);
} while(ret == -1 && errno == EINTR);
return(ret);
return ret;
}
/** Catches thrown signals. Performs necessary cleanup to ensure database is
@ -393,7 +393,7 @@ static void setlibpaths(void)
}
}
#define check_optarg() if(!optarg) { return(1); }
#define check_optarg() if(!optarg) { return 1; }
typedef void (*fn_add) (const char *s);
@ -407,7 +407,7 @@ static int parsearg_util_addlist(fn_add fn)
fn((char *)alpm_list_getdata(item));
}
FREELIST(list);
return(0);
return 0;
}
/** Helper function for parsing operation from command-line arguments.
@ -444,9 +444,9 @@ static int parsearg_op(int opt, int dryrun)
if(dryrun) break;
config->help = 1; break;
default:
return(1);
return 1;
}
return(0);
return 0;
}
/** Helper functions for parsing command-line arguments.
@ -467,7 +467,7 @@ static int parsearg_global(int opt)
if(alpm_option_add_cachedir(optarg) != 0) {
pm_printf(PM_LOG_ERROR, _("problem adding cachedir '%s' (%s)\n"),
optarg, alpm_strerrorlast());
return(1);
return 1;
}
break;
case OP_CONFIG:
@ -492,7 +492,7 @@ static int parsearg_global(int opt)
default:
pm_printf(PM_LOG_ERROR, _("'%s' is not a valid debug level\n"),
optarg);
return(1);
return 1;
}
} else {
config->logmask |= PM_LOG_DEBUG;
@ -511,9 +511,9 @@ static int parsearg_global(int opt)
break;
case 'r': check_optarg(); config->rootdir = strdup(optarg); break;
case 'v': (config->verbose)++; break;
default: return(1);
default: return 1;
}
return(0);
return 0;
}
static int parsearg_database(int opt)
@ -521,9 +521,9 @@ static int parsearg_database(int opt)
switch(opt) {
case OP_ASDEPS: config->flags |= PM_TRANS_FLAG_ALLDEPS; break;
case OP_ASEXPLICIT: config->flags |= PM_TRANS_FLAG_ALLEXPLICIT; break;
default: return(1);
default: return 1;
}
return(0);
return 0;
}
static int parsearg_query(int opt)
@ -543,9 +543,9 @@ static int parsearg_query(int opt)
case 's': config->op_q_search = 1; break;
case 't': config->op_q_unrequired = 1; break;
case 'u': config->op_q_upgrade = 1; break;
default: return(1);
default: return 1;
}
return(0);
return 0;
}
/* options common to -S -R -U */
@ -567,15 +567,15 @@ static int parsearg_trans(int opt)
check_optarg();
config->print_format = strdup(optarg);
break;
default: return(1);
default: return 1;
}
return(0);
return 0;
}
static int parsearg_remove(int opt)
{
if (parsearg_trans(opt) == 0)
return(0);
return 0;
switch(opt) {
case 'c': config->flags |= PM_TRANS_FLAG_CASCADE; break;
case 'n': config->flags |= PM_TRANS_FLAG_NOSAVE; break;
@ -587,16 +587,16 @@ static int parsearg_remove(int opt)
}
break;
case 'u': config->flags |= PM_TRANS_FLAG_UNNEEDED; break;
default: return(1);
default: return 1;
}
return(0);
return 0;
}
/* options common to -S -U */
static int parsearg_upgrade(int opt)
{
if (parsearg_trans(opt) == 0)
return(0);
return 0;
switch(opt) {
case 'f': config->flags |= PM_TRANS_FLAG_FORCE; break;
case OP_ASDEPS: config->flags |= PM_TRANS_FLAG_ALLDEPS; break;
@ -607,15 +607,15 @@ static int parsearg_upgrade(int opt)
case OP_IGNOREGROUP:
parsearg_util_addlist(alpm_option_add_ignoregrp);
break;
default: return(1);
default: return 1;
}
return(0);
return 0;
}
static int parsearg_sync(int opt)
{
if (parsearg_upgrade(opt) == 0)
return(0);
return 0;
switch(opt) {
case OP_NEEDED: config->flags |= PM_TRANS_FLAG_NEEDED; break;
case 'c': (config->op_s_clean)++; break;
@ -631,9 +631,9 @@ static int parsearg_sync(int opt)
config->flags |= PM_TRANS_FLAG_NOCONFLICTS;
break;
case 'y': (config->op_s_sync)++; break;
default: return(1);
default: return 1;
}
return(0);
return 0;
}
/** Parse command-line arguments for each operation.
@ -712,22 +712,22 @@ static int parseargs(int argc, char *argv[])
continue;
} else if(opt == '?') {
/* unknown option, getopt printed an error */
return(1);
return 1;
}
parsearg_op(opt, 0);
}
if(config->op == 0) {
pm_printf(PM_LOG_ERROR, _("only one operation may be used at a time\n"));
return(1);
return 1;
}
if(config->help) {
usage(config->op, mbasename(argv[0]));
return(2);
return 2;
}
if(config->version) {
version();
return(2);
return 2;
}
/* parse all other options */
@ -739,7 +739,7 @@ static int parseargs(int argc, char *argv[])
continue;
} else if(opt == '?') {
/* this should have failed during first pass already */
return(1);
return 1;
} else if(parsearg_op(opt, 1) == 0) { /* opt is an operation */
continue;
}
@ -765,7 +765,7 @@ static int parseargs(int argc, char *argv[])
break;
default:
pm_printf(PM_LOG_ERROR, _("no operation specified (use -h for help)\n"));
return(1);
return 1;
}
if (result == 0)
continue;
@ -775,7 +775,7 @@ static int parseargs(int argc, char *argv[])
if(result != 0) {
/* global option parsing failed, abort */
pm_printf(PM_LOG_ERROR, _("invalid option\n"));
return(result);
return result;
}
}
@ -785,7 +785,7 @@ static int parseargs(int argc, char *argv[])
optind++;
}
return(0);
return 0;
}
/* helper for being used with setrepeatingoption */
@ -838,7 +838,7 @@ static char *get_filename(const char *url) {
if(filename != NULL) {
filename++;
}
return(filename);
return filename;
}
static char *get_destfile(const char *path, const char *filename) {
@ -848,7 +848,7 @@ static char *get_destfile(const char *path, const char *filename) {
destfile = calloc(len, sizeof(char));
snprintf(destfile, len, "%s%s", path, filename);
return(destfile);
return destfile;
}
static char *get_tempfile(const char *path, const char *filename) {
@ -858,7 +858,7 @@ static char *get_tempfile(const char *path, const char *filename) {
tempfile = calloc(len, sizeof(char));
snprintf(tempfile, len, "%s%s.part", path, filename);
return(tempfile);
return tempfile;
}
/** External fetch callback */
@ -950,7 +950,7 @@ cleanup:
free(tempfile);
free(parsedcmd);
return(ret);
return ret;
}
static int _parse_options(const char *key, char *value,
@ -1008,7 +1008,7 @@ static int _parse_options(const char *key, char *value,
if(alpm_option_add_cachedir(value) != 0) {
pm_printf(PM_LOG_ERROR, _("problem adding cachedir '%s' (%s)\n"),
value, alpm_strerrorlast());
return(1);
return 1;
}
pm_printf(PM_LOG_DEBUG, "config: cachedir: %s\n", value);
} else if(strcmp(key, "RootDir") == 0) {
@ -1036,7 +1036,7 @@ static int _parse_options(const char *key, char *value,
}
}
return(0);
return 0;
}
static int _add_mirror(pmdb_t *db, char *value)
@ -1055,7 +1055,7 @@ static int _add_mirror(pmdb_t *db, char *value)
free(temp);
pm_printf(PM_LOG_ERROR, _("The mirror '%s' contains the $arch"
" variable, but no Architecture is defined.\n"), value);
return(1);
return 1;
}
server = temp;
}
@ -1065,11 +1065,11 @@ static int _add_mirror(pmdb_t *db, char *value)
pm_printf(PM_LOG_ERROR, _("could not add server URL to database '%s': %s (%s)\n"),
dbname, server, alpm_strerrorlast());
free(server);
return(1);
return 1;
}
free(server);
return(0);
return 0;
}
/* The real parseconfig. Called with a null section argument by the publicly
@ -1088,7 +1088,7 @@ static int _parseconfig(const char *file, const char *givensection,
fp = fopen(file, "r");
if(fp == NULL) {
pm_printf(PM_LOG_ERROR, _("config file %s could not be read.\n"), file);
return(1);
return 1;
}
/* if we are passed a section, use it as our starting point */
@ -1239,7 +1239,7 @@ cleanup:
/* call setlibpaths here to ensure we have called it at least once */
setlibpaths();
pm_printf(PM_LOG_DEBUG, "config: finished parsing %s\n", file);
return(ret);
return ret;
}
/** Parse a configuration file.
@ -1249,7 +1249,7 @@ cleanup:
static int parseconfig(const char *file)
{
/* call the real parseconfig function with a null section & db argument */
return(_parseconfig(file, NULL, NULL));
return _parseconfig(file, NULL, NULL);
}
/** print commandline to logfile
@ -1476,7 +1476,7 @@ int main(int argc, char *argv[])
cleanup(ret);
/* not reached */
return(EXIT_SUCCESS);
return EXIT_SUCCESS;
}
/* vim: set ts=2 sw=2 noet: */

60
src/pacman/query.c
View File

@ -43,15 +43,15 @@ static char *resolve_path(const char *file)
str = calloc(PATH_MAX + 1, sizeof(char));
if(!str) {
return(NULL);
return NULL;
}
if(!realpath(file, str)) {
free(str);
return(NULL);
return NULL;
}
return(str);
return str;
}
/* check if filename exists in PATH */
@ -61,10 +61,10 @@ static int search_path(char **filename, struct stat *bufptr)
size_t flen;
if ((envpath = getenv("PATH")) == NULL) {
return(-1);
return -1;
}
if ((envpath = envpathsplit = strdup(envpath)) == NULL) {
return(-1);
return -1;
}
flen = strlen(*filename);
@ -84,12 +84,12 @@ static int search_path(char **filename, struct stat *bufptr)
free(*filename);
*filename = fullname;
free(envpath);
return(0);
return 0;
}
free(fullname);
}
free(envpath);
return(-1);
return -1;
}
static int query_fileowner(alpm_list_t *targets)
@ -105,7 +105,7 @@ static int query_fileowner(alpm_list_t *targets)
/* This code is here for safety only */
if(targets == NULL) {
pm_fprintf(stderr, PM_LOG_ERROR, _("no file was specified for --owns\n"));
return(1);
return 1;
}
/* Set up our root path buffer. We only need to copy the location of root in
@ -232,7 +232,7 @@ static int query_search(alpm_list_t *targets)
freelist = 0;
}
if(searchlist == NULL) {
return(1);
return 1;
}
for(i = searchlist; i; i = alpm_list_next(i)) {
@ -280,7 +280,7 @@ static int query_search(alpm_list_t *targets)
if(freelist) {
alpm_list_free(searchlist);
}
return(0);
return 0;
}
static int query_group(alpm_list_t *targets)
@ -343,19 +343,19 @@ static int is_foreign(pmpkg_t *pkg)
}
}
if(match == 0) {
return(1);
return 1;
}
return(0);
return 0;
}
static int is_unrequired(pmpkg_t *pkg)
{
alpm_list_t *requiredby = alpm_pkg_compute_requiredby(pkg);
if(requiredby == NULL) {
return(1);
return 1;
}
FREELIST(requiredby);
return(0);
return 0;
}
static int filter(pmpkg_t *pkg)
@ -363,26 +363,26 @@ static int filter(pmpkg_t *pkg)
/* check if this package was explicitly installed */
if(config->op_q_explicit &&
alpm_pkg_get_reason(pkg) != PM_PKG_REASON_EXPLICIT) {
return(0);
return 0;
}
/* check if this package was installed as a dependency */
if(config->op_q_deps &&
alpm_pkg_get_reason(pkg) != PM_PKG_REASON_DEPEND) {
return(0);
return 0;
}
/* check if this pkg isn't in a sync DB */
if(config->op_q_foreign && !is_foreign(pkg)) {
return(0);
return 0;
}
/* check if this pkg is unrequired */
if(config->op_q_unrequired && !is_unrequired(pkg)) {
return(0);
return 0;
}
/* check if this pkg is outdated */
if(config->op_q_upgrade && (alpm_sync_newversion(pkg, alpm_option_get_syncdbs()) == NULL)) {
return(0);
return 0;
}
return(1);
return 1;
}
/* Loop through the packages. For each package,
@ -400,7 +400,7 @@ static int check(pmpkg_t *pkg)
if(rootlen + 1 > PATH_MAX) {
/* we are in trouble here */
pm_fprintf(stderr, PM_LOG_ERROR, _("path too long: %s%s\n"), root, "");
return(1);
return 1;
}
strcpy(f, root);
@ -434,7 +434,7 @@ static int check(pmpkg_t *pkg)
(unsigned long)errors), errors);
}
return(errors != 0 ? 1 : 0);
return (errors != 0 ? 1 : 0);
}
static int display(pmpkg_t *pkg)
@ -466,7 +466,7 @@ static int display(pmpkg_t *pkg)
printf("%s\n", alpm_pkg_get_name(pkg));
}
}
return(ret);
return ret;
}
int pacman_query(alpm_list_t *targets)
@ -482,13 +482,13 @@ int pacman_query(alpm_list_t *targets)
/* search for a package */
if(config->op_q_search) {
ret = query_search(targets);
return(ret);
return ret;
}
/* looking for groups */
if(config->group) {
ret = query_group(targets);
return(ret);
return ret;
}
if(config->op_q_foreign) {
@ -496,7 +496,7 @@ int pacman_query(alpm_list_t *targets)
alpm_list_t *sync_dbs = alpm_option_get_syncdbs();
if(sync_dbs == NULL || alpm_list_count(sync_dbs) == 0) {
pm_printf(PM_LOG_ERROR, _("no usable package repositories configured.\n"));
return(1);
return 1;
}
}
@ -508,7 +508,7 @@ int pacman_query(alpm_list_t *targets)
if(targets == NULL) {
if(config->op_q_isfile || config->op_q_owns) {
pm_printf(PM_LOG_ERROR, _("no targets specified (use -h for help)\n"));
return(1);
return 1;
}
for(i = alpm_db_get_pkgcache(db_local); i; i = alpm_list_next(i)) {
@ -524,7 +524,7 @@ int pacman_query(alpm_list_t *targets)
if(!match) {
ret = 1;
}
return(ret);
return ret;
}
/* Second: operations that require target(s) */
@ -532,7 +532,7 @@ int pacman_query(alpm_list_t *targets)
/* determine the owner of a file */
if(config->op_q_owns) {
ret = query_fileowner(targets);
return(ret);
return ret;
}
/* operations on named packages in the local DB
@ -570,7 +570,7 @@ int pacman_query(alpm_list_t *targets)
ret = 1;
}
return(ret);
return ret;
}
/* vim: set ts=2 sw=2 noet: */

16
src/pacman/remove.c
View File

@ -40,25 +40,25 @@ static int remove_target(char *target)
if((info = alpm_db_get_pkg(db_local, target)) != NULL) {
if(alpm_remove_pkg(info) == -1) {
pm_fprintf(stderr, PM_LOG_ERROR, "'%s': %s\n", target, alpm_strerrorlast());
return(-1);
return -1;
}
return(0);
return 0;
}
/* fallback to group */
pmgrp_t *grp = alpm_db_readgrp(db_local, target);
if(grp == NULL) {
pm_fprintf(stderr, PM_LOG_ERROR, "'%s': target not found\n", target);
return(-1);
return -1;
}
for(p = alpm_grp_get_pkgs(grp); p; p = alpm_list_next(p)) {
pmpkg_t *pkg = alpm_list_getdata(p);
if(alpm_remove_pkg(pkg) == -1) {
pm_fprintf(stderr, PM_LOG_ERROR, "'%s': %s\n", target, alpm_strerrorlast());
return(-1);
return -1;
}
}
return(0);
return 0;
}
/**
@ -75,12 +75,12 @@ int pacman_remove(alpm_list_t *targets)
if(targets == NULL) {
pm_printf(PM_LOG_ERROR, _("no targets specified (use -h for help)\n"));
return(1);
return 1;
}
/* Step 0: create a new transaction */
if(trans_init(config->flags) == -1) {
return(1);
return 1;
}
/* Step 1: add targets to the created transaction */
@ -173,7 +173,7 @@ cleanup:
if(trans_release() == -1) {
retval = 1;
}
return(retval);
return retval;
}
/* vim: set ts=2 sw=2 noet: */

86
src/pacman/sync.c
View File

@ -47,7 +47,7 @@ static int sync_cleandb(const char *dbpath, int keep_used) {
dir = opendir(dbpath);
if(dir == NULL) {
pm_fprintf(stderr, PM_LOG_ERROR, _("could not access database directory\n"));
return(1);
return 1;
}
syncdbs = alpm_option_get_syncdbs();
@ -84,7 +84,7 @@ static int sync_cleandb(const char *dbpath, int keep_used) {
pm_fprintf(stderr, PM_LOG_ERROR,
_("could not remove %s\n"), path);
closedir(dir);
return(1);
return 1;
}
continue;
}
@ -110,12 +110,12 @@ static int sync_cleandb(const char *dbpath, int keep_used) {
pm_fprintf(stderr, PM_LOG_ERROR,
_("could not remove %s\n"), path);
closedir(dir);
return(1);
return 1;
}
}
}
closedir(dir);
return(0);
return 0;
}
static int sync_cleandb_all(void) {
@ -126,7 +126,7 @@ static int sync_cleandb_all(void) {
dbpath = alpm_option_get_dbpath();
printf(_("Database directory: %s\n"), dbpath);
if(!yesno(_("Do you want to remove unused repositories?"))) {
return(0);
return 0;
}
/* The sync dbs were previously put in dbpath/ but are now in dbpath/sync/.
* We will clean everything in dbpath/ except local/, sync/ and db.lck, and
@ -137,7 +137,7 @@ static int sync_cleandb_all(void) {
ret += sync_cleandb(newdbpath, 1);
printf(_("Database directory cleaned up\n"));
return(ret);
return ret;
}
static int sync_cleancache(int level)
@ -165,12 +165,12 @@ static int sync_cleancache(int level)
printf(_(" All current sync database packages\n"));
}
if(!yesno(_("Do you want to remove all other packages from cache?"))) {
return(0);
return 0;
}
printf(_("removing old packages from cache...\n"));
} else {
if(!noyes(_("Do you want to remove ALL files from cache?"))) {
return(0);
return 0;
}
printf(_("removing all files from cache...\n"));
}
@ -258,7 +258,7 @@ static int sync_cleancache(int level)
closedir(dir);
}
return(ret);
return ret;
}
static int sync_synctree(int level, alpm_list_t *syncs)
@ -267,7 +267,7 @@ static int sync_synctree(int level, alpm_list_t *syncs)
int success = 0, ret;
if(trans_init(0) == -1) {
return(0);
return 0;
}
for(i = syncs; i; i = alpm_list_next(i)) {
@ -286,7 +286,7 @@ static int sync_synctree(int level, alpm_list_t *syncs)
}
if(trans_release() == -1) {
return(0);
return 0;
}
/* We should always succeed if at least one DB was upgraded - we may possibly
* fail later with unresolved deps, but that should be rare, and would be
@ -295,7 +295,7 @@ static int sync_synctree(int level, alpm_list_t *syncs)
if(!success) {
pm_fprintf(stderr, PM_LOG_ERROR, _("failed to synchronize any databases\n"));
}
return(success > 0);
return (success > 0);
}
static void print_installed(pmdb_t *db_local, pmpkg_t *pkg)
@ -384,7 +384,7 @@ static int sync_search(alpm_list_t *syncs, alpm_list_t *targets)
}
}
return(!found);
return !found;
}
static int sync_group(int level, alpm_list_t *syncs, alpm_list_t *targets)
@ -432,7 +432,7 @@ static int sync_group(int level, alpm_list_t *syncs, alpm_list_t *targets)
}
}
return(0);
return 0;
}
static int sync_info(alpm_list_t *syncs, alpm_list_t *targets)
@ -466,7 +466,7 @@ static int sync_info(alpm_list_t *syncs, alpm_list_t *targets)
if(!db) {
pm_fprintf(stderr, PM_LOG_ERROR,
_("repository '%s' does not exist\n"), repo);
return(1);
return 1;
}
for(k = alpm_db_get_pkgcache(db); k; k = alpm_list_next(k)) {
@ -517,7 +517,7 @@ static int sync_info(alpm_list_t *syncs, alpm_list_t *targets)
}
}
return(ret);
return ret;
}
static int sync_list(alpm_list_t *syncs, alpm_list_t *targets)
@ -543,7 +543,7 @@ static int sync_list(alpm_list_t *syncs, alpm_list_t *targets)
pm_fprintf(stderr, PM_LOG_ERROR,
_("repository \"%s\" was not found.\n"),repo);
alpm_list_free(ls);
return(1);
return 1;
}
ls = alpm_list_add(ls, db);
@ -573,7 +573,7 @@ static int sync_list(alpm_list_t *syncs, alpm_list_t *targets)
alpm_list_free(ls);
}
return(0);
return 0;
}
static alpm_list_t *syncfirst(void) {
@ -591,7 +591,7 @@ static alpm_list_t *syncfirst(void) {
}
}
return(res);
return res;
}
static pmdb_t *get_db(const char *dbname)
@ -600,10 +600,10 @@ static pmdb_t *get_db(const char *dbname)
for(i = alpm_option_get_syncdbs(); i; i = i->next) {
pmdb_t *db = i->data;
if(strcmp(alpm_db_get_name(db), dbname) == 0) {
return(db);
return db;
}
}
return(NULL);
return NULL;
}
static int process_pkg(pmpkg_t *pkg)
@ -615,14 +615,14 @@ static int process_pkg(pmpkg_t *pkg)
|| pm_errno == PM_ERR_PKG_IGNORED) {
/* just skip duplicate or ignored targets */
pm_printf(PM_LOG_WARNING, _("skipping target: %s\n"), alpm_pkg_get_name(pkg));
return(0);
return 0;
} else {
pm_fprintf(stderr, PM_LOG_ERROR, "'%s': %s\n", alpm_pkg_get_name(pkg),
alpm_strerrorlast());
return(1);
return 1;
}
}
return(0);
return 0;
}
static int process_group(alpm_list_t *dbs, char *group)
@ -634,7 +634,7 @@ static int process_group(alpm_list_t *dbs, char *group)
if(!count) {
pm_fprintf(stderr, PM_LOG_ERROR, _("target not found: %s\n"), group);
return(1);
return 1;
}
printf(_(":: There are %d members in group %s:\n"), count,
@ -656,7 +656,7 @@ static int process_group(alpm_list_t *dbs, char *group)
cleanup:
alpm_list_free(pkgs);
free(array);
return(ret);
return ret;
}
static int process_targname(alpm_list_t *dblist, char *targname)
@ -667,14 +667,14 @@ static int process_targname(alpm_list_t *dblist, char *targname)
if(pm_errno == PM_ERR_PKG_IGNORED) {
pm_printf(PM_LOG_WARNING, _("skipping target: %s\n"), targname);
pm_errno = 0;
return(0);
return 0;
}
if(pkg) {
return(process_pkg(pkg));
return process_pkg(pkg);
}
/* fallback on group */
return(process_group(dblist, targname));
return process_group(dblist, targname);
}
static int process_target(char *target)
@ -709,7 +709,7 @@ static int process_target(char *target)
}
cleanup:
free(targstring);
return(ret);
return ret;
}
static int sync_trans(alpm_list_t *targets)
@ -721,7 +721,7 @@ static int sync_trans(alpm_list_t *targets)
/* Step 1: create a new transaction... */
if(trans_init(config->flags) == -1) {
return(1);
return 1;
}
/* process targets */
@ -861,7 +861,7 @@ cleanup:
retval = 1;
}
return(retval);
return retval;
}
int pacman_sync(alpm_list_t *targets)
@ -873,7 +873,7 @@ int pacman_sync(alpm_list_t *targets)
int ret = 0;
if(trans_init(0) == -1) {
return(1);
return 1;
}
ret += sync_cleancache(config->op_s_clean);
@ -884,14 +884,14 @@ int pacman_sync(alpm_list_t *targets)
ret++;
}
return(ret);
return ret;
}
/* ensure we have at least one valid sync db set up */
sync_dbs = alpm_option_get_syncdbs();
if(sync_dbs == NULL || alpm_list_count(sync_dbs) == 0) {
pm_printf(PM_LOG_ERROR, _("no usable package repositories configured.\n"));
return(1);
return 1;
}
if(config->op_s_sync) {
@ -899,40 +899,40 @@ int pacman_sync(alpm_list_t *targets)
printf(_(":: Synchronizing package databases...\n"));
alpm_logaction("synchronizing package lists\n");
if(!sync_synctree(config->op_s_sync, sync_dbs)) {
return(1);
return 1;
}
}
/* search for a package */
if(config->op_s_search) {
return(sync_search(sync_dbs, targets));
return sync_search(sync_dbs, targets);
}
/* look for groups */
if(config->group) {
return(sync_group(config->group, sync_dbs, targets));
return sync_group(config->group, sync_dbs, targets);
}
/* get package info */
if(config->op_s_info) {
return(sync_info(sync_dbs, targets));
return sync_info(sync_dbs, targets);
}
/* get a listing of files in sync DBs */
if(config->op_q_list) {
return(sync_list(sync_dbs, targets));
return sync_list(sync_dbs, targets);
}
if(targets == NULL) {
if(config->op_s_upgrade) {
/* proceed */
} else if(config->op_s_sync) {
return(0);
return 0;
} else {
/* don't proceed here unless we have an operation that doesn't require a
* target list */
pm_printf(PM_LOG_ERROR, _("no targets specified (use -h for help)\n"));
return(1);
return 1;
}
}
@ -967,7 +967,7 @@ int pacman_sync(alpm_list_t *targets)
int ret = sync_trans(targs);
FREELIST(targs);
return(ret);
return ret;
}
/* vim: set ts=2 sw=2 noet: */

22
src/pacman/upgrade.c
View File

@ -46,7 +46,7 @@ int pacman_upgrade(alpm_list_t *targets)
if(targets == NULL) {
pm_printf(PM_LOG_ERROR, _("no targets specified (use -h for help)\n"));
return(1);
return 1;
}
/* Check for URL targets and process them
@ -57,7 +57,7 @@ int pacman_upgrade(alpm_list_t *targets)
if(str == NULL) {
pm_fprintf(stderr, PM_LOG_ERROR, "'%s': %s\n",
(char *)i->data, alpm_strerrorlast());
return(1);
return 1;
} else {
free(i->data);
i->data = str;
@ -67,7 +67,7 @@ int pacman_upgrade(alpm_list_t *targets)
/* Step 1: create a new transaction */
if(trans_init(config->flags) == -1) {
return(1);
return 1;
}
/* add targets to the created transaction */
@ -79,14 +79,14 @@ int pacman_upgrade(alpm_list_t *targets)
pm_fprintf(stderr, PM_LOG_ERROR, "'%s': %s\n",
targ, alpm_strerrorlast());
trans_release();
return(1);
return 1;
}
if(alpm_add_pkg(pkg) == -1) {
pm_fprintf(stderr, PM_LOG_ERROR, "'%s': %s\n",
targ, alpm_strerrorlast());
alpm_pkg_free(pkg);
trans_release();
return(1);
return 1;
}
}
@ -135,7 +135,7 @@ int pacman_upgrade(alpm_list_t *targets)
}
trans_release();
FREELIST(data);
return(1);
return 1;
}
/* Step 3: perform the installation */
@ -143,7 +143,7 @@ int pacman_upgrade(alpm_list_t *targets)
if(config->print) {
print_packages(alpm_trans_get_add());
trans_release();
return(0);
return 0;
}
/* print targets and ask user confirmation */
@ -151,7 +151,7 @@ int pacman_upgrade(alpm_list_t *targets)
if(packages == NULL) { /* we are done */
printf(_(" there is nothing to do\n"));
trans_release();
return(retval);
return retval;
}
display_targets(alpm_trans_get_remove(), 0);
display_targets(alpm_trans_get_add(), 1);
@ -159,7 +159,7 @@ int pacman_upgrade(alpm_list_t *targets)
int confirm = yesno(_("Proceed with installation?"));
if(!confirm) {
trans_release();
return(retval);
return retval;
}
if(alpm_trans_commit(&data) == -1) {
@ -197,13 +197,13 @@ int pacman_upgrade(alpm_list_t *targets)
}
FREELIST(data);
trans_release();
return(1);
return 1;
}
if(trans_release() == -1) {
retval = 1;
}
return(retval);
return retval;
}
/* vim: set ts=2 sw=2 noet: */

122
src/pacman/util.c
View File

@ -68,9 +68,9 @@ int trans_init(pmtransflag_t flags)
fprintf(stderr, _(" try running pacman-db-upgrade\n"));
}
return(-1);
return -1;
}
return(0);
return 0;
}
int trans_release(void)
@ -78,25 +78,25 @@ int trans_release(void)
if(alpm_trans_release() == -1) {
pm_fprintf(stderr, PM_LOG_ERROR, _("failed to release transaction (%s)\n"),
alpm_strerrorlast());
return(-1);
return -1;
}
return(0);
return 0;
}
int needs_root(void)
{
switch(config->op) {
case PM_OP_DATABASE:
return(1);
return 1;
case PM_OP_UPGRADE:
case PM_OP_REMOVE:
return(!config->print);
return !config->print;
case PM_OP_SYNC:
return(config->op_s_clean || config->op_s_sync ||
return (config->op_s_clean || config->op_s_sync ||
(!config->group && !config->op_s_info && !config->op_q_list &&
!config->op_s_search && !config->print));
default:
return(0);
return 0;
}
}
@ -125,24 +125,24 @@ int rmrf(const char *path)
DIR *dirp;
if(!unlink(path)) {
return(0);
return 0;
} else {
if(errno == ENOENT) {
return(0);
return 0;
} else if(errno == EPERM) {
/* fallthrough */
} else if(errno == EISDIR) {
/* fallthrough */
} else if(errno == ENOTDIR) {
return(1);
return 1;
} else {
/* not a directory */
return(1);
return 1;
}
dirp = opendir(path);
if(!dirp) {
return(1);
return 1;
}
for(dp = readdir(dirp); dp != NULL; dp = readdir(dirp)) {
if(dp->d_ino) {
@ -157,7 +157,7 @@ int rmrf(const char *path)
if(rmdir(path)) {
errflag++;
}
return(errflag);
return errflag;
}
}
@ -170,9 +170,9 @@ const char *mbasename(const char *path)
{
const char *last = strrchr(path, '/');
if(last) {
return(last + 1);
return last + 1;
}
return(path);
return path;
}
/** Parse the dirname of a program from a path.
@ -187,7 +187,7 @@ char *mdirname(const char *path)
/* null or empty path */
if(path == NULL || path == '\0') {
return(strdup("."));
return strdup(".");
}
ret = strdup(path);
@ -196,11 +196,11 @@ char *mdirname(const char *path)
if(last != NULL) {
/* we found a '/', so terminate our string */
*last = '\0';
return(ret);
return ret;
}
/* no slash found */
free(ret);
return(strdup("."));
return strdup(".");
}
/* output a string, but wrap words properly with a specified indentation
@ -286,7 +286,7 @@ char *strtrim(char *str)
if(str == NULL || *str == '\0') {
/* string is empty, so we're done. */
return(str);
return str;
}
while(isspace((unsigned char)*pch)) {
@ -298,7 +298,7 @@ char *strtrim(char *str)
/* check if there wasn't anything but whitespace in the string. */
if(*str == '\0') {
return(str);
return str;
}
pch = (str + (strlen(str) - 1));
@ -307,7 +307,7 @@ char *strtrim(char *str)
}
*++pch = '\0';
return(str);
return str;
}
/* Replace all occurances of 'needle' with 'replace' in 'str', returning
@ -321,7 +321,7 @@ char *strreplace(const char *str, const char *needle, const char *replace)
size_t newsz;
if(!str) {
return(NULL);
return NULL;
}
p = str;
@ -334,7 +334,7 @@ char *strreplace(const char *str, const char *needle, const char *replace)
/* no occurences of needle found */
if(!list) {
return(strdup(str));
return strdup(str);
}
/* size of new string = size of old string + "number of occurences of needle"
* x "size difference between replace and needle" */
@ -342,7 +342,7 @@ char *strreplace(const char *str, const char *needle, const char *replace)
alpm_list_count(list) * (replacesz - needlesz);
newstr = malloc(newsz);
if(!newstr) {
return(NULL);
return NULL;
}
*newstr = '\0';
@ -368,7 +368,7 @@ char *strreplace(const char *str, const char *needle, const char *replace)
}
*newp = '\0';
return(newstr);
return newstr;
}
/** Splits a string into a list of strings using the chosen character as
@ -388,7 +388,7 @@ alpm_list_t *strsplit(const char *str, const char splitchar)
while((str = strchr(str, splitchar))) {
dup = strndup(prev, (size_t)(str - prev));
if(dup == NULL) {
return(NULL);
return NULL;
}
list = alpm_list_add(list, dup);
@ -398,11 +398,11 @@ alpm_list_t *strsplit(const char *str, const char splitchar)
dup = strdup(prev);
if(dup == NULL) {
return(NULL);
return NULL;
}
list = alpm_list_add(list, dup);
return(list);
return list;
}
static int string_length(const char *s)
@ -411,7 +411,7 @@ static int string_length(const char *s)
wchar_t *wcstr;
if(!s) {
return(0);
return 0;
}
/* len goes from # bytes -> # chars -> # cols */
len = strlen(s) + 1;
@ -420,7 +420,7 @@ static int string_length(const char *s)
len = wcswidth(wcstr, len);
free(wcstr);
return(len);
return len;
}
void string_display(const char *title, const char *string)
@ -568,11 +568,11 @@ static off_t pkg_get_size(pmpkg_t *pkg)
{
switch(config->op) {
case PM_OP_SYNC:
return(alpm_pkg_download_size(pkg));
return alpm_pkg_download_size(pkg);
case PM_OP_UPGRADE:
return(alpm_pkg_get_size(pkg));
return alpm_pkg_get_size(pkg);
default:
return(alpm_pkg_get_isize(pkg));
return alpm_pkg_get_isize(pkg);
}
}
@ -588,14 +588,14 @@ static char *pkg_get_location(pmpkg_t *pkg)
if(dburl) {
char *pkgurl = NULL;
pm_asprintf(&pkgurl, "%s/%s", dburl, alpm_pkg_get_filename(pkg));
return(pkgurl);
return pkgurl;
}
case PM_OP_UPGRADE:
return(strdup(alpm_pkg_get_filename(pkg)));
return strdup(alpm_pkg_get_filename(pkg));
default:
string = NULL;
pm_asprintf(&string, "%s-%s", alpm_pkg_get_name(pkg), alpm_pkg_get_version(pkg));
return(string);
return string;
}
}
@ -657,7 +657,7 @@ void print_packages(const alpm_list_t *packages)
* alpm "compare func" signature */
int str_cmp(const void *s1, const void *s2)
{
return(strcmp(s1, s2));
return strcmp(s1, s2);
}
void display_new_optdepends(pmpkg_t *oldpkg, pmpkg_t *newpkg)
@ -726,13 +726,13 @@ static int parseindex(char *s, int *val, int min, int max)
if(n < min || n > max) {
fprintf(stderr, _("Invalid value: %d is not between %d and %d\n"),
n, min, max);
return(-1);
return -1;
}
*val = n;
return(0);
return 0;
} else {
fprintf(stderr, _("Invalid number: %s\n"), s);
return(-1);
return -1;
}
}
@ -772,20 +772,20 @@ static int multiselect_parse(char *array, int count, char *response)
}
if(parseindex(starts, &start, 1, count) != 0)
return(-1);
return -1;
if(!ends) {
array[start-1] = include;
} else {
if(parseindex(ends, &end, start, count) != 0)
return(-1);
return -1;
for(int d = start; d <= end; d++) {
array[d-1] = include;
}
}
}
return(0);
return 0;
}
int multiselect_question(char *array, int count)
@ -823,7 +823,7 @@ int multiselect_question(char *array, int count)
}
break;
}
return(0);
return 0;
}
int select_question(int count)
@ -855,13 +855,13 @@ int select_question(int count)
int n;
if(parseindex(response, &n, 1, count) != 0)
continue;
return(n-1);
return (n - 1);
}
}
break;
}
return(preset-1);
return (preset - 1);
}
@ -888,22 +888,22 @@ static int question(short preset, char *fmt, va_list args)
if(config->noconfirm) {
fprintf(stream, "\n");
return(preset);
return preset;
}
if(fgets(response, sizeof(response), stdin)) {
strtrim(response);
if(strlen(response) == 0) {
return(preset);
return preset;
}
if(strcasecmp(response, _("Y")) == 0 || strcasecmp(response, _("YES")) == 0) {
return(1);
return 1;
} else if (strcasecmp(response, _("N")) == 0 || strcasecmp(response, _("NO")) == 0) {
return(0);
return 0;
}
}
return(0);
return 0;
}
int yesno(char *fmt, ...)
@ -915,7 +915,7 @@ int yesno(char *fmt, ...)
ret = question(1, fmt, args);
va_end(args);
return(ret);
return ret;
}
int noyes(char *fmt, ...)
@ -927,7 +927,7 @@ int noyes(char *fmt, ...)
ret = question(0, fmt, args);
va_end(args);
return(ret);
return ret;
}
int pm_printf(pmloglevel_t level, const char *format, ...)
@ -940,7 +940,7 @@ int pm_printf(pmloglevel_t level, const char *format, ...)
ret = pm_vfprintf(stdout, level, format, args);
va_end(args);
return(ret);
return ret;
}
int pm_fprintf(FILE *stream, pmloglevel_t level, const char *format, ...)
@ -953,7 +953,7 @@ int pm_fprintf(FILE *stream, pmloglevel_t level, const char *format, ...)
ret = pm_vfprintf(stream, level, format, args);
va_end(args);
return(ret);
return ret;
}
int pm_asprintf(char **string, const char *format, ...)
@ -969,7 +969,7 @@ int pm_asprintf(char **string, const char *format, ...)
}
va_end(args);
return(ret);
return ret;
}
int pm_vasprintf(char **string, pmloglevel_t level, const char *format, va_list args)
@ -1005,7 +1005,7 @@ int pm_vasprintf(char **string, pmloglevel_t level, const char *format, va_list
}
free(msg);
return(ret);
return ret;
}
int pm_vfprintf(FILE *stream, pmloglevel_t level, const char *format, va_list args)
@ -1053,7 +1053,7 @@ int pm_vfprintf(FILE *stream, pmloglevel_t level, const char *format, va_list ar
/* print the message using va_arg list */
ret = vfprintf(stream, format, args);
return(ret);
return ret;
}
#ifndef HAVE_STRNDUP
@ -1062,7 +1062,7 @@ static size_t strnlen(const char *s, size_t max)
{
register const char *p;
for(p = s; *p && max--; ++p);
return(p - s);
return (p - s);
}
char *strndup(const char *s, size_t n)
@ -1074,7 +1074,7 @@ char *strndup(const char *s, size_t n)
return NULL;
new[len] = '\0';
return (char *) memcpy(new, s, len);
return (char *)memcpy(new, s, len);
}
#endif

2
src/util/cleanupdelta.c
View File

@ -119,7 +119,7 @@ int main(int argc, char *argv[])
if(alpm_initialize() == -1) {
fprintf(stderr, "cannot initialize alpm: %s\n", alpm_strerrorlast());
return(1);
return 1;
}
/* let us get log messages from libalpm */

18
src/util/pactree.c
View File

@ -60,12 +60,12 @@ static int alpm_local_init(void)
ret = alpm_initialize();
if(ret != 0) {
return(ret);
return ret;
}
ret = alpm_option_set_root(ROOTDIR);
if(ret != 0) {
return(ret);
return ret;
}
if(dbpath) {
@ -74,15 +74,15 @@ static int alpm_local_init(void)
ret = alpm_option_set_dbpath(DBPATH);
}
if(ret != 0) {
return(ret);
return ret;
}
db_local = alpm_option_get_localdb();
if(!db_local) {
return(1);
return 1;
}
return(0);
return 0;
}
static int parse_options(int argc, char *argv[])
@ -137,12 +137,12 @@ static int parse_options(int argc, char *argv[])
case 'h':
case '?':
default:
return(1);
return 1;
}
}
if(!argv[optind]) {
return(1);
return 1;
}
if(!color) {
@ -159,7 +159,7 @@ static int parse_options(int argc, char *argv[])
indent_size = 0;
}
return(0);
return 0;
}
static void usage(void)
@ -366,7 +366,7 @@ int main(int argc, char *argv[])
finish:
cleanup();
return(ret);
return ret;
}
/* vim: set ts=2 sw=2 noet: */

20
src/util/testdb.c
View File

@ -63,7 +63,7 @@ static int check_localdb_files(void)
snprintf(path, sizeof(path), "%slocal", dbpath);
if(!(dir = opendir(path))) {
fprintf(stderr, "error : %s : %s\n", path, strerror(errno));
return(1);
return 1;
}
while ((ent = readdir(dir)) != NULL) {
@ -85,10 +85,10 @@ static int check_localdb_files(void)
}
if(closedir(dir)) {
fprintf(stderr, "error closing dbpath : %s\n", strerror(errno));
return(1);
return 1;
}
return(ret);
return ret;
}
static int checkdeps(alpm_list_t *pkglist)
@ -107,7 +107,7 @@ static int checkdeps(alpm_list_t *pkglist)
ret++;
}
FREELIST(data);
return(ret);
return ret;
}
static int checkconflicts(alpm_list_t *pkglist)
@ -123,7 +123,7 @@ static int checkconflicts(alpm_list_t *pkglist)
ret++;
}
FREELIST(data);
return(ret);
return ret;
}
static int check_localdb(void) {
@ -133,7 +133,7 @@ static int check_localdb(void) {
ret = check_localdb_files();
if(ret) {
return(ret);
return ret;
}
db = alpm_option_get_localdb();
@ -145,7 +145,7 @@ static int check_localdb(void) {
pkglist = alpm_db_get_pkgcache(db);
ret += checkdeps(pkglist);
ret += checkconflicts(pkglist);
return(ret);
return ret;
}
static int check_syncdbs(alpm_list_t *dbnames) {
@ -169,7 +169,7 @@ static int check_syncdbs(alpm_list_t *dbnames) {
cleanup:
alpm_list_free(syncpkglist);
return(ret);
return ret;
}
static void usage(void) {
@ -206,7 +206,7 @@ int main(int argc, char *argv[])
if(alpm_initialize() == -1) {
fprintf(stderr, "cannot initialize alpm: %s\n", alpm_strerrorlast());
return(EXIT_FAILURE);
return EXIT_FAILURE;
}
/* let us get log messages from libalpm */
@ -214,7 +214,7 @@ int main(int argc, char *argv[])
if(alpm_option_set_dbpath(dbpath) != 0) {
fprintf(stderr, "cannot set dbpath: %s\n", alpm_strerrorlast());
return(EXIT_FAILURE);
return EXIT_FAILURE;
}
if(!dbnames) {

6
src/util/testpkg.c
View File

@ -44,12 +44,12 @@ int main(int argc, char *argv[])
if(argc != 2) {
fprintf(stderr, "usage: %s <package file>\n", BASENAME);
return(1);
return 1;
}
if(alpm_initialize() == -1) {
fprintf(stderr, "cannot initialize alpm: %s\n", alpm_strerrorlast());
return(1);
return 1;
}
/* let us get log messages from libalpm */
@ -79,5 +79,5 @@ int main(int argc, char *argv[])
fprintf(stderr, "error releasing alpm: %s\n", alpm_strerrorlast());
}
return(retval);
return retval;
}

6
src/util/vercmp.c
View File

@ -45,13 +45,13 @@ int main(int argc, char *argv[])
if(argc == 1) {
usage();
return(2);
return 2;
}
if(argc > 1 &&
(strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0
|| strcmp(argv[1], "--usage") == 0)) {
usage();
return(0);
return 0;
}
if(argc > 2) {
s2 = argv[2];
@ -62,5 +62,5 @@ int main(int argc, char *argv[])
ret = alpm_pkg_vercmp(s1, s2);
printf("%d\n", ret);
return(EXIT_SUCCESS);
return EXIT_SUCCESS;
}