Radish alpha
H
HardenedBSD-pkg
rad:z3QDZAW2FAfuLvihrhiyDC9fAD8G9
HardenedBSD Package Manager
Radicle
Git
Commits › 96a2e4e
Merge branch 'pkg_printf'
Matthew Seaman committed 12 years ago
commit 96a2e4eced4261a200b40eddee776484e5dbc8eb
parent cf78eab
8 files changed +131 -120
modified libpkg/pkg.h.in
@@ -1377,6 +1377,7 @@ int pkg_repos(struct pkg_repo **);
const char *pkg_repo_url(struct pkg_repo *r);

const char *pkg_repo_ident(struct pkg_repo *r);

const char *pkg_repo_name(struct pkg_repo *r);
+ 
const char * pkg_repo_ident_from_name(const char *repo_name);

const char *pkg_repo_key(struct pkg_repo *r);

bool pkg_repo_enabled(struct pkg_repo *r);

mirror_t pkg_repo_mirror_type(struct pkg_repo *r);
modified libpkg/pkg_config.c
@@ -1211,6 +1211,13 @@ pkg_repo_ident(struct pkg_repo *r)
	return (r->name + strlen(REPO_NAME_PREFIX));

}
+ 
/* Ditto: The repo identifier from pkg.conf(5): without the 'repo-' prefix */
+ 
const char *
+ 
pkg_repo_ident_from_name(const char *repo_name)
+ 
{
+ 
	return (repo_name + strlen(REPO_NAME_PREFIX));
+ 
}
+ 


/* The basename of the sqlite DB file and the database name */

const char *

pkg_repo_name(struct pkg_repo *r)
modified libpkg/pkg_printf.3
@@ -30,7 +30,7 @@
.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

.\" SUCH DAMAGE.

.\"
- 
.Dd June 8, 2013
+ 
.Dd June 9, 2013

.Dt PKG_PRINTF 3

.Os

.Sh NAME
@@ -478,13 +478,13 @@ Annotation tag name [string]
Annotation value [string]

.Vt struct pkg_note *

.It Cm \^%B
- 
Shared libraries [array]
+ 
Required shared libraries [array]

.Vt struct pkg *

.Pp

Default row format:

.Cm "%B%{%Bn\en%|%}"

.It Cm %Bn
- 
Shared library name [string]
+ 
Required shared library name [string]

.Vt struct pkg_shlib *

.It Cm %C

Categories [array]
@@ -583,6 +583,9 @@ Licence name [string]
.It Cm %M

Package message [string]

.Vt struct pkg *
+ 
.It Cm %N
+ 
Repository identity [string]
+ 
.Vt struct pkg *

.It Cm \^%O

Options [array]

.Vt struct pkg *
@@ -637,6 +640,15 @@ replaced by another.
.It Cm %a

Autoremove flag [boolean]

.Vt struct pkg *
+ 
.It Cm \^%b
+ 
Provided shared libraries [array]
+ 
.Vt struct pkg *
+ 
.Pp
+ 
Default row format:
+ 
.Cm "%b%{%bn\en%|%}"
+ 
.It Cm %bn
+ 
Provided shared library name [string]
+ 
.Vt struct pkg_shlib *

.It Cm %c

Comment [string]

.Vt struct pkg *
modified libpkg/pkg_printf.c
@@ -86,8 +86,7 @@
 * Ln pkg_license  Licence name

 *

 * M  pkg          Message
- 
 *
- 
 * N
+ 
 * N  pkg          Reponame

 *

 * O  pkg          List of options

 * On pkg_option   Option name (key)
@@ -424,6 +423,15 @@ static const struct pkg_printf_fmt fmt[] = {
		PP_ALL,

		&format_message,

	},
+ 
	[PP_PKG_REPO_IDENT] =
+ 
	{
+ 
		'N',
+ 
		'\0',
+ 
		false,
+ 
		true,
+ 
		PP_ALL,
+ 
		&format_repo_ident,
+ 
	},

	[PP_PKG_OPTION_NAME] =

	{

		'O',
@@ -1256,6 +1264,19 @@ format_message(struct sbuf *sbuf, const void *data, struct percent_esc *p)
}



/*
+ 
 * %N -- Repository identity. string.  Accepts field-width, left-align
+ 
 */
+ 
struct sbuf *
+ 
format_repo_ident(struct sbuf *sbuf, const void *data, struct percent_esc *p)
+ 
{
+ 
	const struct pkg	*pkg = data;
+ 
	const char		*reponame;
+
+ 
	pkg_get(pkg, PKG_REPONAME, &reponame);
+ 
	return (string_val(sbuf, pkg_repo_ident_from_name(reponame), p));
+ 
}
+
+ 
/*

 * %O -- Options. list of {option,value} tuples. Optionally accepts

 * following per-field format in %{ %| %}, where %On is replaced by the

 * option name and %Ov by the value.  Default %{%On %Ov\n%|%}
modified libpkg/private/pkg_printf.h
@@ -102,6 +102,7 @@ typedef enum _fmt_code_t {
	PP_PKG_LICENSE_NAME,

	PP_PKG_LICENSES,

	PP_PKG_MESSAGE,
+ 
	PP_PKG_REPO_IDENT,

	PP_PKG_OPTION_NAME,

	PP_PKG_OPTION_VALUE,

	PP_PKG_OPTIONS,
@@ -186,6 +187,7 @@ _static struct sbuf *format_row_counter(struct sbuf *, const void *, struct perc
_static struct sbuf *format_licenses(struct sbuf *, const void *, struct percent_esc *);

_static struct sbuf *format_license_name(struct sbuf *, const void *, struct percent_esc *);

_static struct sbuf *format_message(struct sbuf *, const void *, struct percent_esc *);
+ 
_static struct sbuf *format_repo_ident(struct sbuf *, const void *, struct percent_esc *);

_static struct sbuf *format_options(struct sbuf *, const void *, struct percent_esc *);

_static struct sbuf *format_option_name(struct sbuf *, const void *, struct percent_esc *);

_static struct sbuf *format_option_value(struct sbuf *, const void *, struct percent_esc *);
modified pkg/query.c
@@ -2,6 +2,7 @@
 * Copyright (c) 2011-2012 Baptiste Daroussin <bapt@FreeBSD.org>

 * Copyright (c) 2011-2012 Marin Atanasov Nikolov <dnaeon@gmail.com>

 * Copyright (c) 2012 Bryan Drewery <bryan@shatow.net>
+ 
 * Copyright (c) 2013 Matthew Seaman <matthew@FreeBSD.org>

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without
@@ -76,12 +77,6 @@ static struct query_flags accepted_query_flags[] = {
static void

format_str(struct pkg *pkg, struct sbuf *dest, const char *qstr, void *data)

{
- 
	char size[7];
- 
	const char *tmp;
- 
	bool tmp2;
- 
	int64_t flatsize;
- 
	int64_t timestamp;
- 
	lic_t licenselogic;



	sbuf_clear(dest);
@@ -90,111 +85,86 @@ format_str(struct pkg *pkg, struct sbuf *dest, const char *qstr, void *data)
			qstr++;

			switch (qstr[0]) {

			case 'n':
- 
				pkg_get(pkg, PKG_NAME, &tmp);
- 
				if (tmp != NULL)
- 
					sbuf_cat(dest, tmp);
+ 
				pkg_sbuf_printf(dest, "%n", pkg);

				break;

			case 'v':
- 
				pkg_get(pkg, PKG_VERSION, &tmp);
- 
				if (tmp != NULL)
- 
					sbuf_cat(dest, tmp);
+ 
				pkg_sbuf_printf(dest, "%v", pkg);

				break;

			case 'o':
- 
				pkg_get(pkg, PKG_ORIGIN, &tmp);
- 
				if (tmp != NULL)
- 
					sbuf_cat(dest, tmp);
+ 
				pkg_sbuf_printf(dest, "%o", pkg);

				break;

			case 'R':
- 
				pkg_get(pkg, PKG_REPONAME, &tmp);
- 
				if (tmp != NULL)
- 
					sbuf_cat(dest, tmp);
+ 
				pkg_sbuf_printf(dest, "%N", pkg);

				break;

			case 'p':
- 
				pkg_get(pkg, PKG_PREFIX, &tmp);
- 
				if (tmp != NULL)
- 
					sbuf_cat(dest, tmp);
+ 
				pkg_sbuf_printf(dest, "%p", pkg);

				break;

			case 'm':
- 
				pkg_get(pkg, PKG_MAINTAINER, &tmp);
- 
				if (tmp != NULL)
- 
					sbuf_cat(dest, tmp);
+ 
				pkg_sbuf_printf(dest, "%m", pkg);

				break;

			case 'c':
- 
				pkg_get(pkg, PKG_COMMENT, &tmp);
- 
				if (tmp != NULL)
- 
					sbuf_cat(dest, tmp);
+ 
				pkg_sbuf_printf(dest, "%c", pkg);

				break;

			case 'w':
- 
				pkg_get(pkg, PKG_WWW, &tmp);
- 
				if (tmp != NULL)
- 
					sbuf_cat(dest, tmp);
+ 
				pkg_sbuf_printf(dest, "%w", pkg);

				break;

			case 'a':
- 
				pkg_get(pkg, PKG_AUTOMATIC, &tmp2);
- 
				sbuf_printf(dest, "%d", tmp2);
+ 
				pkg_sbuf_printf(dest, "%a", pkg);

				break;

			case 'k':
- 
				pkg_get(pkg, PKG_LOCKED, &tmp2);
- 
				sbuf_printf(dest, "%d", tmp2);
+ 
				pkg_sbuf_printf(dest, "%k", pkg);

				break;

			case 't':
- 
				pkg_get(pkg, PKG_TIME, &timestamp);
- 
				sbuf_printf(dest, "%" PRId64, timestamp);
+ 
				pkg_sbuf_printf(dest, "%t", pkg);

				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);
- 
				}
+ 
				if (qstr[0] == 'h')
+ 
					pkg_sbuf_printf(dest, "%?sB", pkg);
+ 
			        else if (qstr[0] == 'b')
+ 
					pkg_sbuf_printf(dest, "%s", pkg);

				break;

			case 'e':
- 
				pkg_get(pkg, PKG_DESC, &tmp);
- 
				if (tmp != NULL)
- 
					sbuf_cat(dest, tmp);
+ 
				pkg_sbuf_printf(dest, "%e", pkg);

				break;

			case '?':

				qstr++;

				switch (qstr[0]) {

				case 'd':
- 
					sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_DEPS) > 0);
+ 
					pkg_sbuf_printf(dest, "%?d", pkg);

					break;

				case 'r':
- 
					sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_RDEPS) > 0);
+ 
					pkg_sbuf_printf(dest, "%?r", pkg);

					break;

				case 'C':
- 
					sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_CATEGORIES) > 0);
+ 
					pkg_sbuf_printf(dest, "%?C", pkg);

					break;

				case 'F':
- 
					sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_FILES) > 0);
+ 
					pkg_sbuf_printf(dest, "%?F", pkg);

					break;

				case 'O':
- 
					sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_OPTIONS) > 0);
+ 
					pkg_sbuf_printf(dest, "%?O", pkg);

					break;

				case 'D':
- 
					sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_DIRS) > 0);
+ 
					pkg_sbuf_printf(dest, "%?D", pkg);

					break;

				case 'L':
- 
					sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_LICENSES) > 0);
+ 
					pkg_sbuf_printf(dest, "%?L", pkg);

					break;

				case 'U':
- 
					sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_USERS) > 0);
+ 
					pkg_sbuf_printf(dest, "%?U", pkg);

					break;

				case 'G':
- 
					sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_GROUPS) > 0);
+ 
					pkg_sbuf_printf(dest, "%?G", pkg);

					break;

				case 'B':
- 
					sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_SHLIBS_REQUIRED) > 0);
+ 
					pkg_sbuf_printf(dest, "%?B", pkg);

					break;

				case 'b':
- 
					sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_SHLIBS_PROVIDED) > 0);
+ 
					pkg_sbuf_printf(dest, "%?b", pkg);

					break;

				case 'A':
- 
					sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_ANNOTATIONS) > 0);
+ 
					pkg_sbuf_printf(dest, "%?A", pkg);

					break;

				}

				break;
@@ -202,119 +172,108 @@ format_str(struct pkg *pkg, struct sbuf *dest, const char *qstr, void *data)
				qstr++;

				switch (qstr[0]) {

				case 'd':
- 
					sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_DEPS));
+ 
					pkg_sbuf_printf(dest, "%#d", pkg);

					break;

				case 'r':
- 
					sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_RDEPS));
+ 
					pkg_sbuf_printf(dest, "%#r", pkg);

					break;

				case 'C':
- 
					sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_CATEGORIES));
+ 
					pkg_sbuf_printf(dest, "%#C", pkg);

					break;

				case 'F':
- 
					sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_FILES));
+ 
					pkg_sbuf_printf(dest, "%#F", pkg);

					break;

				case 'O':
- 
					sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_OPTIONS));
+ 
					pkg_sbuf_printf(dest, "%#O", pkg);

					break;

				case 'D':
- 
					sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_DIRS));
+ 
					pkg_sbuf_printf(dest, "%#D", pkg);

					break;

				case 'L':
- 
					sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_LICENSES));
+ 
					pkg_sbuf_printf(dest, "%#L", pkg);

					break;

				case 'U':
- 
					sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_USERS));
+ 
					pkg_sbuf_printf(dest, "%#U", pkg);

					break;

				case 'G':
- 
					sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_GROUPS));
+ 
					pkg_sbuf_printf(dest, "%#G", pkg);

					break;

				case 'B':
- 
					sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_SHLIBS_REQUIRED));
+ 
					pkg_sbuf_printf(dest, "%#B", pkg);

					break;

				case 'b':
- 
					sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_SHLIBS_PROVIDED));
+ 
					pkg_sbuf_printf(dest, "%#b", pkg);

					break;

				case 'A':
- 
					sbuf_printf(dest, "%d", pkg_list_count(pkg, PKG_ANNOTATIONS));
+ 
					pkg_sbuf_printf(dest, "%#A", pkg);

					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;
- 
				}
+ 
				pkg_sbuf_printf(dest, "%l", pkg);

				break;

			case 'd':

				qstr++;

				if (qstr[0] == 'n')
- 
					sbuf_cat(dest, pkg_dep_name((struct pkg_dep *)data));
+ 
					pkg_sbuf_printf(dest, "%dn", data);

				else if (qstr[0] == 'o')
- 
					sbuf_cat(dest, pkg_dep_origin((struct pkg_dep *)data));
+ 
					pkg_sbuf_printf(dest, "%do", data);

				else if (qstr[0] == 'v')
- 
					sbuf_cat(dest, pkg_dep_version((struct pkg_dep *)data));
+ 
					pkg_sbuf_printf(dest, "%dv", data);

				break;

			case 'r':

				qstr++;

				if (qstr[0] == 'n')
- 
					sbuf_cat(dest, pkg_dep_name((struct pkg_dep *)data));
+ 
					pkg_sbuf_printf(dest, "%rn", data);

				else if (qstr[0] == 'o')
- 
					sbuf_cat(dest, pkg_dep_origin((struct pkg_dep *)data));
+ 
					pkg_sbuf_printf(dest, "%ro", data);

				else if (qstr[0] == 'v')
- 
					sbuf_cat(dest, pkg_dep_version((struct pkg_dep *)data));
+ 
					pkg_sbuf_printf(dest, "%rv", data);

				break;

			case 'C':
- 
				sbuf_cat(dest, pkg_category_name((struct pkg_category *)data));
+ 
				pkg_sbuf_printf(dest, "%Cn", data);

				break;

			case 'F':

				qstr++;

				if (qstr[0] == 'p')
- 
					sbuf_cat(dest, pkg_file_path((struct pkg_file *)data));
+ 
					pkg_sbuf_printf(dest, "%Fn", data);

				else if (qstr[0] == 's')
- 
					sbuf_cat(dest, pkg_file_cksum((struct pkg_file *)data));
+ 
					pkg_sbuf_printf(dest, "%Fs", data);

				break;

			case 'O':

				qstr++;

				if (qstr[0] == 'k')
- 
					sbuf_cat(dest, pkg_option_opt((struct pkg_option *)data));
+ 
					pkg_sbuf_printf(dest, "%On", data);

				else if (qstr[0] == 'v')
- 
					sbuf_cat(dest, pkg_option_value((struct pkg_option *)data));
+ 
					pkg_sbuf_printf(dest, "%Ov", data);

				break;

			case 'D':
- 
				sbuf_cat(dest, pkg_dir_path((struct pkg_dir *)data));
+ 
				pkg_sbuf_printf(dest, "%Dn", data);

				break;

			case 'L':
- 
				sbuf_cat(dest, pkg_license_name((struct pkg_license *)data));
+ 
				pkg_sbuf_printf(dest, "%Ln", data);

				break;

			case 'U':
- 
				sbuf_cat(dest, pkg_user_name((struct pkg_user *)data));
+ 
				pkg_sbuf_printf(dest, "%Un", data);

				break;

			case 'G':
- 
				sbuf_cat(dest, pkg_group_name((struct pkg_group *)data));
+ 
				pkg_sbuf_printf(dest, "%Gn", data);

				break;

			case 'B':
+ 
				pkg_sbuf_printf(dest, "%Bn", data);
+ 
				break;

			case 'b':
- 
				sbuf_cat(dest, pkg_shlib_name((struct pkg_shlib *)data));
+ 
				pkg_sbuf_printf(dest, "%bn", data);

				break;

			case 'A':

				qstr++;

				if (qstr[0] == 't')
- 
					sbuf_cat(dest, pkg_annotation_tag((struct pkg_note *)data));
+ 
					pkg_sbuf_printf(dest, "%An", data);

				else if (qstr[0] == 'v')
- 
					sbuf_cat(dest, pkg_annotation_value((struct pkg_note *)data));
+ 
					pkg_sbuf_printf(dest, "%Av", data);

				break;

			case 'M':
- 
				pkg_get(pkg, PKG_MESSAGE, &tmp);
- 
				if (tmp != NULL)
- 
					sbuf_cat(dest, tmp);
+ 
				pkg_sbuf_printf(dest, "%M", pkg);

				break;

			case '%':

				sbuf_putc(dest, '%');
modified pkg/utils.c
@@ -223,14 +223,13 @@ print_info(struct pkg * const pkg, unsigned int options)
	bool print_tag = false;

	bool show_locks = false;

	char size[7];
- 
	const char *reponame, *repourl;
+ 
	const char *repourl;

	unsigned opt;

	int64_t flatsize, oldflatsize, pkgsize;

	int cout = 0;		/* Number of characters output */

	int info_num;		/* Number of different data items to print */



	pkg_get(pkg,
- 
		PKG_REPONAME,      &reponame,

		PKG_REPOURL,       &repourl,

		PKG_FLATSIZE,      &flatsize,

		PKG_OLD_FLATSIZE,  &oldflatsize,
@@ -331,7 +330,7 @@ print_info(struct pkg * const pkg, unsigned int options)
			    repourl != NULL && repourl[0] != '\0') {

				if (print_tag)

					printf("%-15s: ", "Repository");
- 
				printf("%s [%s]\n", reponame, repourl);
+ 
				pkg_printf("%N [%S]\n", pkg, repourl);

			} else if (!print_tag)

				printf("\n");

			break;
@@ -536,7 +535,7 @@ print_jobs_summary(struct pkg_jobs *jobs, const char *msg, ...)
	struct pkg *pkg = NULL;

	char path[MAXPATHLEN];

	struct stat st;
- 
	const char *oldversion, *cachedir, *why, *reponame;
+ 
	const char *oldversion, *cachedir, *why;

	int64_t dlsize, oldsize, newsize;

	int64_t flatsize, oldflatsize, pkgsize;

	char size[7];
@@ -558,8 +557,7 @@ print_jobs_summary(struct pkg_jobs *jobs, const char *msg, ...)
	while (pkg_jobs(jobs, &pkg) == EPKG_OK) {

		pkg_get(pkg, PKG_OLD_VERSION, &oldversion,

		    PKG_FLATSIZE, &flatsize, PKG_OLD_FLATSIZE, &oldflatsize,
- 
		    PKG_PKGSIZE, &pkgsize, PKG_REASON, &why,
- 
		    PKG_REPONAME, &reponame);
+ 
		    PKG_PKGSIZE, &pkgsize, PKG_REASON, &why);



		if (pkg_is_locked(pkg)) {

			pkg_printf("\tPackage %n-%v is locked ", pkg, pkg);
@@ -599,7 +597,6 @@ print_jobs_summary(struct pkg_jobs *jobs, const char *msg, ...)
		case PKG_JOBS_INSTALL:

		case PKG_JOBS_UPGRADE:

			pkg_snprintf(path, MAXPATHLEN, "%S/%R", cachedir, pkg);
- 
			reponame = pkg_repo_ident(pkg_repo_find_name(reponame));



			if (stat(path, &st) == -1 || pkgsize != st.st_size)

				/* file looks corrupted (wrong size),
@@ -614,13 +611,13 @@ print_jobs_summary(struct pkg_jobs *jobs, const char *msg, ...)
				case PKG_DOWNGRADE:

					pkg_printf("\tDowngrading %n: %V -> %v", pkg, pkg, pkg);

					if (pkg_repos_count() > 1)
- 
						printf(" [%s]", reponame);
+ 
						pkg_printf(" [%N]", pkg);

					printf("\n");

					break;

				case PKG_REINSTALL:

					pkg_printf("\tReinstalling %n-%v", pkg, pkg);

					if (pkg_repos_count() > 1)
- 
						printf(" [%s]", reponame);
+ 
						pkg_printf(" [%N]", pkg);

					if (why != NULL)

						printf(" (%s)", why);

					printf("\n");
@@ -628,7 +625,7 @@ print_jobs_summary(struct pkg_jobs *jobs, const char *msg, ...)
				case PKG_UPGRADE:

					pkg_printf("\tUpgrading %n: %V -> %v", pkg, pkg, pkg);

					if (pkg_repos_count() > 1)
- 
						printf(" [%s]", reponame);
+ 
						pkg_printf(" [%N]", pkg);

					printf("\n");

					break;

				}
@@ -639,7 +636,7 @@ print_jobs_summary(struct pkg_jobs *jobs, const char *msg, ...)


				pkg_printf("\tInstalling %n: %v", pkg, pkg);

				if (pkg_repos_count() > 1)
- 
					printf(" [%s]", reponame);
+ 
					pkg_printf(" [%N]", pkg);

				printf("\n");

			}

			break;
modified tests/lib/pkg_printf_test.c
@@ -1375,6 +1375,7 @@ ATF_TC_BODY(format_code, tc)
		{ "Ln", PP_PKG, PP_PKG_LICENSE_NAME,        2, '\0', },

		{ "L",  PP_PKG, PP_PKG_LICENSES,            1, '\0', },

		{ "M",  PP_PKG, PP_PKG_MESSAGE,             1, '\0', },
+ 
		{ "N",  PP_PKG, PP_PKG_REPO_IDENT,          1, '\0', },

		{ "On", PP_PKG, PP_PKG_OPTION_NAME,         2, '\0', },

		{ "Ov", PP_PKG, PP_PKG_OPTION_VALUE,        2, '\0', },

		{ "O",  PP_PKG, PP_PKG_OPTIONS,             1, '\0', },
@@ -1439,6 +1440,7 @@ ATF_TC_BODY(format_code, tc)
		{ "Ln", PP_B, PP_UNKNOWN,                 0, 'L',  },

		{ "L",  PP_B, PP_UNKNOWN,                 0, 'L',  },

		{ "M",  PP_B, PP_PKG_MESSAGE,             1, '\0', },
+ 
		{ "N",  PP_B, PP_PKG_REPO_IDENT,          1, '\0', },

		{ "On", PP_B, PP_UNKNOWN,                 0, 'O',  },

		{ "Ov", PP_B, PP_UNKNOWN,                 0, 'O',  },

		{ "O",  PP_B, PP_UNKNOWN,                 0, 'O',  },
@@ -1503,6 +1505,7 @@ ATF_TC_BODY(format_code, tc)
		{ "Ln", PP_C, PP_UNKNOWN,                 0, 'L',  },

		{ "L",  PP_C, PP_UNKNOWN,                 0, 'L',  },

		{ "M",  PP_C, PP_PKG_MESSAGE,             1, '\0', },
+ 
		{ "N",  PP_C, PP_PKG_REPO_IDENT,          1, '\0', },

		{ "On", PP_C, PP_UNKNOWN,                 0, 'O',  },

		{ "Ov", PP_C, PP_UNKNOWN,                 0, 'O',  },

		{ "O",  PP_C, PP_UNKNOWN,                 0, 'O',  },
@@ -1567,6 +1570,7 @@ ATF_TC_BODY(format_code, tc)
		{ "Ln", PP_D, PP_UNKNOWN,                 0, 'L',  },

		{ "L",  PP_D, PP_UNKNOWN,                 0, 'L',  },

		{ "M",  PP_D, PP_PKG_MESSAGE,             1, '\0', },
+ 
		{ "N",  PP_D, PP_PKG_REPO_IDENT,          1, '\0', },

		{ "On", PP_D, PP_UNKNOWN,                 0, 'O',  },

		{ "Ov", PP_D, PP_UNKNOWN,                 0, 'O',  },

		{ "O",  PP_D, PP_UNKNOWN,                 0, 'O',  },
@@ -1631,6 +1635,7 @@ ATF_TC_BODY(format_code, tc)
		{ "Ln", PP_F, PP_UNKNOWN,                 0, 'L',  },

		{ "L",  PP_F, PP_UNKNOWN,                 0, 'L',  },

		{ "M",  PP_F, PP_PKG_MESSAGE,             1, '\0', },
+ 
		{ "N",  PP_F, PP_PKG_REPO_IDENT,          1, '\0', },

		{ "On", PP_F, PP_UNKNOWN,                 0, 'O',  },

		{ "Ov", PP_F, PP_UNKNOWN,                 0, 'O',  },

		{ "O",  PP_F, PP_UNKNOWN,                 0, 'O',  },
@@ -1695,6 +1700,7 @@ ATF_TC_BODY(format_code, tc)
		{ "Ln", PP_G, PP_UNKNOWN,                 0, 'L',  },

		{ "L",  PP_G, PP_UNKNOWN,                 0, 'L',  },

		{ "M",  PP_G, PP_PKG_MESSAGE,             1, '\0', },
+ 
		{ "N",  PP_G, PP_PKG_REPO_IDENT,          1, '\0', },

		{ "On", PP_G, PP_UNKNOWN,                 0, 'O',  },

		{ "Ov", PP_G, PP_UNKNOWN,                 0, 'O',  },

		{ "O",  PP_G, PP_UNKNOWN,                 0, 'O',  },
@@ -1759,6 +1765,7 @@ ATF_TC_BODY(format_code, tc)
		{ "Ln", PP_L, PP_PKG_LICENSE_NAME,        2, '\0', },

		{ "L",  PP_L, PP_UNKNOWN,                 0, 'L',  },

		{ "M",  PP_L, PP_PKG_MESSAGE,             1, '\0', },
+ 
		{ "N",  PP_L, PP_PKG_REPO_IDENT,          1, '\0', },

		{ "On", PP_L, PP_UNKNOWN,                 0, 'O',  },

		{ "Ov", PP_L, PP_UNKNOWN,                 0, 'O',  },

		{ "O",  PP_L, PP_UNKNOWN,                 0, 'O',  },
@@ -1823,6 +1830,7 @@ ATF_TC_BODY(format_code, tc)
		{ "Ln", PP_O, PP_UNKNOWN,                 0, 'L',  },

		{ "L",  PP_O, PP_UNKNOWN,                 0, 'L',  },

		{ "M",  PP_O, PP_PKG_MESSAGE,             1, '\0', },
+ 
		{ "N",  PP_O, PP_PKG_REPO_IDENT,          1, '\0', },

		{ "On", PP_O, PP_PKG_OPTION_NAME,         2, '\0', },

		{ "Ov", PP_O, PP_PKG_OPTION_VALUE,        2, '\0', },

		{ "O",  PP_O, PP_UNKNOWN,                 0, 'O',  },
@@ -1887,6 +1895,7 @@ ATF_TC_BODY(format_code, tc)
		{ "Ln", PP_U, PP_UNKNOWN,                 0, 'L',  },

		{ "L",  PP_U, PP_UNKNOWN,                 0, 'L',  },

		{ "M",  PP_U, PP_PKG_MESSAGE,             1, '\0', },
+ 
		{ "N",  PP_U, PP_PKG_REPO_IDENT,          1, '\0', },

		{ "On", PP_U, PP_UNKNOWN,                 0, 'O',  },

		{ "Ov", PP_U, PP_UNKNOWN,                 0, 'O',  },

		{ "O",  PP_U, PP_UNKNOWN,                 0, 'O',  },
@@ -1951,6 +1960,7 @@ ATF_TC_BODY(format_code, tc)
		{ "Ln", PP_b, PP_UNKNOWN,                 0, 'L',  },

		{ "L",  PP_b, PP_UNKNOWN,                 0, 'L',  },

		{ "M",  PP_b, PP_PKG_MESSAGE,             1, '\0', },
+ 
		{ "N",  PP_b, PP_PKG_REPO_IDENT,          1, '\0', },

		{ "On", PP_b, PP_UNKNOWN,                 0, 'O',  },

		{ "Ov", PP_b, PP_UNKNOWN,                 0, 'O',  },

		{ "O",  PP_b, PP_UNKNOWN,                 0, 'O',  },
@@ -2016,6 +2026,7 @@ ATF_TC_BODY(format_code, tc)
		{ "Ln", PP_d, PP_UNKNOWN,                 0, 'L',  },

		{ "L",  PP_d, PP_UNKNOWN,                 0, 'L',  },

		{ "M",  PP_d, PP_PKG_MESSAGE,             1, '\0', },
+ 
		{ "N",  PP_d, PP_PKG_REPO_IDENT,          1, '\0', },

		{ "On", PP_d, PP_UNKNOWN,                 0, 'O',  },

		{ "Ov", PP_d, PP_UNKNOWN,                 0, 'O',  },

		{ "O",  PP_d, PP_UNKNOWN,                 0, 'O',  },
@@ -2080,6 +2091,7 @@ ATF_TC_BODY(format_code, tc)
		{ "Ln", PP_r, PP_UNKNOWN,                 0, 'L',  },

		{ "L",  PP_r, PP_UNKNOWN,                 0, 'L',  },

		{ "M",  PP_r, PP_PKG_MESSAGE,             1, '\0', },
+ 
		{ "N",  PP_r, PP_PKG_REPO_IDENT,          1, '\0', },

		{ "On", PP_r, PP_UNKNOWN,                 0, 'O',  },

		{ "Ov", PP_r, PP_UNKNOWN,                 0, 'O',  },

		{ "O",  PP_r, PP_UNKNOWN,                 0, 'O',  },