Radish alpha
H
HardenedBSD-pkg
rad:z3QDZAW2FAfuLvihrhiyDC9fAD8G9
HardenedBSD Package Manager
Radicle
Git
Commits › 76319fc
style(9): fix switch statements, line lengths while I'm here
Will Andrews committed 13 years ago
commit 76319fc2089a78f05e23390151bdbb14359bcffd
parent 6efb836
29 files changed +1285 -1260
modified libpkg/pkg.c
@@ -195,30 +195,30 @@ pkg_vget(struct pkg const *const pkg, va_list ap)
			continue;

		}

		switch (attr) {
- 
			case PKG_FLATSIZE:
- 
				*va_arg(ap, int64_t *) = pkg->flatsize;
- 
				break;
- 
			case PKG_NEW_FLATSIZE:
- 
				*va_arg(ap, int64_t *) = pkg->new_flatsize;
- 
				break;
- 
			case PKG_NEW_PKGSIZE:
- 
				*va_arg(ap, int64_t *) = pkg->new_pkgsize;
- 
				break;
- 
			case PKG_LICENSE_LOGIC:
- 
				*va_arg(ap, lic_t *) = pkg->licenselogic;
- 
				break;
- 
			case PKG_AUTOMATIC:
- 
				*va_arg(ap, bool *) = pkg->automatic;
- 
				break;
- 
			case PKG_TIME:
- 
				*va_arg(ap, int64_t *) = pkg->time;
- 
				break;
- 
			case PKG_ROWID:
- 
				*va_arg(ap, int64_t *) = pkg->rowid;
- 
				break;
- 
			default:
- 
				va_arg(ap, void *); /* ignore */
- 
				break;
+ 
		case PKG_FLATSIZE:
+ 
			*va_arg(ap, int64_t *) = pkg->flatsize;
+ 
			break;
+ 
		case PKG_NEW_FLATSIZE:
+ 
			*va_arg(ap, int64_t *) = pkg->new_flatsize;
+ 
			break;
+ 
		case PKG_NEW_PKGSIZE:
+ 
			*va_arg(ap, int64_t *) = pkg->new_pkgsize;
+ 
			break;
+ 
		case PKG_LICENSE_LOGIC:
+ 
			*va_arg(ap, lic_t *) = pkg->licenselogic;
+ 
			break;
+ 
		case PKG_AUTOMATIC:
+ 
			*va_arg(ap, bool *) = pkg->automatic;
+ 
			break;
+ 
		case PKG_TIME:
+ 
			*va_arg(ap, int64_t *) = pkg->time;
+ 
			break;
+ 
		case PKG_ROWID:
+ 
			*va_arg(ap, int64_t *) = pkg->rowid;
+ 
			break;
+ 
		default:
+ 
			va_arg(ap, void *); /* ignore */
+ 
			break;

		}

	}
@@ -843,26 +843,26 @@ pkg_addshlib(struct pkg *pkg, const char *name)
int

pkg_list_is_empty(struct pkg *pkg, pkg_list list) {

	switch (list) {
- 
		case PKG_DEPS:
- 
			return (STAILQ_EMPTY(&pkg->deps));
- 
		case PKG_RDEPS:
- 
			return (STAILQ_EMPTY(&pkg->rdeps));
- 
		case PKG_LICENSES:
- 
			return (STAILQ_EMPTY(&pkg->licenses));
- 
		case PKG_OPTIONS:
- 
			return (STAILQ_EMPTY(&pkg->options));
- 
		case PKG_CATEGORIES:
- 
			return (STAILQ_EMPTY(&pkg->categories));
- 
		case PKG_FILES:
- 
			return (STAILQ_EMPTY(&pkg->files));
- 
		case PKG_DIRS:
- 
			return (STAILQ_EMPTY(&pkg->dirs));
- 
		case PKG_USERS:
- 
			return (STAILQ_EMPTY(&pkg->users));
- 
		case PKG_GROUPS:
- 
			return (STAILQ_EMPTY(&pkg->groups));
- 
		case PKG_SHLIBS:
- 
			return (STAILQ_EMPTY(&pkg->shlibs));
+ 
	case PKG_DEPS:
+ 
		return (STAILQ_EMPTY(&pkg->deps));
+ 
	case PKG_RDEPS:
+ 
		return (STAILQ_EMPTY(&pkg->rdeps));
+ 
	case PKG_LICENSES:
+ 
		return (STAILQ_EMPTY(&pkg->licenses));
+ 
	case PKG_OPTIONS:
+ 
		return (STAILQ_EMPTY(&pkg->options));
+ 
	case PKG_CATEGORIES:
+ 
		return (STAILQ_EMPTY(&pkg->categories));
+ 
	case PKG_FILES:
+ 
		return (STAILQ_EMPTY(&pkg->files));
+ 
	case PKG_DIRS:
+ 
		return (STAILQ_EMPTY(&pkg->dirs));
+ 
	case PKG_USERS:
+ 
		return (STAILQ_EMPTY(&pkg->users));
+ 
	case PKG_GROUPS:
+ 
		return (STAILQ_EMPTY(&pkg->groups));
+ 
	case PKG_SHLIBS:
+ 
		return (STAILQ_EMPTY(&pkg->shlibs));

	}

	

	return (0);
@@ -881,46 +881,46 @@ pkg_list_free(struct pkg *pkg, pkg_list list) {
	struct pkg_shlib *sl;



	switch (list) {
- 
		case PKG_DEPS:
- 
			LIST_FREE(&pkg->deps, d, pkg_dep_free);
- 
			pkg->flags &= ~PKG_LOAD_DEPS;
- 
			break;
- 
		case PKG_RDEPS:
- 
			LIST_FREE(&pkg->rdeps, d, pkg_dep_free);
- 
			pkg->flags &= ~PKG_LOAD_RDEPS;
- 
			break;
- 
		case PKG_LICENSES:
- 
			LIST_FREE(&pkg->licenses, l, pkg_license_free);
- 
			pkg->flags &= ~PKG_LOAD_LICENSES;
- 
			break;
- 
		case PKG_OPTIONS:
- 
			LIST_FREE(&pkg->options, o, pkg_option_free);
- 
			pkg->flags &= ~PKG_LOAD_OPTIONS;
- 
			break;
- 
		case PKG_CATEGORIES:
- 
			LIST_FREE(&pkg->categories, c, pkg_category_free);
- 
			pkg->flags &= ~PKG_LOAD_CATEGORIES;
- 
			break;
- 
		case PKG_FILES:
- 
			LIST_FREE(&pkg->files, f, pkg_file_free);
- 
			pkg->flags &= ~PKG_LOAD_FILES;
- 
			break;
- 
		case PKG_DIRS:
- 
			LIST_FREE(&pkg->dirs, dir, pkg_dir_free);
- 
			pkg->flags &= ~PKG_LOAD_DIRS;
- 
			break;
- 
		case PKG_USERS:
- 
			LIST_FREE(&pkg->users, u, pkg_user_free);
- 
			pkg->flags &= ~PKG_LOAD_USERS;
- 
			break;
- 
		case PKG_GROUPS:
- 
			LIST_FREE(&pkg->groups, g, pkg_group_free);
- 
			pkg->flags &= ~PKG_LOAD_GROUPS;
- 
			break;
- 
		case PKG_SHLIBS:
- 
			LIST_FREE(&pkg->shlibs, sl, pkg_shlib_free);
- 
			pkg->flags &= ~PKG_LOAD_SHLIBS;
- 
			break;
+ 
	case PKG_DEPS:
+ 
		LIST_FREE(&pkg->deps, d, pkg_dep_free);
+ 
		pkg->flags &= ~PKG_LOAD_DEPS;
+ 
		break;
+ 
	case PKG_RDEPS:
+ 
		LIST_FREE(&pkg->rdeps, d, pkg_dep_free);
+ 
		pkg->flags &= ~PKG_LOAD_RDEPS;
+ 
		break;
+ 
	case PKG_LICENSES:
+ 
		LIST_FREE(&pkg->licenses, l, pkg_license_free);
+ 
		pkg->flags &= ~PKG_LOAD_LICENSES;
+ 
		break;
+ 
	case PKG_OPTIONS:
+ 
		LIST_FREE(&pkg->options, o, pkg_option_free);
+ 
		pkg->flags &= ~PKG_LOAD_OPTIONS;
+ 
		break;
+ 
	case PKG_CATEGORIES:
+ 
		LIST_FREE(&pkg->categories, c, pkg_category_free);
+ 
		pkg->flags &= ~PKG_LOAD_CATEGORIES;
+ 
		break;
+ 
	case PKG_FILES:
+ 
		LIST_FREE(&pkg->files, f, pkg_file_free);
+ 
		pkg->flags &= ~PKG_LOAD_FILES;
+ 
		break;
+ 
	case PKG_DIRS:
+ 
		LIST_FREE(&pkg->dirs, dir, pkg_dir_free);
+ 
		pkg->flags &= ~PKG_LOAD_DIRS;
+ 
		break;
+ 
	case PKG_USERS:
+ 
		LIST_FREE(&pkg->users, u, pkg_user_free);
+ 
		pkg->flags &= ~PKG_LOAD_USERS;
+ 
		break;
+ 
	case PKG_GROUPS:
+ 
		LIST_FREE(&pkg->groups, g, pkg_group_free);
+ 
		pkg->flags &= ~PKG_LOAD_GROUPS;
+ 
		break;
+ 
	case PKG_SHLIBS:
+ 
		LIST_FREE(&pkg->shlibs, sl, pkg_shlib_free);
+ 
		pkg->flags &= ~PKG_LOAD_SHLIBS;
+ 
		break;

	}

}
modified libpkg/pkg_attributes.c
@@ -59,18 +59,18 @@ pkg_dep_get(struct pkg_dep const * const d, const pkg_dep_attr attr)
	assert(d != NULL);



	switch (attr) {
- 
		case PKG_DEP_NAME:
- 
			return (sbuf_get(d->name));
- 
			break;
- 
		case PKG_DEP_ORIGIN:
- 
			return (sbuf_get(d->origin));
- 
			break;
- 
		case PKG_DEP_VERSION:
- 
			return (sbuf_get(d->version));
- 
			break;
- 
		default:
- 
			return (NULL);
- 
			break;
+ 
	case PKG_DEP_NAME:
+ 
		return (sbuf_get(d->name));
+ 
		break;
+ 
	case PKG_DEP_ORIGIN:
+ 
		return (sbuf_get(d->origin));
+ 
		break;
+ 
	case PKG_DEP_VERSION:
+ 
		return (sbuf_get(d->version));
+ 
		break;
+ 
	default:
+ 
		return (NULL);
+ 
		break;

	}

}
@@ -126,21 +126,21 @@ pkg_file_get(struct pkg_file const * const f, const pkg_file_attr attr)
	assert(f != NULL);



	switch (attr) {
- 
		case PKG_FILE_PATH:
- 
			return (f->path);
- 
			break;
- 
		case PKG_FILE_SUM:
- 
			return (f->sum);
- 
			break;
- 
		case PKG_FILE_UNAME:
- 
			return (f->uname);
- 
			break;
- 
		case PKG_FILE_GNAME:
- 
			return (f->gname);
- 
			break;
- 
		default:
- 
			return (NULL);
- 
			break;
+ 
	case PKG_FILE_PATH:
+ 
		return (f->path);
+ 
		break;
+ 
	case PKG_FILE_SUM:
+ 
		return (f->sum);
+ 
		break;
+ 
	case PKG_FILE_UNAME:
+ 
		return (f->uname);
+ 
		break;
+ 
	case PKG_FILE_GNAME:
+ 
		return (f->gname);
+ 
		break;
+ 
	default:
+ 
		return (NULL);
+ 
		break;

	}

}
modified libpkg/pkg_config.c
@@ -365,12 +365,12 @@ pkg_config_kv_get(struct pkg_config_kv *kv, pkg_config_kv_t type)
	assert(kv != NULL);



	switch (type) {
- 
		case PKG_CONFIG_KV_KEY:
- 
			return (kv->key);
- 
			break;
- 
		case PKG_CONFIG_KV_VALUE:
- 
			return (kv->value);
- 
			break;
+ 
	case PKG_CONFIG_KV_KEY:
+ 
		return (kv->key);
+ 
		break;
+ 
	case PKG_CONFIG_KV_VALUE:
+ 
		return (kv->value);
+ 
		break;

	}

	return (NULL);

}
modified libpkg/pkg_elf.c
@@ -194,13 +194,13 @@ analyse_elf(struct pkgdb *db, struct pkg *pkg, const char *fpath)
			goto cleanup;

		}

		switch (shdr.sh_type) {
- 
			case SHT_NOTE:
- 
				note = scn;
- 
				break;
- 
			case SHT_DYNAMIC:
- 
				dynamic = scn;
- 
				sh_link = shdr.sh_link;
- 
				numdyn = shdr.sh_size / shdr.sh_entsize;
+ 
		case SHT_NOTE:
+ 
			note = scn;
+ 
			break;
+ 
		case SHT_DYNAMIC:
+ 
			dynamic = scn;
+ 
			sh_link = shdr.sh_link;
+ 
			numdyn = shdr.sh_size / shdr.sh_entsize;

		}



		if (note != NULL && dynamic != NULL)
modified libpkg/pkg_jobs.c
@@ -312,18 +312,18 @@ pkg_jobs_apply(struct pkg_jobs *j, int force)
	int rc;



	switch (j->type) {
- 
		case PKG_JOBS_INSTALL:
- 
			rc = pkg_jobs_install(j, force);
- 
			break;
- 
		case PKG_JOBS_DEINSTALL:
- 
			rc = pkg_jobs_deinstall(j, force);
- 
			break;
- 
		case PKG_JOBS_FETCH:
- 
			rc = pkg_jobs_fetch(j);
- 
			break;
- 
		default:
- 
			rc = EPKG_FATAL;
- 
			pkg_emit_error("bad jobs argument");
+ 
	case PKG_JOBS_INSTALL:
+ 
		rc = pkg_jobs_install(j, force);
+ 
		break;
+ 
	case PKG_JOBS_DEINSTALL:
+ 
		rc = pkg_jobs_deinstall(j, force);
+ 
		break;
+ 
	case PKG_JOBS_FETCH:
+ 
		rc = pkg_jobs_fetch(j);
+ 
		break;
+ 
	default:
+ 
		rc = EPKG_FATAL;
+ 
		pkg_emit_error("bad jobs argument");

	}



	return (rc);
modified libpkg/pkg_manifest.c
@@ -865,33 +865,33 @@ pkg_emit_manifest(struct pkg *pkg, char **dest)
			continue;



		switch (i) {
- 
			case PKG_SCRIPT_PRE_INSTALL:
- 
				script_types = "pre-install";
- 
				break;
- 
			case PKG_SCRIPT_INSTALL:
- 
				script_types = "install";
- 
				break;
- 
			case PKG_SCRIPT_POST_INSTALL:
- 
				script_types = "post-install";
- 
				break;
- 
			case PKG_SCRIPT_PRE_UPGRADE:
- 
				script_types = "pre-upgrade";
- 
				break;
- 
			case PKG_SCRIPT_UPGRADE:
- 
				script_types = "upgrade";
- 
				break;
- 
			case PKG_SCRIPT_POST_UPGRADE:
- 
				script_types = "post-upgrade";
- 
				break;
- 
			case PKG_SCRIPT_PRE_DEINSTALL:
- 
				script_types = "pre-deinstall";
- 
				break;
- 
			case PKG_SCRIPT_DEINSTALL:
- 
				script_types = "deinstall";
- 
				break;
- 
			case PKG_SCRIPT_POST_DEINSTALL:
- 
				script_types = "post-deinstall";
- 
				break;
+ 
		case PKG_SCRIPT_PRE_INSTALL:
+ 
			script_types = "pre-install";
+ 
			break;
+ 
		case PKG_SCRIPT_INSTALL:
+ 
			script_types = "install";
+ 
			break;
+ 
		case PKG_SCRIPT_POST_INSTALL:
+ 
			script_types = "post-install";
+ 
			break;
+ 
		case PKG_SCRIPT_PRE_UPGRADE:
+ 
			script_types = "pre-upgrade";
+ 
			break;
+ 
		case PKG_SCRIPT_UPGRADE:
+ 
			script_types = "upgrade";
+ 
			break;
+ 
		case PKG_SCRIPT_POST_UPGRADE:
+ 
			script_types = "post-upgrade";
+ 
			break;
+ 
		case PKG_SCRIPT_PRE_DEINSTALL:
+ 
			script_types = "pre-deinstall";
+ 
			break;
+ 
		case PKG_SCRIPT_DEINSTALL:
+ 
			script_types = "deinstall";
+ 
			break;
+ 
		case PKG_SCRIPT_POST_DEINSTALL:
+ 
			script_types = "post-deinstall";
+ 
			break;

		}

		urlencode(pkg_script_get(pkg, i), &tmpsbuf);

		manifest_append_kv(map, script_types, sbuf_get(tmpsbuf),
modified libpkg/pkg_repo.c
@@ -516,8 +516,7 @@ maybe_delete_conflicting(const char *origin, const char *version,
	if (run_prepared_statement(VERSION, origin) != SQLITE_ROW)

		return (EPKG_FATAL); /* sqlite error */

	oversion = sqlite3_column_text(STMT(VERSION), 0);
- 
	switch(pkg_version_cmp(oversion, version))
- 
	{
+ 
	switch(pkg_version_cmp(oversion, version)) {

	case -1:

		pkg_emit_error("duplicate package origin: replacing older "

			       "version %s in repo with package %s for "
@@ -683,8 +682,7 @@ pkg_create_repo(char *path, bool force,
		    pkg_path)) != SQLITE_DONE) {

			if (ret == SQLITE_CONSTRAINT) {

				switch(maybe_delete_conflicting(origin,
- 
				    version, pkg_path))
- 
				{
+ 
				    version, pkg_path)) {

				case EPKG_FATAL: /* sqlite error */

					ERROR_SQLITE(sqlite);

					retcode = EPKG_FATAL;
modified libpkg/pkgdb.c
@@ -196,40 +196,40 @@ populate_pkg(sqlite3_stmt *stmt, struct pkg *pkg) {
	for (icol = 0; icol < sqlite3_column_count(stmt); icol++) {

		colname = sqlite3_column_name(stmt, icol);

		switch (sqlite3_column_type(stmt, icol)) {
- 
			case SQLITE_TEXT:
- 
				for (i = 0; columns[i].name != NULL; i++) {
- 
					if (!strcmp(columns[i].name, colname)) {
- 
						pkg_set(pkg, columns[i].type,
- 
						    sqlite3_column_text(stmt,
- 
						    icol));
- 
						break;
- 
					}
+ 
		case SQLITE_TEXT:
+ 
			for (i = 0; columns[i].name != NULL; i++) {
+ 
				if (!strcmp(columns[i].name, colname)) {
+ 
					pkg_set(pkg, columns[i].type,
+ 
					    sqlite3_column_text(stmt,
+ 
					    icol));
+ 
					break;

				}
- 
				if (columns[i].name == NULL)
- 
					pkg_emit_error("Unknown column %s",
- 
					    colname);
- 
				break;
- 
			case SQLITE_INTEGER:
- 
				for (i = 0; columns[i].name != NULL; i++) {
- 
					if (!strcmp(columns[i].name, colname)) {
- 
						pkg_set(pkg, columns[i].type,
- 
						    sqlite3_column_int64(stmt,
- 
						    icol));
- 
						break;
- 
					}
+ 
			}
+ 
			if (columns[i].name == NULL)
+ 
				pkg_emit_error("Unknown column %s",
+ 
				    colname);
+ 
			break;
+ 
		case SQLITE_INTEGER:
+ 
			for (i = 0; columns[i].name != NULL; i++) {
+ 
				if (!strcmp(columns[i].name, colname)) {
+ 
					pkg_set(pkg, columns[i].type,
+ 
					    sqlite3_column_int64(stmt,
+ 
					    icol));
+ 
					break;

				}
- 
				if (columns[i].name == NULL)
- 
					pkg_emit_error("Unknown column %s",
- 
					    colname);
- 
				break;
- 
			case SQLITE_BLOB:
- 
			case SQLITE_FLOAT:
- 
				pkg_emit_error("Wrong type for column: %s",
+ 
			}
+ 
			if (columns[i].name == NULL)
+ 
				pkg_emit_error("Unknown column %s",

				    colname);
- 
				/* just ignore currently */
- 
				break;
- 
			case SQLITE_NULL:
- 
				break;
+ 
			break;
+ 
		case SQLITE_BLOB:
+ 
		case SQLITE_FLOAT:
+ 
			pkg_emit_error("Wrong type for column: %s",
+ 
			    colname);
+ 
			/* just ignore currently */
+ 
			break;
+ 
		case SQLITE_NULL:
+ 
			break;

		}

	}

}
@@ -330,7 +330,7 @@ pkgdb_pkgcmp(sqlite3_context *ctx, int argc, sqlite3_value **argv, int sign)
		return;

	}
- 
	switch(pkg_version_cmp(version1, version2)) {
+ 
	switch (pkg_version_cmp(version1, version2)) {

	case -1:

		if ((sign & PKGLT) == PKGLT)

			res = 1;
@@ -677,7 +677,7 @@ pkgdb_open_multirepos(const char *dbdir, struct pkgdb *db)
			return (EPKG_FATAL);

		}
- 
		switch(pkg_check_repo_version(db, repo_name)) {
+ 
		switch (pkg_check_repo_version(db, repo_name)) {

		case EPKG_FATAL:

			pkgdb_close(db);

			return (EPKG_FATAL);
@@ -997,25 +997,25 @@ pkgdb_get_match_how(match_t match)
	const char *how = NULL;



	switch (match) {
- 
		case MATCH_ALL:
- 
			how = NULL;
- 
			break;
- 
		case MATCH_EXACT:
- 
			how = "%s = ?1";
- 
			break;
- 
		case MATCH_GLOB:
- 
			how = "%s GLOB ?1";
- 
			break;
- 
		case MATCH_REGEX:
- 
			how = "%s REGEXP ?1";
- 
			break;
- 
		case MATCH_EREGEX:
- 
			how = "EREGEXP(?1, %s)";
- 
			break;
- 
		case MATCH_CONDITION:
- 
			/* Should not be called by pkgdb_get_match_how(). */
- 
			assert(0);
- 
			break;
+ 
	case MATCH_ALL:
+ 
		how = NULL;
+ 
		break;
+ 
	case MATCH_EXACT:
+ 
		how = "%s = ?1";
+ 
		break;
+ 
	case MATCH_GLOB:
+ 
		how = "%s GLOB ?1";
+ 
		break;
+ 
	case MATCH_REGEX:
+ 
		how = "%s REGEXP ?1";
+ 
		break;
+ 
	case MATCH_EREGEX:
+ 
		how = "EREGEXP(?1, %s)";
+ 
		break;
+ 
	case MATCH_CONDITION:
+ 
		/* Should not be called by pkgdb_get_match_how(). */
+ 
		assert(0);
+ 
		break;

	}



	return (how);
@@ -3020,25 +3020,25 @@ pkgdb_search_build_search_query(struct sbuf *sql, match_t match,


	how = pkgdb_get_match_how(match);
- 
	switch(field) {
- 
		case FIELD_NONE:
- 
			what = NULL;
- 
			break;
- 
		case FIELD_ORIGIN:
- 
			what = "origin";
- 
			break;
- 
		case FIELD_NAME:
- 
			what = "name";
- 
			break;
- 
		case FIELD_NAMEVER:
- 
			what = "name || \"-\" || version";
- 
			break;
- 
		case FIELD_COMMENT:
- 
			what = "comment";
- 
			break;
- 
		case FIELD_DESC:
- 
			what = "desc";
- 
			break;
+ 
	switch (field) {
+ 
	case FIELD_NONE:
+ 
		what = NULL;
+ 
		break;
+ 
	case FIELD_ORIGIN:
+ 
		what = "origin";
+ 
		break;
+ 
	case FIELD_NAME:
+ 
		what = "name";
+ 
		break;
+ 
	case FIELD_NAMEVER:
+ 
		what = "name || \"-\" || version";
+ 
		break;
+ 
	case FIELD_COMMENT:
+ 
		what = "comment";
+ 
		break;
+ 
	case FIELD_DESC:
+ 
		what = "desc";
+ 
		break;

	}



	if (what != NULL && how != NULL)
@@ -3343,32 +3343,32 @@ pkgdb_vset(struct pkgdb *db, int64_t id, va_list ap)
		}



		switch (attr) {
- 
			case PKG_SET_FLATSIZE:
- 
				flatsize = va_arg(ap, int64_t);
- 
				sqlite3_bind_int64(stmt, 1, flatsize);
- 
				sqlite3_bind_int64(stmt, 2, id);
- 
				break;
- 
			case PKG_SET_AUTOMATIC:
- 
				automatic = (int64_t)va_arg(ap, int);
- 
				if (automatic != 0 && automatic != 1) {
- 
					sqlite3_finalize(stmt);
- 
					continue;
- 
				}
- 
				sqlite3_bind_int64(stmt, 1, automatic);
- 
				sqlite3_bind_int64(stmt, 2, id);
- 
				break;
- 
			case PKG_SET_DEPORIGIN:
- 
				oldorigin = va_arg(ap, char *);
- 
				neworigin = va_arg(ap, char *);
- 
				sqlite3_bind_text(stmt, 1, neworigin, -1, SQLITE_STATIC);
- 
				sqlite3_bind_int64(stmt, 2, id);
- 
				sqlite3_bind_text(stmt, 3, oldorigin, -1, SQLITE_STATIC);
- 
				break;
- 
			case PKG_SET_ORIGIN:
- 
				neworigin = va_arg(ap, char *);
- 
				sqlite3_bind_text(stmt, 1, neworigin, -1, SQLITE_STATIC);
- 
				sqlite3_bind_int64(stmt, 2, id);
- 
				break;
+ 
		case PKG_SET_FLATSIZE:
+ 
			flatsize = va_arg(ap, int64_t);
+ 
			sqlite3_bind_int64(stmt, 1, flatsize);
+ 
			sqlite3_bind_int64(stmt, 2, id);
+ 
			break;
+ 
		case PKG_SET_AUTOMATIC:
+ 
			automatic = (int64_t)va_arg(ap, int);
+ 
			if (automatic != 0 && automatic != 1) {
+ 
				sqlite3_finalize(stmt);
+ 
				continue;
+ 
			}
+ 
			sqlite3_bind_int64(stmt, 1, automatic);
+ 
			sqlite3_bind_int64(stmt, 2, id);
+ 
			break;
+ 
		case PKG_SET_DEPORIGIN:
+ 
			oldorigin = va_arg(ap, char *);
+ 
			neworigin = va_arg(ap, char *);
+ 
			sqlite3_bind_text(stmt, 1, neworigin, -1, SQLITE_STATIC);
+ 
			sqlite3_bind_int64(stmt, 2, id);
+ 
			sqlite3_bind_text(stmt, 3, oldorigin, -1, SQLITE_STATIC);
+ 
			break;
+ 
		case PKG_SET_ORIGIN:
+ 
			neworigin = va_arg(ap, char *);
+ 
			sqlite3_bind_text(stmt, 1, neworigin, -1, SQLITE_STATIC);
+ 
			sqlite3_bind_int64(stmt, 2, id);
+ 
			break;

		}



		if (sqlite3_step(stmt) != SQLITE_DONE) {
modified libpkg/rcscripts.c
@@ -84,23 +84,23 @@ rc_stop(const char *rc_file)
		return (0);



	switch ((pid = fork())) {
- 
		case -1:
- 
			return (-1);
- 
		case 0:
- 
			/* child */
- 
			/*
- 
			 * We don't need to see the output
- 
			 */
- 
			fd = open("/dev/null", O_WRONLY);
- 
			dup2(fd, STDERR_FILENO);
- 
			dup2(fd, STDOUT_FILENO);
- 
			execl("/usr/sbin/service", "service", rc_file,
- 
			    "onestatus", (char *)NULL);
- 
			_exit(1);
- 
			/* NOT REACHED */
- 
		default:
- 
			/* parent */
- 
			break;
+ 
	case -1:
+ 
		return (-1);
+ 
	case 0:
+ 
		/* child */
+ 
		/*
+ 
		 * We don't need to see the output
+ 
		 */
+ 
		fd = open("/dev/null", O_WRONLY);
+ 
		dup2(fd, STDERR_FILENO);
+ 
		dup2(fd, STDOUT_FILENO);
+ 
		execl("/usr/sbin/service", "service", rc_file,
+ 
		    "onestatus", (char *)NULL);
+ 
		_exit(1);
+ 
		/* NOT REACHED */
+ 
	default:
+ 
		/* parent */
+ 
		break;

	}



	while (waitpid(pid, &pstat, 0) == -1) {
@@ -112,17 +112,17 @@ rc_stop(const char *rc_file)
		return (0);



	switch ((pid = fork())) {
- 
		case -1:
- 
			return (-1);
- 
		case 0:
- 
			/* child */
- 
			execl("/usr/sbin/service", "service",
- 
			    rc_file, "stop", (char *)NULL);
- 
			_exit(1);
- 
			/* NOT REACHED */
- 
		default:
- 
			/* parent */
- 
			break;
+ 
	case -1:
+ 
		return (-1);
+ 
	case 0:
+ 
		/* child */
+ 
		execl("/usr/sbin/service", "service",
+ 
		    rc_file, "stop", (char *)NULL);
+ 
		_exit(1);
+ 
		/* NOT REACHED */
+ 
	default:
+ 
		/* parent */
+ 
		break;

	}



	while (waitpid(pid, &pstat, 0) == -1) {
@@ -143,17 +143,17 @@ rc_start(const char *rc_file)
		return (0);



	switch ((pid = fork())) {
- 
		case -1:
- 
			return (-1);
- 
		case 0:
- 
			/* child */
- 
			execl("/usr/sbin/service", "service", rc_file,
- 
			    "quietstart", (char *)NULL);
- 
			_exit(1);
- 
			/* NOT REACHED */
- 
		default:
- 
			/* parent */
- 
			break;
+ 
	case -1:
+ 
		return (-1);
+ 
	case 0:
+ 
		/* child */
+ 
		execl("/usr/sbin/service", "service", rc_file,
+ 
		    "quietstart", (char *)NULL);
+ 
		_exit(1);
+ 
		/* NOT REACHED */
+ 
	default:
+ 
		/* parent */
+ 
		break;

	}



	while (waitpid(pid, &pstat, 0) == -1) {
modified pkg/audit.c
@@ -88,15 +88,15 @@ fetch_and_extract(const char *src, const char *dest)
		t = st.st_mtime;

	}

	switch (pkg_fetch_file(src, tmp, t)) {
- 
		case EPKG_OK:
- 
			break;
- 
		case EPKG_UPTODATE:
- 
			printf("Audit file up-to-date.\n");
- 
			retcode = EPKG_OK;
- 
			goto cleanup;
- 
		default:
- 
			warnx("Cannot fetch audit file!");
- 
			goto cleanup;
+ 
	case EPKG_OK:
+ 
		break;
+ 
	case EPKG_UPTODATE:
+ 
		printf("Audit file up-to-date.\n");
+ 
		retcode = EPKG_OK;
+ 
		goto cleanup;
+ 
	default:
+ 
		warnx("Cannot fetch audit file!");
+ 
		goto cleanup;

	}



	a = archive_read_new();
@@ -215,17 +215,17 @@ parse_db(const char *path, struct audit_head *h)
		while ((column = strsep(&line, "|")) != NULL)

		{

			switch (column_id) {
- 
				case 0:
- 
					parse_pattern(e, column, linelen);
- 
					break;
- 
				case 1:
- 
					e->url = strdup(column);
- 
					break;
- 
				case 2:
- 
					e->desc = strdup(column);
- 
					break;
- 
				default:
- 
					warn("extra column in audit file");
+ 
			case 0:
+ 
				parse_pattern(e, column, linelen);
+ 
				break;
+ 
			case 1:
+ 
				e->url = strdup(column);
+ 
				break;
+ 
			case 2:
+ 
				e->desc = strdup(column);
+ 
				break;
+ 
			default:
+ 
				warn("extra column in audit file");

			}

			column_id++;

		}
@@ -248,18 +248,18 @@ match_version(const char *pkgversion, struct version_entry *v)
		return true;



	switch (pkg_version_cmp(pkgversion, v->version)) {
- 
		case -1:
- 
			if (v->type == LT || v->type == LTE)
- 
				res = true;
- 
			break;
- 
		case 0:
- 
			if (v->type == EQ || v->type == LTE || v->type == GTE)
- 
				res = true;
- 
			break;
- 
		case 1:
- 
			if (v->type == GT || v->type == GTE)
- 
				res = true;
- 
			break;
+ 
	case -1:
+ 
		if (v->type == LT || v->type == LTE)
+ 
			res = true;
+ 
		break;
+ 
	case 0:
+ 
		if (v->type == EQ || v->type == LTE || v->type == GTE)
+ 
			res = true;
+ 
		break;
+ 
	case 1:
+ 
		if (v->type == GT || v->type == GTE)
+ 
			res = true;
+ 
		break;

	}

	return res;

}
@@ -334,15 +334,15 @@ exec_audit(int argc, char **argv)


	while ((ch = getopt(argc, argv, "qF")) != -1) {

		switch (ch) {
- 
			case 'q':
- 
				quiet = true;
- 
				break;
- 
			case 'F':
- 
				fetch = true;
- 
				break;
- 
			default:
- 
				usage_audit();
- 
				return(EX_USAGE);
+ 
		case 'q':
+ 
			quiet = true;
+ 
			break;
+ 
		case 'F':
+ 
			fetch = true;
+ 
			break;
+ 
		default:
+ 
			usage_audit();
+ 
			return(EX_USAGE);

		}

	}

	argc -= optind;
modified pkg/autoremove.c
@@ -58,14 +58,14 @@ exec_autoremove(int argc, char **argv)


	while ((ch = getopt(argc, argv, "yq")) != -1) {

		switch (ch) {
- 
			case 'q':
- 
				quiet = true;
- 
				break;
- 
			case 'y':
- 
				yes = true;
- 
				break;
- 
			default:
- 
				break;
+ 
		case 'q':
+ 
			quiet = true;
+ 
			break;
+ 
		case 'y':
+ 
			yes = true;
+ 
			break;
+ 
		default:
+ 
			break;

		}

        }

	argc -= optind;
modified pkg/check.c
@@ -249,50 +249,50 @@ exec_check(int argc, char **argv)


	while ((ch = getopt(argc, argv, "yagdBxXsrv")) != -1) {

		switch (ch) {
- 
			case 'a':
- 
				match = MATCH_ALL;
- 
				break;
- 
			case 'x':
- 
				match = MATCH_REGEX;
- 
				break;
- 
			case 'X':
- 
				match = MATCH_EREGEX;
- 
				break;
- 
			case 'g':
- 
				match = MATCH_GLOB;
- 
				break;
- 
			case 'y':
- 
				yes = true;
- 
				break;
- 
			case 'd':
- 
				dcheck = true;
- 
				flags |= PKG_LOAD_DEPS;
- 
				break;
- 
			case 'B':
- 
				pkg_config_bool(PKG_CONFIG_SHLIBS, &shlibs);
- 
				if (!shlibs)
- 
					errx(EX_USAGE, "reanalyzing shlibs requires SHLIBS"
- 
						       " in pkg.conf.");
- 
				reanalyse_shlibs = true;
- 
				flags |= PKG_LOAD_SHLIBS;
- 
				break;
- 
			case 's':
- 
				checksums = true;
- 
				flags |= PKG_LOAD_FILES;
- 
				break;
- 
			case 'r':
- 
				recompute = true;
- 
				flags |= PKG_LOAD_FILES;
- 
				if (geteuid() != 0)
- 
					errx(EX_USAGE, "recomputing the checksums"
- 
					    " and size can only be done as root");
- 
				break;
- 
			case 'v':
- 
				verbose = 1;
- 
				break;
- 
			default:
- 
				usage_check();
- 
				return (EX_USAGE);
+ 
		case 'a':
+ 
			match = MATCH_ALL;
+ 
			break;
+ 
		case 'x':
+ 
			match = MATCH_REGEX;
+ 
			break;
+ 
		case 'X':
+ 
			match = MATCH_EREGEX;
+ 
			break;
+ 
		case 'g':
+ 
			match = MATCH_GLOB;
+ 
			break;
+ 
		case 'y':
+ 
			yes = true;
+ 
			break;
+ 
		case 'd':
+ 
			dcheck = true;
+ 
			flags |= PKG_LOAD_DEPS;
+ 
			break;
+ 
		case 'B':
+ 
			pkg_config_bool(PKG_CONFIG_SHLIBS, &shlibs);
+ 
			if (!shlibs)
+ 
				errx(EX_USAGE, "reanalyzing shlibs requires SHLIBS"
+ 
					       " in pkg.conf.");
+ 
			reanalyse_shlibs = true;
+ 
			flags |= PKG_LOAD_SHLIBS;
+ 
			break;
+ 
		case 's':
+ 
			checksums = true;
+ 
			flags |= PKG_LOAD_FILES;
+ 
			break;
+ 
		case 'r':
+ 
			recompute = true;
+ 
			flags |= PKG_LOAD_FILES;
+ 
			if (geteuid() != 0)
+ 
				errx(EX_USAGE, "recomputing the checksums"
+ 
				    " and size can only be done as root");
+ 
			break;
+ 
		case 'v':
+ 
			verbose = 1;
+ 
			break;
+ 
		default:
+ 
			usage_check();
+ 
			return (EX_USAGE);

		}

	}

	argc -= optind;
modified pkg/create.c
@@ -77,18 +77,18 @@ pkg_create_matches(int argc, char **argv, match_t match, pkg_formats fmt, const
	}



	switch (fmt) {
- 
		case TXZ:
- 
			format = "txz";
- 
			break;
- 
		case TBZ:
- 
			format = "tbz";
- 
			break;
- 
		case TGZ:
- 
			format = "tgz";
- 
			break;
- 
		case TAR:
- 
			format = "tar";
- 
			break;
+ 
	case TXZ:
+ 
		format = "txz";
+ 
		break;
+ 
	case TBZ:
+ 
		format = "tbz";
+ 
		break;
+ 
	case TGZ:
+ 
		format = "tgz";
+ 
		break;
+ 
	case TAR:
+ 
		format = "tar";
+ 
		break;

	}



	for (i = 0; i < argc || match == MATCH_ALL; i++) {
modified pkg/delete.c
@@ -61,33 +61,33 @@ exec_delete(int argc, char **argv)


	while ((ch = getopt(argc, argv, "aqgxXfyR")) != -1) {

		switch (ch) {
- 
			case 'a':
- 
				match = MATCH_ALL;
- 
				break;
- 
			case 'g':
- 
				match = MATCH_GLOB;
- 
				break;
- 
			case 'x':
- 
				match = MATCH_REGEX;
- 
				break;
- 
			case 'X':
- 
				match = MATCH_EREGEX;
- 
				break;
- 
			case 'f':
- 
				force = 1;
- 
				break;
- 
			case 'q':
- 
				quiet = true;
- 
				break;
- 
			case 'y':
- 
				yes = true;
- 
				break;
- 
			case 'R':
- 
				recursive = 1;
- 
				break;
- 
			default:
- 
				usage_delete();
- 
				return (EX_USAGE);
+ 
		case 'a':
+ 
			match = MATCH_ALL;
+ 
			break;
+ 
		case 'g':
+ 
			match = MATCH_GLOB;
+ 
			break;
+ 
		case 'x':
+ 
			match = MATCH_REGEX;
+ 
			break;
+ 
		case 'X':
+ 
			match = MATCH_EREGEX;
+ 
			break;
+ 
		case 'f':
+ 
			force = 1;
+ 
			break;
+ 
		case 'q':
+ 
			quiet = true;
+ 
			break;
+ 
		case 'y':
+ 
			yes = true;
+ 
			break;
+ 
		case 'R':
+ 
			recursive = 1;
+ 
			break;
+ 
		default:
+ 
			usage_delete();
+ 
			return (EX_USAGE);

		}

	}
modified pkg/event.c
@@ -67,11 +67,15 @@ event_callback(void *data, struct pkg_event *ev)
			if (filename != NULL) {

				filename++;

			} else {
- 
				// We failed at beeing smart, display the entire url
+ 
				/*
+ 
				 * We failed at being smart, so display
+ 
				 * the entire url.
+ 
				 */

				filename = ev->e_fetching.url;

			}

			strlcpy(url, filename, sizeof(url));
- 
			start_progress_meter(url, ev->e_fetching.total, &fetched);
+ 
			start_progress_meter(url, ev->e_fetching.total,
+ 
			    &fetched);

		}

		fetched = ev->e_fetching.done;

		if (ev->e_fetching.done == ev->e_fetching.total) {
@@ -82,7 +86,8 @@ event_callback(void *data, struct pkg_event *ev)
	case PKG_EVENT_INSTALL_BEGIN:

		if (quiet)

			break;
- 
		pkg_get(ev->e_install_begin.pkg, PKG_NAME, &name, PKG_VERSION, &version);
+ 
		pkg_get(ev->e_install_begin.pkg, PKG_NAME, &name,
+ 
		    PKG_VERSION, &version);

		printf("Installing %s-%s...", name, version);

		break;

	case PKG_EVENT_INSTALL_FINISHED:
@@ -109,7 +114,8 @@ event_callback(void *data, struct pkg_event *ev)
	case PKG_EVENT_DEINSTALL_BEGIN:

		if (quiet)

			break;
- 
		pkg_get(ev->e_deinstall_begin.pkg, PKG_NAME, &name, PKG_VERSION, &version);
+ 
		pkg_get(ev->e_deinstall_begin.pkg, PKG_NAME, &name,
+ 
		    PKG_VERSION, &version);

		printf("Deinstalling %s-%s...", name, version);

		break;

	case PKG_EVENT_DEINSTALL_FINISHED:
@@ -120,18 +126,20 @@ event_callback(void *data, struct pkg_event *ev)
	case PKG_EVENT_UPGRADE_BEGIN:

		if (quiet)

			break;
- 
		pkg_get(ev->e_upgrade_finished.pkg, PKG_NAME, &name, PKG_VERSION, &version,
- 
		    PKG_NEWVERSION, &newversion);
+ 
		pkg_get(ev->e_upgrade_finished.pkg, PKG_NAME, &name,
+ 
		    PKG_VERSION, &version, PKG_NEWVERSION, &newversion);

		switch (pkg_version_cmp(version, newversion)) {
- 
			case 1:
- 
				printf("Downgrading %s from %s to %s...", name, version, newversion);
- 
				break;
- 
			case 0:
- 
				printf("Reinstalling %s-%s", name, version);
- 
				break;
- 
			case -1:
- 
				printf("Upgrading %s from %s to %s...", name, version, newversion);
- 
				break;
+ 
		case 1:
+ 
			printf("Downgrading %s from %s to %s...", name,
+ 
			    version, newversion);
+ 
			break;
+ 
		case 0:
+ 
			printf("Reinstalling %s-%s", name, version);
+ 
			break;
+ 
		case -1:
+ 
			printf("Upgrading %s from %s to %s...", name,
+ 
			    version, newversion);
+ 
			break;

		}

		break;

	case PKG_EVENT_UPGRADE_FINISHED:
@@ -143,9 +151,9 @@ event_callback(void *data, struct pkg_event *ev)
		pkg = ev->e_required.pkg;

		pkg_get(pkg, PKG_NAME, &name, PKG_VERSION, &version);

		fprintf(stderr, "%s-%s is required by:", name, version);
- 
		while (pkg_rdeps(pkg, &dep) == EPKG_OK) {
- 
			fprintf(stderr, " %s-%s", pkg_dep_name(dep), pkg_dep_version(dep));
- 
		}
+ 
		while (pkg_rdeps(pkg, &dep) == EPKG_OK)
+ 
			fprintf(stderr, " %s-%s", pkg_dep_name(dep),
+ 
			    pkg_dep_version(dep));

		if (ev->e_required.force == 1)

			fprintf(stderr, ", deleting anyway\n");

		else
@@ -154,15 +162,19 @@ event_callback(void *data, struct pkg_event *ev)
	case PKG_EVENT_ALREADY_INSTALLED:

		if (quiet)

			break;
- 
		pkg_get(ev->e_already_installed.pkg, PKG_NAME, &name, PKG_VERSION, &version);
+ 
		pkg_get(ev->e_already_installed.pkg, PKG_NAME, &name,
+ 
		    PKG_VERSION, &version);

		printf("%s-%s already installed\n", name, version);

		break;

	case PKG_EVENT_MISSING_DEP:
- 
		fprintf(stderr, "missing dependency %s-%s", pkg_dep_name(ev->e_missing_dep.dep),
+ 
		fprintf(stderr, "missing dependency %s-%s",
+ 
		    pkg_dep_name(ev->e_missing_dep.dep),

		    pkg_dep_version(ev->e_missing_dep.dep));

		break;

	case PKG_EVENT_NOREMOTEDB:
- 
		fprintf(stderr, "Unable to open remote database \"%s\". Try running '%s update' first.\n", ev->e_remotedb.repo, getprogname());
+ 
		fprintf(stderr, "Unable to open remote database \"%s\". "
+ 
		    "Try running '%s update' first.\n", ev->e_remotedb.repo,
+ 
		    getprogname());

		break;

	case PKG_EVENT_NOLOCALDB:

		/* only cares if run as root */
@@ -170,12 +182,15 @@ event_callback(void *data, struct pkg_event *ev)
			fprintf(stderr, "Unable to create local database!\n");

		break;

	case PKG_EVENT_NEWPKGVERSION:
- 
		printf("New version of pkg detected, it needs to be installed first.\n"
- 
		       "After this upgrade it is recommended that you do a full upgrade using: 'pkg upgrade'\n\n");
+ 
		printf("New version of pkg detected; it needs to be "
+ 
		    "installed first.\nAfter this upgrade it is recommended"
+ 
		    "that you do a full upgrade using: 'pkg upgrade'\n\n");

		break;

	case PKG_EVENT_FILE_MISMATCH:
- 
		pkg_get(ev->e_file_mismatch.pkg, PKG_NAME, &name, PKG_VERSION, &version);
- 
		fprintf(stderr, "%s-%s: checksum mismatch for %s\n", name, version, pkg_file_path(ev->e_file_mismatch.file));
+ 
		pkg_get(ev->e_file_mismatch.pkg, PKG_NAME, &name,
+ 
		    PKG_VERSION, &version);
+ 
		fprintf(stderr, "%s-%s: checksum mismatch for %s\n", name,
+ 
		    version, pkg_file_path(ev->e_file_mismatch.file));

	default:

		break;

	}
modified pkg/info.c
@@ -83,72 +83,73 @@ exec_info(int argc, char **argv)
	/* TODO: exclusive opts ? */

	while ((ch = getopt(argc, argv, "aDegxXEdrlBsqopOfF:R")) != -1) {

		switch (ch) {
- 
			case 'a':
- 
				match = MATCH_ALL;
- 
				break;
- 
			case 'O':
- 
				opt |= INFO_ORIGIN_SEARCH;  /* this is only for ports compat */
- 
				break;
- 
			case 'e':
- 
				opt |= INFO_EXISTS;
- 
				retcode = 1;
- 
				break;
- 
			case 'g':
- 
				match = MATCH_GLOB;
- 
				break;
- 
			case 'x':
- 
				match = MATCH_REGEX;
- 
				break;
- 
			case 'X':
- 
				match = MATCH_EREGEX;
- 
				break;
- 
			case 'D':
- 
				opt |= INFO_PRINT_MESSAGE;
- 
				query_flags |= PKG_LOAD_BASIC;
- 
				break;
- 
			case 'd':
- 
				opt |= INFO_PRINT_DEP;
- 
				query_flags |= PKG_LOAD_DEPS;
- 
				break;
- 
			case 'r':
- 
				opt |= INFO_PRINT_RDEP;
- 
				query_flags |= PKG_LOAD_RDEPS;
- 
				break;
- 
			case 'l':
- 
				opt |= INFO_LIST_FILES;
- 
				query_flags |= PKG_LOAD_FILES;
- 
				break;
- 
			case 'B':
- 
				opt |= INFO_LIST_SHLIBS;
- 
				query_flags |= PKG_LOAD_SHLIBS;
- 
				break;
- 
			case 's':
- 
				opt |= INFO_SIZE;
- 
				break;
- 
			case 'E': /* ports compatibility */
- 
			case 'q':
- 
				opt |= INFO_QUIET;
- 
				break;
- 
			case 'o':
- 
				opt |= INFO_ORIGIN;
- 
				break;
- 
			case 'p':
- 
				opt |= INFO_PREFIX;
- 
				break;
- 
			case 'f':
- 
				opt |= INFO_FULL;
- 
				query_flags |= PKG_LOAD_CATEGORIES|PKG_LOAD_LICENSES|PKG_LOAD_OPTIONS;
- 
				break;
- 
			case 'F':
- 
				file = optarg;
- 
				break;
- 
			case 'R':
- 
				opt |= INFO_RAW;
- 
				query_flags |= PKG_LOAD_FILES|PKG_LOAD_DIRS|PKG_LOAD_CATEGORIES|PKG_LOAD_LICENSES|PKG_LOAD_OPTIONS|PKG_LOAD_SCRIPTS|PKG_LOAD_USERS|PKG_LOAD_GROUPS|PKG_LOAD_DEPS|PKG_LOAD_SHLIBS;
- 
				break;
- 
			default:
- 
				usage_info();
- 
				return(EX_USAGE);
+ 
		case 'a':
+ 
			match = MATCH_ALL;
+ 
			break;
+ 
		case 'O':
+ 
			/* this is only for ports compat */
+ 
			opt |= INFO_ORIGIN_SEARCH;
+ 
			break;
+ 
		case 'e':
+ 
			opt |= INFO_EXISTS;
+ 
			retcode = 1;
+ 
			break;
+ 
		case 'g':
+ 
			match = MATCH_GLOB;
+ 
			break;
+ 
		case 'x':
+ 
			match = MATCH_REGEX;
+ 
			break;
+ 
		case 'X':
+ 
			match = MATCH_EREGEX;
+ 
			break;
+ 
		case 'D':
+ 
			opt |= INFO_PRINT_MESSAGE;
+ 
			query_flags |= PKG_LOAD_BASIC;
+ 
			break;
+ 
		case 'd':
+ 
			opt |= INFO_PRINT_DEP;
+ 
			query_flags |= PKG_LOAD_DEPS;
+ 
			break;
+ 
		case 'r':
+ 
			opt |= INFO_PRINT_RDEP;
+ 
			query_flags |= PKG_LOAD_RDEPS;
+ 
			break;
+ 
		case 'l':
+ 
			opt |= INFO_LIST_FILES;
+ 
			query_flags |= PKG_LOAD_FILES;
+ 
			break;
+ 
		case 'B':
+ 
			opt |= INFO_LIST_SHLIBS;
+ 
			query_flags |= PKG_LOAD_SHLIBS;
+ 
			break;
+ 
		case 's':
+ 
			opt |= INFO_SIZE;
+ 
			break;
+ 
		case 'E': /* ports compatibility */
+ 
		case 'q':
+ 
			opt |= INFO_QUIET;
+ 
			break;
+ 
		case 'o':
+ 
			opt |= INFO_ORIGIN;
+ 
			break;
+ 
		case 'p':
+ 
			opt |= INFO_PREFIX;
+ 
			break;
+ 
		case 'f':
+ 
			opt |= INFO_FULL;
+ 
			query_flags |= PKG_LOAD_CATEGORIES|PKG_LOAD_LICENSES|PKG_LOAD_OPTIONS;
+ 
			break;
+ 
		case 'F':
+ 
			file = optarg;
+ 
			break;
+ 
		case 'R':
+ 
			opt |= INFO_RAW;
+ 
			query_flags |= PKG_LOAD_FILES|PKG_LOAD_DIRS|PKG_LOAD_CATEGORIES|PKG_LOAD_LICENSES|PKG_LOAD_OPTIONS|PKG_LOAD_SCRIPTS|PKG_LOAD_USERS|PKG_LOAD_GROUPS|PKG_LOAD_DEPS|PKG_LOAD_SHLIBS;
+ 
			break;
+ 
		default:
+ 
			usage_info();
+ 
			return(EX_USAGE);

		}

	}
@@ -305,46 +306,50 @@ exec_info(int argc, char **argv)
			pkg_get(pkg, PKG_VERSION, &version);

			if (pkgversion != NULL) {

				switch (pkg_version_cmp(version, pkgversion)) {
- 
					case -1:
- 
						if (sign != LT && sign != LE) {
- 
							gotone = false;
- 
							continue;
- 
						}
- 
						break;
- 
					case 0:
- 
						if (sign != LE && sign != GE && sign != EQ) {
- 
							gotone = false;
- 
							continue;
- 
						}
- 
						break;
- 
					case 1:
- 
						if (sign != GT && sign != GE) {
- 
							gotone = false;
- 
							continue;
- 
						}
- 
						break;
+ 
				case -1:
+ 
					if (sign != LT && sign != LE) {
+ 
						gotone = false;
+ 
						continue;
+ 
					}
+ 
					break;
+ 
				case 0:
+ 
					if (sign != LE &&
+ 
					    sign != GE &&
+ 
					    sign != EQ) {
+ 
						gotone = false;
+ 
						continue;
+ 
					}
+ 
					break;
+ 
				case 1:
+ 
					if (sign != GT && sign != GE) {
+ 
						gotone = false;
+ 
						continue;
+ 
					}
+ 
					break;

				}

			}

			if (pkgversion2 != NULL) {
- 
				switch(pkg_version_cmp(version, pkgversion2)) {
- 
					case -1:
- 
						if (sign2 != LT && sign2 != LE) {
- 
							gotone = false;
- 
							continue;
- 
						}
- 
						break;
- 
					case 0:
- 
						if (sign2 != LE && sign2 != GE && sign2 != EQ) {
- 
							gotone = false;
- 
							continue;
- 
						}
- 
						break;
- 
					case 1:
- 
						if (sign2 != GT && sign2 != GE) {
- 
							gotone = false;
- 
							continue;
- 
						}
- 
						break;
+ 
				switch (pkg_version_cmp(version, pkgversion2)) {
+ 
				case -1:
+ 
					if (sign2 != LT && sign2 != LE) {
+ 
						gotone = false;
+ 
						continue;
+ 
					}
+ 
					break;
+ 
				case 0:
+ 
					if (sign2 != LE &&
+ 
					    sign2 != GE &&
+ 
					    sign2 != EQ) {
+ 
						gotone = false;
+ 
						continue;
+ 
					}
+ 
					break;
+ 
				case 1:
+ 
					if (sign2 != GT && sign2 != GE) {
+ 
						gotone = false;
+ 
						continue;
+ 
					}
+ 
					break;

				}

			}

			if (opt & INFO_EXISTS)
modified pkg/install.c
@@ -67,36 +67,36 @@ exec_install(int argc, char **argv)


	while ((ch = getopt(argc, argv, "yfgxXr:qLR")) != -1) {

		switch (ch) {
- 
			case 'y':
- 
				yes = true;
- 
				break;
- 
			case 'g':
- 
				match = MATCH_GLOB;
- 
				break;
- 
			case 'x':
- 
				match = MATCH_REGEX;
- 
				break;
- 
			case 'X':
- 
				match = MATCH_EREGEX;
- 
				break;
- 
			case 'r':
- 
				reponame = optarg;
- 
				break;
- 
			case 'f':
- 
				force = true;
- 
				break;
- 
			case 'q':
- 
				quiet = true;
- 
				break;
- 
			case 'L':
- 
				auto_update = false;
- 
				break;
- 
			case 'R':
- 
				recursive = true;
- 
				break;
- 
			default:
- 
				usage_install();
- 
				return (EX_USAGE);
+ 
		case 'y':
+ 
			yes = true;
+ 
			break;
+ 
		case 'g':
+ 
			match = MATCH_GLOB;
+ 
			break;
+ 
		case 'x':
+ 
			match = MATCH_REGEX;
+ 
			break;
+ 
		case 'X':
+ 
			match = MATCH_EREGEX;
+ 
			break;
+ 
		case 'r':
+ 
			reponame = optarg;
+ 
			break;
+ 
		case 'f':
+ 
			force = true;
+ 
			break;
+ 
		case 'q':
+ 
			quiet = true;
+ 
			break;
+ 
		case 'L':
+ 
			auto_update = false;
+ 
			break;
+ 
		case 'R':
+ 
			recursive = true;
+ 
			break;
+ 
		default:
+ 
			usage_install();
+ 
			return (EX_USAGE);

		}

	}

	argc -= optind;
modified pkg/main.c
@@ -183,21 +183,21 @@ main(int argc, char **argv)
		usage();



	while ((ch = getopt(argc, argv, "dj:c:vq")) != -1) {
- 
		switch(ch) {
- 
			case 'd':
- 
				debug++;
- 
				break;
- 
			case 'c':
- 
				chroot_path = optarg;
- 
				break;
- 
			case 'j':
- 
				jail_str = optarg;
- 
				break;
- 
			case 'v':
- 
				version++;
- 
				break;
- 
			default:
- 
				break;
+ 
		switch (ch) {
+ 
		case 'd':
+ 
			debug++;
+ 
			break;
+ 
		case 'c':
+ 
			chroot_path = optarg;
+ 
			break;
+ 
		case 'j':
+ 
			jail_str = optarg;
+ 
			break;
+ 
		case 'v':
+ 
			version++;
+ 
			break;
+ 
		default:
+ 
			break;

		}

	}

	argc -= optind;
modified pkg/query.c
@@ -84,201 +84,202 @@ format_str(struct pkg *pkg, struct sbuf *dest, const char *qstr, void *data)
		if (qstr[0] == '%') {

			qstr++;

			switch (qstr[0]) {
- 
				case 'n':
- 
					pkg_get(pkg, PKG_NAME, &tmp);
- 
					if (tmp != NULL)
- 
						sbuf_cat(dest, tmp);
- 
					break;
- 
				case 'v':
- 
					pkg_get(pkg, PKG_VERSION, &tmp);
- 
					if (tmp != NULL)
- 
						sbuf_cat(dest, tmp);
- 
					break;
- 
				case 'o':
- 
					pkg_get(pkg, PKG_ORIGIN, &tmp);
- 
					if (tmp != NULL)
- 
						sbuf_cat(dest, tmp);
- 
					break;
- 
				case 'R':
- 
					pkg_get(pkg, PKG_REPONAME, &tmp);
- 
					if (tmp != NULL)
- 
						sbuf_cat(dest, tmp);
- 
					break;
- 
				case 'p':
- 
					pkg_get(pkg, PKG_PREFIX, &tmp);
- 
					if (tmp != NULL)
- 
						sbuf_cat(dest, tmp);
- 
					break;
- 
				case 'm':
- 
					pkg_get(pkg, PKG_MAINTAINER, &tmp);
- 
					if (tmp != NULL)
- 
						sbuf_cat(dest, tmp);
- 
					break;
- 
				case 'c':
- 
					pkg_get(pkg, PKG_COMMENT, &tmp);
- 
					if (tmp != NULL)
- 
						sbuf_cat(dest, tmp);
- 
					break;
- 
				case 'w':
- 
					pkg_get(pkg, PKG_WWW, &tmp);
- 
					if (tmp != NULL)
- 
						sbuf_cat(dest, tmp);
- 
					break;
- 
				case 'i':
- 
					pkg_get(pkg, PKG_INFOS, &tmp);
- 
					if (tmp != NULL)
- 
						sbuf_cat(dest, tmp);
- 
					break;
- 
				case 'a':
- 
					pkg_get(pkg, PKG_AUTOMATIC, &automatic);
- 
					sbuf_printf(dest, "%d", automatic);
- 
					break;
- 
				case 't':
- 
					pkg_get(pkg, PKG_TIME, &timestamp);
- 
					sbuf_printf(dest, "%" PRId64, timestamp);
- 
					break;
- 
				case 's':
- 
					qstr++;
- 
					pkg_get(pkg, PKG_FLATSIZE, &flatsize);
- 
					if (qstr[0] == 'h') {
- 
						humanize_number(size, sizeof(size), flatsize, "B", HN_AUTOSCALE, 0);
- 
						sbuf_cat(dest, size);
- 
					} else if (qstr[0] == 'b') {
- 
						sbuf_printf(dest, "%" PRId64, flatsize);
- 
					}
- 
					break;
- 
				case '?':
- 
					qstr++;
- 
					switch (qstr[0]) {
- 
						case 'd':
- 
							sbuf_printf(dest, "%d", !pkg_list_is_empty(pkg, PKG_DEPS));
- 
							break;
- 
						case 'r':
- 
							sbuf_printf(dest, "%d", !pkg_list_is_empty(pkg, PKG_RDEPS));
- 
							break;
- 
						case 'C':
- 
							sbuf_printf(dest, "%d", !pkg_list_is_empty(pkg, PKG_CATEGORIES));
- 
							break;
- 
						case 'F':
- 
							sbuf_printf(dest, "%d", !pkg_list_is_empty(pkg, PKG_FILES));
- 
							break;
- 
						case 'O':
- 
							sbuf_printf(dest, "%d", !pkg_list_is_empty(pkg, PKG_OPTIONS));
- 
							break;
- 
						case 'D':
- 
							sbuf_printf(dest, "%d", !pkg_list_is_empty(pkg, PKG_DIRS));
- 
							break;
- 
						case 'L':
- 
							sbuf_printf(dest, "%d", !pkg_list_is_empty(pkg, PKG_LICENSES));
- 
							break;
- 
						case 'U':
- 
							sbuf_printf(dest, "%d", !pkg_list_is_empty(pkg, PKG_USERS));
- 
							break;
- 
						case 'G':
- 
							sbuf_printf(dest, "%d", !pkg_list_is_empty(pkg, PKG_GROUPS));
- 
							break;
- 
						case 'B':
- 
							sbuf_printf(dest, "%d", !pkg_list_is_empty(pkg, PKG_SHLIBS));
- 
							break;
- 
					}
- 
					break;
- 
				case 'l':
- 
					pkg_get(pkg, PKG_LICENSE_LOGIC, &licenselogic);
- 
					switch (licenselogic) {
- 
						case LICENSE_SINGLE:
- 
							sbuf_cat(dest, "single");
- 
							break;
- 
						case LICENSE_OR:
- 
							sbuf_cat(dest, "or");
- 
							break;
- 
						case LICENSE_AND:
- 
							sbuf_cat(dest, "and");
- 
							break;
- 
					}
- 
					break;
+ 
			case 'n':
+ 
				pkg_get(pkg, PKG_NAME, &tmp);
+ 
				if (tmp != NULL)
+ 
					sbuf_cat(dest, tmp);
+ 
				break;
+ 
			case 'v':
+ 
				pkg_get(pkg, PKG_VERSION, &tmp);
+ 
				if (tmp != NULL)
+ 
					sbuf_cat(dest, tmp);
+ 
				break;
+ 
			case 'o':
+ 
				pkg_get(pkg, PKG_ORIGIN, &tmp);
+ 
				if (tmp != NULL)
+ 
					sbuf_cat(dest, tmp);
+ 
				break;
+ 
			case 'R':
+ 
				pkg_get(pkg, PKG_REPONAME, &tmp);
+ 
				if (tmp != NULL)
+ 
					sbuf_cat(dest, tmp);
+ 
				break;
+ 
			case 'p':
+ 
				pkg_get(pkg, PKG_PREFIX, &tmp);
+ 
				if (tmp != NULL)
+ 
					sbuf_cat(dest, tmp);
+ 
				break;
+ 
			case 'm':
+ 
				pkg_get(pkg, PKG_MAINTAINER, &tmp);
+ 
				if (tmp != NULL)
+ 
					sbuf_cat(dest, tmp);
+ 
				break;
+ 
			case 'c':
+ 
				pkg_get(pkg, PKG_COMMENT, &tmp);
+ 
				if (tmp != NULL)
+ 
					sbuf_cat(dest, tmp);
+ 
				break;
+ 
			case 'w':
+ 
				pkg_get(pkg, PKG_WWW, &tmp);
+ 
				if (tmp != NULL)
+ 
					sbuf_cat(dest, tmp);
+ 
				break;
+ 
			case 'i':
+ 
				pkg_get(pkg, PKG_INFOS, &tmp);
+ 
				if (tmp != NULL)
+ 
					sbuf_cat(dest, tmp);
+ 
				break;
+ 
			case 'a':
+ 
				pkg_get(pkg, PKG_AUTOMATIC, &automatic);
+ 
				sbuf_printf(dest, "%d", automatic);
+ 
				break;
+ 
			case 't':
+ 
				pkg_get(pkg, PKG_TIME, &timestamp);
+ 
				sbuf_printf(dest, "%" PRId64, timestamp);
+ 
				break;
+ 
			case 's':
+ 
				qstr++;
+ 
				pkg_get(pkg, PKG_FLATSIZE, &flatsize);
+ 
				if (qstr[0] == 'h') {
+ 
					humanize_number(size, sizeof(size),
+ 
					    flatsize, "B", HN_AUTOSCALE, 0);
+ 
					sbuf_cat(dest, size);
+ 
				} else if (qstr[0] == 'b') {
+ 
					sbuf_printf(dest, "%" PRId64, flatsize);
+ 
				}
+ 
				break;
+ 
			case '?':
+ 
				qstr++;
+ 
				switch (qstr[0]) {

				case 'd':
- 
					qstr++;
- 
					if (qstr[0] == 'n')
- 
						sbuf_cat(dest, pkg_dep_name((struct pkg_dep *)data));
- 
					else if (qstr[0] == 'o')
- 
						sbuf_cat(dest, pkg_dep_origin((struct pkg_dep *)data));
- 
					else if (qstr[0] == 'v')
- 
						sbuf_cat(dest, pkg_dep_version((struct pkg_dep *)data));
+ 
					sbuf_printf(dest, "%d", !pkg_list_is_empty(pkg, PKG_DEPS));

					break;

				case 'r':
- 
					qstr++;
- 
					if (qstr[0] == 'n')
- 
						sbuf_cat(dest, pkg_dep_name((struct pkg_dep *)data));
- 
					else if (qstr[0] == 'o')
- 
						sbuf_cat(dest, pkg_dep_origin((struct pkg_dep *)data));
- 
					else if (qstr[0] == 'v')
- 
						sbuf_cat(dest, pkg_dep_version((struct pkg_dep *)data));
+ 
					sbuf_printf(dest, "%d", !pkg_list_is_empty(pkg, PKG_RDEPS));

					break;

				case 'C':
- 
					sbuf_cat(dest, pkg_category_name((struct pkg_category *)data));
+ 
					sbuf_printf(dest, "%d", !pkg_list_is_empty(pkg, PKG_CATEGORIES));

					break;

				case 'F':
- 
					qstr++;
- 
					if (qstr[0] == 'p')
- 
						sbuf_cat(dest, pkg_file_path((struct pkg_file *)data));
- 
					else if (qstr[0] == 's')
- 
						sbuf_cat(dest, pkg_file_cksum((struct pkg_file *)data));
+ 
					sbuf_printf(dest, "%d", !pkg_list_is_empty(pkg, PKG_FILES));

					break;

				case 'O':
- 
					qstr++;
- 
					if (qstr[0] == 'k')
- 
						sbuf_cat(dest, pkg_option_opt((struct pkg_option *)data));
- 
					else if (qstr[0] == 'v')
- 
						sbuf_cat(dest, pkg_option_value((struct pkg_option *)data));
+ 
					sbuf_printf(dest, "%d", !pkg_list_is_empty(pkg, PKG_OPTIONS));

					break;

				case 'D':
- 
					sbuf_cat(dest, pkg_dir_path((struct pkg_dir *)data));
+ 
					sbuf_printf(dest, "%d", !pkg_list_is_empty(pkg, PKG_DIRS));

					break;

				case 'L':
- 
					sbuf_cat(dest, pkg_license_name((struct pkg_license *)data));
+ 
					sbuf_printf(dest, "%d", !pkg_list_is_empty(pkg, PKG_LICENSES));

					break;

				case 'U':
- 
					sbuf_cat(dest, pkg_user_name((struct pkg_user *)data));
+ 
					sbuf_printf(dest, "%d", !pkg_list_is_empty(pkg, PKG_USERS));

					break;

				case 'G':
- 
					sbuf_cat(dest, pkg_group_name((struct pkg_group *)data));
+ 
					sbuf_printf(dest, "%d", !pkg_list_is_empty(pkg, PKG_GROUPS));

					break;

				case 'B':
- 
					sbuf_cat(dest, pkg_shlib_name((struct pkg_shlib *)data));
+ 
					sbuf_printf(dest, "%d", !pkg_list_is_empty(pkg, PKG_SHLIBS));

					break;
- 
				case 'M':
- 
					pkg_get(pkg, PKG_MESSAGE, &tmp);
- 
					if (tmp != NULL)
- 
						sbuf_cat(dest, tmp);
+ 
				}
+ 
				break;
+ 
			case 'l':
+ 
				pkg_get(pkg, PKG_LICENSE_LOGIC, &licenselogic);
+ 
				switch (licenselogic) {
+ 
				case LICENSE_SINGLE:
+ 
					sbuf_cat(dest, "single");
+ 
					break;
+ 
				case LICENSE_OR:
+ 
					sbuf_cat(dest, "or");

					break;
- 
				case '%':
- 
					sbuf_putc(dest, '%');
+ 
				case LICENSE_AND:
+ 
					sbuf_cat(dest, "and");

					break;
+ 
				}
+ 
				break;
+ 
			case 'd':
+ 
				qstr++;
+ 
				if (qstr[0] == 'n')
+ 
					sbuf_cat(dest, pkg_dep_name((struct pkg_dep *)data));
+ 
				else if (qstr[0] == 'o')
+ 
					sbuf_cat(dest, pkg_dep_origin((struct pkg_dep *)data));
+ 
				else if (qstr[0] == 'v')
+ 
					sbuf_cat(dest, pkg_dep_version((struct pkg_dep *)data));
+ 
				break;
+ 
			case 'r':
+ 
				qstr++;
+ 
				if (qstr[0] == 'n')
+ 
					sbuf_cat(dest, pkg_dep_name((struct pkg_dep *)data));
+ 
				else if (qstr[0] == 'o')
+ 
					sbuf_cat(dest, pkg_dep_origin((struct pkg_dep *)data));
+ 
				else if (qstr[0] == 'v')
+ 
					sbuf_cat(dest, pkg_dep_version((struct pkg_dep *)data));
+ 
				break;
+ 
			case 'C':
+ 
				sbuf_cat(dest, pkg_category_name((struct pkg_category *)data));
+ 
				break;
+ 
			case 'F':
+ 
				qstr++;
+ 
				if (qstr[0] == 'p')
+ 
					sbuf_cat(dest, pkg_file_path((struct pkg_file *)data));
+ 
				else if (qstr[0] == 's')
+ 
					sbuf_cat(dest, pkg_file_cksum((struct pkg_file *)data));
+ 
				break;
+ 
			case 'O':
+ 
				qstr++;
+ 
				if (qstr[0] == 'k')
+ 
					sbuf_cat(dest, pkg_option_opt((struct pkg_option *)data));
+ 
				else if (qstr[0] == 'v')
+ 
					sbuf_cat(dest, pkg_option_value((struct pkg_option *)data));
+ 
				break;
+ 
			case 'D':
+ 
				sbuf_cat(dest, pkg_dir_path((struct pkg_dir *)data));
+ 
				break;
+ 
			case 'L':
+ 
				sbuf_cat(dest, pkg_license_name((struct pkg_license *)data));
+ 
				break;
+ 
			case 'U':
+ 
				sbuf_cat(dest, pkg_user_name((struct pkg_user *)data));
+ 
				break;
+ 
			case 'G':
+ 
				sbuf_cat(dest, pkg_group_name((struct pkg_group *)data));
+ 
				break;
+ 
			case 'B':
+ 
				sbuf_cat(dest, pkg_shlib_name((struct pkg_shlib *)data));
+ 
				break;
+ 
			case 'M':
+ 
				pkg_get(pkg, PKG_MESSAGE, &tmp);
+ 
				if (tmp != NULL)
+ 
					sbuf_cat(dest, tmp);
+ 
				break;
+ 
			case '%':
+ 
				sbuf_putc(dest, '%');
+ 
				break;

			}

		} else  if (qstr[0] == '\\') {

			qstr++;

			switch (qstr[0]) {
- 
				case 'n':
- 
					sbuf_putc(dest, '\n');
- 
					break;
- 
				case 'a':
- 
					sbuf_putc(dest, '\a');
- 
					break;
- 
				case 'b':
- 
					sbuf_putc(dest, '\b');
- 
					break;
- 
				case 'f':
- 
					sbuf_putc(dest, '\f');
- 
					break;
- 
				case 'r':
- 
					sbuf_putc(dest, '\r');
- 
					break;
- 
				case '\\':
- 
					sbuf_putc(dest, '\\');
- 
					break;
- 
				case 't':
- 
					sbuf_putc(dest, '\t');
- 
					break;
+ 
			case 'n':
+ 
				sbuf_putc(dest, '\n');
+ 
				break;
+ 
			case 'a':
+ 
				sbuf_putc(dest, '\a');
+ 
				break;
+ 
			case 'b':
+ 
				sbuf_putc(dest, '\b');
+ 
				break;
+ 
			case 'f':
+ 
				sbuf_putc(dest, '\f');
+ 
				break;
+ 
			case 'r':
+ 
				sbuf_putc(dest, '\r');
+ 
				break;
+ 
			case '\\':
+ 
				sbuf_putc(dest, '\\');
+ 
				break;
+ 
			case 't':
+ 
				sbuf_putc(dest, '\t');
+ 
				break;

			}

		} else {

			sbuf_putc(dest, qstr[0]);
@@ -303,70 +304,70 @@ print_query(struct pkg *pkg, char *qstr, char multiline)
	struct pkg_shlib *shlib = NULL;



	switch (multiline) {
- 
		case 'd':
- 
			while (pkg_deps(pkg, &dep) == EPKG_OK) {
- 
				format_str(pkg, output, qstr, dep);
- 
				printf("%s\n", sbuf_data(output));
- 
				break;
- 
		}
- 
		case 'r':
- 
			while (pkg_rdeps(pkg, &dep) == EPKG_OK) {
- 
				format_str(pkg, output, qstr, dep);
- 
				printf("%s\n", sbuf_data(output));
- 
			}
- 
			break;
- 
		case 'C':
- 
			while (pkg_categories(pkg, &cat) == EPKG_OK) {
- 
				format_str(pkg, output, qstr, cat);
- 
				printf("%s\n", sbuf_data(output));
- 
			}
- 
			break;
- 
		case 'O':
- 
			while (pkg_options(pkg, &option) == EPKG_OK) {
- 
				format_str(pkg, output, qstr, option);
- 
				printf("%s\n", sbuf_data(output));
- 
			}
- 
			break;
- 
		case 'F':
- 
			while (pkg_files(pkg, &file) == EPKG_OK) {
- 
				format_str(pkg, output, qstr, file);
- 
				printf("%s\n", sbuf_data(output));
- 
			}
- 
			break;
- 
		case 'D':
- 
			while (pkg_dirs(pkg, &dir) == EPKG_OK) {
- 
				format_str(pkg, output, qstr, dir);
- 
				printf("%s\n", sbuf_data(output));
- 
			}
- 
			break;
- 
		case 'L':
- 
			while (pkg_licenses(pkg, &lic) == EPKG_OK) {
- 
				format_str(pkg, output, qstr, lic);
- 
				printf("%s\n", sbuf_data(output));
- 
			}
- 
			break;
- 
		case 'U':
- 
			while (pkg_users(pkg, &user) == EPKG_OK) {
- 
				format_str(pkg, output, qstr, user);
- 
				printf("%s\n", sbuf_data(output));
- 
			}
- 
			break;
- 
		case 'G':
- 
			while (pkg_groups(pkg, &group) == EPKG_OK) {
- 
				format_str(pkg, output, qstr, group);
- 
				printf("%s\n", sbuf_data(output));
- 
			}
- 
			break;
- 
		case 'B':
- 
			while (pkg_shlibs(pkg, &shlib) == EPKG_OK) {
- 
				format_str(pkg, output, qstr, shlib);
- 
				printf("%s\n", sbuf_data(output));
- 
			}
- 
			break;
- 
		default:
+ 
	case 'd':
+ 
		while (pkg_deps(pkg, &dep) == EPKG_OK) {

			format_str(pkg, output, qstr, dep);

			printf("%s\n", sbuf_data(output));

			break;
+ 
		}
+ 
	case 'r':
+ 
		while (pkg_rdeps(pkg, &dep) == EPKG_OK) {
+ 
			format_str(pkg, output, qstr, dep);
+ 
			printf("%s\n", sbuf_data(output));
+ 
		}
+ 
		break;
+ 
	case 'C':
+ 
		while (pkg_categories(pkg, &cat) == EPKG_OK) {
+ 
			format_str(pkg, output, qstr, cat);
+ 
			printf("%s\n", sbuf_data(output));
+ 
		}
+ 
		break;
+ 
	case 'O':
+ 
		while (pkg_options(pkg, &option) == EPKG_OK) {
+ 
			format_str(pkg, output, qstr, option);
+ 
			printf("%s\n", sbuf_data(output));
+ 
		}
+ 
		break;
+ 
	case 'F':
+ 
		while (pkg_files(pkg, &file) == EPKG_OK) {
+ 
			format_str(pkg, output, qstr, file);
+ 
			printf("%s\n", sbuf_data(output));
+ 
		}
+ 
		break;
+ 
	case 'D':
+ 
		while (pkg_dirs(pkg, &dir) == EPKG_OK) {
+ 
			format_str(pkg, output, qstr, dir);
+ 
			printf("%s\n", sbuf_data(output));
+ 
		}
+ 
		break;
+ 
	case 'L':
+ 
		while (pkg_licenses(pkg, &lic) == EPKG_OK) {
+ 
			format_str(pkg, output, qstr, lic);
+ 
			printf("%s\n", sbuf_data(output));
+ 
		}
+ 
		break;
+ 
	case 'U':
+ 
		while (pkg_users(pkg, &user) == EPKG_OK) {
+ 
			format_str(pkg, output, qstr, user);
+ 
			printf("%s\n", sbuf_data(output));
+ 
		}
+ 
		break;
+ 
	case 'G':
+ 
		while (pkg_groups(pkg, &group) == EPKG_OK) {
+ 
			format_str(pkg, output, qstr, group);
+ 
			printf("%s\n", sbuf_data(output));
+ 
		}
+ 
		break;
+ 
	case 'B':
+ 
		while (pkg_shlibs(pkg, &shlib) == EPKG_OK) {
+ 
			format_str(pkg, output, qstr, shlib);
+ 
			printf("%s\n", sbuf_data(output));
+ 
		}
+ 
		break;
+ 
	default:
+ 
		format_str(pkg, output, qstr, dep);
+ 
		printf("%s\n", sbuf_data(output));
+ 
		break;

	}

	sbuf_delete(output);

}
@@ -396,160 +397,160 @@ format_sql_condition(const char *str, struct sbuf *sqlcond, bool for_remote)
			if (str[0] == '%') {

				str++;

				switch (str[0]) {
- 
					case 'n':
- 
						sbuf_cat(sqlcond, "name");
- 
						state = OPERATOR_STRING;
- 
						break;
- 
					case 'o':
- 
						sbuf_cat(sqlcond, "origin");
- 
						state = OPERATOR_STRING;
- 
						break;
- 
					case 'p':
- 
						sbuf_cat(sqlcond, "prefix");
- 
						state = OPERATOR_STRING;
- 
						break;
- 
					case 'm':
- 
						sbuf_cat(sqlcond, "maintainer");
- 
						state = OPERATOR_STRING;
- 
						break;
- 
					case 'c':
- 
						sbuf_cat(sqlcond, "comment");
- 
						state = OPERATOR_STRING;
- 
						break;
- 
					case 'w':
- 
						sbuf_cat(sqlcond, "www");
- 
						state = OPERATOR_STRING;
- 
						break;
- 
					case 's':
- 
						sbuf_cat(sqlcond, "flatsize");
- 
						state = OPERATOR_INT;
- 
						break;
- 
					case 'a':
- 
						if (for_remote)
- 
							goto bad_option;
- 
						sbuf_cat(sqlcond, "automatic");
- 
						state = OPERATOR_INT;
- 
						break;
- 
					case 'M':
- 
						if (for_remote)
- 
							goto bad_option;
- 
						sbuf_cat(sqlcond, "message");
- 
						state = OPERATOR_STRING;
- 
						break;
- 
					case 'i':
- 
						if (for_remote)
- 
							goto bad_option;
- 
						sbuf_cat(sqlcond, "infos");
- 
						state = OPERATOR_STRING;
- 
						break;
- 
					case 't':
- 
						if (for_remote)
- 
							goto bad_option;
- 
						sbuf_cat(sqlcond, "time");
- 
						state = OPERATOR_INT;
- 
						break;
- 
					case '#':
- 
						str++;
- 
						const char *dbstr = for_remote ? "%1$s." : "";
- 
						switch (str[0]) {
- 
							case 'd':
- 
								sbuf_printf(sqlcond, "(SELECT COUNT(*) FROM %sdeps AS d WHERE d.package_id=p.id)", dbstr);
- 
								break;
- 
							case 'r':
- 
								sbuf_printf(sqlcond, "(SELECT COUNT(*) FROM %sdeps AS d WHERE d.origin=p.origin)", dbstr);
- 
								break;
- 
							case 'C':
- 
								sbuf_printf(sqlcond, "(SELECT COUNT(*) FROM %spkg_categories AS d WHERE d.package_id=p.id)", dbstr);
- 
								break;
- 
							case 'F':
- 
								if (for_remote)
- 
									goto bad_option;
- 
								sbuf_printf(sqlcond, "(SELECT COUNT(*) FROM %sfiles AS d WHERE d.package_id=p.id)", dbstr);
- 
								break;
- 
							case 'O':
- 
								sbuf_printf(sqlcond, "(SELECT COUNT(*) FROM %soptions AS d WHERE d.package_id=p.id)", dbstr);
- 
								break;
- 
							case 'D':
- 
								if (for_remote)
- 
									goto bad_option;
- 
								sbuf_printf(sqlcond, "(SELECT COUNT(*) FROM %spkg_directories AS d WHERE d.package_id=p.id)", dbstr);
- 
								break;
- 
							case 'L':
- 
								sbuf_printf(sqlcond, "(SELECT COUNT(*) FROM %spkg_licenses AS d WHERE d.package_id=p.id)", dbstr);
- 
								break;
- 
							case 'U':
- 
								if (for_remote)
- 
									goto bad_option;
- 
								sbuf_printf(sqlcond, "(SELECT COUNT(*) FROM %spkg_users AS d WHERE d.package_id=p.id)", dbstr);
- 
								break;
- 
							case 'G':
- 
								if (for_remote)
- 
									goto bad_option;
- 
								sbuf_printf(sqlcond, "(SELECT COUNT(*) FROM %spkg_groups AS d WHERE d.package_id=p.id)", dbstr);
- 
								break;
- 
							case 'B':
- 
								sbuf_printf(sqlcond, "(SELECT COUNT(*) FROM %spkg_shlibs AS d WHERE d.package_id=p.id)", dbstr);
- 
								break;
- 
							default:
+ 
				case 'n':
+ 
					sbuf_cat(sqlcond, "name");
+ 
					state = OPERATOR_STRING;
+ 
					break;
+ 
				case 'o':
+ 
					sbuf_cat(sqlcond, "origin");
+ 
					state = OPERATOR_STRING;
+ 
					break;
+ 
				case 'p':
+ 
					sbuf_cat(sqlcond, "prefix");
+ 
					state = OPERATOR_STRING;
+ 
					break;
+ 
				case 'm':
+ 
					sbuf_cat(sqlcond, "maintainer");
+ 
					state = OPERATOR_STRING;
+ 
					break;
+ 
				case 'c':
+ 
					sbuf_cat(sqlcond, "comment");
+ 
					state = OPERATOR_STRING;
+ 
					break;
+ 
				case 'w':
+ 
					sbuf_cat(sqlcond, "www");
+ 
					state = OPERATOR_STRING;
+ 
					break;
+ 
				case 's':
+ 
					sbuf_cat(sqlcond, "flatsize");
+ 
					state = OPERATOR_INT;
+ 
					break;
+ 
				case 'a':
+ 
					if (for_remote)
+ 
						goto bad_option;
+ 
					sbuf_cat(sqlcond, "automatic");
+ 
					state = OPERATOR_INT;
+ 
					break;
+ 
				case 'M':
+ 
					if (for_remote)
+ 
						goto bad_option;
+ 
					sbuf_cat(sqlcond, "message");
+ 
					state = OPERATOR_STRING;
+ 
					break;
+ 
				case 'i':
+ 
					if (for_remote)
+ 
						goto bad_option;
+ 
					sbuf_cat(sqlcond, "infos");
+ 
					state = OPERATOR_STRING;
+ 
					break;
+ 
				case 't':
+ 
					if (for_remote)
+ 
						goto bad_option;
+ 
					sbuf_cat(sqlcond, "time");
+ 
					state = OPERATOR_INT;
+ 
					break;
+ 
				case '#':
+ 
					str++;
+ 
					const char *dbstr = for_remote ? "%1$s." : "";
+ 
					switch (str[0]) {
+ 
						case 'd':
+ 
							sbuf_printf(sqlcond, "(SELECT COUNT(*) FROM %sdeps AS d WHERE d.package_id=p.id)", dbstr);
+ 
							break;
+ 
						case 'r':
+ 
							sbuf_printf(sqlcond, "(SELECT COUNT(*) FROM %sdeps AS d WHERE d.origin=p.origin)", dbstr);
+ 
							break;
+ 
						case 'C':
+ 
							sbuf_printf(sqlcond, "(SELECT COUNT(*) FROM %spkg_categories AS d WHERE d.package_id=p.id)", dbstr);
+ 
							break;
+ 
						case 'F':
+ 
							if (for_remote)

								goto bad_option;
- 
						}
- 
						state = OPERATOR_INT;
- 
						break;
- 
					default:
+ 
							sbuf_printf(sqlcond, "(SELECT COUNT(*) FROM %sfiles AS d WHERE d.package_id=p.id)", dbstr);
+ 
							break;
+ 
						case 'O':
+ 
							sbuf_printf(sqlcond, "(SELECT COUNT(*) FROM %soptions AS d WHERE d.package_id=p.id)", dbstr);
+ 
							break;
+ 
						case 'D':
+ 
							if (for_remote)
+ 
								goto bad_option;
+ 
							sbuf_printf(sqlcond, "(SELECT COUNT(*) FROM %spkg_directories AS d WHERE d.package_id=p.id)", dbstr);
+ 
							break;
+ 
						case 'L':
+ 
							sbuf_printf(sqlcond, "(SELECT COUNT(*) FROM %spkg_licenses AS d WHERE d.package_id=p.id)", dbstr);
+ 
							break;
+ 
						case 'U':
+ 
							if (for_remote)
+ 
								goto bad_option;
+ 
							sbuf_printf(sqlcond, "(SELECT COUNT(*) FROM %spkg_users AS d WHERE d.package_id=p.id)", dbstr);
+ 
							break;
+ 
						case 'G':
+ 
							if (for_remote)
+ 
								goto bad_option;
+ 
							sbuf_printf(sqlcond, "(SELECT COUNT(*) FROM %spkg_groups AS d WHERE d.package_id=p.id)", dbstr);
+ 
							break;
+ 
						case 'B':
+ 
							sbuf_printf(sqlcond, "(SELECT COUNT(*) FROM %spkg_shlibs AS d WHERE d.package_id=p.id)", dbstr);
+ 
							break;
+ 
						default:
+ 
							goto bad_option;
+ 
					}
+ 
					state = OPERATOR_INT;
+ 
					break;
+ 
				default:

bad_option:
- 
						fprintf(stderr, "malformed evaluation string\n");
- 
						return (EPKG_FATAL);
+ 
					fprintf(stderr, "malformed evaluation string\n");
+ 
					return (EPKG_FATAL);

				}

			} else {

				switch (str[0]) {
- 
					case '(':
- 
						bracket_level++;
- 
						sbuf_putc(sqlcond, str[0]);
- 
						break;
- 
					case ' ':
- 
					case '\t':
- 
						break;
- 
					default:
- 
						fprintf(stderr, "unexpected character: %c\n", str[0]);
- 
						return (EPKG_FATAL);
- 
				}
- 
			}
- 
		} else if (state == POST_EXPR) {
- 
			switch (str[0]) {
- 
				case ')':
- 
					if (bracket_level == 0) {
- 
						fprintf(stderr, "too many closing brackets.\n");
- 
						return (EPKG_FATAL);
- 
					}
- 
					bracket_level--;
+ 
				case '(':
+ 
					bracket_level++;

					sbuf_putc(sqlcond, str[0]);

					break;

				case ' ':

				case '\t':

					break;
- 
				case '|':
- 
					if (str[1] == '|') {
- 
						str++;
- 
						state = NONE;
- 
						sbuf_cat(sqlcond, " OR ");
- 
						break;
- 
					} else {
- 
						fprintf(stderr, "unexpected character %c\n", str[1]);
- 
						return (EPKG_FATAL);
- 
					}
- 
				case '&':
- 
					if (str[1] == '&') {
- 
						str++;
- 
						state = NONE;
- 
						sbuf_cat(sqlcond, " AND ");
- 
						break;
- 
					} else {
- 
						fprintf(stderr, "unexpected character %c\n", str[1]);
- 
						return (EPKG_FATAL);
- 
					}

				default:
- 
					fprintf(stderr, "unexpected character %c\n", str[0]);
+ 
					fprintf(stderr, "unexpected character: %c\n", str[0]);

					return (EPKG_FATAL);
+ 
				}
+ 
			}
+ 
		} else if (state == POST_EXPR) {
+ 
			switch (str[0]) {
+ 
			case ')':
+ 
				if (bracket_level == 0) {
+ 
					fprintf(stderr, "too many closing brackets.\n");
+ 
					return (EPKG_FATAL);
+ 
				}
+ 
				bracket_level--;
+ 
				sbuf_putc(sqlcond, str[0]);
+ 
				break;
+ 
			case ' ':
+ 
			case '\t':
+ 
				break;
+ 
			case '|':
+ 
				if (str[1] == '|') {
+ 
					str++;
+ 
					state = NONE;
+ 
					sbuf_cat(sqlcond, " OR ");
+ 
					break;
+ 
				} else {
+ 
					fprintf(stderr, "unexpected character %c\n", str[1]);
+ 
					return (EPKG_FATAL);
+ 
				}
+ 
			case '&':
+ 
				if (str[1] == '&') {
+ 
					str++;
+ 
					state = NONE;
+ 
					sbuf_cat(sqlcond, " AND ");
+ 
					break;
+ 
				} else {
+ 
					fprintf(stderr, "unexpected character %c\n", str[1]);
+ 
					return (EPKG_FATAL);
+ 
				}
+ 
			default:
+ 
				fprintf(stderr, "unexpected character %c\n", str[0]);
+ 
				return (EPKG_FATAL);

			}

		} else if (state == OPERATOR_STRING || state == OPERATOR_INT) {

			/* only operators or space are allowed here */
@@ -775,28 +776,28 @@ exec_query(int argc, char **argv)


	while ((ch = getopt(argc, argv, "agxXF:e:")) != -1) {

		switch (ch) {
- 
			case 'a':
- 
				match = MATCH_ALL;
- 
				break;
- 
			case 'g':
- 
				match = MATCH_GLOB;
- 
				break;
- 
			case 'x':
- 
				match = MATCH_REGEX;
- 
				break;
- 
			case 'X':
- 
				match = MATCH_EREGEX;
- 
				break;
- 
			case 'F':
- 
				pkgname = optarg;
- 
				break;
- 
			case 'e':
- 
				match = MATCH_CONDITION;
- 
				condition = optarg;
- 
				break;
- 
			default:
- 
				usage_query();
- 
				return (EX_USAGE);
+ 
		case 'a':
+ 
			match = MATCH_ALL;
+ 
			break;
+ 
		case 'g':
+ 
			match = MATCH_GLOB;
+ 
			break;
+ 
		case 'x':
+ 
			match = MATCH_REGEX;
+ 
			break;
+ 
		case 'X':
+ 
			match = MATCH_EREGEX;
+ 
			break;
+ 
		case 'F':
+ 
			pkgname = optarg;
+ 
			break;
+ 
		case 'e':
+ 
			match = MATCH_CONDITION;
+ 
			condition = optarg;
+ 
			break;
+ 
		default:
+ 
			usage_query();
+ 
			return (EX_USAGE);

		}

	}
modified pkg/register.c
@@ -109,29 +109,29 @@ exec_register(int argc, char **argv)
	pkg_new(&pkg, PKG_INSTALLED);

	while ((ch = getopt(argc, argv, "f:m:i:ld")) != -1) {

		switch (ch) {
- 
			case 'f':
- 
				if ((plist = strdup(optarg)) == NULL)
- 
					err(1, "cannot allocate memory");
-
- 
				break;
- 
			case 'm':
- 
				if ((mdir = strdup(optarg)) == NULL)
- 
					err(1, "cannot allocate memory");
- 
				break;
- 
			case 'd':
- 
				pkg_set(pkg, PKG_AUTOMATIC, true);
- 
				break;
- 
			case 'i':
- 
				if ((input_path = strdup(optarg)) == NULL)
- 
					err(1, "cannot allocate memory");
- 
				break;
- 
			case 'l':
- 
				legacy = true;
- 
				break;
- 
			default:
- 
				printf("%c\n", ch);
- 
				usage_register();
- 
				return (EX_USAGE);
+ 
		case 'f':
+ 
			if ((plist = strdup(optarg)) == NULL)
+ 
				err(1, "cannot allocate memory");
+
+ 
			break;
+ 
		case 'm':
+ 
			if ((mdir = strdup(optarg)) == NULL)
+ 
				err(1, "cannot allocate memory");
+ 
			break;
+ 
		case 'd':
+ 
			pkg_set(pkg, PKG_AUTOMATIC, true);
+ 
			break;
+ 
		case 'i':
+ 
			if ((input_path = strdup(optarg)) == NULL)
+ 
				err(1, "cannot allocate memory");
+ 
			break;
+ 
		case 'l':
+ 
			legacy = true;
+ 
			break;
+ 
		default:
+ 
			printf("%c\n", ch);
+ 
			usage_register();
+ 
			return (EX_USAGE);

		}

	}
modified pkg/rquery.c
@@ -94,28 +94,28 @@ exec_rquery(int argc, char **argv)


	while ((ch = getopt(argc, argv, "agxXe:r:")) != -1) {

		switch (ch) {
- 
			case 'a':
- 
				match = MATCH_ALL;
- 
				break;
- 
			case 'g':
- 
				match = MATCH_GLOB;
- 
				break;
- 
			case 'x':
- 
				match = MATCH_REGEX;
- 
				break;
- 
			case 'X':
- 
				match = MATCH_EREGEX;
- 
				break;
- 
			case 'e':
- 
				match = MATCH_CONDITION;
- 
				condition = optarg;
- 
				break;
- 
			case 'r':
- 
				reponame = optarg;
- 
				break;
- 
			default:
- 
				usage_rquery();
- 
				return (EX_USAGE);
+ 
		case 'a':
+ 
			match = MATCH_ALL;
+ 
			break;
+ 
		case 'g':
+ 
			match = MATCH_GLOB;
+ 
			break;
+ 
		case 'x':
+ 
			match = MATCH_REGEX;
+ 
			break;
+ 
		case 'X':
+ 
			match = MATCH_EREGEX;
+ 
			break;
+ 
		case 'e':
+ 
			match = MATCH_CONDITION;
+ 
			condition = optarg;
+ 
			break;
+ 
		case 'r':
+ 
			reponame = optarg;
+ 
			break;
+ 
		default:
+ 
			usage_rquery();
+ 
			return (EX_USAGE);

		}

	}
modified pkg/search.c
@@ -61,49 +61,49 @@ exec_search(int argc, char **argv)


	while ((ch = getopt(argc, argv, "gxXcdr:fDsqop")) != -1) {

		switch (ch) {
- 
			case 'e':
- 
				match = MATCH_EXACT;
- 
				break;
- 
			case 'g':
- 
				match = MATCH_GLOB;
- 
				break;
- 
			case 'x':
- 
				match = MATCH_REGEX;
- 
				break;
- 
			case 'X':
- 
				match = MATCH_EREGEX;
- 
				break;
- 
			case 'c':
- 
				field = FIELD_COMMENT;
- 
				break;
- 
			case 'd':
- 
				field = FIELD_DESC;
- 
				break;
- 
			case 'r':
- 
				reponame = optarg;
- 
			case 'f':
- 
				opt |= INFO_FULL;
- 
				flags |= PKG_LOAD_CATEGORIES|PKG_LOAD_LICENSES|PKG_LOAD_OPTIONS|PKG_LOAD_SHLIBS;
- 
				break;
- 
			case 'D':
- 
				opt |= INFO_PRINT_DEP;
- 
				flags |= PKG_LOAD_DEPS;
- 
				break;
- 
			case 's':
- 
				opt |= INFO_SIZE;
- 
				break;
- 
			case 'q':
- 
				opt |= INFO_QUIET;
- 
				break;
- 
			case 'o':
- 
				opt |= INFO_ORIGIN;
- 
				break;
- 
			case 'p':
- 
				opt |= INFO_PREFIX;
- 
				break;
- 
			default:
- 
				usage_search();
- 
				return (EX_USAGE);
+ 
		case 'e':
+ 
			match = MATCH_EXACT;
+ 
			break;
+ 
		case 'g':
+ 
			match = MATCH_GLOB;
+ 
			break;
+ 
		case 'x':
+ 
			match = MATCH_REGEX;
+ 
			break;
+ 
		case 'X':
+ 
			match = MATCH_EREGEX;
+ 
			break;
+ 
		case 'c':
+ 
			field = FIELD_COMMENT;
+ 
			break;
+ 
		case 'd':
+ 
			field = FIELD_DESC;
+ 
			break;
+ 
		case 'r':
+ 
			reponame = optarg;
+ 
		case 'f':
+ 
			opt |= INFO_FULL;
+ 
			flags |= PKG_LOAD_CATEGORIES|PKG_LOAD_LICENSES|PKG_LOAD_OPTIONS|PKG_LOAD_SHLIBS;
+ 
			break;
+ 
		case 'D':
+ 
			opt |= INFO_PRINT_DEP;
+ 
			flags |= PKG_LOAD_DEPS;
+ 
			break;
+ 
		case 's':
+ 
			opt |= INFO_SIZE;
+ 
			break;
+ 
		case 'q':
+ 
			opt |= INFO_QUIET;
+ 
			break;
+ 
		case 'o':
+ 
			opt |= INFO_ORIGIN;
+ 
			break;
+ 
		case 'p':
+ 
			opt |= INFO_PREFIX;
+ 
			break;
+ 
		default:
+ 
			usage_search();
+ 
			return (EX_USAGE);

		}

	}
modified pkg/set.c
@@ -68,47 +68,53 @@ exec_set(int argc, char **argv)


	while ((ch = getopt(argc, argv, "ayA:kxXgo:")) != -1) {

		switch (ch) {
- 
			case 'y':
- 
				yes_flag = true;
- 
				break;
- 
			case 'a':
- 
				match = MATCH_ALL;
- 
				break;
- 
			case 'x':
- 
				match = MATCH_REGEX;
- 
				break;
- 
			case 'X':
- 
				match = MATCH_EREGEX;
- 
				break;
- 
			case 'g':
- 
				match = MATCH_GLOB;
- 
				break;
- 
			case 'A':
- 
				sets |= AUTOMATIC;
- 
				newautomatic = strtonum(optarg, 0, 1, &errstr);
- 
				if (errstr)
- 
					errx(EX_USAGE, "Wrong value for -A. Expecting 0 or 1, got: %s (%s)", optarg, errstr);
- 
				break;
- 
			case 'o':
- 
				sets |= ORIGIN;
- 
				loads |= PKG_LOAD_DEPS;
- 
				match = MATCH_ALL;
- 
				oldorigin = strdup(optarg);
- 
				neworigin = strrchr(oldorigin, ':');
- 
				if (neworigin == NULL) {
- 
					free(oldorigin);
- 
					errx(EX_USAGE, "Wrong format for -o. Expecting oldorigin:neworigin, got: %s", optarg);
- 
				}
- 
				*neworigin = '\0';
- 
				neworigin++;
- 
				if (strrchr(oldorigin, '/') == NULL || strrchr(neworigin, '/') == NULL) {
- 
					free(oldorigin);
- 
					errx(EX_USAGE, "Bad origin format, got: %s", optarg);
- 
				}
- 
				break;
- 
			default:
- 
				usage_set();
- 
				return (EX_USAGE);
+ 
		case 'y':
+ 
			yes_flag = true;
+ 
			break;
+ 
		case 'a':
+ 
			match = MATCH_ALL;
+ 
			break;
+ 
		case 'x':
+ 
			match = MATCH_REGEX;
+ 
			break;
+ 
		case 'X':
+ 
			match = MATCH_EREGEX;
+ 
			break;
+ 
		case 'g':
+ 
			match = MATCH_GLOB;
+ 
			break;
+ 
		case 'A':
+ 
			sets |= AUTOMATIC;
+ 
			newautomatic = strtonum(optarg, 0, 1, &errstr);
+ 
			if (errstr)
+ 
				errx(EX_USAGE, "Wrong value for -A. "
+ 
				    "Expecting 0 or 1, got: %s (%s)",
+ 
				    optarg, errstr);
+ 
			break;
+ 
		case 'o':
+ 
			sets |= ORIGIN;
+ 
			loads |= PKG_LOAD_DEPS;
+ 
			match = MATCH_ALL;
+ 
			oldorigin = strdup(optarg);
+ 
			neworigin = strrchr(oldorigin, ':');
+ 
			if (neworigin == NULL) {
+ 
				free(oldorigin);
+ 
				errx(EX_USAGE, "Wrong format for -o. "
+ 
				    "Expecting oldorigin:neworigin, got: %s",
+ 
				    optarg);
+ 
			}
+ 
			*neworigin = '\0';
+ 
			neworigin++;
+ 
			if (strrchr(oldorigin, '/') == NULL ||
+ 
			    strrchr(neworigin, '/') == NULL) {
+ 
				free(oldorigin);
+ 
				errx(EX_USAGE,
+ 
				    "Bad origin format, got: %s", optarg);
+ 
			}
+ 
			break;
+ 
		default:
+ 
			usage_set();
+ 
			return (EX_USAGE);

		}

	}
modified pkg/update.c
@@ -113,15 +113,15 @@ exec_update(int argc, char **argv)


	while ((ch = getopt(argc, argv, "fq")) != -1) {

		switch (ch) {
- 
			case 'q':
- 
				quiet = true;
- 
				break;
- 
			case 'f':
- 
				force = true;
- 
				break;
- 
			default:
- 
				usage_update();
- 
				return (EX_USAGE);
+ 
		case 'q':
+ 
			quiet = true;
+ 
			break;
+ 
		case 'f':
+ 
			force = true;
+ 
			break;
+ 
		default:
+ 
			usage_update();
+ 
			return (EX_USAGE);

		}

	}

	argc -= optind;
modified pkg/updating.c
@@ -71,15 +71,15 @@ exec_updating(int argc, char **argv)


	while ((ch = getopt(argc, argv, "d:f:")) != -1) {

		switch (ch) {
- 
			case 'd':
- 
				date = optarg;
- 
				break;
- 
			case 'f':
- 
				updatingfile = optarg;
- 
				break;
- 
			default:
- 
				usage_updating();
- 
				return (EX_USAGE);
+ 
		case 'd':
+ 
			date = optarg;
+ 
			break;
+ 
		case 'f':
+ 
			updatingfile = optarg;
+ 
			break;
+ 
		default:
+ 
			usage_updating();
+ 
			return (EX_USAGE);

		}

	}

	argc -= optind;
modified pkg/upgrade.c
@@ -62,25 +62,25 @@ exec_upgrade(int argc, char **argv)


	while ((ch = getopt(argc, argv, "yr:fqL")) != -1) {

		switch (ch) {
- 
			case 'y':
- 
				yes = true;
- 
				break;
- 
			case 'r':
- 
				reponame = optarg;
- 
				break;
- 
			case 'q':
- 
				quiet = true;
- 
				break;
- 
			case 'f':
- 
				all = true;
- 
				break;
- 
			case 'L':
- 
				auto_update = false;
- 
				break;
- 
			default:
- 
				usage_upgrade();
- 
				return (EX_USAGE);
- 
				break; /* NOT REACHED */
+ 
		case 'y':
+ 
			yes = true;
+ 
			break;
+ 
		case 'r':
+ 
			reponame = optarg;
+ 
			break;
+ 
		case 'q':
+ 
			quiet = true;
+ 
			break;
+ 
		case 'f':
+ 
			all = true;
+ 
			break;
+ 
		case 'L':
+ 
			auto_update = false;
+ 
			break;
+ 
		default:
+ 
			usage_upgrade();
+ 
			return (EX_USAGE);
+ 
			break; /* NOT REACHED */

		}

	}

	argc -= optind;
modified pkg/utils.c
@@ -94,24 +94,24 @@ absolutepath(const char *src, char *dest, size_t dest_len) {
		else

			len = strlen(ptr);
- 
		switch(len) {
- 
			case 2:
- 
				if (ptr[0] == '.' && ptr[1] == '.') {
- 
					slash = strrchr(res, '/');
- 
					if (slash != NULL) {
- 
						res_len = slash - res;
- 
						res[res_len] = '\0';
- 
					}
- 
					continue;
+ 
		switch (len) {
+ 
		case 2:
+ 
			if (ptr[0] == '.' && ptr[1] == '.') {
+ 
				slash = strrchr(res, '/');
+ 
				if (slash != NULL) {
+ 
					res_len = slash - res;
+ 
					res[res_len] = '\0';

				}
- 
				break;
- 
			case 1:
- 
				if (ptr[0] == '.')
- 
					continue;
-
- 
				break;
- 
			case 0:

				continue;
+ 
			}
+ 
			break;
+ 
		case 1:
+ 
			if (ptr[0] == '.')
+ 
				continue;
+
+ 
			break;
+ 
		case 0:
+ 
			continue;

		}

		res[res_len++] = '/';

		strlcpy(res + res_len, ptr, res_size);
modified pkg/version.c
@@ -77,18 +77,18 @@ print_version(struct pkg *pkg, const char *source, const char *ver, char limchar
			key = '?';

	} else {

		switch (pkg_version_cmp(version, ver)) {
- 
			case -1:
- 
				key = '<';
- 
				break;
- 
			case 0:
- 
				key = '=';
- 
				break;
- 
			case 1:
- 
				key = '>';
- 
				break;
- 
			default:
- 
				key = '!';
- 
				break;
+ 
		case -1:
+ 
			key = '<';
+ 
			break;
+ 
		case 0:
+ 
			key = '=';
+ 
			break;
+ 
		case 1:
+ 
			key = '>';
+ 
			break;
+ 
		default:
+ 
			key = '!';
+ 
			break;

		}

	}
@@ -107,7 +107,7 @@ print_version(struct pkg *pkg, const char *source, const char *ver, char limchar
	free(namever);



	if (opt & VERSION_VERBOSE) {
- 
		switch(key) {
+ 
		switch (key) {

		case '<':

			printf("   needs updating (%s has %s)", source, ver);

			break;
@@ -159,54 +159,54 @@ exec_version(int argc, char **argv)


	while ((ch = getopt(argc, argv, "hIoqvl:L:X:x:g:e:OtT")) != -1) {

		switch (ch) {
- 
			case 'h':
- 
				usage_version();
- 
				return (EX_OK);
- 
			case 'I':
- 
				opt |= VERSION_INDEX;
- 
				break;
- 
			case 'o':
- 
				opt |= VERSION_ORIGIN;
- 
				break;
- 
			case 'q':
- 
				opt |= VERSION_QUIET;
- 
				break;
- 
			case 'v':
- 
				opt |= VERSION_VERBOSE;
- 
				break;
- 
			case 'l':
- 
				opt |= VERSION_STATUS;
- 
				limchar = *optarg;
- 
				break;
- 
			case 'L':
- 
				opt |= VERSION_NOSTATUS;
- 
				limchar = *optarg;
- 
				break;
- 
			case 'X':
- 
				match = MATCH_EREGEX;
- 
				pattern = optarg;
- 
				break;
- 
			case 'x':
- 
				match = MATCH_REGEX;
- 
				pattern = optarg;
- 
				break;
- 
			case 'g':
- 
				match = MATCH_GLOB;
- 
				pattern = optarg;
- 
				break;
- 
			case 'e':
- 
				match = MATCH_EXACT;
- 
				pattern = optarg;
- 
				break;
- 
			case 'O':
- 
				opt |= VERSION_WITHORIGIN;
- 
				break;
- 
			case 't':
- 
				opt |= VERSION_TESTVERSION;
- 
				break;
- 
			case 'T':
- 
				opt |= VERSION_TESTPATTERN;
- 
				break;
+ 
		case 'h':
+ 
			usage_version();
+ 
			return (EX_OK);
+ 
		case 'I':
+ 
			opt |= VERSION_INDEX;
+ 
			break;
+ 
		case 'o':
+ 
			opt |= VERSION_ORIGIN;
+ 
			break;
+ 
		case 'q':
+ 
			opt |= VERSION_QUIET;
+ 
			break;
+ 
		case 'v':
+ 
			opt |= VERSION_VERBOSE;
+ 
			break;
+ 
		case 'l':
+ 
			opt |= VERSION_STATUS;
+ 
			limchar = *optarg;
+ 
			break;
+ 
		case 'L':
+ 
			opt |= VERSION_NOSTATUS;
+ 
			limchar = *optarg;
+ 
			break;
+ 
		case 'X':
+ 
			match = MATCH_EREGEX;
+ 
			pattern = optarg;
+ 
			break;
+ 
		case 'x':
+ 
			match = MATCH_REGEX;
+ 
			pattern = optarg;
+ 
			break;
+ 
		case 'g':
+ 
			match = MATCH_GLOB;
+ 
			pattern = optarg;
+ 
			break;
+ 
		case 'e':
+ 
			match = MATCH_EXACT;
+ 
			pattern = optarg;
+ 
			break;
+ 
		case 'O':
+ 
			opt |= VERSION_WITHORIGIN;
+ 
			break;
+ 
		case 't':
+ 
			opt |= VERSION_TESTVERSION;
+ 
			break;
+ 
		case 'T':
+ 
			opt |= VERSION_TESTPATTERN;
+ 
			break;

		}

	}

	argc -= optind;
@@ -232,15 +232,15 @@ exec_version(int argc, char **argv)
	

	} else if (opt == VERSION_TESTVERSION) {

		switch (pkg_version_cmp(argv[0], argv[1])) {
- 
			case -1:
- 
				printf("<\n");
- 
				break;
- 
			case 0:
- 
				printf("=\n");
- 
				break;
- 
			case 1:
- 
				printf(">\n");
- 
				break;
+ 
		case -1:
+ 
			printf("<\n");
+ 
			break;
+ 
		case 0:
+ 
			printf("=\n");
+ 
			break;
+ 
		case 1:
+ 
			printf(">\n");
+ 
			break;

		}

	} else if (opt & VERSION_INDEX) {

		uname(&u);
modified pkg/which.c
@@ -57,12 +57,12 @@ exec_which(int argc, char **argv)


	while ((ch = getopt(argc, argv, "qo")) != -1) {

		switch (ch) {
- 
			case 'q':
- 
				quiet = true;
- 
				break;
- 
			case 'o':
- 
				orig = true;
- 
				break;
+ 
		case 'q':
+ 
			quiet = true;
+ 
			break;
+ 
		case 'o':
+ 
			orig = true;
+ 
			break;

		}

	}