commit: d87d181cd692247a5a7411fd6284c862bc73f28b
Author: Fabian Groffen <grobian <AT> gentoo <DOT> org>
AuthorDate: Mon May 6 17:31:29 2019 +0000
Commit: Fabian Groffen <grobian <AT> gentoo <DOT> 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 <grobian <AT> 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:<br>
`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 <ctype.h>
#include <xalloc.h>
-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,
