fprintf(stderr, "       pkg info [-BDdefgIlOqRrsXx] <pkg-name>\n");

	fprintf(stderr, "       pkg info [-BDdfIlqRrs] -F <pkg-file>\n\n");

	int query_flags;

	unsigned int opt = INFO_TAG_NAMEVER;

	bool pkg_exists = false;

	bool origin_search = false;

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

			origin_search = true;  /* only for ports compat */

			pkg_exists = true;;

			opt |= INFO_MESSAGE;

			opt |= INFO_DEPS;

			break;

		case 'I':

			opt |= INFO_COMMENT;

			opt |= INFO_RDEPS;

			opt |= INFO_FILES;

			opt |= INFO_SHLIBS;

			opt |= INFO_FLATSIZE;

			/* FALLSTHROUGH */

			quiet = true;

		if (origin_search)

	/* When no other data is requested, default is to print

	 * 'name-ver comment' For -O, just print name-ver */

	if (!origin_search && (opt & INFO_ALL) == 0 && match == MATCH_ALL) 

		opt |= INFO_COMMENT;

	/* Special compatibility: handle -O and -q -O */

	if (origin_search) {

		if (quiet) {

			opt = INFO_TAG_NAMEVER;

			quiet = false;

		} else {

			opt = INFO_TAG_NAMEVER|INFO_COMMENT;

		}

	}

		if (!quiet)

		if (origin_search)

		query_flags = info_flags(opt);

			if (pkg_exists)

			if (!quiet)

.Op Fl BDdefgIlOqRrsXx

.Op Fl BDdfIlqRrs

.Dd July 11, 2012

.Nd search package repository catalogues

.Op Fl egxX

.Op Fl r Ar repo

.Op Fl S Ar search

.Op Fl L Ar label

.Op Fl M Ar mod

.Ar pattern

.Op Fl cDdefgopqXx

.Op Fl r Ar repo

is used for searching package repository catalogues.

Packages available for installation can be matched by name, by name

and version, by origin or by text in the package comments or package

descriptions.

The output defaults to displaying the field matched by the search

term, but any of the searchable fields may be displayed.

The output may be modified to additionally show many other package

data available from the repository catalogues.

It is recommended to update the local copies of the repository

catalogues before running

.Nm .

See

.Xr pkg-update 8 .

Package repositories are defined in the

.Fa pkg.conf

file; see

.Xr pkg.conf 5.

.It Fl c

Search for packages with comment text matching

.Ar pattern .

Equivalent to

.Fl "S comment" . 

.It Fl D

Display the list of packages depended on by each matched package.

Equivalent to

.Fl "M depends-on" .

.It Fl d

Search for packages with description text matching

.Ar pattern .

Equivalent to

.Fl "S description" .

should be an exact match against the search field.

.It Fl f

Show ``full'' information about the package.

Equivalent to

.Fl "M full" . 

as a shell globbing expression.

The glob pattern must match the entire field being seached.

.It Fl L Ar label

Select which identifying label is printed for each matched package,

unless

.Fl q

is used.

Several different fields from the repository catalogue database may be

used to search on, or to generate the label, as indicated by the

.Ar label

argument.

See the 

.Qq Sx Search and Label Options

section for details.

If unspecified,

.Ar label

is set to the same as the value searched via the

.Fl S Ar search

option.

.It Fl M Ar mod

Modify the output by adding an additional field to the result.

Multiple fields can be added by using additional

.Fl M Ar mod

flags.  See the

.Qq Sx Output Modifier Options

section for details.

.It Fl o

List packages by origin for each package matching

.Ar pattern .

Equivalent to

.Fl "L origin" .

.It Fl p

Display the package installation prefix for each matched package.

Equivalent to

.Fl "M prefix" . 

.It Fl q

Be ``quiet''.

Produce less output.

In particular don't show an identifying label field for each package.

.It Fl r Ar repo

In multi-repo mode, select only the repository catalogue from

.Sy repo

to search.

By default all known repository catalogues are searched.

.It Fl S Ar search

Specify the field to search the repository catalogue on.

If unspecified, searches on

.Ar pkg-name

unless the search term contains a 

.Sy /

character, when it searches on port

.Ar origin .

Output will be sorted in order of the

.Ar search

field.

See the

.Qq Sx Search and Label Options

sections for more details.

.It Fl s

Display the installed size of matched packages.

Equivalent to

.Fl "M size" . 

Matches any substring of the search field unless explicit beginning

or ending anchor terms are used.

.It Fl x

Treat

as a regular expression.  This is the default.

Matches any substring of the search field unless explicit beginning

or ending anchor terms are used.

.El

.Ss Search and Label Options

The following database fields (or composites of several fields) can

be used both for searching for a match to the given

and as identifying labels for the block of output for each package.

.Bl -tag -width 2n

.It Sy comment

The one line comment field describing the port, derived from the

.Cm COMMENT

variable in the port's

.Fa Makefile .

When chosen as a label option, the output format will additionally

include the packge name, equivalent to

.Fl "L pkg-name"

.Fl "M comment" .

When chosen as a search option, only the

.Sy comment

field is used for sorting the output.

.It Sy description

The multi-line package description from the

.Fa pkg-descr

file in the port.

This does include the

.Cm WWW

URL reference, if any, from that file.

When chosen as a label option, the output format will additionally

include the package name, equivalent to

.Fl "L pkg-name"

.Fl "M description" .

When chosen as a search option, only the

.Sy description

field is used for sorting the output.

.It Sy name

The name of the package, derived from the

.Cm PORTNAME

variable in the port's

.Fa Makefile .

.It Sy origin

The port origin, in the format

.Fa category/port ,

that the package was compiled from.

.It Sy pkg-name

The package name in the format

.Sy name Ns - Ns Cm version .

The same as the

.Cm PKGNAME

variable in the port's

.Fa Makefile .

.Pp

Any unambiguous prefix of the label name may be used on the command line.

Thus

.Fl "Sd" ,

.Fl "S descr"

and

.Fl "S description"

are all equivalent.

.Ss Output Modifier Options

Additional data from the repository catalogue to print for each matched

package.

Multiple output modifiers can be combined.

Where more than one output field is required, either because multiple

.Fl M Ar mod

options were given, or one or more

.Fl M Ar mod

option was combined with the

.Fl "L comment"

or

.Fl "L description"

options, then each output field will be tagged with the field name.

.Bl -tag -width 2n

.It Sy arch

The architecture string indicating what OS version and CPU architecture

the package is suitable for.  For example,

.Ar freebsd:9:x86:64

indicates a package suitable for FreeBSD 9.x running on an amd64 processor,

while

.Ar freebsd:*

indicates an architecture independent package suitable for any version of

FreeBSD.

.It Sy categories

All categories, real and virtual, the underlying package belongs to,

derived from the

.Cm CATEGORIES

variable in the port's

.Fa Makefile .

.It Sy comment

The one line comment field describing the port, derived from the

.Cm COMMENT

variable in the port's

.Fa Makefile .

.It Sy depends-on

The list of packages the named package depends on.

Dependency packages are listed in the format

.Sy name Ns - Ns Cm version

one per line.

If the port has no dependencies, nothing will be output for

this field, including suppressing the tag name when multiple

output fields are requested.

.It Sy description

The multi-line package description from the

.Fa pkg-descr

file in the port.

This does include the

.Cm WWW

URL reference, if any, from that file.

.It Sy full

Show a standard set of fields, equivalent to a combination of the

.Sy name ,

.Sy version ,

.Sy origin ,

.Sy prefix ,

.Sy repository ,

.Sy categories ,

.Sy license ,

.Sy maintainer ,

.Sy www ,

.Sy comment ,

.Sy options ,

.Sy shared-libs ,

.Sy size ,

.Sy pkg-size

and

.Sy descr

fields, in that order.

.It Sy licenses

Displays a list of all the licenses the package is relesed under on a

single line.

Where more than one license applies, indicate if the terms of all

licenses should apply

.Sy (&)

or if one or more licenses may be selected out of those available

.Sy (|) .

.It Sy maintainer

Display the maintainer's e-mail address.

.It Sy name

Display the port name, which is derived from the

.Cm PORTNAME

variable in the port's

.Fa Makefile .

.It Sy options

Displays a list of the port options and their state (

.Sy on

or

.Sy off )

when the package was built.

If the package does not have any options to set, nothing will be

output for this field, including suppressing the tag name when

multiple output fields are requested.

.It Sy pkg-size

Display the size of the compressed package tarball, ie. how much would

need to be downloaded from the repository.

.It Sy prefix

Display the installation prefix for the package, usually

.Fa /usr/local .

.It Sy repository

Displays the repository label and the corresponding base Url for the

repository.

In multi-repo mode, the repository label and URL are one of the pairs

defined in

.Fa pkg.conf .  

In normal mode the label is always ``remote'', and the URL is the

value of

.Cm PACKAGESITE .

.It Sy required-by

Displays all of the packages in the repository that require the named

package as a dependency.

Dependency packages are listed in the format

.Sy name Ns - Ns Cm version

one per line.

If the no other packages require the named package, nothing will be

output for this field, including suppressing the tag name when

multiple output fields are requested.

.It Sy shared-libs

If the package contains dynamically linked FreeBSD ELF binaries,

display a list of all of the shared libraries other than those from

the base system required for those binaries to run.

Shared libraries for foreign (eg. Linux) binaries run

under emulation will not be displayed.

If the package does not require any shared libraries, nothing will be

output for this field including suppressing the tag name when multiple

fields are requested.

.It Sy size

Display the total amount of filesystem space the package files will

take up once unpacked and installed.

.It Sy url

Display the URL that would be used to download the package from the

repository.

.It Sy www

Display the general URL, if any, for the project developing the

software used in the package.

This is extracted from the

.Fa pkg-descr

file in the port. 

.El

.Pp

Any unambiguous prefix of the modifier name may be used on the command

line.

Thus

.Fl "Mm" ,

.Fl "M maint"

and

.Fl "M maintainer"

are all equivalent,

but you need to use at least

.Fl "M si"

and

.Fl "M sh"

to distinguish

.Cm size

from

.Cm shared-libs .

.It Ev PKG_DBDIR

/* These are the fields of the Full output, in order */

#define INFO_NAME	(1<<0)

#define INFO_VERSION	(1<<1)

#define INFO_ORIGIN	(1<<2)

#define INFO_PREFIX	(1<<3)

#define INFO_REPOSITORY	(1<<4)

#define INFO_CATEGORIES	(1<<5)

#define INFO_LICENSES	(1<<6)

#define INFO_MAINTAINER	(1<<7)

#define INFO_WWW	(1<<8)

#define INFO_COMMENT	(1<<9)

#define INFO_OPTIONS	(1<<10)

#define INFO_SHLIBS	(1<<11)

#define INFO_FLATSIZE	(1<<12)

#define INFO_PKGSIZE	(1<<13)

#define INFO_DESCR	(1<<14)

/* Other fields not part of the Full output */

#define INFO_MESSAGE	(1<<15)

#define INFO_DEPS	(1<<16)

#define INFO_RDEPS	(1<<17)

#define INFO_FILES	(1<<18)

#define INFO_DIRS	(1<<19)

#define INFO_USERS	(1<<20)

#define INFO_GROUPS	(1<<21)

#define INFO_ARCH	(1<<22)

#define INFO_REPOURL	(1<<23)

#define INFO_LASTFIELD	INFO_REPOURL

#define INFO_ALL	(((INFO_LASTFIELD) << 1) - 1)

/* Identifying tags */

#define INFO_TAG_NAME		(1<<28)

#define INFO_TAG_ORIGIN		(1<<29)

#define INFO_TAG_NAMEVER	(1<<30)

/* Output YAML format */

#define INFO_RAW	(1<<31)

/* Everything in the 'full' package output */

#define INFO_FULL	(INFO_NAME|INFO_VERSION|INFO_ORIGIN|INFO_PREFIX| \

			 INFO_REPOSITORY|INFO_CATEGORIES|INFO_LICENSES|  \

			 INFO_MAINTAINER|INFO_WWW|INFO_COMMENT|          \

			 INFO_OPTIONS|INFO_SHLIBS|INFO_FLATSIZE|         \

			 INFO_PKGSIZE|INFO_DESCR)

/* Everything that can take more than one line to print */

#define INFO_MULTILINE	(INFO_OPTIONS|INFO_SHLIBS|INFO_DESCR|INFO_MESSAGE| \

			 INFO_DEPS|INFO_RDEPS|INFO_FILES|INFO_DIRS)

int info_flags(unsigned int opt);

void print_jobs_summary(struct pkg_jobs *j, pkg_jobs_t type,

			const char *msg, ...);

int format_sql_condition(const char *str, struct sbuf *sqlcond,

			 bool for_remote);

int analyse_query_string(char *qstr, struct query_flags *q_flags,

			 const unsigned int q_flags_len, int *flags,

			 char *multiline);

#include <err.h>

typedef struct _cliopt {

	const char *option;

	char key;

} cliopt;

/* an option string should not be a prefix of any other option string */ 

static const cliopt search_label[] = {

	{ "comment",     'c'  },

	{ "description", 'd'  },

	{ "name",        'n'  },

	{ "origin",      'o'  },

	{ "pkg-name",    'p'  },

	{ NULL,          '\0' },

};

static const cliopt modifiers[] = {

	{ "arch",         'a'  },

	{ "categories",   'C'  },

	{ "comment",      'c'  },

	{ "depends-on",   'd'  },

	{ "description",  'D'  },

	{ "full",         'f'  },

	{ "licenses",     'l'  },

	{ "maintainer",   'm'  },

	{ "name",         'n'  },

	{ "options",      'o'  },

	{ "pkg-size",	  'P'  },

	{ "prefix",       'p'  },

	{ "repository",   'R'  },

	{ "required-by",  'r'  },

	{ "shared-libs",  'S'  },

	{ "size",         's'  },

	{ "url",          'u'  },

	{ "www",          'w'  },

	{ NULL,           '\0' },

};	

static char

match_optarg(const cliopt *optlist, const char *opt)

{

	int i, matched = -1;

	char key = '\0';

	size_t optlen;

	optlen = strlen(opt);

	/* Match any unique prefix from  optlist */

	for (i = 0; optlist[i].option != NULL; i++) {

		if (strncmp(opt, optlist[i].option, optlen) != 0)

			continue;

		if (matched > 0) {

			warnx("\"%s\" is ambiguous: did you mean "

			      "\"%s\" or \"%s\"?", opt,

			      optlist[matched].option, optlist[i].option);

			key = '\0';

			break;

		}

		matched = i;

		key = optlist[i].key;

	}

	return (key);

}

static pkgdb_field

search_label_opt(const char *optionarg)

{

	pkgdb_field field;

	/* label options */

	switch(match_optarg(search_label, optionarg)) {

	case 'o':

		field = FIELD_ORIGIN;

		break;

	case 'n':

		field = FIELD_NAME;

		break;

	case 'p':

		field = FIELD_NAMEVER;

		break;

	case 'c':

		field = FIELD_COMMENT;

		break;

	case 'd':

		field = FIELD_DESC;

		break;

	default:

		usage_search();

		errx(EX_USAGE, "Unknown search/label option: %s", optionarg);

		/* NOTREACHED */

	}

	return field;

}

static unsigned int

modifier_opt(const char *optionarg)

{

	unsigned int opt;

	/* output modifiers */

	switch(match_optarg(modifiers, optionarg)) {

	case 'a':

		opt = INFO_ARCH;

		break;

	case 'C':

		opt = INFO_CATEGORIES;

		break;

	case 'c':

		opt = INFO_COMMENT;

		break;

	case 'd':

		opt = INFO_DEPS;

		break;

	case 'D':

		opt = INFO_DESCR;

		break;

	case 'f':

		opt = INFO_FULL;

		break;

	case 'l':

		opt = INFO_LICENSES;

		break;

	case 'm':

		opt = INFO_MAINTAINER;

		break;

	case 'n':

		opt = INFO_NAME;

		break;

	case 'o':

		opt = INFO_OPTIONS;

		break;

	case 'P':

		opt = INFO_PKGSIZE;

		break;

	case 'p':

		opt = INFO_PREFIX;

		break;

	case 'R':

		opt = INFO_REPOSITORY;

		break;

	case 'r':

		opt = INFO_RDEPS;

		break;

	case 'S':

		opt = INFO_SHLIBS;

		break;

	case 's':

		opt = INFO_FLATSIZE;

		break;

	case 'u':

		opt = INFO_REPOURL;

		break;

	case 'v':

		opt = INFO_VERSION;

		break;

	case 'w':

		opt = INFO_WWW;

		break;

	default:

		usage_search();

		errx(EX_USAGE, "Unkown modifier option %s", optionarg);

		/* NOTREACHED */

	}

	return opt;

}

	int i, n;

	fprintf(stderr, "usage: pkg search [-egXx] [-r repo] [-S search] "

	    "[-L label] [-M mod]... <pkg-name>\n");

	fprintf(stderr, "       pkg search [-cDdefgopqXx] [-r repo] "

	    "<pattern>\n\n");

	n = fprintf(stderr, "       Search and Label options:");

	for (i = 0; search_label[i].option != NULL; i++) {

		if (n > 72)

			n = fprintf(stderr, "\n            ");

		n += fprintf(stderr, " %s", search_label[i].option);

	}

	fprintf(stderr, "\n");

	n = fprintf(stderr, "       Output Modifiers:");

	for (i = 0; modifiers[i].option != NULL; i++) {

		if (n > 68)

			n = fprintf(stderr, "\n            ");

		n += fprintf(stderr, " %s", modifiers[i].option);

	}

	fprintf(stderr, "\n");

	int flags;

	pkgdb_field search = FIELD_NONE;

	pkgdb_field label = FIELD_NONE;

	while ((ch = getopt(argc, argv, "cDdefgL:M:opqr:S:sXx")) != -1) {

		case 'c':	/* Same as -S comment */

			search = search_label_opt("comment");

			break;

		case 'D':	/* Same as -M depends-on  */

			opt |= modifier_opt("depends-on");

			break;

		case 'd':	/* Same as -S description */

			search = search_label_opt("description");

			break;

		case 'f':	/* Same as -M full */

			opt |= modifier_opt("full");

			break;

		case 'L':

			label = search_label_opt(optarg);

		case 'M':

			opt |= modifier_opt(optarg);

			break;

		case 'o':	/* Same as -L origin */

			label = search_label_opt("origin");

		case 'p':	/* Same as -M prefix */

			opt |= modifier_opt("prefix");

		case 'q':

			quiet = true;

		case 'S':

			search = search_label_opt(optarg);

		case 's':	/* Same as -M size */

			opt |= modifier_opt("size");

		case 'X':

			match = MATCH_EREGEX;

		case 'x':

			match = MATCH_REGEX;

	if (search == FIELD_NONE) {

		if (strchr(pattern, '/') != NULL)

			search = FIELD_ORIGIN;

		else

			search = FIELD_NAMEVER; /* Default search */

	}

	if (label == FIELD_NONE)

		label = search; /* By default, show what was searched  */

	switch(label) {

	case FIELD_NONE:

		break;		/* should never happen */

	case FIELD_ORIGIN:

		opt |= INFO_TAG_ORIGIN;

		break;

	case FIELD_NAME:

		opt |= INFO_TAG_NAME;

		break;

	case FIELD_NAMEVER:

		opt |= INFO_TAG_NAMEVER;

		break;

	case FIELD_COMMENT:

		opt |= INFO_TAG_NAMEVER|INFO_COMMENT;

		break;

	case FIELD_DESC:

		opt |= INFO_TAG_NAMEVER|INFO_DESCR;

		break;

	}

	if ((it = pkgdb_search(db, pattern, match, search, reponame)) ==

	    NULL) {

	flags = info_flags(opt);

	return ((ret == EPKG_OK || ret == EPKG_END) ? EX_OK : EX_SOFTWARE);

 * Copyright (c) 2012 Matthew Seaman <matthew@FreeBSD.org>

	while ((c = getchar()) != '\n' && c != EOF)

/* what the pkg needs to load in order to display the requested info */

int

info_flags(unsigned int opt)

{

	int flags = PKG_LOAD_BASIC;

	if (opt & INFO_CATEGORIES)

		flags |= PKG_LOAD_CATEGORIES;

	if (opt & INFO_LICENSES)

		flags |= PKG_LOAD_LICENSES;

	if (opt & INFO_OPTIONS)

		flags |= PKG_LOAD_OPTIONS;

	if (opt & INFO_SHLIBS)

		flags |= PKG_LOAD_SHLIBS;

	if (opt & INFO_DEPS)

		flags |= PKG_LOAD_DEPS;

	if (opt & INFO_RDEPS)

		flags |= PKG_LOAD_RDEPS;

	if (opt & INFO_FILES)

		flags |= PKG_LOAD_FILES;

	if (opt & INFO_DIRS)

		flags |= PKG_LOAD_DIRS;

	if (opt & INFO_USERS)

		flags |= PKG_LOAD_USERS;

	if (opt & INFO_GROUPS)

		flags |= PKG_LOAD_GROUPS;

	return flags;

}

print_info(struct pkg * const pkg, unsigned int options)

	struct pkg_category *cat    = NULL;

	struct pkg_dep	    *dep    = NULL;

	struct pkg_dir	    *dir    = NULL;

	struct pkg_file	    *file   = NULL;

	struct pkg_group    *group  = NULL;

	struct pkg_license  *lic    = NULL;

	struct pkg_option   *option = NULL;

	struct pkg_shlib    *shlib  = NULL;

	struct pkg_user	    *user   = NULL;

	bool print_tag = false;

	const char *maintainer, *www, *comment, *desc, *message, *arch;

	const char *repopath;

	char *m;

	unsigned opt;

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

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

	pkg_get(pkg,

		PKG_NAME,          &name,

		PKG_VERSION,       &version,

		PKG_PREFIX,        &prefix,

		PKG_ORIGIN,        &origin,

		PKG_REPONAME,      &reponame,

		PKG_REPOURL,       &repourl,

		PKG_MAINTAINER,    &maintainer,

		PKG_WWW,           &www,

		PKG_COMMENT,       &comment,

		PKG_DESC,          &desc,

		PKG_FLATSIZE,      &flatsize,

		PKG_NEW_FLATSIZE,  &newflatsize,

		PKG_NEW_PKGSIZE,   &newpkgsize,

		PKG_LICENSE_LOGIC, &licenselogic,

		PKG_MESSAGE,       &message,

		PKG_ARCH,	   &arch,

		PKG_REPOPATH,	   &repopath);

	if (!multirepos_enabled)

		pkg_config_string(PKG_CONFIG_REPO, &repourl);

	if (options & INFO_RAW) { /* Not for remote packages */

		if (pkg_type(pkg) != PKG_REMOTE) {

			pkg_emit_manifest(pkg, &m);

			printf("%s\n", m);

			free(m);

		return;

	}

	if (!quiet) {

		/* Print a tag-line identifying the package -- either

		   NAMEVER, ORIGIN or NAME (in that order of

		   preference).  This may be the only output from this

		   function */

		if (options & INFO_TAG_NAMEVER)

			cout = printf("%s-%s", name, version);

		else if (options & INFO_TAG_ORIGIN)

			cout = printf("%s", origin);

		else if (options & INFO_TAG_NAME)

			cout = printf("%s", name);

	}

	/* If we printed a tag, and there are no other items to print,

	   then just return now. If there's only one single-line item

	   to print, show it at column 32 on the same line. If there's

	   one multi-line item to print, start a new line. If there is

	   more than one item to print per pkg, use 'key : value'

	   style to show on a new line.  */

	info_num = 0;

	for (opt = 0x1; opt <= INFO_LASTFIELD; opt <<= 1) 

		if ((opt & options) != 0)

			info_num++;

	if (info_num == 0 && cout > 0) {

		return;

	}

	if (info_num == 1) {

		/* Only one item to print */

		print_tag = false;

		if (!quiet) {

			if (options & INFO_MULTILINE)

				printf(":\n");

			else {

				if (cout < 31)

					cout = 31 - cout;

				else

					cout = 1;

				printf("%*s", cout, " ");

			}

	} else {

		/* Several items to print */

		print_tag = true;

		if (!quiet)

			printf("\n");

	}

	for (opt = 0x1; opt <= INFO_LASTFIELD; opt <<= 1) {

		if ((opt & options) == 0)

			continue;

		switch (opt) {

		case INFO_NAME:

			if (print_tag)

				printf("%-15s: ", "Name");

			printf("%s\n", name);

			break;

		case INFO_VERSION:

			if (print_tag)

				printf("%-15s: ", "Version");

			printf("%s\n", version);

			break;

		case INFO_ORIGIN:

			if (print_tag)

				printf("%-15s: ", "Origin");

			printf("%s\n", origin);

			break;

		case INFO_PREFIX:

			if (print_tag)

				printf("%-15s: ", "Prefix");

			printf("%s\n", prefix);

			break;

		case INFO_REPOSITORY:

			if (pkg_type(pkg) == PKG_REMOTE &&

			    repourl != NULL && repourl[0] != '\0') {

				if (print_tag)

					printf("%-15s: ", "Repository");

				printf("%s [%s]\n", reponame, repourl);

			} else if (!print_tag)

				printf("\n");

			break;

		case INFO_CATEGORIES:

			if (!pkg_list_is_empty(pkg, PKG_CATEGORIES)) {

				if (print_tag)

					printf("%-15s: ", "Categories");

				if (pkg_categories(pkg, &cat) == EPKG_OK)

					printf("%s", pkg_category_name(cat));

				while (pkg_categories(pkg, &cat) == EPKG_OK)

					printf(" %s", pkg_category_name(cat));

				printf("\n");

			} else if (!print_tag)

				printf("\n");

			break;

		case INFO_LICENSES:

			if (!pkg_list_is_empty(pkg, PKG_LICENSES)) {

				if (print_tag)

					printf("%-15s: ", "Licenses");

				if (pkg_licenses(pkg, &lic) == EPKG_OK)

					printf("%s", pkg_license_name(lic));

				while (pkg_licenses(pkg, &lic) == EPKG_OK) {

					if (licenselogic != 1)

						printf(" %c", licenselogic);

					printf(" %s", pkg_license_name(lic));

				}

				printf("\n");				

			} else if (!print_tag)

				printf("\n");

			break;

		case INFO_MAINTAINER:

			if (print_tag)

				printf("%-15s: ", "Maintainer");

			printf("%s\n", maintainer);

			break;

		case INFO_WWW:	

			if (print_tag)

				printf("%-15s: ", "WWW");

			printf("%s\n", www);

			break;

		case INFO_COMMENT:

			if (print_tag)

				printf("%-15s: ", "Comment");

			printf("%s\n", comment);

			break;

		case INFO_OPTIONS:

			if (!pkg_list_is_empty(pkg, PKG_OPTIONS)) {

				if (print_tag)

					printf("%-15s:\n", "Options");

				while (pkg_options(pkg, &option) == EPKG_OK)

					printf("\t%-15s: %s\n",

					       pkg_option_opt(option),

					       pkg_option_value(option));

			}

			break;

		case INFO_SHLIBS:

			if (!pkg_list_is_empty(pkg, PKG_SHLIBS)) {

				if (print_tag)

					printf("%-15s:\n", "Shared Libs");

				while (pkg_shlibs(pkg, &shlib) == EPKG_OK)

					printf("\t%s\n", pkg_shlib_name(shlib));

			}

			break;

		case INFO_FLATSIZE:

			if (pkg_type(pkg) == PKG_INSTALLED ||

			    pkg_type(pkg) == PKG_FILE)

				humanize_number(size, sizeof(size),

						flatsize,"B",

						HN_AUTOSCALE, 0);

				humanize_number(size, sizeof(size),

						newflatsize,"B",

						HN_AUTOSCALE, 0);

			if (print_tag)

				printf("%-15s: ", "Flat size");

			printf("%s\n", size);

			break;

		case INFO_PKGSIZE: /* Remote pkgs only */

			if (pkg_type(pkg) == PKG_REMOTE) {

				humanize_number(size, sizeof(size),

						newpkgsize,"B",

						HN_AUTOSCALE, 0);

				if (print_tag)

					printf("%-15s: ", "Pkg size");

				printf("%s\n", size);

			} else if (!print_tag)

				printf("\n");

			break;

		case INFO_DESCR:

			if (print_tag)

				printf("%-15s:\n", "Description");

			printf("%s\n", desc);

			break;

		case INFO_MESSAGE:

			if (message) {

				if (print_tag)

					printf("%-15s:\n", "Message");

				printf("%s\n", message);

			}

			break;

		case INFO_DEPS:

			if (!pkg_list_is_empty(pkg, PKG_DEPS)) {

				if (print_tag)

					printf("%-15s:\n", "Depends on");

				while (pkg_deps(pkg, &dep) == EPKG_OK)

					printf("\t%s-%s\n",

					       pkg_dep_name(dep),

					       pkg_dep_version(dep));

			}

			break;

		case INFO_RDEPS:

			if (!pkg_list_is_empty(pkg, PKG_RDEPS)) {

				if (print_tag)

					printf("%-15s:\n", "Required by");

				while (pkg_rdeps(pkg, &dep) == EPKG_OK)

					printf("\t%s-%s\n",

					       pkg_dep_name(dep),

					       pkg_dep_version(dep));

			}

			break;

		case INFO_FILES: /* Installed pkgs only */

			if (pkg_type(pkg) != PKG_REMOTE &&

			    !pkg_list_is_empty(pkg, PKG_FILES)) {

				if (print_tag)

					printf("%-15s:\n", "Files");

				while (pkg_files(pkg, &file) == EPKG_OK)

					printf("\t%s\n",

					       pkg_file_path(file));

			}

			break;

		case INFO_DIRS:	/* Installed pkgs only */

			if (pkg_type(pkg) != PKG_REMOTE &&

			    !pkg_list_is_empty(pkg, PKG_DIRS)) {

				if (print_tag)

					printf("%-15s:\n", "Directories");

				while (pkg_dirs(pkg, &dir) == EPKG_OK)

					printf("\t%s\n",

					       pkg_dir_path(dir));

			}

			break;

		case INFO_USERS: /* Installed pkgs only */

			if (pkg_type(pkg) != PKG_REMOTE &&

			    !pkg_list_is_empty(pkg, PKG_USERS)) {

				if (print_tag)

					printf("%-15s: ", "Users");

				if (pkg_users(pkg, &user) == EPKG_OK)

					printf("%s", pkg_user_name(user));

				while (pkg_users(pkg, &user) == EPKG_OK)

					printf(" %s", pkg_user_name(user));

				printf("\n");

			}

			break;

		case INFO_GROUPS: /* Installed pkgs only */

			if (pkg_type(pkg) != PKG_REMOTE &&

			    !pkg_list_is_empty(pkg, PKG_GROUPS)) {

				if (print_tag)

					printf("%-15s: ", "Groups");

				if (pkg_groups(pkg, &group) == EPKG_OK)

					printf("%s", pkg_group_name(group));

				while (pkg_groups(pkg, &group) == EPKG_OK)

					printf(" %s", pkg_group_name(group));

				printf("\n");

			}

			break;

		case INFO_ARCH:

			if (print_tag)

				printf("%-15s: ", "Architecture");

			printf("%s\n", arch);

			break;

		case INFO_REPOURL:

			if (pkg_type(pkg) == PKG_REMOTE &&

			    repourl != NULL && repourl[0] != '\0') {

				if (print_tag)

					printf("%-15s: ", "Pkg URL");

				if (repourl[strlen(repourl) -1] == '/')

					printf("%s%s\n", repourl, repopath);

				else

					printf("%s/%s\n", repourl, repopath);

			} else if (!print_tag)

				printf("\n");

			break;

	}