[gentoo-commits] proj/portage-utils:master commit in: /

["Fabian Groffen" <grobian@gentoo.org>]

commit:     f2e63b4a1280d0a2c18cb1a66ceffd9699d1b9ac
Author:     Fabian Groffen <grobian <AT> gentoo <DOT> org>
AuthorDate: Mon May 25 10:39:05 2020 +0000
Commit:     Fabian Groffen <grobian <AT> gentoo <DOT> org>
CommitDate: Mon May 25 10:39:05 2020 +0000
URL:        https://gitweb.gentoo.org/proj/portage-utils.git/commit/?id=f2e63b4a

qmerge: use libq/tree for binpkg/Packages needs

Instead of manual parsing of Packages file and traversing binpkgs, use
the functionality provided by libq/tree, most notably tree_match_atom().

This is just phase one, where we replace the custom code with libq/tree
code and then fill in the Pkg structure.  In a next phase we should skip
this and directly use tree_match_ctx, with atom and meta in there.

Signed-off-by: Fabian Groffen <grobian <AT> gentoo.org>

 qmerge.c | 596 +++++++++++++--------------------------------------------------
 1 file changed, 116 insertions(+), 480 deletions(-)

diff --git a/qmerge.c b/qmerge.c
index 087c5f2..554e3dc 100644
--- a/qmerge.c
+++ b/qmerge.c
@@ -120,8 +120,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(tree_pkg_ctx *, set *, int, char **, int, char **);
-static struct pkg_t *grab_binpkg_info(const char *);
-static char *find_binpkg(const char *);
+static struct pkg_t *grab_binpkg_info(depend_atom *);
 
 static bool
 prompt(const char *p)
@@ -129,12 +128,12 @@ prompt(const char *p)
 	printf("%s? [Y/n] ", p);
 	fflush(stdout);
 	switch (getc(stdin)) {
-	case '\n':
-	case 'y':
-	case 'Y':
-		return true;
-	default:
-		return false;
+		case '\n':
+		case 'y':
+		case 'Y':
+			return true;
+		default:
+			return false;
 	}
 }
 
@@ -579,7 +578,7 @@ qprint_tree_node(int level, const depend_atom *atom, const struct pkg_t *pkg)
 	} else {
 		depend_atom *subatom = atom_explode(p);
 		if (subatom != NULL) {
-			ret = atom_compare(atom, subatom);
+			ret = atom_compare(subatom, atom);
 			switch (ret) {
 				case EQUAL: c = 'R'; break;
 				case NEWER: c = 'U'; break;
@@ -1009,7 +1008,7 @@ pkg_merge(int level, const depend_atom *atom, const struct pkg_t *pkg)
 		if (((c == 'R') || (c == 'D')) && update_only)
 			return;
 
-	if (pkg->RDEPEND[0] && follow_rdepends) {
+	if (pkg->RDEPEND[0] != '\0' && follow_rdepends) {
 		const char *rdepend;
 
 		IF_DEBUG(fprintf(stderr, "\n+Parent: %s/%s\n", pkg->CATEGORY, pkg->PF));
@@ -1040,30 +1039,17 @@ pkg_merge(int level, const depend_atom *atom, const struct pkg_t *pkg)
 				case '\0':
 					break;
 				default:
-					if (*name == '~') {
-						name = ARGV[i] + 1;
-						/* warn("newname = %s", name); */
-					}
 					if ((subatom = atom_explode(name)) != NULL) {
 						struct pkg_t *subpkg;
-						char *resolved = NULL;
-
-						resolved = find_binpkg(name);
 
-						IF_DEBUG(fprintf(stderr,
-									"+Atom: argv0(%s) resolved(%s)\n",
-									name, resolved));
-
-						if (strlen(resolved) < 1) {
-							warn("Cant find a binpkg for %s from rdepend(%s)",
+						subpkg = grab_binpkg_info(subatom); /* free me later */
+						if (subpkg == NULL) {
+							warn("Cannot find a binpkg for %s from rdepend(%s)",
 									name, pkg->RDEPEND);
 							atom_implode(subatom);
 							continue;
 						}
 
-						/* ratom = atom_explode(resolved); */
-						subpkg = grab_binpkg_info(resolved); /* free me later */
-
 						assert(subpkg != NULL);
 						IF_DEBUG(fprintf(stderr, "+Subpkg: %s/%s\n",
 									subpkg->CATEGORY, subpkg->PF));
@@ -1182,7 +1168,8 @@ pkg_merge(int level, const depend_atom *atom, const struct pkg_t *pkg)
 			} else if (mlen == 257+6 &&
 					magic[257] == 'u' && magic[258] == 's' &&
 					magic[259] == 't' && magic[260] == 'a' &&
-					magic[261] == 'r' && magic[262] == '\0')
+					magic[261] == 'r' &&
+					(magic[262] == '\0' || magic[262] == ' '))
 			{
 				compr = "";
 			} else if (mlen >= 4 &&
@@ -1399,7 +1386,7 @@ pkg_merge(int level, const depend_atom *atom, const struct pkg_t *pkg)
 	rmdir("../qmerge");
 
 	printf("%s>>>%s %s%s%s/%s%s%s\n",
-			YELLOW, NORM, WHITE, atom->CATEGORY, NORM, CYAN, pkg->PF, NORM);
+			YELLOW, NORM, WHITE, pkg->CATEGORY, NORM, CYAN, pkg->PF, NORM);
 
 	tree_close_cat(cat_ctx);
 	tree_close(vdb);
@@ -1622,7 +1609,7 @@ pkg_verify_checksums(
 	}
 
 	if (pkg->MD5[0]) {
-		if (md5 != NULL && strcmp(md5, pkg->MD5) == 0) {
+		if (strcmp(md5, pkg->MD5) == 0) {
 			if (display)
 				printf("MD5:  [%sOK%s] %s %s/%s\n",
 						GREEN, NORM, md5, atom->CATEGORY, pkg->PF);
@@ -1634,7 +1621,7 @@ pkg_verify_checksums(
 		}
 	}
 
-	if (sha1 != NULL && pkg->SHA1[0]) {
+	if (pkg->SHA1[0]) {
 		if (strcmp(sha1, pkg->SHA1) == 0) {
 			if (display)
 				qprintf("SHA1: [%sOK%s] %s %s/%s\n",
@@ -1663,7 +1650,8 @@ pkg_fetch(int level, const depend_atom *atom, const struct pkg_t *pkg)
 
 	/* qmerge -pv patch */
 	if (pretend) {
-		if (!install) install++;
+		if (!install)
+			install++;
 		/* qprint_tree_node(level, atom, pkg); */
 		pkg_merge(level, atom, pkg);
 		return;
@@ -1679,13 +1667,12 @@ pkg_fetch(int level, const depend_atom *atom, const struct pkg_t *pkg)
 		return;
 	}
 
-	/* XXX: should do a size check here for partial downloads */
-
 	if (force_download && (access(buf, R_OK) == 0) &&
 			(pkg->SHA1[0] || pkg->MD5[0]))
 	{
 		if (pkg_verify_checksums(buf, pkg, atom, 0, 0) != 0)
-			unlink(buf);
+			if (getenv("QMERGE") == NULL)
+				unlink(buf);
 	}
 	if (access(buf, R_OK) == 0) {
 		if (!pkg->SHA1[0] && !pkg->MD5[0]) {
@@ -1742,7 +1729,7 @@ print_Pkg(int full, const depend_atom *atom, const struct pkg_t *pkg)
 	char *p = NULL;
 	char buf[512];
 
-	printf("%s%s/%s%s:%s%s%s%s%s\n", BOLD, atom->CATEGORY, BLUE, pkg->PF, pkg->SLOT, NORM,
+	printf("%s%s%s%s\n", atom_format("%[CAT]%[PF]%[SLOT]", atom),
 		!quiet ? " [" : "",
 		!quiet ? make_human_readable_str(pkg->SIZE, 1, KILOBYTE) : "",
 		!quiet ? " KiB]" : "");
@@ -1757,7 +1744,8 @@ print_Pkg(int full, const depend_atom *atom, const struct pkg_t *pkg)
 	if (pkg->MD5[0])
 		printf(" %sMd5%s:%s %s\n", DKGREEN, YELLOW, NORM, pkg->MD5);
 	if (!pkg->MD5[0] && !pkg->SHA1[0])
-		printf(" %sSums%s:%s %s(MISSING!)%s\n", DKGREEN, YELLOW, NORM, RED, NORM);
+		printf(" %sSums%s:%s %s(MISSING!)%s\n",
+				DKGREEN, YELLOW, NORM, RED, NORM);
 	if (pkg->SLOT[0])
 		printf(" %sSlot%s:%s %s\n", DKGREEN, YELLOW, NORM, pkg->SLOT);
 	if (pkg->LICENSE[0])
@@ -1781,7 +1769,8 @@ print_Pkg(int full, const depend_atom *atom, const struct pkg_t *pkg)
 				case OLDER: icolor = BLUE;   break;
 				default:    icolor = NORM;   break;
 			}
-			printf(" %sInstalled%s:%s %s%s%s\n", DKGREEN, YELLOW, NORM, icolor, p, NORM);
+			printf(" %sInstalled%s:%s %s%s%s\n",
+					DKGREEN, YELLOW, NORM, icolor, p, NORM);
 		}
 	}
 }
@@ -1833,453 +1822,70 @@ unmerge_packages(set *todo)
 	return ret;
 }
 
-static FILE *
-open_binpkg_index(void)
-{
-	FILE *fp;
-	char *path;
-
-	xasprintf(&path, "%s/portage/%s", port_tmpdir, Packages);
-	fp = fopen(path, "r");
-	if (fp)
-		goto done;
-	free(path);
-
-	xasprintf(&path, "%s/%s", pkgdir, Packages);
-	fp = fopen(path, "r");
-	if (fp)
-		goto done;
-
-	/* This is normal when installing from local repo only. */
-	warnp("Unable to open package file %s in %s/portage or %s",
-		Packages, port_tmpdir, pkgdir);
-	warn("Attempting to manually regen via `emaint binhost`");
-
-	pid_t p;
-	int status;
-
-	char argv_emaint[] = "emaint";
-	char argv_binhost[] = "binhost";
-	char argv_fix[] = "--fix";
-	char *argv[] = {
-		argv_emaint,
-		argv_binhost,
-		argv_fix,
-		NULL,
-	};
-
-	p = vfork();
-	switch (p) {
-	case 0:
-		_exit(execvp(argv[0], argv));
-	case -1:
-		errp("vfork failed");
-	}
-	waitpid(p, &status, 0);
-
-	fp = fopen(path, "r");
-
- done:
-	free(path);
-	return fp;
-}
-
+static tree_ctx *_grab_binpkg_info_tree = NULL;
 static struct pkg_t *
-grab_binpkg_info(const char *name)
-{
-	FILE *fp;
-	char buf[BUFSIZ];
-	char *p;
-	depend_atom *atom;
-
-	struct pkg_t Pkg;
-	struct pkg_t *pkg = xzalloc(sizeof(struct pkg_t));
-	struct pkg_t *rpkg = xzalloc(sizeof(struct pkg_t));
-
-	static char best_match[sizeof(Pkg.PF)+2+sizeof(Pkg.CATEGORY)];
-
-	best_match[0] = 0;
-	strcpy(pkg->SLOT,"0");
-
-	fp = open_binpkg_index();
-
-	while (fgets(buf, sizeof(buf), fp) != NULL) {
-		if (*buf == '\n') {
-			if (pkg->PF[0] && pkg->CATEGORY[0]) {
-				int ret;
-
-				snprintf(buf, sizeof(buf), "%s/%s", pkg->CATEGORY, pkg->PF);
-				if (strstr(buf, name) != NULL) {
-					if (!best_match[0])
-						snprintf(best_match, sizeof(best_match), "%.*s",
-								(int)sizeof(best_match) - 1, buf);
-
-					atom = atom_explode(buf);
-					if (atom->PR_int) {
-						snprintf(buf, sizeof(buf), "%s/%s-%s-r%i",
-								atom->CATEGORY, atom->PN,
-								atom->PV, atom->PR_int);
-					} else {
-						snprintf(buf, sizeof(buf), "%s/%s-%s",
-								atom->CATEGORY, atom->PN, atom->PV);
-					}
-					ret = atom_compare_str(name, buf);
-					IF_DEBUG(fprintf(stderr,
-								"=== atom_compare(%s, %s) = %d %s\n",
-								name, buf, ret, booga[ret]));
-					/* buf(%s) depend(%s)\n", ret, pkg->CATEGORY,
-					 * pkg->PF, name, pkg->RDEPEND); */
-					switch (ret) {
-						case EQUAL:
-						case NEWER:
-							snprintf(buf, sizeof(buf), "%s/%s",
-									pkg->CATEGORY, pkg->PF);
-							ret = atom_compare_str(buf, best_match);
-							if (ret == NEWER || ret == EQUAL) {
-								snprintf(best_match, sizeof(best_match), "%.*s",
-										(int)sizeof(best_match) - 1, buf);
-								memcpy(rpkg, pkg, sizeof(struct pkg_t));
-								IF_DEBUG(fprintf(stderr,
-											"--- %s/%s depend(%s)\n",
-											rpkg->CATEGORY, rpkg->PF,
-											rpkg->RDEPEND));
-							}
-						case OLDER: break;
-						default:
-							break;
-					}
-					atom_implode(atom);
-				}
-				memset(pkg, 0, sizeof(struct pkg_t));
-				strcpy(pkg->SLOT,"0");
-			}
-			continue;
-		}
-
-		if ((p = strchr(buf, '\n')) != NULL)
-			*p = 0;
-		if ((p = strchr(buf, ':')) == NULL)
-			continue;
-		if (p[1] != ' ')
-			continue;
-		*p = 0;
-		p += 2;
-
-		if (*buf) {
-			/* we dont need all the info */
-			if (strcmp(buf, "RDEPEND") == 0)
-				snprintf(pkg->RDEPEND, sizeof(Pkg.RDEPEND), "%.*s",
-						(int)sizeof(Pkg.RDEPEND) - 1, p);
-			if (strcmp(buf, "PF") == 0)
-				snprintf(pkg->PF, sizeof(Pkg.PF), "%.*s",
-						(int)sizeof(Pkg.PF) - 1, p);
-			if (strcmp(buf, "CATEGORY") == 0)
-				snprintf(pkg->CATEGORY, sizeof(Pkg.CATEGORY), "%.*s",
-						(int)sizeof(Pkg.CATEGORY) - 1, p);
-			if (strcmp(buf, "REPO") == 0)
-				snprintf(pkg->REPO, sizeof(Pkg.REPO), "%.*s",
-						(int)sizeof(Pkg.REPO) - 1, p);
-
-			if (strcmp(buf, "CPV") == 0) {
-				if ((atom = atom_explode(p)) != NULL) {
-					if (atom->PR_int) {
-						snprintf(buf, sizeof(buf), "%s-%s-r%i",
-								atom->PN, atom->PV, atom->PR_int);
-					} else {
-						snprintf(buf, sizeof(buf), "%s-%s", atom->PN, atom->PV);
-					}
-					snprintf(pkg->PF, sizeof(Pkg.PF), "%.*s",
-							(int)sizeof(Pkg.PF) - 1, buf);
-					snprintf(pkg->CATEGORY, sizeof(Pkg.CATEGORY), "%.*s",
-							(int)sizeof(Pkg.CATEGORY) - 1, atom->CATEGORY);
-					atom_implode(atom);
-				}
-			}
-			if (strcmp(buf, "SLOT") == 0)
-				snprintf(pkg->SLOT, sizeof(Pkg.SLOT), "%.*s",
-						(int)sizeof(Pkg.SLOT) - 1, p);
-			if (strcmp(buf, "USE") == 0)
-				snprintf(pkg->USE, sizeof(Pkg.USE), "%.*s",
-						(int)sizeof(Pkg.USE) - 1, p);
-			/* checksums. We must have 1 or the other unless --*/
-			if (strcmp(buf, "MD5") == 0)
-				snprintf(pkg->MD5, sizeof(Pkg.MD5), "%.*s",
-						(int)sizeof(Pkg.MD5) - 1, p);
-			if (strcmp(buf, "SHA1") == 0)
-				snprintf(pkg->SHA1, sizeof(Pkg.SHA1), "%.*s",
-						(int)sizeof(Pkg.SHA1) - 1, p);
-		}
-	}
-	fclose(fp);
-	free(pkg);
-	return rpkg;
-}
-
-static char *
-find_binpkg(const char *name)
+grab_binpkg_info(depend_atom *atom)
 {
-	FILE *fp;
-	char buf[BUFSIZ];
-	char *p;
-	struct pkg_t Pkg;
-	char PF[sizeof(Pkg.PF)];
-	char CATEGORY[sizeof(Pkg.CATEGORY)];
-
-	static char best_match[sizeof(Pkg.PF)+2+sizeof(Pkg.CATEGORY)];
-
-	best_match[0] = 0;
-	if (NULL == name)
-		return best_match;
-
-	fp = open_binpkg_index();
-	PF[0] = CATEGORY[0] = '\0';
-
-	while (fgets(buf, sizeof(buf), fp) != NULL) {
-		if (*buf == '\n') {
-			if (PF[0] && CATEGORY[0]) {
-				int ret;
-				snprintf(buf, sizeof(buf), "%s/%s", CATEGORY, PF);
-				if (strstr(buf, name) != NULL) {
-					depend_atom *atom;
-
-					if (!best_match[0])
-						snprintf(best_match, sizeof(best_match), "%.*s",
-								(int)sizeof(best_match) - 1, buf);
-
-					atom = atom_explode(buf);
-					snprintf(buf, sizeof(buf), "%s/%s",
-							atom->CATEGORY, atom->PN);
-					ret = atom_compare_str(name, buf);
-					switch (ret) {
-						case OLDER: break;
-						case NEWER:
-						case EQUAL:
-							snprintf(buf, sizeof(buf), "%s/%s", CATEGORY, PF);
-							ret = atom_compare_str(buf, best_match);
-							if (ret == NEWER || ret == EQUAL)
-								snprintf(best_match, sizeof(best_match), "%.*s",
-										(int)sizeof(best_match) - 1, buf);
-							/* printf("[%s == %s] = %d; %s/%s\n",
-							 * name, buf, ret, CATEGORY, PF); */
-						default:
-							break;
-					}
-					atom_implode(atom);
-				}
-			}
-			continue;
-		}
-
-		if ((p = strchr(buf, '\n')) != NULL)
-			*p = 0;
-		if ((p = strchr(buf, ':')) == NULL)
-			continue;
-		if (p[1] != ' ')
-			continue;
-		*p = 0;
-		p += 2;
-
-		if (*buf) {
-			if (strcmp(buf, "CPV") == 0) {
-				depend_atom *atom;
-				if ((atom = atom_explode(p)) != NULL) {
-					if (atom->PR_int) {
-						snprintf(buf, sizeof(buf), "%s-%s-r%i",
-								atom->PN, atom->PV, atom->PR_int);
-					} else {
-						snprintf(buf, sizeof(buf), "%s-%s", atom->PN, atom->PV);
-					}
-					snprintf(PF, sizeof(PF), "%.*s", (int)sizeof(PF) - 1, buf);
-					snprintf(CATEGORY, sizeof(CATEGORY), "%.*s",
-							(int)sizeof(CATEGORY) - 1, atom->CATEGORY);
-					atom_implode(atom);
-				}
-			}
-			if (strcmp(buf, "PF") == 0)
-				snprintf(PF, sizeof(PF), "%.*s", (int)sizeof(PF) - 1, p);
-			if (strcmp(buf, "CATEGORY") == 0)
-				snprintf(CATEGORY, sizeof(CATEGORY), "%.*s",
-						(int)sizeof(CATEGORY) - 1, p);
-		}
-	}
-	fclose(fp);
-	return best_match;
-}
-
-static int
-parse_packages(set *todo)
-{
-	FILE *fp;
-	int linelen;
-	size_t buflen;
-	char *buf, *p;
-	struct pkg_t Pkg;
-	depend_atom *pkg_atom;
-	char repo[sizeof(Pkg.REPO)];
-	depend_atom **todo_atoms = NULL;
-	size_t todo_cnt = 0;
-	size_t i;
-
-	fp = open_binpkg_index();
-	if (fp == NULL)
-		return EXIT_FAILURE;
-
-	buf = NULL;
-	buflen = 0;  /* make getline allocate */
-	repo[0] = '\0';
-
-	/* First consume the header with the common data. */
-	while ((linelen = getline(&buf, &buflen, fp)) >= 0) {
-		rmspace_len(buf, (size_t)linelen);
-		if (buf[0] == '\0')
-			break;
-
-		if ((p = strchr(buf, ':')) == NULL)
-			continue;
-		if (p[1] != ' ')
-			continue;
-		*p = 0;
-		p += 2;
-
-		switch (*buf) {
-		case 'R':
-			if (!strcmp(buf, "REPO"))
-				snprintf(repo, sizeof(repo), "%.*s", (int)sizeof(repo) - 1, p);
-			break;
+	tree_ctx *tree = _grab_binpkg_info_tree;
+	tree_match_ctx *tpkg;
+	struct pkg_t *pkg = NULL;
+	char path[BUFSIZ];
+	FILE *d;
+
+	/* reuse previously opened tree, so we really employ the cache
+	 * from libq/tree */
+	if (tree == NULL) {
+		snprintf(path, sizeof(path), "%s/portage/Packages", port_tmpdir);
+		/* we don't use ROOT on package tree here, operating on ROOT
+		 * should be for package merges/unmerges, but be able to pull
+		 * binpkgs from current system */
+		if ((d = fopen(path, "r")) != NULL) {
+			fclose(d);
+			snprintf(path, sizeof(path), "%s/portage", port_tmpdir);
+			tree = tree_open_binpkg("/", path);
+		} else {
+			tree = tree_open_binpkg("/", pkgdir);
 		}
-	}
+		_grab_binpkg_info_tree = tree;
 
-	pkg_atom = NULL;
-	memset(&Pkg, 0, sizeof(Pkg));
-	strcpy(Pkg.SLOT, "0");
-
-	/* build list with exploded atoms for each access below */
-	if (todo != NULL) {
-		char **todo_strs;
-		todo_cnt = list_set(todo, &todo_strs);
-		todo_atoms = xmalloc(sizeof(*todo_atoms) * todo_cnt);
-		for (i = 0; i < todo_cnt; i++)
-			todo_atoms[i] = atom_explode(todo_strs[i]);
-		free(todo_strs);
+		/* if opening the tree failed somehow, we can't return anything */
+		if (tree == NULL)
+			return NULL;
 	}
 
-	/* Then walk all the package entries. */
-	while (getline(&buf, &buflen, fp) != -1) {
-		if (*buf == '\n') {
-			if (pkg_atom) {
-				if (search_pkgs && !todo) {
-					print_Pkg(verbose, pkg_atom, &Pkg);
-				} else {
-					for (i = 0; i < todo_cnt; i++) {
-						pkg_atom->REPO = todo_atoms[i]->REPO ? Pkg.REPO : NULL;
-						pkg_atom->SLOT = todo_atoms[i]->SLOT ? Pkg.SLOT : NULL;
-						if (atom_compare(pkg_atom, todo_atoms[i]) == EQUAL) {
-							if (search_pkgs)
-								print_Pkg(verbose, pkg_atom, &Pkg);
-							else
-								pkg_fetch(0, pkg_atom, &Pkg);
-						}
-					}
-				}
 
-				atom_implode(pkg_atom);
-				pkg_atom = NULL;
-			}
-			memset(&Pkg, 0, sizeof(Pkg));
-			strcpy(Pkg.SLOT, "0");
-			strcpy(Pkg.REPO, repo);
-			continue;
-		}
-
-		if ((p = strchr(buf, '\n')) != NULL)
-			*p = 0;
-		if ((p = strchr(buf, ':')) == NULL)
-			continue;
-		if (p[1] != ' ')
-			continue;
-		*p = 0;
-		p += 2;
-
-		switch (*buf) {
-			case 'U':
-				if (strcmp(buf, "USE") == 0)
-					snprintf(Pkg.USE, sizeof(Pkg.USE), "%.*s",
-							(int)sizeof(Pkg.USE) - 1, p);
-				break;
-			case 'P':
-				if (strcmp(buf, "PF") == 0)
-					snprintf(Pkg.PF, sizeof(Pkg.PF), "%.*s",
-							(int)sizeof(Pkg.PF) - 1, p);
-				break;
-			case 'S':
-				if (strcmp(buf, "SIZE") == 0)
-					Pkg.SIZE = atol(p);
-				if (strcmp(buf, "SLOT") == 0)
-					snprintf(Pkg.SLOT, sizeof(Pkg.SLOT), "%.*s",
-							(int)sizeof(Pkg.SLOT) - 1, p);
-				if (strcmp(buf, "SHA1") == 0)
-					snprintf(Pkg.SHA1, sizeof(Pkg.SHA1), "%.*s",
-							(int)sizeof(Pkg.SHA1) - 1, p);
-				break;
-			case 'M':
-				if (strcmp(buf, "MD5") == 0)
-					snprintf(Pkg.MD5, sizeof(Pkg.MD5), "%.*s",
-							(int)sizeof(Pkg.MD5) - 1, p);
-				break;
-			case 'R':
-				if (strcmp(buf, "REPO") == 0)
-					snprintf(Pkg.REPO, sizeof(Pkg.REPO), "%.*s",
-							(int)sizeof(Pkg.REPO) - 1, p);
-				if (strcmp(buf, "RDEPEND") == 0)
-					snprintf(Pkg.RDEPEND, sizeof(Pkg.RDEPEND), "%.*s",
-							(int)sizeof(Pkg.RDEPEND) - 1, p);
-				break;
-			case 'L':
-				if (strcmp(buf, "LICENSE") == 0)
-					snprintf(Pkg.LICENSE, sizeof(Pkg.LICENSE), "%.*s",
-							(int)sizeof(Pkg.LICENSE) - 1, p);
-				break;
-			case 'C':
-				if (strcmp(buf, "CATEGORY") == 0)
-					snprintf(Pkg.CATEGORY, sizeof(Pkg.CATEGORY), "%.*s",
-							(int)sizeof(Pkg.CATEGORY) - 1, p);
-				if (strcmp(buf, "CPV") == 0) {
-					if (pkg_atom != NULL)  /* hypothetical Coverity case */
-						atom_implode(pkg_atom);
-					if ((pkg_atom = atom_explode(p)) != NULL) {
-						if (pkg_atom->PR_int)
-							snprintf(Pkg.PF, sizeof(Pkg.PF), "%s-%s-r%i",
-									pkg_atom->PN, pkg_atom->PV,
-									pkg_atom->PR_int);
-						else
-							snprintf(Pkg.PF, sizeof(Pkg.PF), "%s-%s",
-									pkg_atom->PN, pkg_atom->PV);
-						snprintf(Pkg.CATEGORY, sizeof(Pkg.CATEGORY),
-								"%.*s", (int)sizeof(Pkg.CATEGORY) - 1,
-								pkg_atom->CATEGORY);
-					}
-				}
-				break;
-			case 'D':
-				if (strcmp(buf, "DESC") == 0)
-					snprintf(Pkg.DESC, sizeof(Pkg.DESC), "%.*s",
-							(int)sizeof(Pkg.DESC) - 1, p);
-				break;
-			default:
-				break;
-		}
+	tpkg = tree_match_atom(tree, atom,
+			TREE_MATCH_FIRST | TREE_MATCH_VIRTUAL | TREE_MATCH_METADATA);
+	if (tpkg != NULL) {
+		depend_atom *tatom = tpkg->atom;
+		tree_pkg_meta *meta = tpkg->meta;
+		pkg = xzalloc(sizeof(struct pkg_t));
+
+		snprintf(pkg->PF, sizeof(pkg->PF), "%s", tatom->PF);
+		snprintf(pkg->CATEGORY, sizeof(pkg->CATEGORY), "%s", tatom->CATEGORY);
+		if (meta->Q_DESCRIPTION != NULL)
+			snprintf(pkg->DESC, sizeof(pkg->DESC), "%s", meta->Q_DESCRIPTION);
+		if (meta->Q_LICENSE != NULL)
+			snprintf(pkg->LICENSE, sizeof(pkg->LICENSE), "%s", meta->Q_LICENSE);
+		if (meta->Q_RDEPEND != NULL)
+			snprintf(pkg->RDEPEND, sizeof(pkg->RDEPEND), "%s", meta->Q_RDEPEND);
+		if (meta->Q_MD5 != NULL)
+			snprintf(pkg->MD5, sizeof(pkg->MD5), "%s", meta->Q_MD5);
+		if (meta->Q_SHA1 != NULL)
+			snprintf(pkg->SHA1, sizeof(pkg->SHA1), "%s", meta->Q_SHA1);
+		if (meta->Q_USE != NULL)
+			snprintf(pkg->USE, sizeof(pkg->USE), "%s", meta->Q_USE);
+		if (meta->Q_repository != NULL)
+			snprintf(pkg->REPO, sizeof(pkg->REPO), "%s", meta->Q_repository);
+		if (meta->Q_SLOT != NULL)
+			snprintf(pkg->REPO, sizeof(pkg->REPO), "%s", meta->Q_SLOT);
+		if (meta->Q_SIZE != NULL)
+			pkg->SIZE = atoi(meta->Q_SIZE);
+
+		tree_match_close(tpkg);
 	}
 
-	free(buf);
-	fclose(fp);
-	if (pkg_atom)
-		atom_implode(pkg_atom);
-
-	for (i = 0; i < todo_cnt; i++)
-		atom_implode(todo_atoms[i]);
-	free(todo_atoms);
-
-	return EXIT_SUCCESS;
+	return pkg;
 }
 
 static set *
@@ -2366,10 +1972,40 @@ qmerge_add_set(char *buf, set *q)
 static int
 qmerge_run(set *todo)
 {
-	if (uninstall)
+	if (uninstall) {
 		return unmerge_packages(todo);
-	else
-		return parse_packages(todo);
+	} else {
+		if (todo == NULL && search_pkgs) {
+			/* disputable, this should be qlist -kIv or something */
+			warn("please use qlist -kI");
+
+			return EXIT_SUCCESS;
+		} else {
+			char **todo_strs;
+			size_t todo_cnt = list_set(todo, &todo_strs);
+			size_t i;
+			depend_atom *atom;
+			struct pkg_t *pkg;
+			int ret = EXIT_FAILURE;
+
+			for (i = 0; i < todo_cnt; i++) {
+				atom = atom_explode(todo_strs[i]);
+				pkg = grab_binpkg_info(atom);
+				if (pkg != NULL) {
+					if (search_pkgs)
+						print_Pkg(verbose, atom, pkg);
+					else
+						pkg_fetch(0, atom, pkg);
+					free(pkg);
+					ret = EXIT_SUCCESS;
+				}
+				atom_implode(atom);
+			}
+			free(todo_strs);
+
+			return ret;
+		}
+	}
 }
 
 int qmerge_main(int argc, char **argv)
@@ -2437,10 +2073,10 @@ int qmerge_main(int argc, char **argv)
 
 		if (uninstall) {
 			if (!prompt("OK to unmerge these packages"))
-				return 0;
+				return EXIT_FAILURE;
 		} else {
 			if (!prompt("OK to merge these packages"))
-				return 0;
+				return EXIT_FAILURE;
 		}
 
 		pretend = save_pretend;