pkg_users;

	pkg_utils_count_spaces;

	pkg_utils_tokenize;

	pkg_vasprintf;

	pkg_vdprintf;

	pkg_version_change;

 */

int pkg_vasprintf(char **ret, const char * restrict format, va_list ap);

bool pkg_has_message(struct pkg *p);

bool pkg_is_locked(const struct pkg * restrict p);

/*

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

 * All rights reserved.

 * 

 * Redistribution and use in source and binary forms, with or without

#include <string.h>

#include <time.h>

#include <utlist.h>

#include "pkg.h"

#include <private/pkg_printf.h>

 *

 * z  pkg          short checksum

 */

struct pkg_printf_fmt {

	char	         fmt_main;

	bool		 has_trailer;

	bool		 struct_pkg; /* or else a sub-type? */

	unsigned	 context;

					struct percent_esc *);

};

 * packages.  Optionally accepts per-field format in %{ %| %} Default

 * %{%An: %Av\n%|%}

 */  

{

	const struct pkg	*pkg = data;

	struct pkg_kv		*kv;

		set_list_defaults(p, "%An: %Av\n", "");

		count = 1;

		LL_FOREACH(pkg->annotations, kv) {

			if (count > 1)

					     kv, count, PP_A);

				     kv, count, PP_A);

			count++;

		}

/*

 * %An -- Annotation tag name.

 */

{

	const struct pkg_kv	*kv = data;

/*

 * %Av -- Annotation value.

 */

{

	const struct pkg_kv	*kv = data;

 * binaries in the pkg.  Optionally accepts per-field format in %{ %|

 * %}.  Default %{%Bn\n%|%}

 */

{

	const struct pkg	*pkg = data;

		set_list_defaults(p, "%Bn\n", "");

		count = 1;

		while (pkg_shlibs_required(pkg, &buffer) == EPKG_OK) {

			if (count > 1)

					     buffer, count, PP_B);

				     buffer, count, PP_B);

			count++;

		}

 * %Bn -- Required Shared Library name or %bn -- Provided Shared

 * Library name

 */

{

	const char	*shlib = data;

 * Optionally accepts per-field format in %{ %| %}, where %n is

 * replaced by the category name.  Default %{%Cn%|, %}

 */

{

	const struct pkg	*pkg = data;

	int			 count = 0;

		set_list_defaults(p, "%Cn", ", ");

		count = 1;

		kh_each_value(pkg->categories, cat, {

			if (count > 1)

				    cat, count, PP_C);

			    count, PP_C);

			count++;

		});

/*

 * %Cn -- Category name.

 */

{

	const char *cat = data;

 * %{ %| %}, where %Dn is replaced by the directory name.  Default

 * %{%Dn\n%|%}

 */

{

	const struct pkg	*pkg = data;

		set_list_defaults(p, "%Dn\n", "");

		count = 1;

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

			if (count > 1)

					     dir, count, PP_D);

				     dir, count, PP_D);

			count++;

		}

/*

 * %Dg -- Directory group. TODO: numeric gid

 */

		       struct percent_esc *p)

{

	const struct pkg_dir	*dir = data;

/*

 * %Dn -- Directory path name.

 */

{

	const struct pkg_dir	*dir = data;

/*

 * %Dp -- Directory permissions.

 */

		       struct percent_esc *p)

{

	const struct pkg_dir	*dir = data;

/*

 * %Du -- Directory user. TODO: numeric UID

 */

		      struct percent_esc *p)

{

	const struct pkg_dir	*dir = data;

 * %}, where %n is replaced by the filename, %s by the checksum, etc.

 * Default %{%Fn\n%|%}

 */

{

	const struct pkg	*pkg = data;

		set_list_defaults(p, "%Fn\n", "");

		count = 1;

		LL_FOREACH(pkg->files, file) {

			if (count > 1)

					     file, count, PP_F);

				     file, count, PP_F);

			count++;

		}

/*

 * %Fg -- File group.

 */

{

	const struct pkg_file	*file = data;

/*

 * %Fn -- File path name.

 */

{

	const struct pkg_file	*file = data;

/*

 * %Fp -- File permissions.

 */

{

	const struct pkg_file	*file = data;

/*

 * %Fs -- File SHA256 Checksum.

 */

{

	const struct pkg_file	*file = data;

/*

 * %Fu -- File user.

 */

{

	const struct pkg_file	*file = data;

 * groupname or %#Gn by the gid -- a line from

 * /etc/group. Default %{%Gn\n%|%}

 */

{

	const struct pkg	*pkg = data;

		set_list_defaults(p, "%Gn\n", "");

		count = 1;

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

			if (count > 1)

					     group, count, PP_G);

				     group, count, PP_G);

			count++;

		}

/*

 * %Gn -- Group name.

 */

{

	const char	*group = data;

/*

 * %I -- Row counter (integer*). Usually used only in per-field format.

 */

{

	const int *counter = data;

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

 * license name and %l by the license logic.  Default %{%n%| %l %}

 */

{

	const struct pkg	*pkg = data;

	char			*lic;

		set_list_defaults(p, "%Ln", " %l ");

		count = 1;

		kh_each_value(pkg->licenses, lic, {

			if (count > 1)

				    lic, count, PP_L);

			    count, PP_L);

			count++;

		});

/*

 * %Ln -- License name.

 */

{

	const char *lic = data;

/*

 * %M -- Pkg message. string.  Accepts field-width, left-align

 */

{

	const struct pkg	*pkg = data;

	struct pkg_message	*msg;

	char			*message;

	LL_FOREACH(pkg->message, msg) {

		switch(msg->type) {

		case PKG_MESSAGE_ALWAYS:

			break;

		case PKG_MESSAGE_UPGRADE:

			if (msg->minimum_version != NULL ||

			    msg->maximum_version != NULL) {

			}

			if (msg->minimum_version != NULL) {

			}

			if (msg->maximum_version != NULL) {

			}

			break;

		case PKG_MESSAGE_INSTALL:

			break;

		case PKG_MESSAGE_REMOVE:

			break;

		}

	}

		message = NULL;

	buf = string_val(buffer, message, p);

	return (buf);

}

/*

 * %N -- Repository identity. string.  Accepts field-width, left-align

 */

{

	const struct pkg	*pkg = data;

	const char		*reponame;

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

 * option name and %Ov by the value.  Default %{%On %Ov\n%|%}

 */ 

{

	const struct pkg	*pkg = data;

		set_list_defaults(p, "%On %Ov\n", "");

		count = 1;

		while (pkg_options(pkg, &opt) == EPKG_OK) {

			if (count > 1)

					     opt, count, PP_O);

				     opt, count, PP_O);

			count++;

		}

/*

 * %On -- Option name.

 */

{

	const struct pkg_option	*option = data;

/*

 * %Ov -- Option value.

 */

{

	const struct pkg_option	*option = data;

/*

 * %Od -- Option default value.

 */

{

	const struct pkg_option	*option = data;

/*

 * %OD -- Option description

 */

{

	const struct pkg_option	*option = data;

/*

 * %Q -- pkg architecture a.k.a ABI string.  Accepts field-width, left-align

 */

{

	const struct pkg	*pkg = data;

/*

 * %R -- Repo path. string.

 */

{

	const struct pkg	*pkg = data;

/*

 * %S -- Character string.

 */

{

	const char	*charstring = data;

 * username or %#Un by the uid -- a line from

 * /etc/passwd. Default %{%Un\n%|%}

 */

{

	const struct pkg	*pkg = data;

		set_list_defaults(p, "%Un\n", "");

		count = 1;

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

			if (count > 1)

					     user, count, PP_U);

				     user, count, PP_U);

			count++;

		}

/*

 * %Un -- User name.

 */

{

	const char	*user = data;

/*

 * %V -- Old package version. string. Accepts field width, left align

 */

{

	const struct pkg	*pkg = data;

/*

 * %X -- Package checksum. string. Accepts field width, left align

 */

{

	struct pkg	*pkg = (struct pkg *)data;

 * binaries in the pkg.  Optionally accepts per-field format in %{ %|

 * %}.  Default %{%Yn\n%|%}

 */

{

	const struct pkg	*pkg = data;

		set_list_defaults(p, "%Yn\n", "");

		count = 1;

		while (pkg_requires(pkg, &provide) == EPKG_OK) {

			if (count > 1)

					     provide, count, PP_Y);

				     provide, count, PP_Y);

			count++;

		}

/*

 * %Yn -- Required name or %yn -- Provided name

 */

{

	const char	*provide = data;

 * Standard form: 0, 1.  Alternate form1: no, yes.  Alternate form2:

 * false, true

 */

{

	const struct pkg	*pkg = data;

 * binaries in the pkg.  Optionally accepts per-field format in %{ %|

 * %}, where %n is replaced by the shlib name.  Default %{%bn\n%|%}

 */

{

	const struct pkg	*pkg = data;

		set_list_defaults(p, "%bn\n", "");

		count = 1;

		while (pkg_shlibs_provided(pkg, &shlib) == EPKG_OK) {

			if (count > 1)

					     shlib, count, PP_b);

				     shlib, count, PP_b);

			count++;

		}

/*

 * %c -- Comment. string.  Accepts field-width, left-align

 */

{

	const struct pkg	*pkg = data;

 * per-field format string in %{ %| %} using any pkg_printf() *scalar*

 * formats. Defaults to printing "%dn-%dv\n" for each dependency.

 */

{

	const struct pkg	*pkg = data;

		set_list_defaults(p, "%dn-%dv\n", "");

		count = 1;

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

			if (count > 1)

					     dep, count, PP_d);

				     dep, count, PP_d);

			count++;

		}

/*

 * %dk -- Dependency lock status or %rk -- Requirement lock status.

 */

		       struct percent_esc *p)

{

	const struct pkg_dep	*dep = data;

/*

 * %dn -- Dependency name or %rn -- Requirement name.

 */

		       struct percent_esc *p)

{

	const struct pkg_dep	*dep = data;

/*

 * %do -- Dependency origin or %ro -- Requirement origin.

 */

			 struct percent_esc *p)

{

	const struct pkg_dep	*dep = data;

/*

 * %dv -- Dependency version or %rv -- Requirement version.

 */

			  struct percent_esc *p)

{

	const struct pkg_dep	*dep = data;

/*

 * %e -- Description. string. Accepts field-width, left-align

 */

{

	const struct pkg	*pkg = data;

 * Standard form: 0, 1.  Alternate form1: no, yes.  Alternate form2:

 * false, true

 */

{

	const struct pkg	*pkg = data;

 * Standard form: and, or, single. Alternate form 1: &, |, ''.

 * Alternate form 2: &&, ||, ==

 */

{

	const struct pkg	*pkg = data;

/*

 * %m -- Maintainer e-mail address. string.  Accepts field-width, left-align

 */

{

	const struct pkg	*pkg = data;

/*

 * %n -- Package name. string.  Accepts field-width, left-align

 */

{

	const struct pkg	*pkg = data;

/*

 * %o -- Package origin. string.  Accepts field-width, left-align

 */

{

	const struct pkg	*pkg = data;

/*

 * %p -- Installation prefix. string. Accepts field-width, left-align

 */

{

	const struct pkg	*pkg = data;

/*

 * %q -- pkg architecture a.k.a ABI string.  Accepts field-width, left-align

 */

{

	const struct pkg	*pkg = data;

 * per-field format string in %{ %| %} using any pkg_printf() *scalar*

 * formats. Defaults to printing "%{%rn-%rv\n%|%}" for each dependency.

 */

{

	const struct pkg	*pkg = data;

		set_list_defaults(p, "%rn-%rv\n", "");

		count = 1;

		while (pkg_rdeps(pkg, &req) == EPKG_OK) {

			if (count > 1)

					     req, count, PP_r);

				     req, count, PP_r);

			count++;

		}

 * exponents (k, M, G).  Alternate form 2, ditto, but using binary

 * scale prefixes (ki, Mi, Gi etc.)

 */

{

	const struct pkg	*pkg = data;

 * format string in %{ %}.  Default is to print seconds-since-epoch as

 * an integer applying our integer format modifiers.

 */

{

	const struct pkg	*pkg = data;

		return (int_val(buf, pkg->timestamp, p));

	else {

		char	 buffer[1024];

		time_t	 tsv;

		tsv = (time_t)pkg->timestamp;

			 localtime(&tsv));

	}

	return (buf);

}

/*

 * %v -- Package version. string. Accepts field width, left align

 */

{

	const struct pkg	*pkg = data;

/*

 * %u -- Package checksum. string. Accepts field width, left align

 */

{

	const struct pkg	*pkg = data;

/*

 * %w -- Home page URL.  string.  Accepts field width, left align

 */

{

	const struct pkg	*pkg = data;

 * exponents (k, M, G).  Alternate form 2, ditto, but using binary

 * scale prefixes (ki, Mi, Gi etc.)

 */

{

	const struct pkg	*pkg = data;

 * binaries in the pkg.  Optionally accepts per-field format in %{ %|

 * %}.  Default %{%yn\n%|%}

 */

{

	const struct pkg	*pkg = data;

		set_list_defaults(p, "%yn\n", "");

		count = 1;

		while (pkg_provides(pkg, &provide) == EPKG_OK) {

			if (count > 1)

					     provide, count, PP_y);

				     provide, count, PP_y);

			count++;

		}

/*

 * %z -- Package short checksum. string. Accepts field width, left align

 */

{

	const struct pkg	*pkg = data;

	char	 csum[PKG_FILE_CKSUM_CHARS + 1];

/*

 * %% -- Output a literal '%' character

 */

		       __unused struct percent_esc *p)

{

	return (buf);

}

 * Unknown format code -- return NULL to signal upper layers to pass

 * the text through unchanged.

 */

		       __unused struct percent_esc *p)

{

	return (NULL);

}

	struct percent_esc	*p;

	p = xcalloc(1, sizeof(struct percent_esc));

	return (p);

}

	p->flags = 0;

	p->width = 0;

	p->trailer_status = 0;

	p->fmt_code = '\0';

{

	if (p) {

		if (p->item_fmt)

		if (p->sep_fmt)

		free(p);

	}

	return;

}

{

	double		 num;

	int		 sign;

			precision = 0;

	}

	if (scale > 0)

		    bin_scale ? bin_pfx[scale] : si_pfx[scale]);

	return (buf);

}

{

	char	format[16];

	if (gen_format(format, sizeof(format), p->flags, "s") == NULL)

		return (NULL);

	return (buf);

}

{

	if (p->flags & (PP_ALTERNATE_FORM1|PP_ALTERNATE_FORM2))

		return (human_number(buf, value, p));

		    == NULL)

			return (NULL);

	}

	return (buf);

}

{

	static const char	*boolean_str[2][3] = {

		[false]	= { "false", "no",  ""    },

	return (string_val(buf, boolean_str[value][alternate], p));

}

{

	/*

         * Print mode as an octal integer '%o' by default.

		    == NULL)

			return (NULL);

	}

	return (buf);

}

{

	int			 alternate;

	int			 llogic = PP_LIC_SINGLE;

	return (string_val(buf, liclog_str[llogic][alternate], p));

}

{

	/* Convert to 0 or 1 for %?X */

	if (p->flags & PP_ALTERNATE_FORM1)

		  const char *sep_fmt)

{

	if ((p->trailer_status & ITEM_FMT_SET) != ITEM_FMT_SET) {

		p->trailer_status |= ITEM_FMT_SET;

	}

	if ((p->trailer_status & SEP_FMT_SET) != SEP_FMT_SET) {

		p->trailer_status |= SEP_FMT_SET;

	}

	return (p);

}

	     const void *data, int count, unsigned context)

{

	const char		*f;

	p = new_percent_esc();

	if (p == NULL) {

		return (buf);	/* Out of memory */

	}

			f = process_escape(buf, f);

			break;

		default:

			f++;

			break;

		}

		if (f == NULL) {

			break;	/* Out of memory */

		}

	}

				f1 = f2 + 2;

				break;

			}

		}

					f1 = f2 + 2;

					break;

				}

			}

		}

		if (done) {

			f = f1;

		} else {

		}

	}

}

const char*

{

	/* Hex escapes are of the form \xNN -- always two hex digits */

			break;

		}

		f++;

	} else {

		/* Pass through unchanged if it's not a recognizable

		   hex byte. */

	}

	return (f);

}

const char*

{

	int	val = 0;

	int	count = 0;

		f++;

	} 

done:

	return (f);

}

const char *

{

	f++;			/* Eat the \ */

	switch (*f) {

	case 'a':

		f++;

		break;

	case 'b':

		f++;

		break;

	case 'f':

		f++;

		break;

	case 'n':

		f++;

		break;

	case 't':

		f++;

		break;

	case 'v':

		f++;

		break;

	case '\'':

		f++;

		break;

	case '"':

		f++;

		break;

	case '\\':

		f++;

		break;

	case 'x':		/* Hex escape: \xNN */

	default:		/* If it's not a recognised escape,

				   leave f pointing at the escaped

				   character */

		break;

	}

}

const char *

		       const char *f, const struct pkg *pkg, 

		       const void *data, int count, unsigned context)

{

	const char		*fstart;

	fstart = f;

	f = parse_format(f, context, p);

}

const char *

		const char *fstart, const char *fend, void *data)

{

	s = fmt[p->fmt_code].fmt_handler(buf, data, p);

int

pkg_vprintf(const char * restrict format, va_list ap)

{

	int		 count;

	if (buf)

	} else

		count = -1;

	if (buf)

	return (count);

}

int

pkg_vfprintf(FILE * restrict stream, const char * restrict format, va_list ap)

{

	int		 count;

	if (buf)

	} else

		count = -1;

	if (buf)

	return (count);

}

int

pkg_vdprintf(int fd, const char * restrict format, va_list ap)

{

	int		 count;

	if (buf)

	} else 

		count = -1;

	if (buf)

	return (count);

}

pkg_vsnprintf(char * restrict str, size_t size, const char * restrict format,

	     va_list ap)

{

	int		 count;

	if (buf)

	} else

		count = -1;

	if (buf)

	return (count);

}

int

pkg_vasprintf(char **ret, const char * restrict format, va_list ap)

{

	int		 count;

	if (buf)

	} else {

		count = -1;

		*ret = NULL;

	}

	if (buf)

	return (count);

}

/**

 * store data from pkg into buf as indicated by the format code format.