Radish alpha
H
HardenedBSD-pkg
HardenedBSD Package Manager
Radicle
Git (anonymous pull)
Log in to clone via SSH
Commits ›
Remove useless use of sbuf Remove useless accessors
Baptiste Daroussin committed 11 years ago
commit d2b47ebd147daa2a1654677ba43b6d4c411646bd
parent 093841ff80a62d587ff1efd5e663ba36caf02de9
12 files changed +35 -53
modified libpkg/pkg.c
@@ -1328,12 +1328,10 @@ pkg_addconflict(struct pkg *pkg, const char *uniqueid)
		return (EPKG_OK);



	pkg_conflict_new(&c);
- 
	sbuf_set(&c->uniqueid, uniqueid);
+ 
	c->uid = strdup(uniqueid);

	pkg_debug(3, "Pkg: add a new conflict origin: %s, with %s", pkg->uid, uniqueid);
- 
	HASH_ADD_KEYPTR(hh, pkg->conflicts,
- 
	    __DECONST(char *, pkg_conflict_uniqueid(c)),
- 
	    sbuf_size(c->uniqueid), c);
+ 
	HASH_ADD_KEYPTR(hh, pkg->conflicts, c->uid, strlen(c->uid), c);



	return (EPKG_OK);

}
modified libpkg/pkg.h.in
@@ -758,9 +758,6 @@ const char *pkg_option_value(struct pkg_option const * const);
const char *pkg_option_default_value(struct pkg_option const * const);

const char *pkg_option_description(struct pkg_option const * const);
- 
/* pkg_conflict */
- 
const char *pkg_conflict_uniqueid(const struct pkg_conflict *);
- 


/* pkg_provide */

const char *pkg_provide_name(const struct pkg_provide *);
modified libpkg/pkg_attributes.c
@@ -283,18 +283,10 @@ pkg_conflict_free(struct pkg_conflict *c)
	if (c == NULL)

		return;
- 
	sbuf_free(c->uniqueid);
+ 
	free(c->uid);

	free(c);

}
- 
const char *
- 
pkg_conflict_uniqueid(const struct pkg_conflict *c)
- 
{
- 
	assert(c != NULL);
-
- 
	return (sbuf_get(c->uniqueid));
- 
}
- 


/*

 * Provides

 */
modified libpkg/pkg_cudf.c
@@ -156,7 +156,7 @@ cudf_emit_pkg(struct pkg *pkg, int version, FILE *f,
		if (fprintf(f, "conflicts: ") < 0)

			return (EPKG_FATAL);

		HASH_ITER(hh, pkg->conflicts, conflict, ctmp) {
- 
			if (cudf_print_element(f, pkg_conflict_uniqueid(conflict),
+ 
			if (cudf_print_element(f, conflict->uid,

					(conflict->hh.next != NULL), &column) < 0) {

				return (EPKG_FATAL);

			}
modified libpkg/pkg_jobs.c
@@ -1115,8 +1115,7 @@ pkg_jobs_need_upgrade(struct pkg *rp, struct pkg *lp)
			return (true);

		}

		if (ret1 == EPKG_OK) {
- 
			if (strcmp(pkg_conflict_uniqueid(rc),
- 
					pkg_conflict_uniqueid(lc)) != 0) {
+ 
			if (strcmp(rc->uid, lc->uid) != 0) {

				free(rp->reason);

				rp->reason = strdup("direct conflict changed");

				return (true);
modified libpkg/pkg_jobs_conflicts.c
@@ -140,7 +140,7 @@ pkg_conflicts_request_resolve(struct pkg_jobs *j)
			continue;



		HASH_ITER(hh, req->item->pkg->conflicts, c, ctmp) {
- 
			unit = pkg_jobs_universe_find(j->universe, pkg_conflict_uniqueid(c));
+ 
			unit = pkg_jobs_universe_find(j->universe, c->uid);

			if (unit != NULL) {

				HASH_FIND_STR(j->request_add, unit->pkg->uid, found);

				if (found && !found->skip) {
@@ -174,15 +174,15 @@ pkg_conflicts_register(struct pkg *p1, struct pkg *p2, enum pkg_conflict_type ty
		c1->type = c2->type = type;

		HASH_FIND_STR(p1->conflicts, p2->uid, test);

		if (test == NULL) {
- 
			sbuf_set(&c1->uniqueid, p2->uid);
- 
			HASH_ADD_KEYPTR(hh, p1->conflicts, pkg_conflict_uniqueid(c1), sbuf_size(c1->uniqueid), c1);
+ 
			c1->uid = strdup(p2->uid);
+ 
			HASH_ADD_KEYPTR(hh, p1->conflicts, c1->uid, strlen(c1->uid), c1);

			pkg_debug(2, "registering conflict between %s and %s", p1->uid, p2->uid);

		}



		HASH_FIND_STR(p2->conflicts, p1->uid, test);

		if (test == NULL) {
- 
			sbuf_set(&c2->uniqueid, p1->uid);
- 
			HASH_ADD_KEYPTR(hh, p2->conflicts, pkg_conflict_uniqueid(c2), sbuf_size(c2->uniqueid), c2);
+ 
			c1->uid = strdup(p1->uid);
+ 
			HASH_ADD_KEYPTR(hh, p2->conflicts, c2->uid, strlen(c2->uid), c2);

			pkg_debug(2, "registering conflict between %s and %s", p2->uid, p1->uid);

		}

	}
@@ -247,12 +247,10 @@ pkg_conflicts_register_unsafe(struct pkg *p1, struct pkg *p2,
	pkg_conflict_new(&c1);

	pkg_conflict_new(&c2);

	c1->type = c2->type = type;
- 
	sbuf_set(&c1->uniqueid, p2->uid);
- 
	sbuf_set(&c2->uniqueid, p1->uid);
- 
	HASH_ADD_KEYPTR(hh, p1->conflicts, pkg_conflict_uniqueid(c1),
- 
		sbuf_size(c1->uniqueid), c1);
- 
	HASH_ADD_KEYPTR(hh, p2->conflicts, pkg_conflict_uniqueid(c2),
- 
		sbuf_size(c2->uniqueid), c2);
+ 
	c1->uid = strdup(p2->uid);
+ 
	c2->uid = strdup(p2->uid);
+ 
	HASH_ADD_KEYPTR(hh, p1->conflicts, c1->uid, strlen(c1->uid), c1);
+ 
	HASH_ADD_KEYPTR(hh, p2->conflicts, c2->uid, strlen(c1->uid), c2);

	pkg_debug(2, "registering conflict between %s and %s on path %s",

		p1->uid, p2->uid, path);

}
modified libpkg/pkg_jobs_universe.c
@@ -296,14 +296,14 @@ pkg_jobs_universe_process_conflicts(struct pkg_jobs_universe *universe,
	struct pkg *npkg;



	while (pkg_conflicts(pkg, &c) == EPKG_OK) {
- 
		HASH_FIND_STR(universe->items, pkg_conflict_uniqueid(c), unit);
+ 
		HASH_FIND_STR(universe->items, c->uid, unit);

		if (unit != NULL)

			continue;



		/* Check local and remote conflicts */

		if (pkg->type == PKG_INSTALLED) {

			/* Installed packages can conflict with remote ones */
- 
			npkg = pkg_jobs_universe_get_remote(universe, pkg_conflict_uniqueid(c), 0);
+ 
			npkg = pkg_jobs_universe_get_remote(universe, c->uid, 0);

			if (npkg == NULL)

				continue;
@@ -311,14 +311,14 @@ pkg_jobs_universe_process_conflicts(struct pkg_jobs_universe *universe,
		}

		else {

			/* Remote packages can conflict with remote and local */
- 
			npkg = pkg_jobs_universe_get_local(universe, pkg_conflict_uniqueid(c), 0);
+ 
			npkg = pkg_jobs_universe_get_local(universe, c->uid, 0);

			if (npkg != NULL) {

				if (pkg_jobs_universe_process_item(universe, npkg, NULL) != EPKG_OK)

					continue;



				if (c->type != PKG_CONFLICT_REMOTE_LOCAL) {

					npkg = pkg_jobs_universe_get_remote(universe,
- 
						pkg_conflict_uniqueid(c), 0);
+ 
					    c->uid, 0);

					if (npkg == NULL)

						continue;
@@ -616,7 +616,7 @@ pkg_jobs_update_universe_item_priority(struct pkg_jobs_universe *universe,
		}

		if (it->pkg->type != PKG_INSTALLED) {

			while (pkg_conflicts(it->pkg, &c) == EPKG_OK) {
- 
				HASH_FIND_STR(universe->items, pkg_conflict_uniqueid(c), found);
+ 
				HASH_FIND_STR(universe->items, c->uid, found);

				if (found != NULL) {

					LL_FOREACH(found, cur) {

						if (cur->pkg->type == PKG_INSTALLED) {
@@ -644,7 +644,7 @@ pkg_jobs_update_conflict_priority(struct pkg_jobs_universe *universe,


	while (pkg_conflicts(lp, &c) == EPKG_OK) {

		rit = NULL;
- 
		HASH_FIND_STR(universe->items, pkg_conflict_uniqueid(c), found);
+ 
		HASH_FIND_STR(universe->items, c->uid, found);

		assert(found != NULL);



		LL_FOREACH(found, cur) {
modified libpkg/pkg_manifest.c
@@ -1069,7 +1069,7 @@ pkg_emit_object(struct pkg *pkg, short flags)
			map = ucl_object_typed_new(UCL_OBJECT);

		ucl_object_insert_key(map,

		    ucl_object_fromstring(pkg_option_value(option)),
- 
		    pkg_conflict_uniqueid(conflict), 0, false);
+ 
		    conflict->uid, 0, false);

	}

	if (map)

		ucl_object_insert_key(top, map, "conflicts", 9, false);
modified libpkg/pkg_repo_create.c
@@ -88,11 +88,9 @@ pkg_repo_new_conflict(const char *uniqueid, struct pkg_conflict_bulk *bulk)
	struct pkg_conflict *new;



	pkg_conflict_new(&new);
- 
	sbuf_set(&new->uniqueid, uniqueid);
+ 
	new->uid = strdup(uniqueid);
- 
	HASH_ADD_KEYPTR(hh, bulk->conflicts,
- 
			pkg_conflict_uniqueid(new),
- 
			sbuf_size(new->uniqueid), new);
+ 
	HASH_ADD_KEYPTR(hh, bulk->conflicts, new->uid, strlen(new->uid), new);

}



static void
@@ -109,7 +107,7 @@ pkg_repo_write_conflicts (struct pkg_conflict_bulk *bulk, FILE *out)


	HASH_ITER (hh, bulk, cur, tmp) {

		HASH_ITER (hh, cur->conflicts, c1, c1tmp) {
- 
			HASH_FIND_STR(pkg_bulk, sbuf_get(c1->uniqueid), s);
+ 
			HASH_FIND_STR(pkg_bulk, c1->uid, s);

			if (s == NULL) {

				/* New entry required */

				s = malloc(sizeof(struct pkg_conflict_bulk));
@@ -118,17 +116,17 @@ pkg_repo_write_conflicts (struct pkg_conflict_bulk *bulk, FILE *out)
					goto out;

				}

				memset(s, 0, sizeof(struct pkg_conflict_bulk));
- 
				s->file = sbuf_get(c1->uniqueid);
+ 
				s->file = c1->uid;

				HASH_ADD_KEYPTR(hh, pkg_bulk, s->file, strlen(s->file), s);

			}

			/* Now add all new entries from this file to this conflict structure */

			HASH_ITER (hh, cur->conflicts, c2, c2tmp) {
- 
				if (strcmp(sbuf_get(c1->uniqueid), sbuf_get(c2->uniqueid)) == 0)
+ 
				if (strcmp(c1->uid, c2->uid) == 0)

					continue;
- 
				HASH_FIND_STR(s->conflicts, sbuf_get(c2->uniqueid), ctmp);
+ 
				HASH_FIND_STR(s->conflicts, c2->uid, ctmp);

				if (ctmp == NULL)
- 
					pkg_repo_new_conflict(sbuf_get(c2->uniqueid), s);
+ 
					pkg_repo_new_conflict(c2->uid, s);

			}

		}

	}
@@ -137,16 +135,16 @@ pkg_repo_write_conflicts (struct pkg_conflict_bulk *bulk, FILE *out)
		fprintf(out, "%s:", cur->file);

		HASH_ITER (hh, cur->conflicts, c1, c1tmp) {

			if (c1->hh.next != NULL)
- 
				fprintf(out, "%s,", sbuf_get(c1->uniqueid));
+ 
				fprintf(out, "%s,", c1->uid);

			else
- 
				fprintf(out, "%s\n", sbuf_get(c1->uniqueid));
+ 
				fprintf(out, "%s\n", c1->uid);

		}

	}

out:

	HASH_ITER (hh, pkg_bulk, cur, tmp) {

		HASH_ITER (hh, cur->conflicts, c1, c1tmp) {

			HASH_DEL(cur->conflicts, c1);
- 
			sbuf_free(c1->uniqueid);
+ 
			free(c1->uid);

			free(c1);

		}

		HASH_DEL(pkg_bulk, cur);
@@ -773,7 +771,7 @@ pkg_create_repo(char *path, const char *output_dir, bool filelist,
cleanup:

	HASH_ITER (hh, conflicts, curcb, tmpcb) {

		HASH_ITER (hh, curcb->conflicts, c, ctmp) {
- 
			sbuf_free(c->uniqueid);
+ 
			free(c->uid);

			HASH_DEL(curcb->conflicts, c);

			free(c);

		}
modified libpkg/pkg_solve.c
@@ -379,7 +379,7 @@ pkg_solve_add_conflict_rule(struct pkg_solve_problem *problem,
	struct pkg_solve_rule *rule = NULL;

	struct pkg_solve_item *it = NULL;
- 
	uid = pkg_conflict_uniqueid(conflict);
+ 
	uid = conflict->uid;

	HASH_FIND_STR(problem->variables_by_uid, uid, confvar);

	if (confvar == NULL) {

		pkg_debug(2, "cannot find conflict %s", uid);
modified libpkg/pkgdb.c
@@ -1813,7 +1813,7 @@ pkgdb_register_pkg(struct pkgdb *db, struct pkg *pkg, int complete, int forced)
	 * Insert conflicts

	 */

	while (pkg_conflicts(pkg, &conflict) == EPKG_OK) {
- 
		if (run_prstmt(CONFLICT, package_id, pkg_conflict_uniqueid(conflict))
+ 
		if (run_prstmt(CONFLICT, package_id, conflict->uid)

				!= SQLITE_DONE) {

			ERROR_SQLITE(s, SQL(CONFLICT));

			goto cleanup;
modified libpkg/private/pkg.h
@@ -201,7 +201,7 @@ enum pkg_conflict_type {
};



struct pkg_conflict {
- 
	struct sbuf		*uniqueid;
+ 
	char *uid;

	enum pkg_conflict_type type;

	UT_hash_handle	hh;

};