From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from lists.gentoo.org (pigeon.gentoo.org [208.92.234.80]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by finch.gentoo.org (Postfix) with ESMTPS id 227D8138334 for ; Mon, 6 May 2019 17:33:11 +0000 (UTC) Received: from pigeon.gentoo.org (localhost [127.0.0.1]) by pigeon.gentoo.org (Postfix) with SMTP id 1A49EE087C; Mon, 6 May 2019 17:33:10 +0000 (UTC) Received: from smtp.gentoo.org (smtp.gentoo.org [140.211.166.183]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by pigeon.gentoo.org (Postfix) with ESMTPS id E1240E087C for ; Mon, 6 May 2019 17:33:09 +0000 (UTC) Received: from oystercatcher.gentoo.org (oystercatcher.gentoo.org [148.251.78.52]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.gentoo.org (Postfix) with ESMTPS id 3756334394F for ; Mon, 6 May 2019 17:33:08 +0000 (UTC) Received: from localhost.localdomain (localhost [IPv6:::1]) by oystercatcher.gentoo.org (Postfix) with ESMTP id 8814D566 for ; Mon, 6 May 2019 17:33:06 +0000 (UTC) From: "Fabian Groffen" To: gentoo-commits@lists.gentoo.org Content-Transfer-Encoding: 8bit Content-type: text/plain; charset=UTF-8 Reply-To: gentoo-dev@lists.gentoo.org, "Fabian Groffen" Message-ID: <1557163889.d87d181cd692247a5a7411fd6284c862bc73f28b.grobian@gentoo> Subject: [gentoo-commits] proj/portage-utils:master commit in: /, libq/ X-VCS-Repository: proj/portage-utils X-VCS-Files: TODO.md libq/cache.c libq/cache.h libq/vdb.c libq/vdb.h qcheck.c qdepends.c qfile.c qgrep.c qlist.c qmerge.c qpkg.c qsize.c X-VCS-Directories: / libq/ X-VCS-Committer: grobian X-VCS-Committer-Name: Fabian Groffen X-VCS-Revision: d87d181cd692247a5a7411fd6284c862bc73f28b X-VCS-Branch: master Date: Mon, 6 May 2019 17:33:06 +0000 (UTC) Precedence: bulk List-Post: List-Help: List-Unsubscribe: List-Subscribe: List-Id: Gentoo Linux mail X-BeenThere: gentoo-commits@lists.gentoo.org X-Auto-Response-Suppress: DR, RN, NRN, OOF, AutoReply X-Archives-Salt: 9d72fd6c-6857-4eab-be5c-aa5d0ff5adb5 X-Archives-Hash: f37b8bad240e787608b5424127eee78f commit: d87d181cd692247a5a7411fd6284c862bc73f28b Author: Fabian Groffen gentoo org> AuthorDate: Mon May 6 17:31:29 2019 +0000 Commit: Fabian Groffen gentoo org> CommitDate: Mon May 6 17:31:29 2019 +0000 URL: https://gitweb.gentoo.org/proj/portage-utils.git/commit/?id=d87d181c libq/vdb: drop q_ prefix Signed-off-by: Fabian Groffen gentoo.org> TODO.md | 2 +- libq/cache.c | 40 +++++++++---------- libq/cache.h | 6 +-- libq/vdb.c | 127 ++++++++++++++++++++++++++++++----------------------------- libq/vdb.h | 74 +++++++++++++++++----------------- qcheck.c | 10 ++--- qdepends.c | 8 ++-- qfile.c | 10 ++--- qgrep.c | 4 +- qlist.c | 24 +++++------ qmerge.c | 48 +++++++++++----------- qpkg.c | 14 +++---- qsize.c | 6 +-- 13 files changed, 187 insertions(+), 186 deletions(-) diff --git a/TODO.md b/TODO.md index bc4f524..6fda56d 100644 --- a/TODO.md +++ b/TODO.md @@ -23,7 +23,7 @@ we end up getting just:
`ACCEPT_LICENSE=" bar"` -- q\_vdb\_foreach\_pkg should have variant that takes an atom (or just +- vdb\_foreach\_pkg should have variant that takes an atom (or just cat?) to reduce search space, same for cache\_foreach\_pkg - vdb repo/slot think about when it is freed (see cache\_pkg\_close) diff --git a/libq/cache.c b/libq/cache.c index c0ea85e..304cd34 100644 --- a/libq/cache.c +++ b/libq/cache.c @@ -66,7 +66,7 @@ cache_open(const char *sroot, const char *portdir) } snprintf(buf, sizeof(buf), "%s/%s", portdir, portcachedir_md5); - ret = q_vdb_open2(sroot, buf, true); + ret = vdb_open2(sroot, buf, true); if (ret != NULL) { ret->cachetype = CACHE_METADATA_MD5; ret->repo = repo; @@ -74,14 +74,14 @@ cache_open(const char *sroot, const char *portdir) } snprintf(buf, sizeof(buf), "%s/%s", portdir, portcachedir_pms); - ret = q_vdb_open2(sroot, buf, true); + ret = vdb_open2(sroot, buf, true); if (ret != NULL) { ret->cachetype = CACHE_METADATA_PMS; ret->repo = repo; return ret; } - ret = q_vdb_open2(sroot, portdir, true); + ret = vdb_open2(sroot, portdir, true); if (ret != NULL) { ret->cachetype = CACHE_EBUILD; ret->repo = repo; @@ -101,31 +101,31 @@ cache_close(cache_ctx *ctx) free(ctx->repo); if (ctx->ebuilddir_ctx != NULL) free(ctx->ebuilddir_ctx); - q_vdb_close(ctx); + vdb_close(ctx); } cache_cat_ctx * cache_open_cat(cache_ctx *ctx, const char *name) { - return q_vdb_open_cat(ctx, name); + return vdb_open_cat(ctx, name); } cache_cat_ctx * cache_next_cat(cache_ctx *ctx) { - return q_vdb_next_cat(ctx); + return vdb_next_cat(ctx); } void cache_close_cat(cache_cat_ctx *cat_ctx) { - return q_vdb_close_cat(cat_ctx); + return vdb_close_cat(cat_ctx); } cache_pkg_ctx * cache_open_pkg(cache_cat_ctx *cat_ctx, const char *name) { - return q_vdb_open_pkg(cat_ctx, name); + return vdb_open_pkg(cat_ctx, name); } cache_pkg_ctx * @@ -141,13 +141,13 @@ cache_next_pkg(cache_cat_ctx *cat_ctx) * to CAT/P like in VDB and metadata */ do { if (ctx->ebuilddir_pkg_ctx == NULL) { - q_vdb_ctx *pkgdir = ctx->ebuilddir_ctx; + vdb_ctx *pkgdir = ctx->ebuilddir_ctx; if (pkgdir == NULL) - pkgdir = ctx->ebuilddir_ctx = xmalloc(sizeof(q_vdb_ctx)); + pkgdir = ctx->ebuilddir_ctx = xmalloc(sizeof(vdb_ctx)); memset(ctx->ebuilddir_ctx, '\0', sizeof(*ctx->ebuilddir_ctx)); - if ((ctx->ebuilddir_pkg_ctx = q_vdb_next_pkg(cat_ctx)) == NULL) + if ((ctx->ebuilddir_pkg_ctx = vdb_next_pkg(cat_ctx)) == NULL) return NULL; pkgdir->portroot_fd = -1; @@ -159,7 +159,7 @@ cache_next_pkg(cache_cat_ctx *cat_ctx) pkgdir->cachetype = ctx->cachetype; ctx->ebuilddir_cat_ctx = - q_vdb_open_cat(pkgdir, ctx->ebuilddir_pkg_ctx->name); + vdb_open_cat(pkgdir, ctx->ebuilddir_pkg_ctx->name); /* opening might fail if what we found wasn't a * directory or something */ @@ -172,9 +172,9 @@ cache_next_pkg(cache_cat_ctx *cat_ctx) ctx->ebuilddir_cat_ctx->name = cat_ctx->name; } - ret = q_vdb_next_pkg(ctx->ebuilddir_cat_ctx); + ret = vdb_next_pkg(ctx->ebuilddir_cat_ctx); if (ret == NULL) { - q_vdb_close_cat(ctx->ebuilddir_cat_ctx); + vdb_close_cat(ctx->ebuilddir_cat_ctx); ctx->ebuilddir_pkg_ctx = NULL; } else { if ((p = strstr(ret->name, ".ebuild")) == NULL) { @@ -186,7 +186,7 @@ cache_next_pkg(cache_cat_ctx *cat_ctx) } } while (ret == NULL); } else { - ret = q_vdb_next_pkg(cat_ctx); + ret = vdb_next_pkg(cat_ctx); } return ret; @@ -627,16 +627,16 @@ cache_close_metadata(cache_metadata_xml *meta_ctx) void cache_close_pkg(cache_pkg_ctx *pkg_ctx) { - /* avoid free of cache_ctx' repo by q_vdb_close_pkg */ + /* avoid free of cache_ctx' repo by vdb_close_pkg */ if (pkg_ctx->cat_ctx->ctx->repo == pkg_ctx->repo) pkg_ctx->repo = NULL; - q_vdb_close_pkg(pkg_ctx); + vdb_close_pkg(pkg_ctx); } static int cache_foreach_pkg_int(const char *sroot, const char *portdir, - q_vdb_pkg_cb callback, void *priv, q_vdb_cat_filter filter, + vdb_pkg_cb callback, void *priv, vdb_cat_filter filter, bool sort, void *catsortfunc, void *pkgsortfunc) { cache_ctx *ctx; @@ -671,7 +671,7 @@ cache_foreach_pkg_int(const char *sroot, const char *portdir, int cache_foreach_pkg(const char *sroot, const char *portdir, - q_vdb_pkg_cb callback, void *priv, q_vdb_cat_filter filter) + vdb_pkg_cb callback, void *priv, vdb_cat_filter filter) { return cache_foreach_pkg_int(sroot, portdir, callback, priv, filter, false, NULL, NULL); @@ -679,7 +679,7 @@ cache_foreach_pkg(const char *sroot, const char *portdir, int cache_foreach_pkg_sorted(const char *sroot, const char *portdir, - q_vdb_pkg_cb callback, void *priv, + vdb_pkg_cb callback, void *priv, void *catsortfunc, void *pkgsortfunc) { return cache_foreach_pkg_int(sroot, portdir, callback, priv, diff --git a/libq/cache.h b/libq/cache.h index 2ad2e78..e863daf 100644 --- a/libq/cache.h +++ b/libq/cache.h @@ -13,9 +13,9 @@ #include "atom.h" #include "vdb.h" -#define cache_ctx q_vdb_ctx -#define cache_cat_ctx q_vdb_cat_ctx -#define cache_pkg_ctx q_vdb_pkg_ctx +#define cache_ctx vdb_ctx +#define cache_cat_ctx vdb_cat_ctx +#define cache_pkg_ctx vdb_pkg_ctx typedef struct { char *_data; diff --git a/libq/vdb.c b/libq/vdb.c index 034a28c..5dc5e79 100644 --- a/libq/vdb.c +++ b/libq/vdb.c @@ -18,10 +18,10 @@ #include #include -q_vdb_ctx * -q_vdb_open2(const char *sroot, const char *svdb, bool quiet) +vdb_ctx * +vdb_open2(const char *sroot, const char *svdb, bool quiet) { - q_vdb_ctx *ctx = xmalloc(sizeof(*ctx)); + vdb_ctx *ctx = xmalloc(sizeof(*ctx)); ctx->portroot_fd = open(sroot, O_RDONLY|O_CLOEXEC|O_PATH); if (ctx->portroot_fd == -1) { @@ -64,14 +64,14 @@ q_vdb_open2(const char *sroot, const char *svdb, bool quiet) return NULL; } -q_vdb_ctx * -q_vdb_open(const char *sroot, const char *svdb) +vdb_ctx * +vdb_open(const char *sroot, const char *svdb) { - return q_vdb_open2(sroot, svdb, false); + return vdb_open2(sroot, svdb, false); } void -q_vdb_close(q_vdb_ctx *ctx) +vdb_close(vdb_ctx *ctx) { closedir(ctx->dir); /* closedir() above does this for us: */ @@ -83,7 +83,7 @@ q_vdb_close(q_vdb_ctx *ctx) } int -q_vdb_filter_cat(const struct dirent *de) +vdb_filter_cat(const struct dirent *de) { int i; bool founddash; @@ -124,10 +124,10 @@ q_vdb_filter_cat(const struct dirent *de) return i; } -q_vdb_cat_ctx * -q_vdb_open_cat(q_vdb_ctx *ctx, const char *name) +vdb_cat_ctx * +vdb_open_cat(vdb_ctx *ctx, const char *name) { - q_vdb_cat_ctx *cat_ctx; + vdb_cat_ctx *cat_ctx; int fd; DIR *dir; @@ -151,21 +151,21 @@ q_vdb_open_cat(q_vdb_ctx *ctx, const char *name) return cat_ctx; } -q_vdb_cat_ctx * -q_vdb_next_cat(q_vdb_ctx *ctx) +vdb_cat_ctx * +vdb_next_cat(vdb_ctx *ctx) { /* search for a category directory */ - q_vdb_cat_ctx *cat_ctx = NULL; + vdb_cat_ctx *cat_ctx = NULL; if (ctx->do_sort) { if (ctx->cat_de == NULL) { ctx->cat_cnt = scandirat(ctx->vdb_fd, - ".", &ctx->cat_de, q_vdb_filter_cat, ctx->catsortfunc); + ".", &ctx->cat_de, vdb_filter_cat, ctx->catsortfunc); ctx->cat_cur = 0; } while (ctx->cat_cur < ctx->cat_cnt) { - cat_ctx = q_vdb_open_cat(ctx, ctx->cat_de[ctx->cat_cur++]->d_name); + cat_ctx = vdb_open_cat(ctx, ctx->cat_de[ctx->cat_cur++]->d_name); if (!cat_ctx) continue; break; @@ -178,10 +178,10 @@ q_vdb_next_cat(q_vdb_ctx *ctx) if (!de) break; - if (q_vdb_filter_cat(de) == 0) + if (vdb_filter_cat(de) == 0) continue; - cat_ctx = q_vdb_open_cat(ctx, de->d_name); + cat_ctx = vdb_open_cat(ctx, de->d_name); if (!cat_ctx) continue; @@ -193,7 +193,7 @@ q_vdb_next_cat(q_vdb_ctx *ctx) } void -q_vdb_close_cat(q_vdb_cat_ctx *cat_ctx) +vdb_close_cat(vdb_cat_ctx *cat_ctx) { closedir(cat_ctx->dir); /* closedir() above does this for us: */ @@ -204,7 +204,7 @@ q_vdb_close_cat(q_vdb_cat_ctx *cat_ctx) } int -q_vdb_filter_pkg(const struct dirent *de) +vdb_filter_pkg(const struct dirent *de) { int i; bool founddash = false; @@ -235,33 +235,34 @@ q_vdb_filter_pkg(const struct dirent *de) return i; } -q_vdb_pkg_ctx * -q_vdb_open_pkg(q_vdb_cat_ctx *cat_ctx, const char *name) +vdb_pkg_ctx * +vdb_open_pkg(vdb_cat_ctx *cat_ctx, const char *name) { - q_vdb_pkg_ctx *pkg_ctx = xmalloc(sizeof(*pkg_ctx)); + vdb_pkg_ctx *pkg_ctx = xmalloc(sizeof(*pkg_ctx)); pkg_ctx->name = name; pkg_ctx->slot = NULL; pkg_ctx->repo = cat_ctx->ctx->repo; pkg_ctx->fd = -1; pkg_ctx->cat_ctx = cat_ctx; + pkg_ctx->atom = NULL; return pkg_ctx; } -q_vdb_pkg_ctx * -q_vdb_next_pkg(q_vdb_cat_ctx *cat_ctx) +vdb_pkg_ctx * +vdb_next_pkg(vdb_cat_ctx *cat_ctx) { - q_vdb_pkg_ctx *pkg_ctx = NULL; + vdb_pkg_ctx *pkg_ctx = NULL; if (cat_ctx->ctx->do_sort) { if (cat_ctx->pkg_de == NULL) { cat_ctx->pkg_cnt = scandirat(cat_ctx->fd, ".", &cat_ctx->pkg_de, - q_vdb_filter_pkg, cat_ctx->ctx->pkgsortfunc); + vdb_filter_pkg, cat_ctx->ctx->pkgsortfunc); cat_ctx->pkg_cur = 0; } while (cat_ctx->pkg_cur < cat_ctx->pkg_cnt) { pkg_ctx = - q_vdb_open_pkg(cat_ctx, + vdb_open_pkg(cat_ctx, cat_ctx->pkg_de[cat_ctx->pkg_cur++]->d_name); if (!pkg_ctx) continue; @@ -274,10 +275,10 @@ q_vdb_next_pkg(q_vdb_cat_ctx *cat_ctx) if (!de) break; - if (q_vdb_filter_pkg(de) == 0) + if (vdb_filter_pkg(de) == 0) continue; - pkg_ctx = q_vdb_open_pkg(cat_ctx, de->d_name); + pkg_ctx = vdb_open_pkg(cat_ctx, de->d_name); if (!pkg_ctx) continue; @@ -289,7 +290,7 @@ q_vdb_next_pkg(q_vdb_cat_ctx *cat_ctx) } int -q_vdb_pkg_openat(q_vdb_pkg_ctx *pkg_ctx, const char *file, int flags, mode_t mode) +vdb_pkg_openat(vdb_pkg_ctx *pkg_ctx, const char *file, int flags, mode_t mode) { if (pkg_ctx->fd == -1) { pkg_ctx->fd = openat(pkg_ctx->cat_ctx->fd, pkg_ctx->name, @@ -302,13 +303,13 @@ q_vdb_pkg_openat(q_vdb_pkg_ctx *pkg_ctx, const char *file, int flags, mode_t mod } FILE * -q_vdb_pkg_fopenat(q_vdb_pkg_ctx *pkg_ctx, const char *file, +vdb_pkg_fopenat(vdb_pkg_ctx *pkg_ctx, const char *file, int flags, mode_t mode, const char *fmode) { FILE *fp; int fd; - fd = q_vdb_pkg_openat(pkg_ctx, file, flags, mode); + fd = vdb_pkg_openat(pkg_ctx, file, flags, mode); if (fd == -1) return NULL; @@ -320,9 +321,9 @@ q_vdb_pkg_fopenat(q_vdb_pkg_ctx *pkg_ctx, const char *file, } bool -q_vdb_pkg_eat(q_vdb_pkg_ctx *pkg_ctx, const char *file, char **bufptr, size_t *buflen) +vdb_pkg_eat(vdb_pkg_ctx *pkg_ctx, const char *file, char **bufptr, size_t *buflen) { - int fd = q_vdb_pkg_openat(pkg_ctx, file, O_RDONLY, 0); + int fd = vdb_pkg_openat(pkg_ctx, file, O_RDONLY, 0); bool ret = eat_file_fd(fd, bufptr, buflen); rmspace(*bufptr); if (fd != -1) @@ -331,7 +332,7 @@ q_vdb_pkg_eat(q_vdb_pkg_ctx *pkg_ctx, const char *file, char **bufptr, size_t *b } void -q_vdb_close_pkg(q_vdb_pkg_ctx *pkg_ctx) +vdb_close_pkg(vdb_pkg_ctx *pkg_ctx) { if (pkg_ctx->fd != -1) close(pkg_ctx->fd); @@ -343,16 +344,16 @@ q_vdb_close_pkg(q_vdb_pkg_ctx *pkg_ctx) } static int -q_vdb_foreach_pkg_int(const char *sroot, const char *svdb, - q_vdb_pkg_cb callback, void *priv, q_vdb_cat_filter filter, +vdb_foreach_pkg_int(const char *sroot, const char *svdb, + vdb_pkg_cb callback, void *priv, vdb_cat_filter filter, bool sort, void *catsortfunc, void *pkgsortfunc) { - q_vdb_ctx *ctx; - q_vdb_cat_ctx *cat_ctx; - q_vdb_pkg_ctx *pkg_ctx; + vdb_ctx *ctx; + vdb_cat_ctx *cat_ctx; + vdb_pkg_ctx *pkg_ctx; int ret; - ctx = q_vdb_open(sroot, svdb); + ctx = vdb_open(sroot, svdb); if (!ctx) return EXIT_FAILURE; @@ -363,38 +364,38 @@ q_vdb_foreach_pkg_int(const char *sroot, const char *svdb, ctx->pkgsortfunc = pkgsortfunc; ret = 0; - while ((cat_ctx = q_vdb_next_cat(ctx))) { + while ((cat_ctx = vdb_next_cat(ctx))) { if (filter && !filter(cat_ctx, priv)) continue; - while ((pkg_ctx = q_vdb_next_pkg(cat_ctx))) { + while ((pkg_ctx = vdb_next_pkg(cat_ctx))) { ret |= callback(pkg_ctx, priv); - q_vdb_close_pkg(pkg_ctx); + vdb_close_pkg(pkg_ctx); } - q_vdb_close_cat(cat_ctx); + vdb_close_cat(cat_ctx); } - q_vdb_close(ctx); + vdb_close(ctx); return ret; } int -q_vdb_foreach_pkg(const char *sroot, const char *svdb, - q_vdb_pkg_cb callback, void *priv, q_vdb_cat_filter filter) +vdb_foreach_pkg(const char *sroot, const char *svdb, + vdb_pkg_cb callback, void *priv, vdb_cat_filter filter) { - return q_vdb_foreach_pkg_int(sroot, svdb, callback, priv, + return vdb_foreach_pkg_int(sroot, svdb, callback, priv, filter, false, NULL, NULL); } int -q_vdb_foreach_pkg_sorted(const char *sroot, const char *svdb, - q_vdb_pkg_cb callback, void *priv) +vdb_foreach_pkg_sorted(const char *sroot, const char *svdb, + vdb_pkg_cb callback, void *priv) { - return q_vdb_foreach_pkg_int(sroot, svdb, callback, priv, + return vdb_foreach_pkg_int(sroot, svdb, callback, priv, NULL, true, NULL, NULL); } struct dirent * -q_vdb_get_next_dir(DIR *dir) +vdb_get_next_dir(DIR *dir) { /* search for a category directory */ struct dirent *ret; @@ -406,23 +407,23 @@ next_entry: return NULL; } - if (q_vdb_filter_cat(ret) == 0) + if (vdb_filter_cat(ret) == 0) goto next_entry; return ret; } depend_atom * -q_vdb_get_atom(q_vdb_pkg_ctx *pkg_ctx) +vdb_get_atom(vdb_pkg_ctx *pkg_ctx) { pkg_ctx->atom = atom_explode(pkg_ctx->name); if (pkg_ctx->atom == NULL) return NULL; pkg_ctx->atom->CATEGORY = (char *)pkg_ctx->cat_ctx->name; - q_vdb_pkg_eat(pkg_ctx, "SLOT", &pkg_ctx->slot, &pkg_ctx->slot_len); + vdb_pkg_eat(pkg_ctx, "SLOT", &pkg_ctx->slot, &pkg_ctx->slot_len); pkg_ctx->atom->SLOT = pkg_ctx->slot; - q_vdb_pkg_eat(pkg_ctx, "repository", &pkg_ctx->repo, &pkg_ctx->repo_len); + vdb_pkg_eat(pkg_ctx, "repository", &pkg_ctx->repo, &pkg_ctx->repo_len); pkg_ctx->atom->REPO = pkg_ctx->repo; return pkg_ctx->atom; @@ -431,7 +432,7 @@ q_vdb_get_atom(q_vdb_pkg_ctx *pkg_ctx) set * get_vdb_atoms(const char *sroot, const char *svdb, int fullcpv) { - q_vdb_ctx *ctx; + vdb_ctx *ctx; int cfd, j; int dfd, i; @@ -447,18 +448,18 @@ get_vdb_atoms(const char *sroot, const char *svdb, int fullcpv) depend_atom *atom = NULL; set *cpf = NULL; - ctx = q_vdb_open(sroot, svdb); + ctx = vdb_open(sroot, svdb); if (!ctx) return NULL; /* scan the cat first */ - cfd = scandirat(ctx->vdb_fd, ".", &cat, q_vdb_filter_cat, alphasort); + cfd = scandirat(ctx->vdb_fd, ".", &cat, vdb_filter_cat, alphasort); if (cfd < 0) goto fuckit; for (j = 0; j < cfd; j++) { dfd = scandirat(ctx->vdb_fd, cat[j]->d_name, - &pf, q_vdb_filter_pkg, alphasort); + &pf, vdb_filter_pkg, alphasort); if (dfd < 0) continue; for (i = 0; i < dfd; i++) { @@ -499,6 +500,6 @@ get_vdb_atoms(const char *sroot, const char *svdb, int fullcpv) scandir_free(cat, cfd); fuckit: - q_vdb_close(ctx); + vdb_close(ctx); return cpf; } diff --git a/libq/vdb.h b/libq/vdb.h index 3cfa95b..2954bef 100644 --- a/libq/vdb.h +++ b/libq/vdb.h @@ -11,12 +11,12 @@ #include "set.h" -typedef struct q_vdb_ctx q_vdb_ctx; -typedef struct q_vdb_cat_ctx q_vdb_cat_ctx; -typedef struct q_vdb_pkg_ctx q_vdb_pkg_ctx; +typedef struct vdb_ctx vdb_ctx; +typedef struct vdb_cat_ctx vdb_cat_ctx; +typedef struct vdb_pkg_ctx vdb_pkg_ctx; /* VDB context */ -struct q_vdb_ctx { +struct vdb_ctx { int portroot_fd; int vdb_fd; DIR *dir; @@ -33,64 +33,64 @@ struct q_vdb_ctx { CACHE_EBUILD, CACHE_VDB, } cachetype:3; - q_vdb_pkg_ctx *ebuilddir_pkg_ctx; - q_vdb_cat_ctx *ebuilddir_cat_ctx; - q_vdb_ctx *ebuilddir_ctx; + vdb_pkg_ctx *ebuilddir_pkg_ctx; + vdb_cat_ctx *ebuilddir_cat_ctx; + vdb_ctx *ebuilddir_ctx; char *repo; }; /* Category context */ -struct q_vdb_cat_ctx { +struct vdb_cat_ctx { const char *name; int fd; DIR *dir; - const q_vdb_ctx *ctx; + const vdb_ctx *ctx; struct dirent **pkg_de; size_t pkg_cnt; size_t pkg_cur; }; /* Package context */ -struct q_vdb_pkg_ctx { +struct vdb_pkg_ctx { const char *name; char *slot; char *repo; size_t slot_len; size_t repo_len; int fd; - q_vdb_cat_ctx *cat_ctx; + vdb_cat_ctx *cat_ctx; depend_atom *atom; }; /* Global helpers */ -typedef int (q_vdb_pkg_cb)(q_vdb_pkg_ctx *, void *priv); -typedef int (q_vdb_cat_filter)(q_vdb_cat_ctx *, void *priv); +typedef int (vdb_pkg_cb)(vdb_pkg_ctx *, void *priv); +typedef int (vdb_cat_filter)(vdb_cat_ctx *, void *priv); -q_vdb_ctx *q_vdb_open(const char *sroot, const char *svdb); -q_vdb_ctx *q_vdb_open2(const char *sroot, const char *svdb, bool quiet); -void q_vdb_close(q_vdb_ctx *ctx); -int q_vdb_filter_cat(const struct dirent *de); -q_vdb_cat_ctx *q_vdb_open_cat(q_vdb_ctx *ctx, const char *name); -q_vdb_cat_ctx *q_vdb_next_cat(q_vdb_ctx *ctx); -void q_vdb_close_cat(q_vdb_cat_ctx *cat_ctx); -int q_vdb_filter_pkg(const struct dirent *de); -q_vdb_pkg_ctx *q_vdb_open_pkg(q_vdb_cat_ctx *cat_ctx, const char *name); -q_vdb_pkg_ctx *q_vdb_next_pkg(q_vdb_cat_ctx *cat_ctx); -int q_vdb_pkg_openat(q_vdb_pkg_ctx *pkg_ctx, const char *file, int flags, mode_t mode); -FILE *q_vdb_pkg_fopenat(q_vdb_pkg_ctx *pkg_ctx, const char *file, +vdb_ctx *vdb_open(const char *sroot, const char *svdb); +vdb_ctx *vdb_open2(const char *sroot, const char *svdb, bool quiet); +void vdb_close(vdb_ctx *ctx); +int vdb_filter_cat(const struct dirent *de); +vdb_cat_ctx *vdb_open_cat(vdb_ctx *ctx, const char *name); +vdb_cat_ctx *vdb_next_cat(vdb_ctx *ctx); +void vdb_close_cat(vdb_cat_ctx *cat_ctx); +int vdb_filter_pkg(const struct dirent *de); +vdb_pkg_ctx *vdb_open_pkg(vdb_cat_ctx *cat_ctx, const char *name); +vdb_pkg_ctx *vdb_next_pkg(vdb_cat_ctx *cat_ctx); +int vdb_pkg_openat(vdb_pkg_ctx *pkg_ctx, const char *file, int flags, mode_t mode); +FILE *vdb_pkg_fopenat(vdb_pkg_ctx *pkg_ctx, const char *file, int flags, mode_t mode, const char *fmode); -#define q_vdb_pkg_fopenat_ro(pkg_ctx, file) \ - q_vdb_pkg_fopenat(pkg_ctx, file, O_RDONLY, 0, "r") -#define q_vdb_pkg_fopenat_rw(pkg_ctx, file) \ - q_vdb_pkg_fopenat(pkg_ctx, file, O_RDWR|O_CREAT|O_TRUNC, 0644, "w") -bool q_vdb_pkg_eat(q_vdb_pkg_ctx *pkg_ctx, const char *file, char **bufptr, size_t *buflen); -void q_vdb_close_pkg(q_vdb_pkg_ctx *pkg_ctx); -int q_vdb_foreach_pkg(const char *sroot, const char *svdb, - q_vdb_pkg_cb callback, void *priv, q_vdb_cat_filter filter); -int q_vdb_foreach_pkg_sorted(const char *sroot, const char *svdb, - q_vdb_pkg_cb callback, void *priv); -struct dirent *q_vdb_get_next_dir(DIR *dir); +#define vdb_pkg_fopenat_ro(pkg_ctx, file) \ + vdb_pkg_fopenat(pkg_ctx, file, O_RDONLY, 0, "r") +#define vdb_pkg_fopenat_rw(pkg_ctx, file) \ + vdb_pkg_fopenat(pkg_ctx, file, O_RDWR|O_CREAT|O_TRUNC, 0644, "w") +bool vdb_pkg_eat(vdb_pkg_ctx *pkg_ctx, const char *file, char **bufptr, size_t *buflen); +void vdb_close_pkg(vdb_pkg_ctx *pkg_ctx); +int vdb_foreach_pkg(const char *sroot, const char *svdb, + vdb_pkg_cb callback, void *priv, vdb_cat_filter filter); +int vdb_foreach_pkg_sorted(const char *sroot, const char *svdb, + vdb_pkg_cb callback, void *priv); +struct dirent *vdb_get_next_dir(DIR *dir); set *get_vdb_atoms(const char *sroot, const char *svdb, int fullcpv); -depend_atom *q_vdb_get_atom(q_vdb_pkg_ctx *pkg_ctx); +depend_atom *vdb_get_atom(vdb_pkg_ctx *pkg_ctx); #endif diff --git a/qcheck.c b/qcheck.c index 0585396..377a187 100644 --- a/qcheck.c +++ b/qcheck.c @@ -65,7 +65,7 @@ struct qcheck_opt_state { }; static int -qcheck_process_contents(q_vdb_pkg_ctx *pkg_ctx, struct qcheck_opt_state *state) +qcheck_process_contents(vdb_pkg_ctx *pkg_ctx, struct qcheck_opt_state *state) { int fd_contents; FILE *fp_contents, *fp_contents_update; @@ -81,7 +81,7 @@ qcheck_process_contents(q_vdb_pkg_ctx *pkg_ctx, struct qcheck_opt_state *state) fp_contents_update = NULL; /* Open contents */ - fd_contents = q_vdb_pkg_openat(pkg_ctx, "CONTENTS", O_RDONLY|O_CLOEXEC, 0); + fd_contents = vdb_pkg_openat(pkg_ctx, "CONTENTS", O_RDONLY|O_CLOEXEC, 0); if (fd_contents == -1) return EXIT_SUCCESS; if (fstat(fd_contents, &cst)) { @@ -99,7 +99,7 @@ qcheck_process_contents(q_vdb_pkg_ctx *pkg_ctx, struct qcheck_opt_state *state) (state->qc_update ? "Updat" : "Check"), GREEN, catname, pkgname, NORM); if (state->qc_update) { - fp_contents_update = q_vdb_pkg_fopenat_rw(pkg_ctx, "CONTENTS~"); + fp_contents_update = vdb_pkg_fopenat_rw(pkg_ctx, "CONTENTS~"); if (fp_contents_update == NULL) { fclose(fp_contents); warnp("unable to fopen(%s/%s, w)", pkgname, "CONTENTS~"); @@ -363,7 +363,7 @@ qcheck_process_contents(q_vdb_pkg_ctx *pkg_ctx, struct qcheck_opt_state *state) } static int -qcheck_cb(q_vdb_pkg_ctx *pkg_ctx, void *priv) +qcheck_cb(vdb_pkg_ctx *pkg_ctx, void *priv) { struct qcheck_opt_state *state = priv; const char *catname = pkg_ctx->cat_ctx->name; @@ -439,7 +439,7 @@ int qcheck_main(int argc, char **argv) xarraypush_ptr(atoms, atom); } - ret = q_vdb_foreach_pkg_sorted(portroot, portvdb, qcheck_cb, &state); + ret = vdb_foreach_pkg_sorted(portroot, portvdb, qcheck_cb, &state); { void *regex; array_for_each(regex_arr, i, regex) diff --git a/qdepends.c b/qdepends.c index 7bb8818..e49e533 100644 --- a/qdepends.c +++ b/qdepends.c @@ -92,7 +92,7 @@ qdepends_print_depend(FILE *fp, const char *depend) } static int -qdepends_results_cb(q_vdb_pkg_ctx *pkg_ctx, void *priv) +qdepends_results_cb(vdb_pkg_ctx *pkg_ctx, void *priv) { struct qdepends_opt_state *state = priv; depend_atom *atom; @@ -116,7 +116,7 @@ qdepends_results_cb(q_vdb_pkg_ctx *pkg_ctx, void *priv) * *DEPEND alters the search somewhat and affects results printing. */ - datom = q_vdb_get_atom(pkg_ctx); + datom = vdb_get_atom(pkg_ctx); if (datom == NULL) return ret; @@ -145,7 +145,7 @@ qdepends_results_cb(q_vdb_pkg_ctx *pkg_ctx, void *priv) for (i = QMODE_DEPEND; i <= QMODE_BDEPEND; i <<= 1, dfile++) { if (!(state->qmode & i)) continue; - if (!q_vdb_pkg_eat(pkg_ctx, *dfile, + if (!vdb_pkg_eat(pkg_ctx, *dfile, &state->depend, &state->depend_len)) continue; @@ -302,7 +302,7 @@ int qdepends_main(int argc, char **argv) xarraypush_ptr(atoms, atom); } - ret = q_vdb_foreach_pkg(portroot, portvdb, + ret = vdb_foreach_pkg(portroot, portvdb, qdepends_results_cb, &state, NULL); if (state.depend != NULL) diff --git a/qfile.c b/qfile.c index 19b156e..3d1543e 100644 --- a/qfile.c +++ b/qfile.c @@ -74,7 +74,7 @@ struct qfile_opt_state { * We assume the people calling us have chdir(/var/db/pkg) and so * we use relative paths throughout here. */ -static int qfile_cb(q_vdb_pkg_ctx *pkg_ctx, void *priv) +static int qfile_cb(vdb_pkg_ctx *pkg_ctx, void *priv) { struct qfile_opt_state *state = priv; const char *catname = pkg_ctx->cat_ctx->name; @@ -115,14 +115,14 @@ static int qfile_cb(q_vdb_pkg_ctx *pkg_ctx, void *priv) } if (state->exclude_slot == NULL) goto qlist_done; /* "(CAT/)?(PN|PF)" matches, and no SLOT specified */ - q_vdb_pkg_eat(pkg_ctx, "SLOT", &state->buf, &state->buflen); + vdb_pkg_eat(pkg_ctx, "SLOT", &state->buf, &state->buflen); rmspace(state->buf); if (strcmp(state->exclude_slot, state->buf) == 0) goto qlist_done; /* "(CAT/)?(PN|PF):SLOT" matches */ } dont_skip_pkg: /* End of the package exclusion tests. */ - fp = q_vdb_pkg_fopenat_ro(pkg_ctx, "CONTENTS"); + fp = vdb_pkg_fopenat_ro(pkg_ctx, "CONTENTS"); if (fp == NULL) goto qlist_done; @@ -227,7 +227,7 @@ static int qfile_cb(q_vdb_pkg_ctx *pkg_ctx, void *priv) /* XXX: This assumes the buf is big enough. */ char *slot_hack = slot + 1; size_t slot_len = sizeof(slot) - 1; - q_vdb_pkg_eat(pkg_ctx, "SLOT", &slot_hack, &slot_len); + vdb_pkg_eat(pkg_ctx, "SLOT", &slot_hack, &slot_len); rmspace(slot_hack); slot[0] = ':'; } else @@ -479,7 +479,7 @@ int qfile_main(int argc, char **argv) nb_of_queries = prepare_qfile_args(argc, (const char **) argv, &state); /* Now do the actual `qfile` checking */ if (nb_of_queries > 0) - found += q_vdb_foreach_pkg_sorted(portroot, portvdb, qfile_cb, &state); + found += vdb_foreach_pkg_sorted(portroot, portvdb, qfile_cb, &state); if (state.args.non_orphans) { /* display orphan files */ diff --git a/qgrep.c b/qgrep.c index 6cb5697..f38f461 100644 --- a/qgrep.c +++ b/qgrep.c @@ -441,7 +441,7 @@ qgrep_cache_cb(cache_pkg_ctx *pkg_ctx, void *priv) } static int -qgrep_vdb_cb(q_vdb_pkg_ctx *pkg_ctx, void *priv) +qgrep_vdb_cb(vdb_pkg_ctx *pkg_ctx, void *priv) { struct qgrep_grepargs *data = (struct qgrep_grepargs *)priv; char buf[_Q_PATH_MAX]; @@ -687,7 +687,7 @@ int qgrep_main(int argc, char **argv) } closedir(eclass_dir); } else if (do_installed) { - status = q_vdb_foreach_pkg(portroot, portvdb, + status = vdb_foreach_pkg(portroot, portvdb, qgrep_vdb_cb, &args, NULL); } else { /* do_ebuild */ status = cache_foreach_pkg(portroot, overlay, diff --git a/qlist.c b/qlist.c index 313ff56..9314385 100644 --- a/qlist.c +++ b/qlist.c @@ -96,7 +96,7 @@ cmpstringp(const void *p1, const void *p2) */ static char _umapstr_buf[BUFSIZ]; static const char * -umapstr(char display, q_vdb_pkg_ctx *pkg_ctx) +umapstr(char display, vdb_pkg_ctx *pkg_ctx) { char *bufp = _umapstr_buf; char *use = NULL; @@ -115,10 +115,10 @@ umapstr(char display, q_vdb_pkg_ctx *pkg_ctx) if (!display) return bufp; - q_vdb_pkg_eat(pkg_ctx, "USE", &use, &use_len); + vdb_pkg_eat(pkg_ctx, "USE", &use, &use_len); if (!use[0]) return bufp; - q_vdb_pkg_eat(pkg_ctx, "IUSE", &iuse, &iuse_len); + vdb_pkg_eat(pkg_ctx, "IUSE", &iuse, &iuse_len); if (!iuse[0]) return bufp; @@ -173,13 +173,13 @@ umapstr(char display, q_vdb_pkg_ctx *pkg_ctx) /* forward declaration necessary for misuse from qmerge.c, see HACK there */ bool qlist_match( - q_vdb_pkg_ctx *pkg_ctx, + vdb_pkg_ctx *pkg_ctx, const char *name, depend_atom **name_atom, bool exact); bool qlist_match( - q_vdb_pkg_ctx *pkg_ctx, + vdb_pkg_ctx *pkg_ctx, const char *name, depend_atom **name_atom, bool exact) @@ -200,7 +200,7 @@ qlist_match( uslot = NULL; else { if (!pkg_ctx->slot) - q_vdb_pkg_eat(pkg_ctx, "SLOT", &pkg_ctx->slot, + vdb_pkg_eat(pkg_ctx, "SLOT", &pkg_ctx->slot, &pkg_ctx->slot_len); uslot_len = strlen(uslot); } @@ -209,7 +209,7 @@ qlist_match( urepo = strstr(name, "::"); if (urepo) { if (!pkg_ctx->repo) - q_vdb_pkg_eat(pkg_ctx, "repository", &pkg_ctx->repo, + vdb_pkg_eat(pkg_ctx, "repository", &pkg_ctx->repo, &pkg_ctx->repo_len); urepo += 2; urepo_len = strlen(urepo); @@ -338,7 +338,7 @@ struct qlist_opt_state { }; static int -qlist_cb(q_vdb_pkg_ctx *pkg_ctx, void *priv) +qlist_cb(vdb_pkg_ctx *pkg_ctx, void *priv) { struct qlist_opt_state *state = priv; int i; @@ -359,7 +359,7 @@ qlist_cb(q_vdb_pkg_ctx *pkg_ctx, void *priv) atom = (verbose ? NULL : atom_explode(pkgname)); if ((state->all + state->just_pkgname) < 2) { if (state->show_slots && !pkg_ctx->slot) { - q_vdb_pkg_eat(pkg_ctx, "SLOT", + vdb_pkg_eat(pkg_ctx, "SLOT", &pkg_ctx->slot, &pkg_ctx->slot_len); /* chop off the subslot if desired */ if (state->show_slots == 1) { @@ -369,7 +369,7 @@ qlist_cb(q_vdb_pkg_ctx *pkg_ctx, void *priv) } } if (state->show_repo && !pkg_ctx->repo) - q_vdb_pkg_eat(pkg_ctx, "repository", + vdb_pkg_eat(pkg_ctx, "repository", &pkg_ctx->repo, &pkg_ctx->repo_len); /* display it */ printf("%s%s/%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s\n", @@ -398,7 +398,7 @@ qlist_cb(q_vdb_pkg_ctx *pkg_ctx, void *priv) printf("%s%s/%s%s%s %sCONTENTS%s:\n", BOLD, catname, BLUE, pkgname, NORM, DKBLUE, NORM); - fp = q_vdb_pkg_fopenat_ro(pkg_ctx, "CONTENTS"); + fp = vdb_pkg_fopenat_ro(pkg_ctx, "CONTENTS"); if (fp == NULL) return 1; @@ -489,7 +489,7 @@ int qlist_main(int argc, char **argv) state.buf = xmalloc(state.buflen); state.atoms = xcalloc(argc - optind, sizeof(*state.atoms)); - ret = q_vdb_foreach_pkg_sorted(portroot, portvdb, qlist_cb, &state); + ret = vdb_foreach_pkg_sorted(portroot, portvdb, qlist_cb, &state); free(state.buf); for (i = optind; i < state.argc; ++i) if (state.atoms[i - optind]) diff --git a/qmerge.c b/qmerge.c index 97726db..41488fa 100644 --- a/qmerge.c +++ b/qmerge.c @@ -118,7 +118,7 @@ typedef struct llist_char_t llist_char; static void pkg_fetch(int, const depend_atom *, const struct pkg_t *); static void pkg_merge(int, const depend_atom *, const struct pkg_t *); -static int pkg_unmerge(q_vdb_pkg_ctx *, set *, int, char **, int, char **); +static int pkg_unmerge(vdb_pkg_ctx *, set *, int, char **, int, char **); static struct pkg_t *grab_binpkg_info(const char *); static char *find_binpkg(const char *); @@ -282,7 +282,7 @@ struct qmerge_bv_state { }; static int -qmerge_filter_cat(q_vdb_cat_ctx *cat_ctx, void *priv) +qmerge_filter_cat(vdb_cat_ctx *cat_ctx, void *priv) { struct qmerge_bv_state *state = priv; return !state->catname || strcmp(cat_ctx->name, state->catname) == 0; @@ -292,13 +292,13 @@ qmerge_filter_cat(q_vdb_cat_ctx *cat_ctx, void *priv) * should however figure out how to do what match does here from e.g. * atom */ extern bool qlist_match( - q_vdb_pkg_ctx *pkg_ctx, + vdb_pkg_ctx *pkg_ctx, const char *name, depend_atom **name_atom, bool exact); static int -qmerge_best_version_cb(q_vdb_pkg_ctx *pkg_ctx, void *priv) +qmerge_best_version_cb(vdb_pkg_ctx *pkg_ctx, void *priv) { struct qmerge_bv_state *state = priv; if (qlist_match(pkg_ctx, state->buf, NULL, true)) @@ -338,7 +338,7 @@ best_version(const char *catname, const char *pkgname, const char *slot) retbuf[0] = '\0'; snprintf(state.buf, sizeof(state.buf), "%s%s%s:%s", catname ? : "", catname ? "/" : "", pkgname, slot); - q_vdb_foreach_pkg(portroot, portvdb, + vdb_foreach_pkg(portroot, portvdb, qmerge_best_version_cb, &state, qmerge_filter_cat); done: @@ -999,8 +999,8 @@ static void pkg_merge(int level, const depend_atom *atom, const struct pkg_t *pkg) { set *objs; - q_vdb_ctx *vdb_ctx; - q_vdb_cat_ctx *cat_ctx; + vdb_ctx *vdb; + vdb_cat_ctx *cat_ctx; FILE *fp, *contents; static char *phases; static size_t phases_len; @@ -1122,19 +1122,19 @@ pkg_merge(int level, const depend_atom *atom, const struct pkg_t *pkg) } /* Get a handle on the main vdb repo */ - vdb_ctx = q_vdb_open(portroot, portvdb); - if (!vdb_ctx) + vdb = vdb_open(portroot, portvdb); + if (!vdb) return; - cat_ctx = q_vdb_open_cat(vdb_ctx, pkg->CATEGORY); + cat_ctx = vdb_open_cat(vdb, pkg->CATEGORY); if (!cat_ctx) { if (errno != ENOENT) { - q_vdb_close(vdb_ctx); + vdb_close(vdb); return; } - mkdirat(vdb_ctx->vdb_fd, pkg->CATEGORY, 0755); - cat_ctx = q_vdb_open_cat(vdb_ctx, pkg->CATEGORY); + mkdirat(vdb->vdb_fd, pkg->CATEGORY, 0755); + cat_ctx = vdb_open_cat(vdb, pkg->CATEGORY); if (!cat_ctx) { - q_vdb_close(vdb_ctx); + vdb_close(vdb); return; } } @@ -1345,10 +1345,10 @@ pkg_merge(int level, const depend_atom *atom, const struct pkg_t *pkg) /* TODO: Should see about merging with unmerge_packages() */ while (1) { int ret; - q_vdb_pkg_ctx *pkg_ctx; + vdb_pkg_ctx *pkg_ctx; depend_atom *old_atom; - pkg_ctx = q_vdb_next_pkg(cat_ctx); + pkg_ctx = vdb_next_pkg(cat_ctx); if (!pkg_ctx) break; @@ -1377,7 +1377,7 @@ pkg_merge(int level, const depend_atom *atom, const struct pkg_t *pkg) pkg_unmerge(pkg_ctx, objs, cp_argc, cp_argv, cpm_argc, cpm_argv); next_pkg: - q_vdb_close_pkg(pkg_ctx); + vdb_close_pkg(pkg_ctx); } freeargv(cp_argc, cp_argv); @@ -1416,14 +1416,14 @@ pkg_merge(int level, const depend_atom *atom, const struct pkg_t *pkg) printf("%s>>>%s %s%s%s/%s%s%s\n", YELLOW, NORM, WHITE, atom->CATEGORY, NORM, CYAN, atom->PN, NORM); - q_vdb_close(vdb_ctx); + vdb_close(vdb); } static int -pkg_unmerge(q_vdb_pkg_ctx *pkg_ctx, set *keep, +pkg_unmerge(vdb_pkg_ctx *pkg_ctx, set *keep, int cp_argc, char **cp_argv, int cpm_argc, char **cpm_argv) { - q_vdb_cat_ctx *cat_ctx = pkg_ctx->cat_ctx; + vdb_cat_ctx *cat_ctx = pkg_ctx->cat_ctx; const char *cat = cat_ctx->name; const char *pkgname = pkg_ctx->name; size_t buflen; @@ -1447,7 +1447,7 @@ pkg_unmerge(q_vdb_pkg_ctx *pkg_ctx, set *keep, return 0; /* First get a handle on the things to clean up */ - fp = q_vdb_pkg_fopenat_ro(pkg_ctx, "CONTENTS"); + fp = vdb_pkg_fopenat_ro(pkg_ctx, "CONTENTS"); if (fp == NULL) return ret; @@ -1455,7 +1455,7 @@ pkg_unmerge(q_vdb_pkg_ctx *pkg_ctx, set *keep, /* Then execute the pkg_prerm step */ if (!pretend) { - q_vdb_pkg_eat(pkg_ctx, "DEFINED_PHASES", &phases, &phases_len); + vdb_pkg_eat(pkg_ctx, "DEFINED_PHASES", &phases, &phases_len); mkdirat(pkg_ctx->fd, "temp", 0755); pkg_run_func_at(pkg_ctx->fd, ".", phases, "pkg_prerm", T, T); } @@ -1776,7 +1776,7 @@ print_Pkg(int full, const depend_atom *atom, const struct pkg_t *pkg) } static int -qmerge_unmerge_cb(q_vdb_pkg_ctx *pkg_ctx, void *priv) +qmerge_unmerge_cb(vdb_pkg_ctx *pkg_ctx, void *priv) { int cp_argc; int cpm_argc; @@ -1804,7 +1804,7 @@ qmerge_unmerge_cb(q_vdb_pkg_ctx *pkg_ctx, void *priv) static int unmerge_packages(set *todo) { - return q_vdb_foreach_pkg(portroot, portvdb, qmerge_unmerge_cb, todo, NULL); + return vdb_foreach_pkg(portroot, portvdb, qmerge_unmerge_cb, todo, NULL); } static FILE * diff --git a/qpkg.c b/qpkg.c index af8df37..b93823b 100644 --- a/qpkg.c +++ b/qpkg.c @@ -334,9 +334,9 @@ qpkg_make(depend_atom *atom) int qpkg_main(int argc, char **argv) { - q_vdb_ctx *ctx; - q_vdb_cat_ctx *cat_ctx; - q_vdb_pkg_ctx *pkg_ctx; + vdb_ctx *ctx; + vdb_cat_ctx *cat_ctx; + vdb_pkg_ctx *pkg_ctx; size_t s, pkgs_made; int i; struct stat st; @@ -417,15 +417,15 @@ retry_mkdir: } /* now try to run through vdb and locate matches for user inputs */ - ctx = q_vdb_open(portroot, portvdb); + ctx = vdb_open(portroot, portvdb); if (!ctx) return EXIT_FAILURE; /* scan all the categories */ - while ((cat_ctx = q_vdb_next_cat(ctx))) { + while ((cat_ctx = vdb_next_cat(ctx))) { /* scan all the packages in this category */ const char *catname = cat_ctx->name; - while ((pkg_ctx = q_vdb_next_pkg(cat_ctx))) { + while ((pkg_ctx = vdb_next_pkg(cat_ctx))) { const char *pkgname = pkg_ctx->name; /* see if user wants any of these packages */ @@ -449,7 +449,7 @@ retry_mkdir: atom_implode(atom); next_pkg: - q_vdb_close_pkg(pkg_ctx); + vdb_close_pkg(pkg_ctx); } } diff --git a/qsize.c b/qsize.c index 80d496c..4fbbe47 100644 --- a/qsize.c +++ b/qsize.c @@ -97,7 +97,7 @@ struct qsize_opt_state { }; static int -qsize_cb(q_vdb_pkg_ctx *pkg_ctx, void *priv) +qsize_cb(vdb_pkg_ctx *pkg_ctx, void *priv) { struct qsize_opt_state *state = priv; const char *catname = pkg_ctx->cat_ctx->name; @@ -126,7 +126,7 @@ qsize_cb(q_vdb_pkg_ctx *pkg_ctx, void *priv) if (!showit) return EXIT_SUCCESS; - if ((fp = q_vdb_pkg_fopenat_ro(pkg_ctx, "CONTENTS")) == NULL) + if ((fp = vdb_pkg_fopenat_ro(pkg_ctx, "CONTENTS")) == NULL) return EXIT_SUCCESS; num_ignored = num_files = num_nonfiles = num_bytes = 0; @@ -230,7 +230,7 @@ int qsize_main(int argc, char **argv) state.buflen = _Q_PATH_MAX; state.buf = xmalloc(state.buflen); - ret = q_vdb_foreach_pkg(portroot, portvdb, qsize_cb, &state, NULL); + ret = vdb_foreach_pkg(portroot, portvdb, qsize_cb, &state, NULL); if (state.summary) { printf(" %sTotals%s: %'zu files, %'zu non-files, ", BOLD, NORM,