personality: drop want_default_pure on windows

We still retain want_default_static to satisfy the requirements of the PE/COFF
linking model.

Fixes: 008d7069 ("libpkgconf: personality: default: set want_default_static and want_default_pure to true on windows")
Signed-off-by: Ariadne Conill <ariadne@dereferenced.org>
Closes: #364

.github/workflows/test.yml

@@ -35,7 +35,7 @@ jobs:
           # the code assumes msvc style printf atm
           export CFLAGS=-D__USE_MINGW_ANSI_STDIO=0
 
-          meson -Dtests=false _build
+          meson -Dtests=disabled _build
           meson compile -C _build
 
   debian-meson:

.gitignore

@@ -1,13 +1,19 @@
+Makefile
+Makefile.in
+.dirstamp
+stamp-h*
 *.h.in~
 *.o
 *.og
 *.op
+*.lo
 *.gcno
 *.gcda
 *.gcov
 core
 .gdb_history
 
+.libs
 .deps
 
 *.exe
@@ -16,8 +22,8 @@ core
 *.orig
 *.patch
 *.rej
-/tests/run.sh
 
+# autoconf stuff
 /aclocal.m4
 /autom4te.cache/
 /buildsys.mk
@@ -26,8 +32,47 @@ core
 /config.log
 /config.status
 /configure
+/compile
+/config.guess
+/config.sub
+/depcomp
+/install-sh
+/missing
+
+# programs
+/bomtool
 /pkgconf
 /pkgconf-gcov
 /pkgconf-profile
 
-Makefile
+# libtool
+/libtool
+/ltmain.sh
+/libpkgconf.la
+/m4/libtool.m4
+/m4/lt~obsolete.m4
+/m4/ltoptions.m4
+/m4/ltsugar.m4
+/m4/ltversion.m4
+
+# pkgconfig file
+/libpkgconf.pc
+
+# autoheader
+/libpkgconf/config.h
+/libpkgconf/config.h.in
+
+# tests
+/Kyuafile
+/tests/Kyuafile
+/tests/basic
+/tests/builtins
+/tests/conflicts
+/tests/framework
+/tests/parser
+/tests/provides
+/tests/regress
+/tests/requires
+/tests/sysroot
+/tests/test_env.sh
+/tests/version

Makefile.am

@@ -9,9 +9,10 @@ personality_dir        = @PERSONALITY_PATH@
 pkgconfigdir           = $(libdir)/pkgconfig
 nodist_pkgconfig_DATA  = libpkgconf.pc
 
+ACLOCAL_AMFLAGS = -I m4
 AM_CFLAGS = -DPERSONALITY_PATH=\"$(personality_dir)\" -DPKG_DEFAULT_PATH=\"$(pkg_default_dir)\" -DSYSTEM_INCLUDEDIR=\"$(system_includedir)\" -DSYSTEM_LIBDIR=\"$(system_libdir)\"
 
-bin_PROGRAMS = pkgconf
+bin_PROGRAMS = pkgconf bomtool
 lib_LTLIBRARIES = libpkgconf.la
 
 EXTRA_DIST =	pkg.m4 \
@@ -22,10 +23,13 @@ EXTRA_DIST =	pkg.m4 \
 		libpkgconf/win-dirent.h \
 		tests/lib-relocatable/lib/pkgconfig/foo.pc \
 		tests/lib1/argv-parse-2.pc \
+		tests/lib1/billion-laughs.pc \
 		tests/lib1/dos-lineendings.pc \
 		tests/lib1/paren-quoting.pc \
 		tests/lib1/argv-parse-3.pc \
 		tests/lib1/foo.pc \
+		tests/lib1/foobar.pc \
+		tests/lib1/unavailable-provider.pc \
 		tests/lib1/prefix-foo1.pc \
 		tests/lib1/argv-parse.pc \
 		tests/lib1/framework-1.pc \
@@ -89,6 +93,10 @@ EXTRA_DIST =	pkg.m4 \
 		tests/lib1/malformed-1.pc \
 		tests/lib1/malformed-quoting.pc \
 		tests/lib1/malformed-version.pc \
+		tests/lib1/metapackage.pc \
+		tests/lib1/metapackage-1.pc \
+		tests/lib1/metapackage-2.pc \
+		tests/lib1/metapackage-3.pc \
 		tests/lib1/explicit-sysroot.pc \
 		tests/lib1/escaped-backslash.pc \
 		tests/lib1/cflags-internal.pc \
@@ -103,6 +111,7 @@ EXTRA_DIST =	pkg.m4 \
 		tests/lib1/sysroot-dir-3.pc \
 		tests/lib1/sysroot-dir-4.pc \
 		tests/lib1/sysroot-dir-5.pc \
+		tests/lib1/child-prefix/pkgconfig/child-prefix-1.pc \
 		$(test_scripts) \
 		doc/conf.py \
 		doc/extract.py \
@@ -131,7 +140,8 @@ test_scripts=	tests/meson.build \
 		tests/sysroot.sh \
 		tests/version.sh
 
-check_SCRIPTS=	$(test_scripts:.sh=)
+test_sh = $(filter-out tests/meson.build, $(test_scripts))
+check_SCRIPTS = $(test_sh:.sh=)
 
 SUFFIXES=	.sh
 
@@ -151,7 +161,7 @@ libpkgconf_la_SOURCES  =	\
 		libpkgconf/path.c		\
 		libpkgconf/personality.c	\
 		libpkgconf/parser.c
-libpkgconf_la_LDFLAGS = -no-undefined -version-info 4:0:0 -export-symbols-regex '^pkgconf_'
+libpkgconf_la_LDFLAGS = -no-undefined -version-info 5:0:0 -export-symbols-regex '^pkgconf_'
 
 dist_man_MANS    = 		\
 	man/pkgconf.1		\
@@ -164,11 +174,17 @@ pkgconf_SOURCES  = \
 	cli/main.c				\
 	cli/getopt_long.c			\
 	cli/renderer-msvc.c
-pkgconf_CPPFLAGS = -Ilibpkgconf -Icli
+pkgconf_CPPFLAGS = -I$(top_srcdir)/libpkgconf -I$(top_srcdir)/cli
 noinst_HEADERS   = \
 	cli/getopt_long.h			\
 	cli/renderer-msvc.h
 
+bomtool_LDADD    = libpkgconf.la
+bomtool_SOURCES  = \
+	cli/bomtool/main.c				\
+	cli/getopt_long.c
+bomtool_CPPFLAGS = -I$(top_srcdir)/libpkgconf -I$(top_srcdir)/cli -I$(top_srcdir)/cli/bomtool
+
 dist_doc_DATA = README.md AUTHORS
 
 m4datadir              = $(datadir)/aclocal

Makefile.lite

@@ -39,7 +39,7 @@ all: pkgconf-lite
 libpkgconf/config.h:
 	@echo '#define PACKAGE_NAME "pkgconf-lite"' >> $@
 	@echo '#define PACKAGE_BUGREPORT "https://git.dereferenced.org/pkgconf/pkgconf/issues"' >> $@
-	@echo '#define PACKAGE_VERSION "1.6.2"' >> $@
+	@echo '#define PACKAGE_VERSION "2.3.0"' >> $@
 	@echo '#define PACKAGE PACKAGE_NAME " " PACKAGE_VERSION' >> $@
 	@echo '#define HAVE_STRLCPY' >> $@
 	@echo '#define HAVE_STRLCAT' >> $@

NEWS

@@ -1,6 +1,226 @@
 Changes from previous version of pkgconf
 ========================================
 
+Changes from 2.2.0 to 2.3.0:
+----------------------------
+
+* Fix compile with Meson on Solaris by defining __EXTENSIONS__.
+
+* Add support for the PKG_CONFIG_RELOCATE_PATHS environmental variable.
+  When set, the program will act as if --define-prefix is always enabled.
+
+* Color solution nodes that were part of the original query, and use
+  that coloring to skip over dependencies when generating DocumentNames
+  in bomtool.
+
+* Enhance --env option to support variables with both --variable=varname
+  and --print-variables.
+
+* Add --exists-cflags option which creates synthetic preprocessor
+  definition flags for every queried dependency when found.
+
+* Document that Requires.private is always used for header paths.
+  Patch by Petr Písař.
+
+* Fix minor documentation typos.
+  Patch by Pierce.
+
+* Ensure string comparisons using <ctype.h> functions are done with
+  unsigned bytes to avoid undefined behavior.
+  Patch by Taylor R Campbell.
+
+* Fix parsing edge-case bugs with dependency versions.
+  Patch by Kai Pastor.
+
+* Change PKG_PROG_PKG_CONFIG autoconf macro to add a customizable
+  failure handler if pkg-config is not found.
+  Patch by Ismael Luceno.
+
+Changes from 2.1.1 to 2.2.0:
+----------------------------
+
+* libpkgconf SOVERSION is now 5.
+
+* Significant solver rework to flatten both requires and requires.private
+  dependencies in a single pass.  Improves performance slightly and ensures
+  proper dependency order.
+  Patches by Kai Pastor.
+
+* Improve `--digraph` output to reflect more of the solver's state in the
+  rendered dependency graph.
+  Patches by Kai Pastor.
+
+* Do not reference the graph root by name when presenting error messages about
+  directly requested dependency nodes.
+  Patch by Kai Pastor.
+
+Changes from 2.1.0 to 2.1.1:
+----------------------------
+
+* Documentation fixes from Sam James and Stefan Weil.
+
+* Fix --modversion with constraints.
+  Patch by Kai Pastor.
+
+* Reintroduce an optimization to the dependency graph walker which avoids
+  revisiting already visited nodes.
+  Patch by Yi Chou with some modifications.
+
+* Add a regression test to check that the dependency flattener is working
+  as expected.
+  Patch by Kai Pastor.
+
+Changes from 2.0.3 to 2.1.0:
+----------------------------
+
+* Do not flatten the solver solution into the original world used as
+  input to the solver.
+  Patches by Kai Pastor.
+
+* Fix warnings with GCC 14 -Walloc-size.
+  Patch by Sam James.
+
+* Add --solution to the pkgconf CLI to dump the solver state.
+
+* Improve the --digraph output to clarify cancelled edges in a given
+  solution.
+
+* Demote requires dependencies to requires.private when a parent
+  dependency is pulled in via requires.private.
+
+* Trim trailing whitespace when processing package arguments.
+  Patch by Colin Gillespie.
+
+* Avoid strncmp() in --modversion version comparison.
+  Patch by Colin Gillespie.
+
+* Update autoconf compile flag checking macro.
+  Patch by Peter Kokot.
+
+* Add system default path configuration to Meson.
+  Patch by L. E. Segovia.
+
+* Fix order of PKG_CONFIG_LIBDIR and PKG_CONFIG_PATH element processing.
+
+Changes from 2.0.2 to 2.0.3:
+----------------------------
+
+* Fix some edge-cases with the new `--modversion` implementation
+  and add additional regression tests.
+  Patch by Colin Gillespie.
+
+* Fix some format specifiers to use PRIu64 in debug tracing.
+
+Changes from 2.0.1 to 2.0.2:
+----------------------------
+
+* Fix long-standing bug where package identifiers for "uninstalled"
+  packages incorrectly included the "-uninstalled" suffix.
+
+  This was exposed by the recent change to `--modversion` in 2.0.1.
+
+Changes from 2.0.0 to 2.0.1:
+----------------------------
+
+* The behavior of --modversion was largely reverted back to the traditional
+  pkg-config behavior, but still operates on a solved dependency graph.
+
+  The order of --modversion output is based on the dependency resolution
+  queue which is passed to the solver, which itself generally maps to the
+  order of the constrants provided on the command line.
+
+* A new flag, --verbose, has been added.  When used with `--modversion`, it
+  is possible to disambiguate which version belongs to which module:
+
+    % pkgconf --modversion --verbose foo bar
+    foo: 1.2.3
+    bar: 1.3
+
+Changes from 1.9.5 to 2.0.0:
+----------------------------
+
+* When flattening the dependency graph, retain the latest seen edges
+  rather than the earliest.
+
+* Fix a long-standing bug where the dependency resolution queue was
+  evaluated in reverse.  This bug masked the aforementioned dependency
+  flattening bug in many cases.
+
+* Fix handling of --with-path, which was appending paths to the search
+  list rather than prepending them as intended.
+
+* Error when --modversion is requested with more than one package, as
+  the output is ambiguous.
+
+Changes from 1.9.4 to 1.9.5:
+----------------------------
+
+* Fix incorrect assumptions involving the use of ctype(3) functions.
+  Patch by Taylor R Campbell.
+
+* Fix detection of provided functions on autoconf.
+  Patches by Harmen Stoppels.
+
+* Fix deletion of tests/meson.build by the autoconf build system.
+  Patch by h30032433.
+
+* Fix quoting rules in argvsplit.c.
+  Patch by huyubiao.
+
+* Update libpkgconf documentation and documentation building scripts.
+  Patches by Andrew Shadura.
+
+* Enforce maximum package count correctly for --modversion.
+
+Changes from 1.9.3 to 1.9.4:
+----------------------------
+
+* Fix a buffer overflow vulnerability involving very large variable expansions.
+  CVE-2023-24056
+
+* Fix a bunch of minor regressions with the solver.
+
+* Create separate solutions for `--cflags` and `--libs` when `--static` is not
+  used.
+
+* Remove final trailing whitespace in pkgconf_fragment_render_buf().
+
+* Revert broken pkg.m4 change involving querying module versions in
+  PKG_CHECK_MODULES.
+
+* Fix handling of tildes in version strings.
+
+* Various C99 formatting string fixes involving SIZE_FMT_SPECIFIER.
+
+Changes from 1.9.2 to 1.9.3:
+----------------------------
+
+* Fix a bunch of minor code issues pointed out using Clang static analyzer.
+
+* New API: pkgconf_solution_free(), which frees a compiled solution graph.
+
+* Fix behavior when overriding global variables with `--define-variable`.
+
+Changes from 1.9.1 to 1.9.2:
+----------------------------
+
+* Do not try to break dependency cycles across dependency lists.  This causes
+  the solved graph to sometimes miss required dependency nodes because the
+  solver detected an incorrect dependency cycle.
+
+* New API: pkgconf_queue_solve(), which replaces pkgconf_queue_apply().
+  pkgconf_queue_apply is now deprecated and should not be used in new code.
+
+Changes from 1.9.0 to 1.9.1:
+----------------------------
+
+* Skip graph flattening and traversal for query types which only make sense
+  for a single pkg-config module.
+
+  The old solver walked these graphs with --maximum-traverse-depth=1 in
+  these cases, but this is no longer helpful because the graph is flattened
+  by the new solver.
+
 Changes from 1.8.0 to 1.9.0:
 ----------------------------
 

README.md

@@ -50,7 +50,7 @@ As previously mentioned, pkgconf makes optimizations to the linker flags in both
 case of static and shared linking in order to avoid overlinking binaries and also
 simplifies the `CFLAGS` and `LIBS` output of the pkgconf tool for improved readability.
 
-This functionality depends on the pkg-config module properly declaring it's dependency
+This functionality depends on the pkg-config module properly declaring its dependency
 tree instead of using `Libs` and `Cflags` fields to directly link against other modules
 which have pkg-config metadata files installed.
 
@@ -116,10 +116,10 @@ flags like so:
 
 
 pkgconf is compiled using [Meson](https://mesonbuild.com) on Windows. In theory, you could also use
-Meson to build on UNIX, but this is not recommended at this time as it pkgconf is typically built
+Meson to build on UNIX, but this is not recommended at this time as pkgconf is typically built
 much earlier than Meson.
 
-    $ meson setup build -Dtests=false
+    $ meson setup build -Dtests=disabled
     $ meson compile -C build
     $ meson install -C build
 
@@ -137,8 +137,8 @@ to make this determination themselves.
 
 ## release tarballs
 
-Release tarballs are available at <https://distfiles.dereferenced.org/pkgconf/>.
-Please only use the tarballs from distfiles.dereferenced.org.
+Release tarballs are available at <https://distfiles.ariadne.space/pkgconf/>.
+Please only use the tarballs from distfiles.ariadne.space.
 
 ## contacts
 

cli/bomtool/main.c

@@ -0,0 +1,368 @@
+/*
+ * bomtool/main.c
+ * main() routine, printer functions
+ *
+ * Copyright (c) 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019
+ *     pkgconf authors (see AUTHORS).
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * This software is provided 'as is' and without any warranty, express or
+ * implied.  In no event shall the authors be liable for any damages arising
+ * from the use of this software.
+ */
+
+#include "libpkgconf/config.h"
+#include <libpkgconf/stdinc.h>
+#include <libpkgconf/libpkgconf.h>
+#include "getopt_long.h"
+
+#define PKG_VERSION			(((uint64_t) 1) << 1)
+#define PKG_ABOUT			(((uint64_t) 1) << 2)
+#define PKG_HELP			(((uint64_t) 1) << 3)
+
+static const char *spdx_version = "SPDX-2.2";
+static const char *bom_license = "CC0-1.0";
+static const char *document_ref = "SPDXRef-DOCUMENT";
+
+static pkgconf_client_t pkg_client;
+static uint64_t want_flags;
+static size_t maximum_package_count = 0;
+static int maximum_traverse_depth = 2000;
+FILE *error_msgout = NULL;
+
+static bool
+error_handler(const char *msg, const pkgconf_client_t *client, void *data)
+{
+	(void) client;
+	(void) data;
+	fprintf(error_msgout, "%s", msg);
+	return true;
+}
+
+static const char *
+sbom_spdx_identity(pkgconf_pkg_t *pkg)
+{
+	static char buf[PKGCONF_ITEM_SIZE];
+
+	snprintf(buf, sizeof buf, "%sC64%s", pkg->id, pkg->version);
+
+	return buf;
+}
+
+static const char *
+sbom_name(pkgconf_pkg_t *world)
+{
+	static char buf[PKGCONF_BUFSIZE];
+	pkgconf_node_t *node;
+
+	pkgconf_strlcpy(buf, "SBOM-SPDX", sizeof buf);
+
+	PKGCONF_FOREACH_LIST_ENTRY(world->required.head, node)
+	{
+		pkgconf_dependency_t *dep = node->data;
+		pkgconf_pkg_t *match = dep->match;
+
+		if ((dep->flags & PKGCONF_PKG_DEPF_QUERY) != PKGCONF_PKG_DEPF_QUERY)
+			continue;
+
+		if (!dep->match)
+			continue;
+
+		pkgconf_strlcat(buf, "-", sizeof buf);
+		pkgconf_strlcat(buf, sbom_spdx_identity(match), sizeof buf);
+	}
+
+	return buf;
+}
+
+static void
+write_sbom_header(pkgconf_client_t *client, pkgconf_pkg_t *world)
+{
+	(void) client;
+	(void) world;
+
+	printf("SPDXVersion: %s\n", spdx_version);
+	printf("DataLicense: %s\n", bom_license);
+	printf("SPDXID: %s\n", document_ref);
+	printf("DocumentName: %s\n", sbom_name(world));
+	printf("DocumentNamespace: https://spdx.org/spdxdocs/bomtool-%s\n", PACKAGE_VERSION);
+	printf("Creator: Tool: bomtool %s\n", PACKAGE_VERSION);
+
+	printf("\n\n");
+}
+
+static const char *
+sbom_identity(pkgconf_pkg_t *pkg)
+{
+	static char buf[PKGCONF_ITEM_SIZE];
+
+	snprintf(buf, sizeof buf, "%s@%s", pkg->id, pkg->version);
+
+	return buf;
+}
+
+static void
+write_sbom_package(pkgconf_client_t *client, pkgconf_pkg_t *pkg, void *unused)
+{
+	(void) client;
+	(void) unused;
+
+	if (pkg->flags & PKGCONF_PKG_PROPF_VIRTUAL)
+		return;
+
+	printf("##### Package: %s\n\n", sbom_identity(pkg));
+
+	printf("PackageName: %s\n", sbom_identity(pkg));
+	printf("SPDXID: SPDXRef-Package-%s\n", sbom_spdx_identity(pkg));
+	printf("PackageVersion: %s\n", pkg->version);
+	printf("PackageDownloadLocation: NOASSERTION\n");
+	printf("PackageVerificationCode: NOASSERTION\n");
+
+	/* XXX: What about projects? */
+	if (pkg->maintainer != NULL)
+		printf("PackageSupplier: Person: %s\n", pkg->maintainer);
+
+	if (pkg->url != NULL)
+		printf("PackageHomePage: %s\n", pkg->url);
+
+	printf("PackageLicenseDeclared: %s\n", pkg->license != NULL ? pkg->license : "NOASSERTION");
+
+	if (pkg->copyright != NULL)
+		printf("PackageCopyrightText: <text>%s</text>\n", pkg->copyright);
+
+	if (pkg->description != NULL)
+		printf("PackageSummary: <text>%s</text>\n", pkg->description);
+
+	printf("\n\n");
+}
+
+static void
+write_sbom_relationships(pkgconf_client_t *client, pkgconf_pkg_t *pkg, void *unused)
+{
+	(void) client;
+	(void) unused;
+
+	char baseref[PKGCONF_ITEM_SIZE];
+	pkgconf_node_t *node;
+
+	if (pkg->flags & PKGCONF_PKG_PROPF_VIRTUAL)
+		return;
+
+	snprintf(baseref, sizeof baseref, "SPDXRef-Package-%sC64%s", pkg->id, pkg->version);
+
+	PKGCONF_FOREACH_LIST_ENTRY(pkg->required.head, node)
+	{
+		pkgconf_dependency_t *dep = node->data;
+		pkgconf_pkg_t *match = dep->match;
+
+		if (!dep->match)
+			continue;
+
+		printf("Relationship: %s DEPENDS_ON SPDXRef-Package-%s\n", baseref, sbom_spdx_identity(match));
+		printf("Relationship: SPDXRef-Package-%s DEPENDENCY_OF %s\n", sbom_spdx_identity(match), baseref);
+	}
+
+	PKGCONF_FOREACH_LIST_ENTRY(pkg->requires_private.head, node)
+	{
+		pkgconf_dependency_t *dep = node->data;
+		pkgconf_pkg_t *match = dep->match;
+
+		if (!dep->match)
+			continue;
+
+		printf("Relationship: %s DEPENDS_ON SPDXRef-Package-%s\n", baseref, sbom_spdx_identity(match));
+		printf("Relationship: SPDXRef-Package-%s DEV_DEPENDENCY_OF %s\n", sbom_spdx_identity(match), baseref);
+	}
+
+	if (pkg->required.head != NULL || pkg->requires_private.head != NULL)
+		printf("\n\n");
+}
+
+static bool
+generate_sbom_from_world(pkgconf_client_t *client, pkgconf_pkg_t *world)
+{
+	int eflag;
+	pkgconf_node_t *node;
+
+	write_sbom_header(client, world);
+
+	eflag = pkgconf_pkg_traverse(client, world, write_sbom_package, NULL, maximum_traverse_depth, 0);
+	if (eflag != PKGCONF_PKG_ERRF_OK)
+		return false;
+
+	eflag = pkgconf_pkg_traverse(client, world, write_sbom_relationships, NULL, maximum_traverse_depth, 0);
+	if (eflag != PKGCONF_PKG_ERRF_OK)
+		return false;
+
+	PKGCONF_FOREACH_LIST_ENTRY(world->required.head, node)
+	{
+		pkgconf_dependency_t *dep = node->data;
+		pkgconf_pkg_t *match = dep->match;
+
+		if (!dep->match)
+			continue;
+
+		printf("Relationship: %s DESCRIBES SPDXRef-Package-%s\n", document_ref, sbom_spdx_identity(match));
+	}
+
+	return true;
+}
+
+static int
+version(void)
+{
+	printf("bomtool %s\n", PACKAGE_VERSION);
+	return EXIT_SUCCESS;
+}
+
+static int
+about(void)
+{
+	printf("bomtool (%s %s)\n", PACKAGE_NAME, PACKAGE_VERSION);
+	printf("Copyright (c) 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021\n");
+	printf("    pkgconf authors (see AUTHORS in documentation directory).\n\n");
+	printf("Permission to use, copy, modify, and/or distribute this software for any\n");
+	printf("purpose with or without fee is hereby granted, provided that the above\n");
+	printf("copyright notice and this permission notice appear in all copies.\n\n");
+	printf("This software is provided 'as is' and without any warranty, express or\n");
+	printf("implied.  In no event shall the authors be liable for any damages arising\n");
+	printf("from the use of this software.\n\n");
+	printf("Report bugs at <%s>.\n", PACKAGE_BUGREPORT);
+	return EXIT_SUCCESS;
+}
+
+static int
+usage(void)
+{
+	printf("usage: bomtool [--flags] [modules]\n");
+
+	printf("\nbasic options:\n\n");
+
+	printf("  --help                            this message\n");
+	printf("  --about                           print bomtool version and license to stdout\n");
+	printf("  --version                         print bomtool version to stdout\n");
+
+	return EXIT_SUCCESS;
+}
+
+int
+main(int argc, char *argv[])
+{
+	int ret = EXIT_SUCCESS;
+	pkgconf_list_t pkgq = PKGCONF_LIST_INITIALIZER;
+	unsigned int want_client_flags = PKGCONF_PKG_PKGF_SEARCH_PRIVATE;
+	pkgconf_cross_personality_t *personality = pkgconf_cross_personality_default();
+	pkgconf_pkg_t world = {
+		.id = "virtual:world",
+		.realname = "virtual world package",
+		.flags = PKGCONF_PKG_PROPF_STATIC | PKGCONF_PKG_PROPF_VIRTUAL,
+	};
+
+	error_msgout = stderr;
+
+	struct pkg_option options[] = {
+		{ "version", no_argument, &want_flags, PKG_VERSION, },
+		{ "about", no_argument, &want_flags, PKG_ABOUT, },
+		{ "help", no_argument, &want_flags, PKG_HELP, },
+		{ NULL, 0, NULL, 0 }
+	};
+
+	while ((ret = pkg_getopt_long_only(argc, argv, "", options, NULL)) != -1)
+	{
+		switch (ret)
+		{
+		case '?':
+		case ':':
+			return EXIT_FAILURE;
+		default:
+			break;
+		}
+	}
+
+	pkgconf_client_init(&pkg_client, error_handler, NULL, personality);
+
+	/* we have determined what features we want most likely.  in some cases, we override later. */
+	pkgconf_client_set_flags(&pkg_client, want_client_flags);
+
+	/* at this point, want_client_flags should be set, so build the dir list */
+	pkgconf_client_dir_list_build(&pkg_client, personality);
+
+	if ((want_flags & PKG_ABOUT) == PKG_ABOUT)
+		return about();
+
+	if ((want_flags & PKG_VERSION) == PKG_VERSION)
+		return version();
+
+	if ((want_flags & PKG_HELP) == PKG_HELP)
+		return usage();
+
+	while (1)
+	{
+		const char *package = argv[pkg_optind];
+
+		if (package == NULL)
+			break;
+
+		/* check if there is a limit to the number of packages allowed to be included, if so and we have hit
+		 * the limit, stop adding packages to the queue.
+		 */
+		if (maximum_package_count > 0 && pkgq.length > maximum_package_count)
+			break;
+
+		while (isspace((unsigned char)package[0]))
+			package++;
+
+		/* skip empty packages */
+		if (package[0] == '\0') {
+			pkg_optind++;
+			continue;
+		}
+
+		if (argv[pkg_optind + 1] == NULL || !PKGCONF_IS_OPERATOR_CHAR(*(argv[pkg_optind + 1])))
+		{
+			pkgconf_queue_push(&pkgq, package);
+			pkg_optind++;
+		}
+		else
+		{
+			char packagebuf[PKGCONF_BUFSIZE];
+
+			snprintf(packagebuf, sizeof packagebuf, "%s %s %s", package, argv[pkg_optind + 1], argv[pkg_optind + 2]);
+			pkg_optind += 3;
+
+			pkgconf_queue_push(&pkgq, packagebuf);
+		}
+	}
+
+	if (pkgq.head == NULL)
+	{
+		fprintf(stderr, "Please specify at least one package name on the command line.\n");
+		ret = EXIT_FAILURE;
+		goto out;
+	}
+
+	ret = EXIT_SUCCESS;
+
+	if (!pkgconf_queue_solve(&pkg_client, &pkgq, &world, maximum_traverse_depth))
+	{
+		ret = EXIT_FAILURE;
+		goto out;
+	}
+
+	if (!generate_sbom_from_world(&pkg_client, &world))
+	{
+		ret = EXIT_FAILURE;
+		goto out;
+	}
+
+out:
+	pkgconf_solution_free(&pkg_client, &world);
+	pkgconf_queue_free(&pkgq);
+	pkgconf_cross_personality_deinit(personality);
+	pkgconf_client_deinit(&pkg_client);
+
+	return ret;
+}

cli/main.c

@@ -71,11 +71,14 @@
 #define PKG_DUMP_PERSONALITY		(((uint64_t) 1) << 43)
 #define PKG_SHARED			(((uint64_t) 1) << 44)
 #define PKG_DUMP_LICENSE		(((uint64_t) 1) << 45)
+#define PKG_SOLUTION			(((uint64_t) 1) << 46)
+#define PKG_EXISTS_CFLAGS		(((uint64_t) 1) << 47)
 
 static pkgconf_client_t pkg_client;
 static const pkgconf_fragment_render_ops_t *want_render_ops = NULL;
 
 static uint64_t want_flags;
+static int verbosity = 0;
 static int maximum_traverse_depth = 2000;
 static size_t maximum_package_count = 0;
 
@@ -252,32 +255,71 @@ apply_provides(pkgconf_client_t *client, pkgconf_pkg_t *world, void *unused, int
 
 #ifndef PKGCONF_LITE
 static void
-print_digraph_node(pkgconf_client_t *client, pkgconf_pkg_t *pkg, void *unused)
+print_digraph_node(pkgconf_client_t *client, pkgconf_pkg_t *pkg, void *data)
 {
 	pkgconf_node_t *node;
 	(void) client;
-	(void) unused;
+	pkgconf_pkg_t **last_seen = data;
 
-	printf("\"%s\" [fontname=Sans fontsize=8]\n", pkg->id);
+	if(pkg->flags & PKGCONF_PKG_PROPF_VIRTUAL)
+		return;
+
+	if (pkg->flags & PKGCONF_PKG_PROPF_VISITED_PRIVATE)
+		printf("\"%s\" [fontname=Sans fontsize=8 fontcolor=gray color=gray]\n", pkg->id);
+	else
+		printf("\"%s\" [fontname=Sans fontsize=8]\n", pkg->id);
+
+	if (last_seen != NULL)
+	{
+		if (*last_seen != NULL)
+			printf("\"%s\" -> \"%s\" [fontname=Sans fontsize=8 color=red]\n", (*last_seen)->id, pkg->id);
+
+		*last_seen = pkg;
+	}
 
 	PKGCONF_FOREACH_LIST_ENTRY(pkg->required.head, node)
 	{
 		pkgconf_dependency_t *dep = node->data;
+		const char *dep_id = (dep->match != NULL) ? dep->match->id : dep->package;
 
-		printf("\"%s\" -- \"%s\" [fontname=Sans fontsize=8]\n", dep->package, pkg->id);
+		if ((dep->flags & PKGCONF_PKG_DEPF_PRIVATE) == 0)
+			printf("\"%s\" -> \"%s\" [fontname=Sans fontsize=8]\n", pkg->id, dep_id);
+		else
+			printf("\"%s\" -> \"%s\" [fontname=Sans fontsize=8 color=gray]\n", pkg->id, dep_id);
+	}
+
+	PKGCONF_FOREACH_LIST_ENTRY(pkg->requires_private.head, node)
+	{
+		pkgconf_dependency_t *dep = node->data;
+		const char *dep_id = (dep->match != NULL) ? dep->match->id : dep->package;
+
+		printf("\"%s\" -> \"%s\" [fontname=Sans fontsize=8 color=gray]\n", pkg->id, dep_id);
 	}
 }
 
 static bool
-apply_digraph(pkgconf_client_t *client, pkgconf_pkg_t *world, void *unused, int maxdepth)
+apply_digraph(pkgconf_client_t *client, pkgconf_pkg_t *world, void *data, int maxdepth)
 {
 	int eflag;
+	pkgconf_list_t *list = data;
+	pkgconf_pkg_t *last_seen = NULL;
+	pkgconf_node_t *iter;
 
-	printf("graph deptree {\n");
+	printf("digraph deptree {\n");
 	printf("edge [color=blue len=7.5 fontname=Sans fontsize=8]\n");
 	printf("node [fontname=Sans fontsize=8]\n");
+	printf("\"user:request\" [fontname=Sans fontsize=8]\n");
 
-	eflag = pkgconf_pkg_traverse(client, world, print_digraph_node, unused, maxdepth, 0);
+	PKGCONF_FOREACH_LIST_ENTRY(list->head, iter)
+	{
+		pkgconf_queue_t *pkgq = iter->data;
+		pkgconf_pkg_t *pkg = pkgconf_pkg_find(client, pkgq->package);
+		printf("\"user:request\" -> \"%s\" [fontname=Sans fontsize=8]\n", pkg == NULL ? pkgq->package : pkg->id);
+		if (pkg != NULL)
+			pkgconf_pkg_unref(client, pkg);
+	}
+
+	eflag = pkgconf_pkg_traverse(client, world, print_digraph_node, &last_seen, maxdepth, 0);
 
 	if (eflag != PKGCONF_PKG_ERRF_OK)
 		return false;
@@ -285,23 +327,62 @@ apply_digraph(pkgconf_client_t *client, pkgconf_pkg_t *world, void *unused, int
 	printf("}\n");
 	return true;
 }
+
+static void
+print_solution_node(pkgconf_client_t *client, pkgconf_pkg_t *pkg, void *unused)
+{
+	(void) client;
+	(void) unused;
+
+	printf("%s (%"PRIu64")\n", pkg->id, pkg->identifier);
+}
+
+static bool
+apply_print_solution(pkgconf_client_t *client, pkgconf_pkg_t *world, void *unused, int maxdepth)
+{
+	int eflag;
+
+	eflag = pkgconf_pkg_traverse(client, world, print_solution_node, unused, maxdepth, 0);
+
+	return eflag == PKGCONF_PKG_ERRF_OK;
+}
 #endif
 
 static bool
-apply_modversion(pkgconf_client_t *client, pkgconf_pkg_t *world, void *unused, int maxdepth)
+apply_modversion(pkgconf_client_t *client, pkgconf_pkg_t *world, void *data, int maxdepth)
 {
-	pkgconf_node_t *iter;
+	pkgconf_node_t *queue_iter;
+	pkgconf_list_t *pkgq = data;
 	(void) client;
-	(void) unused;
 	(void) maxdepth;
 
-	PKGCONF_FOREACH_LIST_ENTRY(world->required.head, iter)
+	PKGCONF_FOREACH_LIST_ENTRY(pkgq->head, queue_iter)
 	{
-		pkgconf_dependency_t *dep = iter->data;
-		pkgconf_pkg_t *pkg = dep->match;
+		pkgconf_node_t *world_iter;
+		pkgconf_queue_t *queue_node = queue_iter->data;
 
-		if (pkg->version != NULL)
-			printf("%s\n", pkg->version);
+		PKGCONF_FOREACH_LIST_ENTRY(world->required.head, world_iter)
+		{
+			pkgconf_dependency_t *dep = world_iter->data;
+			pkgconf_pkg_t *pkg = dep->match;
+
+			const size_t name_len = strlen(pkg->why);
+			if (name_len > strlen(queue_node->package) ||
+			    strncmp(pkg->why, queue_node->package, name_len) ||
+			    (queue_node->package[name_len] != 0 &&
+			     !isspace((unsigned char)queue_node->package[name_len]) &&
+			     !PKGCONF_IS_OPERATOR_CHAR(queue_node->package[name_len])))
+				continue;
+
+			if (pkg->version != NULL) {
+				if (verbosity)
+					printf("%s: ", pkg->id);
+
+				printf("%s\n", pkg->version);
+			}
+
+			break;
+		}
 	}
 
 	return true;
@@ -373,7 +454,8 @@ apply_variable(pkgconf_client_t *client, pkgconf_pkg_t *world, void *variable, i
 static bool
 apply_env_var(const char *prefix, pkgconf_client_t *client, pkgconf_pkg_t *world, int maxdepth,
 	unsigned int (*collect_fn)(pkgconf_client_t *client, pkgconf_pkg_t *world, pkgconf_list_t *list, int maxdepth),
-	bool (*filter_fn)(const pkgconf_client_t *client, const pkgconf_fragment_t *frag, void *data))
+	bool (*filter_fn)(const pkgconf_client_t *client, const pkgconf_fragment_t *frag, void *data),
+	void (*postprocess_fn)(pkgconf_client_t *client, pkgconf_pkg_t *world, pkgconf_list_t *fragment_list))
 {
 	pkgconf_list_t unfiltered_list = PKGCONF_LIST_INITIALIZER;
 	pkgconf_list_t filtered_list = PKGCONF_LIST_INITIALIZER;
@@ -386,6 +468,9 @@ apply_env_var(const char *prefix, pkgconf_client_t *client, pkgconf_pkg_t *world
 
 	pkgconf_fragment_filter(client, &filtered_list, &unfiltered_list, filter_fn, NULL);
 
+	if (postprocess_fn != NULL)
+		postprocess_fn(client, world, &filtered_list);
+
 	if (filtered_list.head == NULL)
 		goto out;
 
@@ -400,6 +485,94 @@ out:
 	return true;
 }
 
+static void
+maybe_add_module_definitions(pkgconf_client_t *client, pkgconf_pkg_t *world, pkgconf_list_t *fragment_list)
+{
+	pkgconf_node_t *world_iter;
+
+	if ((want_flags & PKG_EXISTS_CFLAGS) != PKG_EXISTS_CFLAGS)
+		return;
+
+	PKGCONF_FOREACH_LIST_ENTRY(world->required.head, world_iter)
+	{
+		pkgconf_dependency_t *dep = world_iter->data;
+		char havebuf[PKGCONF_ITEM_SIZE];
+		char *p;
+
+		if ((dep->flags & PKGCONF_PKG_DEPF_QUERY) != PKGCONF_PKG_DEPF_QUERY)
+			continue;
+
+		if (dep->match == NULL)
+			continue;
+
+		snprintf(havebuf, sizeof havebuf, "HAVE_%s", dep->match->id);
+
+		for (p = havebuf; *p; p++)
+		{
+			switch (*p)
+			{
+				case ' ':
+				case '-':
+					*p = '_';
+					break;
+
+				default:
+					*p = toupper((unsigned char) *p);
+			}
+		}
+
+		pkgconf_fragment_insert(client, fragment_list, 'D', havebuf, false);
+	}
+}
+
+static void
+apply_env_variables(pkgconf_client_t *client, pkgconf_pkg_t *world, const char *env_prefix)
+{
+	(void) client;
+	pkgconf_node_t *world_iter;
+
+	PKGCONF_FOREACH_LIST_ENTRY(world->required.head, world_iter)
+	{
+		pkgconf_dependency_t *dep = world_iter->data;
+		pkgconf_pkg_t *pkg = dep->match;
+		pkgconf_node_t *tuple_iter;
+
+		if ((dep->flags & PKGCONF_PKG_DEPF_QUERY) != PKGCONF_PKG_DEPF_QUERY)
+			continue;
+
+		if (dep->match == NULL)
+			continue;
+
+		PKGCONF_FOREACH_LIST_ENTRY(pkg->vars.head, tuple_iter)
+		{
+			pkgconf_tuple_t *tuple = tuple_iter->data;
+			char havebuf[PKGCONF_ITEM_SIZE];
+			char *p;
+
+			if (want_variable != NULL && strcmp(want_variable, tuple->key))
+				continue;
+
+			snprintf(havebuf, sizeof havebuf, "%s_%s", env_prefix, tuple->key);
+
+			for (p = havebuf; *p; p++)
+			{
+				switch (*p)
+				{
+					case ' ':
+					case '-':
+						*p = '_';
+						break;
+
+					default:
+						*p = toupper((unsigned char) *p);
+				}
+			}
+
+			printf("%s='%s'\n", havebuf, tuple->value);
+		}
+	}
+}
+
 static bool
 apply_env(pkgconf_client_t *client, pkgconf_pkg_t *world, void *env_prefix_p, int maxdepth)
 {
@@ -407,17 +580,21 @@ apply_env(pkgconf_client_t *client, pkgconf_pkg_t *world, void *env_prefix_p, in
 	char workbuf[PKGCONF_ITEM_SIZE];
 
 	for (it = want_env_prefix; *it != '\0'; it++)
-		if (!isalpha(*it) && !isdigit(*it))
+		if (!isalpha((unsigned char)*it) &&
+		    !isdigit((unsigned char)*it))
 			return false;
 
 	snprintf(workbuf, sizeof workbuf, "%s_CFLAGS", want_env_prefix);
-	if (!apply_env_var(workbuf, client, world, maxdepth, pkgconf_pkg_cflags, filter_cflags))
+	if (!apply_env_var(workbuf, client, world, maxdepth, pkgconf_pkg_cflags, filter_cflags, maybe_add_module_definitions))
 		return false;
 
 	snprintf(workbuf, sizeof workbuf, "%s_LIBS", want_env_prefix);
-	if (!apply_env_var(workbuf, client, world, maxdepth, pkgconf_pkg_libs, filter_libs))
+	if (!apply_env_var(workbuf, client, world, maxdepth, pkgconf_pkg_libs, filter_libs, NULL))
 		return false;
 
+	if ((want_flags & PKG_VARIABLES) == PKG_VARIABLES || want_variable != NULL)
+		apply_env_variables(client, world, want_env_prefix);
+
 	return true;
 }
 
@@ -435,6 +612,7 @@ apply_cflags(pkgconf_client_t *client, pkgconf_pkg_t *world, void *unused, int m
 		return false;
 
 	pkgconf_fragment_filter(client, &filtered_list, &unfiltered_list, filter_cflags, NULL);
+	maybe_add_module_definitions(client, world, &filtered_list);
 
 	if (filtered_list.head == NULL)
 		goto out;
@@ -642,6 +820,7 @@ usage(void)
 	printf("  --help                            this message\n");
 	printf("  --about                           print pkgconf version and license to stdout\n");
 	printf("  --version                         print supported pkg-config version to stdout\n");
+	printf("  --verbose                         print additional information\n");
 	printf("  --atleast-pkgconfig-version       check whether or not pkgconf is compatible\n");
 	printf("                                    with a specified pkg-config version\n");
 	printf("  --errors-to-stdout                print all errors on stdout instead of stderr\n");
@@ -708,6 +887,7 @@ usage(void)
 	printf("  --print-variables                 print all known variables in module to stdout\n");
 #ifndef PKGCONF_LITE
 	printf("  --digraph                         print entire dependency graph in graphviz 'dot' format\n");
+	printf("  --solution                        print dependency graph solution in a simple format\n");
 #endif
 	printf("  --keep-system-cflags              keep -I%s entries in cflags output\n", SYSTEM_INCLUDEDIR);
 	printf("  --keep-system-libs                keep -L%s entries in libs output\n", SYSTEM_LIBDIR);
@@ -715,12 +895,14 @@ usage(void)
 	printf("  --modversion                      print the specified module's version to stdout\n");
 	printf("  --internal-cflags                 do not filter 'internal' cflags from output\n");
 	printf("  --license                         print the specified module's license to stdout if known\n");
+	printf("  --exists-cflags                   add -DHAVE_FOO fragments to cflags for each found module\n");
 
 	printf("\nfiltering output:\n\n");
 #ifndef PKGCONF_LITE
 	printf("  --msvc-syntax                     print translatable fragments in MSVC syntax\n");
 #endif
 	printf("  --fragment-filter=types           filter output fragments to the specified types\n");
+	printf("  --env=prefix                      print output as shell-compatible environmental variables\n");
 
 	printf("\nreport bugs to <%s>.\n", PACKAGE_BUGREPORT);
 }
@@ -822,6 +1004,11 @@ main(int argc, char *argv[])
 	unsigned int want_client_flags = PKGCONF_PKG_PKGF_NONE;
 	pkgconf_cross_personality_t *personality = NULL;
 	bool opened_error_msgout = false;
+	pkgconf_pkg_t world = {
+		.id = "virtual:world",
+		.realname = "virtual world package",
+		.flags = PKGCONF_PKG_PROPF_STATIC | PKGCONF_PKG_PROPF_VIRTUAL,
+	};
 
 	want_flags = 0;
 
@@ -855,6 +1042,7 @@ main(int argc, char *argv[])
 		{ "print-variables", no_argument, &want_flags, PKG_VARIABLES|PKG_PRINT_ERRORS, },
 #ifndef PKGCONF_LITE
 		{ "digraph", no_argument, &want_flags, PKG_DIGRAPH, },
+		{ "solution", no_argument, &want_flags, PKG_SOLUTION, },
 #endif
 		{ "help", no_argument, &want_flags, PKG_HELP, },
 		{ "env-only", no_argument, &want_flags, PKG_ENV_ONLY, },
@@ -903,6 +1091,8 @@ main(int argc, char *argv[])
 		{ "personality", required_argument, NULL, 53 },
 #endif
 		{ "license", no_argument, &want_flags, PKG_DUMP_LICENSE },
+		{ "verbose", no_argument, NULL, 55 },
+		{ "exists-cflags", no_argument, &want_flags, PKG_EXISTS_CFLAGS },
 		{ NULL, 0, NULL, 0 }
 	};
 
@@ -943,7 +1133,7 @@ main(int argc, char *argv[])
 			logfile_arg = pkg_optarg;
 			break;
 		case 42:
-			pkgconf_path_add(pkg_optarg, &dir_list, true);
+			pkgconf_path_prepend(pkg_optarg, &dir_list, true);
 			break;
 		case 43:
 			pkgconf_client_set_prefix_varname(&pkg_client, pkg_optarg);
@@ -962,6 +1152,9 @@ main(int argc, char *argv[])
 			personality = pkgconf_cross_personality_find(pkg_optarg);
 			break;
 #endif
+		case 55:
+			verbosity++;
+			break;
 		case '?':
 		case ':':
 			ret = EXIT_FAILURE;
@@ -1089,7 +1282,7 @@ main(int argc, char *argv[])
 /* On Windows we want to always redefine the prefix by default
  * but allow that behavior to be manually disabled */
 #if !defined(_WIN32) && !defined(_WIN64)
-	if ((want_flags & PKG_DEFINE_PREFIX) == PKG_DEFINE_PREFIX)
+	if ((want_flags & PKG_DEFINE_PREFIX) == PKG_DEFINE_PREFIX || getenv("PKG_CONFIG_RELOCATE_PATHS") != NULL)
 #endif
 		want_client_flags |= PKGCONF_PKG_PKGF_REDEFINE_PREFIX;
 
@@ -1105,28 +1298,24 @@ main(int argc, char *argv[])
 	if ((want_flags & PKG_INTERNAL_CFLAGS) == PKG_INTERNAL_CFLAGS)
 		want_client_flags |= PKGCONF_PKG_PKGF_DONT_FILTER_INTERNAL_CFLAGS;
 
-#ifdef XXX_NOTYET
-	/* if these selectors are used, it means that we are inquiring about a single package.
-	 * so signal to libpkgconf that we do not want to use the dependency resolver for more than one level,
-	 * and also limit the SAT problem to a single package.
-	 *
-	 * i disabled this because too many upstream maintainers are still invoking pkg-config correctly to have
-	 * the more sane behaviour as default.  use --maximum-traverse-depth=1 or PKG_CONFIG_MAXIMUM_TRAVERSE_DEPTH
-	 * environment variable to get the same results in meantime.
+	/* if these selectors are used, it means that we are querying metadata.
+	 * so signal to libpkgconf that we only want to walk the flattened dependency set.
 	 */
-	if ((want_flags & PKG_EXISTS) == 0 &&
-		((want_flags & PKG_REQUIRES) == PKG_REQUIRES ||
-		(want_flags & PKG_REQUIRES_PRIVATE) == PKG_REQUIRES_PRIVATE ||
-		(want_flags & PKG_PROVIDES) == PKG_PROVIDES ||
-		(want_flags & PKG_VARIABLES) == PKG_VARIABLES ||
-		(want_flags & PKG_MODVERSION) == PKG_MODVERSION ||
-		(want_flags & PKG_PATH) == PKG_PATH ||
-		want_variable != NULL))
-	{
-		maximum_package_count = 1;
+	if ((want_flags & PKG_MODVERSION) == PKG_MODVERSION ||
+	    (want_flags & PKG_REQUIRES) == PKG_REQUIRES ||
+	    (want_flags & PKG_REQUIRES_PRIVATE) == PKG_REQUIRES_PRIVATE ||
+	    (want_flags & PKG_PROVIDES) == PKG_PROVIDES ||
+	    (want_flags & PKG_VARIABLES) == PKG_VARIABLES ||
+	    (want_flags & PKG_PATH) == PKG_PATH)
 		maximum_traverse_depth = 1;
-	}
-#endif
+
+	/* if we are asking for a variable, path or list of variables, this only makes sense
+	 * for a single package.
+	 */
+	if ((want_flags & PKG_VARIABLES) == PKG_VARIABLES ||
+	    (want_flags & PKG_PATH) == PKG_PATH ||
+	    want_variable != NULL)
+		maximum_package_count = 1;
 
 	if (getenv("PKG_CONFIG_ALLOW_SYSTEM_CFLAGS") != NULL)
 		want_flags |= PKG_KEEP_SYSTEM_CFLAGS;
@@ -1137,6 +1326,12 @@ main(int argc, char *argv[])
 	if ((builddir = getenv("PKG_CONFIG_TOP_BUILD_DIR")) != NULL)
 		pkgconf_client_set_buildroot_dir(&pkg_client, builddir);
 
+	if ((want_flags & PKG_REQUIRES_PRIVATE) == PKG_REQUIRES_PRIVATE ||
+		(want_flags & PKG_CFLAGS))
+	{
+		want_client_flags |= PKGCONF_PKG_PKGF_SEARCH_PRIVATE;
+	}
+
 	if ((sysroot_dir = getenv("PKG_CONFIG_SYSROOT_DIR")) != NULL)
 	{
 		const char *destdir;
@@ -1312,7 +1507,8 @@ cleanup3:
 
 	while (1)
 	{
-		const char *package = argv[pkg_optind];
+		char *package = argv[pkg_optind];
+		char *end;
 
 		if (package == NULL)
 			break;
@@ -1320,10 +1516,10 @@ cleanup3:
 		/* check if there is a limit to the number of packages allowed to be included, if so and we have hit
 		 * the limit, stop adding packages to the queue.
 		 */
-		if (maximum_package_count > 0 && pkgq.length > maximum_package_count)
+		if (maximum_package_count > 0 && pkgq.length >= maximum_package_count)
 			break;
 
-		while (isspace((unsigned int)package[0]))
+		while (isspace((unsigned char)package[0]))
 			package++;
 
 		/* skip empty packages */
@@ -1332,11 +1528,24 @@ cleanup3:
 			continue;
 		}
 
+		end = package + strlen(package) - 1;
+		while(end > package && isspace((unsigned char)end[0])) end--;
+		end[1] = '\0';
+
 		if (argv[pkg_optind + 1] == NULL || !PKGCONF_IS_OPERATOR_CHAR(*(argv[pkg_optind + 1])))
 		{
 			pkgconf_queue_push(&pkgq, package);
 			pkg_optind++;
 		}
+		else if (argv[pkg_optind + 2] == NULL)
+		{
+			char packagebuf[PKGCONF_BUFSIZE];
+
+			snprintf(packagebuf, sizeof packagebuf, "%s %s", package, argv[pkg_optind + 1]);
+			pkg_optind += 2;
+
+			pkgconf_queue_push(&pkgq, packagebuf);
+		}
 		else
 		{
 			char packagebuf[PKGCONF_BUFSIZE];
@@ -1357,86 +1566,68 @@ cleanup3:
 
 	ret = EXIT_SUCCESS;
 
+	if (!pkgconf_queue_solve(&pkg_client, &pkgq, &world, maximum_traverse_depth))
+	{
+		ret = EXIT_FAILURE;
+		goto out;
+	}
+
 #ifndef PKGCONF_LITE
 	if ((want_flags & PKG_SIMULATE) == PKG_SIMULATE)
 	{
 		want_flags &= ~(PKG_CFLAGS|PKG_LIBS);
 
 		pkgconf_client_set_flags(&pkg_client, want_client_flags | PKGCONF_PKG_PKGF_SKIP_ERRORS);
-		if (!pkgconf_queue_apply(&pkg_client, &pkgq, apply_simulate, -1, NULL))
-		{
-			ret = EXIT_FAILURE;
-			goto out;
-		}
+		apply_simulate(&pkg_client, &world, NULL, -1);
 	}
 #endif
 
-	if (!pkgconf_queue_validate(&pkg_client, &pkgq, maximum_traverse_depth))
-	{
-		ret = EXIT_FAILURE;
-		goto out;
-	}
-
 	if ((want_flags & PKG_VALIDATE) == PKG_VALIDATE)
 		goto out;
 
 	if ((want_flags & PKG_DUMP_LICENSE) == PKG_DUMP_LICENSE)
 	{
-		pkgconf_queue_apply(&pkg_client, &pkgq, apply_license, maximum_traverse_depth, &ret);
+		apply_license(&pkg_client, &world, &ret, 2);
 		goto out;
 	}
 
 	if ((want_flags & PKG_UNINSTALLED) == PKG_UNINSTALLED)
 	{
 		ret = EXIT_FAILURE;
-		pkgconf_queue_apply(&pkg_client, &pkgq, apply_uninstalled, maximum_traverse_depth, &ret);
+		apply_uninstalled(&pkg_client, &world, &ret, 2);
 		goto out;
 	}
 
 	if (want_env_prefix != NULL)
 	{
-		if (!pkgconf_queue_apply(&pkg_client, &pkgq, apply_env, maximum_traverse_depth, want_env_prefix))
-		{
-			ret = EXIT_FAILURE;
-			goto out;
-		}
-
-		want_flags = 0;
+		apply_env(&pkg_client, &world, want_env_prefix, 2);
+		goto out;
 	}
 
 	if ((want_flags & PKG_PROVIDES) == PKG_PROVIDES)
 	{
 		want_flags &= ~(PKG_CFLAGS|PKG_LIBS);
-
-		if (!pkgconf_queue_apply(&pkg_client, &pkgq, apply_provides, maximum_traverse_depth, NULL))
-		{
-			ret = EXIT_FAILURE;
-			goto out;
-		}
+		apply_provides(&pkg_client, &world, NULL, 2);
 	}
 
 #ifndef PKGCONF_LITE
 	if ((want_flags & PKG_DIGRAPH) == PKG_DIGRAPH)
 	{
 		want_flags &= ~(PKG_CFLAGS|PKG_LIBS);
+		apply_digraph(&pkg_client, &world, &pkgq, 2);
+	}
 
-		if (!pkgconf_queue_apply(&pkg_client, &pkgq, apply_digraph, maximum_traverse_depth, NULL))
-		{
-			ret = EXIT_FAILURE;
-			goto out;
-		}
+	if ((want_flags & PKG_SOLUTION) == PKG_SOLUTION)
+	{
+		want_flags &= ~(PKG_CFLAGS|PKG_LIBS);
+		apply_print_solution(&pkg_client, &world, NULL, 2);
 	}
 #endif
 
 	if ((want_flags & PKG_MODVERSION) == PKG_MODVERSION)
 	{
 		want_flags &= ~(PKG_CFLAGS|PKG_LIBS);
-
-		if (!pkgconf_queue_apply(&pkg_client, &pkgq, apply_modversion, maximum_traverse_depth, NULL))
-		{
-			ret = EXIT_FAILURE;
-			goto out;
-		}
+		apply_modversion(&pkg_client, &world, &pkgq, 2);
 	}
 
 	if ((want_flags & PKG_PATH) == PKG_PATH)
@@ -1444,22 +1635,13 @@ cleanup3:
 		want_flags &= ~(PKG_CFLAGS|PKG_LIBS);
 
 		pkgconf_client_set_flags(&pkg_client, want_client_flags | PKGCONF_PKG_PKGF_SKIP_ROOT_VIRTUAL);
-		if (!pkgconf_queue_apply(&pkg_client, &pkgq, apply_path, maximum_traverse_depth, NULL))
-		{
-			ret = EXIT_FAILURE;
-			goto out;
-		}
+		apply_path(&pkg_client, &world, NULL, 2);
 	}
 
 	if ((want_flags & PKG_VARIABLES) == PKG_VARIABLES)
 	{
 		want_flags &= ~(PKG_CFLAGS|PKG_LIBS);
-
-		if (!pkgconf_queue_apply(&pkg_client, &pkgq, apply_variables, maximum_traverse_depth, NULL))
-		{
-			ret = EXIT_FAILURE;
-			goto out;
-		}
+		apply_variables(&pkg_client, &world, NULL, 2);
 	}
 
 	if (want_variable)
@@ -1467,66 +1649,43 @@ cleanup3:
 		want_flags &= ~(PKG_CFLAGS|PKG_LIBS);
 
 		pkgconf_client_set_flags(&pkg_client, want_client_flags | PKGCONF_PKG_PKGF_SKIP_ROOT_VIRTUAL);
-		if (!pkgconf_queue_apply(&pkg_client, &pkgq, apply_variable, maximum_traverse_depth, want_variable))
-		{
-			ret = EXIT_FAILURE;
-			goto out;
-		}
+		apply_variable(&pkg_client, &world, want_variable, 2);
 	}
 
 	if ((want_flags & PKG_REQUIRES) == PKG_REQUIRES)
 	{
 		want_flags &= ~(PKG_CFLAGS|PKG_LIBS);
-
-		if (!pkgconf_queue_apply(&pkg_client, &pkgq, apply_requires, maximum_traverse_depth, NULL))
-		{
-			ret = EXIT_FAILURE;
-			goto out;
-		}
+		apply_requires(&pkg_client, &world, NULL, 2);
 	}
 
 	if ((want_flags & PKG_REQUIRES_PRIVATE) == PKG_REQUIRES_PRIVATE)
 	{
 		want_flags &= ~(PKG_CFLAGS|PKG_LIBS);
 
-		pkgconf_client_set_flags(&pkg_client, want_client_flags | PKGCONF_PKG_PKGF_SEARCH_PRIVATE);
-
-		if (!pkgconf_queue_apply(&pkg_client, &pkgq, apply_requires_private, maximum_traverse_depth, NULL))
-		{
-			ret = EXIT_FAILURE;
-			goto out;
-		}
-
-		pkgconf_client_set_flags(&pkg_client, want_client_flags);
+		apply_requires_private(&pkg_client, &world, NULL, 2);
 	}
 
 	if ((want_flags & PKG_CFLAGS))
 	{
-		pkgconf_client_set_flags(&pkg_client, want_client_flags | PKGCONF_PKG_PKGF_SEARCH_PRIVATE);
-
-		if (!pkgconf_queue_apply(&pkg_client, &pkgq, apply_cflags, maximum_traverse_depth, NULL))
-		{
-			ret = EXIT_FAILURE;
-			goto out_println;
-		}
-
-		pkgconf_client_set_flags(&pkg_client, want_client_flags);
+		apply_cflags(&pkg_client, &world, NULL, 2);
 	}
 
 	if ((want_flags & PKG_LIBS))
 	{
-		if (!pkgconf_queue_apply(&pkg_client, &pkgq, apply_libs, maximum_traverse_depth, NULL))
-		{
-			ret = EXIT_FAILURE;
-			goto out_println;
-		}
+		if (want_flags & PKG_CFLAGS)
+			printf(" ");
+
+		if (!(want_flags & PKG_STATIC))
+			pkgconf_client_set_flags(&pkg_client, pkg_client.flags & ~PKGCONF_PKG_PKGF_SEARCH_PRIVATE);
+
+		apply_libs(&pkg_client, &world, NULL, 2);
 	}
 
-out_println:
 	if (want_flags & (PKG_CFLAGS|PKG_LIBS))
 		printf("\n");
 
 out:
+	pkgconf_solution_free(&pkg_client, &world);
 	pkgconf_queue_free(&pkgq);
 	pkgconf_cross_personality_deinit(personality);
 	pkgconf_client_deinit(&pkg_client);

cli/renderer-msvc.c

@@ -149,7 +149,6 @@ msvc_renderer_render_buf(const pkgconf_list_t *list, char *buf, size_t buflen, b
 		{
 			cnt = pkgconf_strlcpy(bptr, ".lib", buf_remaining);
 			bptr += cnt;
-			buf_remaining -= cnt;
 		}
 
 		if (escape)

configure.ac

@@ -12,7 +12,7 @@ dnl implied.  In no event shall the authors be liable for any damages arising
 dnl from the use of this software.
 
 AC_PREREQ([2.71])
-AC_INIT([pkgconf],[1.9.0],[https://github.com/pkgconf/pkgconf/issues/new])
+AC_INIT([pkgconf],[2.3.0],[https://github.com/pkgconf/pkgconf/issues/new])
 AC_CONFIG_SRCDIR([cli/main.c])
 AC_CONFIG_MACRO_DIR([m4])
 AX_CHECK_COMPILE_FLAG([-Wall], [CFLAGS="$CFLAGS -Wall"])
@@ -22,7 +22,8 @@ AX_CHECK_COMPILE_FLAG([-std=gnu99], [CFLAGS="$CFLAGS -std=gnu99"], [
 	AX_CHECK_COMPILE_FLAG([-std=c99], [CFLAGS="$CFLAGS -std=c99"])
 ])
 AC_CONFIG_HEADERS([libpkgconf/config.h])
-AC_CHECK_FUNCS([strlcpy strlcat strndup reallocarray])
+AC_CHECK_DECLS([strlcpy, strlcat, strndup], [], [], [[#include <string.h>]])
+AC_CHECK_DECLS([reallocarray])
 AC_CHECK_HEADERS([sys/stat.h])
 AM_INIT_AUTOMAKE([foreign dist-xz subdir-objects])
 AM_SILENT_RULES([yes])

doc/extract.py

@@ -70,21 +70,21 @@ def extract_comments(filename):
             while True:
                 char = source_file.read(1)
                 if not char:
-                    if state is 3 or state is 4:
+                    if state == 3 or state == 4:
                         raise UnterminatedCommentError()
-                    if state is 2:
+                    if state == 2:
                         # Was in single line comment. Create comment.
                         comment = Comment(current_comment, line_counter, False)
                         comments.append(comment)
                     return comments
-                if state is 0:
+                if state == 0:
                     # Waiting for comment start character or beginning of
                     # string.
                     if char == '/':
                         state = 1
                     elif char == '"':
                         state = 5
-                elif state is 1:
+                elif state == 1:
                     # Found comment start character, classify next character and
                     # determine if single or multiline comment.
                     if char == '/':
@@ -94,7 +94,7 @@ def extract_comments(filename):
                         state = 3
                     else:
                         state = 0
-                elif state is 2:
+                elif state == 2:
                     # In single line comment, read characters until EOL.
                     if char == '\n':
                         comment = Comment(current_comment, line_counter, False)
@@ -103,14 +103,14 @@ def extract_comments(filename):
                         state = 0
                     else:
                         current_comment += char
-                elif state is 3:
+                elif state == 3:
                     # In multi-line comment, add characters until '*'
                     # encountered.
                     if char == '*':
                         state = 4
                     else:
                         current_comment += char
-                elif state is 4:
+                elif state == 4:
                     # In multi-line comment with asterisk found. Determine if
                     # comment is ending.
                     if char == '/':
@@ -125,13 +125,13 @@ def extract_comments(filename):
                         if char != '*':
                             current_comment += char
                             state = 3
-                elif state is 5:
+                elif state == 5:
                     # In string literal, expect literal end or escape char.
                     if char == '"':
                         state = 0
                     elif char == '\\':
                         state = 6
-                elif state is 6:
+                elif state == 6:
                     # In string literal, escaping current char.
                     state = 5
                 if char == '\n':

doc/libpkgconf-client.rst

@@ -9,21 +9,32 @@ in parallel.
 Client objects are not thread safe, in other words, a client object should not be shared across
 thread boundaries.
 
-.. c:function:: void pkgconf_client_init(pkgconf_client_t *client, pkgconf_error_handler_func_t error_handler)
+.. c:function:: void pkgconf_client_dir_list_build(pkgconf_client_t *client)
+
+   Bootstraps the package search paths.  If the ``PKGCONF_PKG_PKGF_ENV_ONLY`` `flag` is set on the client,
+   then only the ``PKG_CONFIG_PATH`` environment variable will be used, otherwise both the
+   ``PKG_CONFIG_PATH`` and ``PKG_CONFIG_LIBDIR`` environment variables will be used.
+
+   :param pkgconf_client_t* client: The pkgconf client object to bootstrap.
+   :return: nothing
+
+.. c:function:: void pkgconf_client_init(pkgconf_client_t *client, pkgconf_error_handler_func_t error_handler, void *error_handler_data, const pkgconf_cross_personality_t *personality)
 
    Initialise a pkgconf client object.
 
    :param pkgconf_client_t* client: The client to initialise.
    :param pkgconf_error_handler_func_t error_handler: An optional error handler to use for logging errors.
    :param void* error_handler_data: user data passed to optional error handler
+   :param pkgconf_cross_personality_t* personality: the cross-compile personality to use for defaults
    :return: nothing
 
-.. c:function:: pkgconf_client_t* pkgconf_client_new(pkgconf_error_handler_func_t error_handler)
+.. c:function:: pkgconf_client_t* pkgconf_client_new(pkgconf_error_handler_func_t error_handler, void *error_handler_data, const pkgconf_cross_personality_t *personality)
 
    Allocate and initialise a pkgconf client object.
 
    :param pkgconf_error_handler_func_t error_handler: An optional error handler to use for logging errors.
    :param void* error_handler_data: user data passed to optional error handler
+   :param pkgconf_cross_personality_t* personality: cross-compile personality to use
    :return: A pkgconf client object.
    :rtype: pkgconf_client_t*
 
@@ -97,11 +108,14 @@ thread boundaries.
    :return: true if the warn handler processed the message, else false.
    :rtype: bool
 
-.. c:function:: bool pkgconf_trace(const pkgconf_client_t *client, const char *format, ...)
+.. c:function:: bool pkgconf_trace(const pkgconf_client_t *client, const char *filename, size_t len, const char *funcname, const char *format, ...)
 
    Report a message to a client-registered trace handler.
 
    :param pkgconf_client_t* client: The pkgconf client object to report the trace message to.
+   :param char* filename: The file the function is in.
+   :param size_t lineno: The line number currently being executed.
+   :param char* funcname: The function name to use.
    :param char* format: A printf-style format string to use for formatting the trace message.
    :return: true if the trace handler processed the message, else false.
    :rtype: bool

doc/libpkgconf-dependency.rst

@@ -14,6 +14,7 @@ The `dependency` module provides support for building `dependency lists` (the ba
    :param char* package: The package `atom` to set on the dependency node.
    :param char* version: The package `version` to set on the dependency node.
    :param pkgconf_pkg_comparator_t compare: The comparison operator to set on the dependency node.
+   :param uint flags: Any flags to attach to the dependency node.
    :return: A dependency node.
    :rtype: pkgconf_dependency_t *
 
@@ -25,9 +26,32 @@ The `dependency` module provides support for building `dependency lists` (the ba
    :param pkgconf_dependency_t* tail: The dependency node to add to the tail of the dependency list.
    :return: nothing
 
+.. c:function:: void pkgconf_dependency_free_one(pkgconf_dependency_t *dep)
+
+   Frees a dependency node.
+
+   :param pkgconf_dependency_t* dep: The dependency node to free.
+   :return: nothing
+
+.. c:function:: pkgconf_dependency_t *pkgconf_dependency_ref(pkgconf_client_t *owner, pkgconf_dependency_t *dep)
+
+   Increases a dependency node's refcount.
+
+   :param pkgconf_client_t* owner: The client object which owns the memory of this dependency node.
+   :param pkgconf_dependency_t* dep: The dependency to increase the refcount of.
+   :return: the dependency node on success, else NULL
+
+.. c:function:: void pkgconf_dependency_unref(pkgconf_client_t *owner, pkgconf_dependency_t *dep)
+
+   Decreases a dependency node's refcount and frees it if necessary.
+
+   :param pkgconf_client_t* owner: The client object which owns the memory of this dependency node.
+   :param pkgconf_dependency_t* dep: The dependency to decrease the refcount of.
+   :return: nothing
+
 .. c:function:: void pkgconf_dependency_free(pkgconf_list_t *list)
 
-   Release a dependency list and it's child dependency nodes.
+   Release a dependency list and its child dependency nodes.
 
    :param pkgconf_list_t* list: The dependency list to release.
    :return: nothing
@@ -41,6 +65,7 @@ The `dependency` module provides support for building `dependency lists` (the ba
    :param pkgconf_client_t* client: The client object that owns the package this dependency list belongs to.
    :param pkgconf_list_t* deplist_head: The dependency list to populate with dependency nodes.
    :param char* depends: The dependency data to parse.
+   :param uint flags: Any flags to attach to the dependency nodes.
    :return: nothing
 
 .. c:function:: void pkgconf_dependency_parse(const pkgconf_client_t *client, pkgconf_pkg_t *pkg, pkgconf_list_t *deplist, const char *depends)
@@ -53,4 +78,13 @@ The `dependency` module provides support for building `dependency lists` (the ba
    :param pkgconf_pkg_t* pkg: The package object that owns this dependency list.
    :param pkgconf_list_t* deplist: The dependency list to populate with dependency nodes.
    :param char* depends: The dependency data to parse.
+   :param uint flags: Any flags to attach to the dependency nodes.
    :return: nothing
+
+.. c:function:: pkgconf_dependency_t *pkgconf_dependency_copy(pkgconf_client_t *client, const pkgconf_dependency_t *dep)
+
+   Copies a dependency node to a new one.
+
+   :param pkgconf_client_t* client: The client object that will own this dependency.
+   :param pkgconf_dependency_t* dep: The dependency node to copy.
+   :return: a pointer to a new dependency node, else NULL

doc/libpkgconf-fragment.rst

@@ -6,13 +6,14 @@ The `fragment` module provides low-level management and rendering of fragment li
 `fragment list` contains various `fragments` of text (such as ``-I /usr/include``) in a matter
 which is composable, mergeable and reorderable.
 
-.. c:function:: void pkgconf_fragment_add(const pkgconf_client_t *client, pkgconf_list_t *list, const char *string)
+.. c:function:: void pkgconf_fragment_add(const pkgconf_client_t *client, pkgconf_list_t *list, const char *string, unsigned int flags)
 
    Adds a `fragment` of text to a `fragment list`, possibly modifying the fragment if a sysroot is set.
 
    :param pkgconf_client_t* client: The pkgconf client being accessed.
    :param pkgconf_list_t* list: The fragment list.
    :param char* string: The string of text to add as a fragment to the fragment list.
+   :param uint flags: Parsing-related flags for the package.
    :return: nothing
 
 .. c:function:: bool pkgconf_fragment_has_system_dir(const pkgconf_client_t *client, const pkgconf_fragment_t *frag)
@@ -110,5 +111,6 @@ which is composable, mergeable and reorderable.
    :param pkgconf_client_t* client: The pkgconf client being accessed.
    :param pkgconf_list_t* list: The `fragment list` to add the fragment entries to.
    :param pkgconf_list_t* vars: A list of variables to use for variable substitution.
+   :param uint flags: Any parsing flags to be aware of.
    :param char* value: The string to parse into fragments.
    :return: true on success, false on parse error

doc/libpkgconf-path.rst

@@ -25,12 +25,12 @@ variables.
    :return: number of path nodes added to the path list
    :rtype: size_t
 
-.. c:function:: size_t pkgconf_path_build_from_environ(const char *environ, const char *fallback, pkgconf_list_t *dirlist)
+.. c:function:: size_t pkgconf_path_build_from_environ(const char *envvarname, const char *fallback, pkgconf_list_t *dirlist)
 
    Adds the paths specified in an environment variable to a path list.  If the environment variable is not set,
    an optional default set of paths is added.
 
-   :param char* environ: The environment variable to look up.
+   :param char* envvarname: The environment variable to look up.
    :param char* fallback: The fallback paths to use if the environment variable is not set.
    :param pkgconf_list_t* dirlist: The path list to add the path nodes to.
    :param bool filter: Whether to perform duplicate filtering.
@@ -46,6 +46,14 @@ variables.
    :return: true if the path list has a matching prefix, otherwise false
    :rtype: bool
 
+.. c:function:: void pkgconf_path_copy_list(pkgconf_list_t *dst, const pkgconf_list_t *src)
+
+   Copies a path list to another path list.
+
+   :param pkgconf_list_t* dst: The path list to copy to.
+   :param pkgconf_list_t* src: The path list to copy from.
+   :return: nothing
+
 .. c:function:: void pkgconf_path_free(pkgconf_list_t *dirlist)
 
    Releases any path nodes attached to the given path list.

doc/libpkgconf-personality.rst

@@ -0,0 +1,27 @@
+
+libpkgconf `personality` module
+=========================
+
+.. c:function:: const pkgconf_cross_personality_t *pkgconf_cross_personality_default(void)
+
+   Returns the default cross-compile personality.
+
+   Not thread safe.
+
+   :rtype: pkgconf_cross_personality_t*
+   :return: the default cross-compile personality
+
+.. c:function:: void pkgconf_cross_personality_deinit(pkgconf_cross_personality_t *)
+
+   Decrements the count of default cross personality instances.
+
+   Not thread safe.
+
+   :rtype: void
+
+.. c:function:: pkgconf_cross_personality_t *pkgconf_cross_personality_find(const char *triplet)
+
+   Attempts to find a cross-compile personality given a triplet.
+
+   :rtype: pkgconf_cross_personality_t*
+   :return: the default cross-compile personality

doc/libpkgconf-pkg.rst

@@ -5,22 +5,14 @@ libpkgconf `pkg` module
 The `pkg` module provides dependency resolution services and the overall `.pc` file parsing
 routines.
 
-.. c:function:: void pkgconf_pkg_dir_list_build(pkgconf_client_t *client)
-
-   Bootstraps the package search paths.  If the ``PKGCONF_PKG_PKGF_ENV_ONLY`` `flag` is set on the client,
-   then only the ``PKG_CONFIG_PATH`` environment variable will be used, otherwise both the
-   ``PKG_CONFIG_PATH`` and ``PKG_CONFIG_LIBDIR`` environment variables will be used.
-
-   :param pkgconf_client_t* client: The pkgconf client object to bootstrap.
-   :return: nothing
-
-.. c:function:: pkgconf_pkg_t *pkgconf_pkg_new_from_file(const pkgconf_client_t *client, const char *filename, FILE *f)
+.. c:function:: pkgconf_pkg_t *pkgconf_pkg_new_from_file(const pkgconf_client_t *client, const char *filename, FILE *f, unsigned int flags)
 
    Parse a .pc file into a pkgconf_pkg_t object structure.
 
    :param pkgconf_client_t* client: The pkgconf client object to use for dependency resolution.
    :param char* filename: The filename of the package file (including full path).
    :param FILE* f: The file object to read from.
+   :param uint flags: The flags to use when parsing.
    :returns: A ``pkgconf_pkg_t`` object which contains the package data.
    :rtype: pkgconf_pkg_t *
 
@@ -76,7 +68,7 @@ routines.
 
    :param char* a: The first version to compare in the pair.
    :param char* b: The second version to compare in the pair.
-   :return: -1 if the first version is greater, 0 if both versions are equal, 1 if the second version is greater.
+   :return: -1 if the first version is less than, 0 if both versions are equal, 1 if the second version is less than.
    :rtype: int
 
 .. c:function:: pkgconf_pkg_t *pkgconf_builtin_pkg_get(const char *name)
@@ -126,7 +118,7 @@ routines.
    :return: On success, ``PKGCONF_PKG_ERRF_OK`` (0), else an error code.
    :rtype: unsigned int
 
-.. c:function:: unsigned int pkgconf_pkg_traverse(pkgconf_client_t *client, pkgconf_pkg_t *root, pkgconf_pkg_traverse_func_t func, void *data, int maxdepth)
+.. c:function:: unsigned int pkgconf_pkg_traverse(pkgconf_client_t *client, pkgconf_pkg_t *root, pkgconf_pkg_traverse_func_t func, void *data, int maxdepth, unsigned int skip_flags)
 
    Walk and resolve the dependency graph up to `maxdepth` levels.
 
@@ -135,6 +127,7 @@ routines.
    :param pkgconf_pkg_traverse_func_t func: A traversal function to call for each resolved node in the dependency graph.
    :param void* data: An opaque pointer to data to be passed to the traversal function.
    :param int maxdepth: The maximum depth to walk the dependency graph for.  -1 means infinite recursion.
+   :param uint skip_flags: Skip over dependency nodes containing the specified flags.  A setting of 0 skips no dependency nodes.
    :return: ``PKGCONF_PKG_ERRF_OK`` on success, else an error code.
    :rtype: unsigned int
 

doc/libpkgconf-queue.rst

@@ -33,11 +33,32 @@ Using the `queue` module functions is the recommended way of working with depend
    :param pkgconf_list_t* list: The dependency resolution queue to release.
    :return: nothing
 
+.. c:function:: void pkgconf_solution_free(pkgconf_client_t *client, pkgconf_pkg_t *world, int maxdepth)
+
+   Removes references to package nodes contained in a solution.
+
+   :param pkgconf_client_t* client: The pkgconf client object to use for dependency resolution.
+   :param pkgconf_pkg_t* world: The root for the generated dependency graph.  Should have PKGCONF_PKG_PROPF_VIRTUAL flag.
+   :returns: nothing
+
+.. c:function:: bool pkgconf_queue_solve(pkgconf_client_t *client, pkgconf_list_t *list, pkgconf_pkg_t *world, int maxdepth)
+
+   Solves and flattens the dependency graph for the supplied dependency list.
+
+   :param pkgconf_client_t* client: The pkgconf client object to use for dependency resolution.
+   :param pkgconf_list_t* list: The list of dependency requests to consider.
+   :param pkgconf_pkg_t* world: The root for the generated dependency graph, provided by the caller.  Should have PKGCONF_PKG_PROPF_VIRTUAL flag.
+   :param int maxdepth: The maximum allowed depth for the dependency resolver.  A depth of -1 means unlimited.
+   :returns: true if the dependency resolver found a solution, otherwise false.
+   :rtype: bool
+
 .. c:function:: void pkgconf_queue_apply(pkgconf_client_t *client, pkgconf_list_t *list, pkgconf_queue_apply_func_t func, int maxdepth, void *data)
 
    Attempt to compile a dependency resolution queue into a dependency resolution problem, then attempt to solve the problem and
    feed the solution to a callback function if a complete dependency graph is found.
 
+   This function should not be used in new code.  Use pkgconf_queue_solve instead.
+
    :param pkgconf_client_t* client: The pkgconf client object to use for dependency resolution.
    :param pkgconf_list_t* list: The list of dependency requests to consider.
    :param pkgconf_queue_apply_func_t func: The callback function to call if a solution is found by the dependency resolver.

doc/libpkgconf-tuple.rst

@@ -64,13 +64,14 @@ attached to a given client object.
    :return: the value of the variable or ``NULL``
    :rtype: char *
 
-.. c:function:: char *pkgconf_tuple_parse(const pkgconf_client_t *client, pkgconf_list_t *vars, const char *value)
+.. c:function:: char *pkgconf_tuple_parse(const pkgconf_client_t *client, pkgconf_list_t *vars, const char *value, unsigned int flags)
 
    Parse an expression for variable substitution.
 
    :param pkgconf_client_t* client: The pkgconf client object to access.
    :param pkgconf_list_t* list: The variable list to search for variables (along side the global variable list).
    :param char* value: The ``key=value`` string to parse.
+   :param uint flags: Any flags to consider while parsing.
    :return: the variable data with any variables substituted
    :rtype: char *
 

doc/libpkgconf.rst

@@ -11,6 +11,7 @@ libpkgconf - an API for managing `pkg-config` modules
    libpkgconf-dependency
    libpkgconf-fragment
    libpkgconf-path
+   libpkgconf-personality
    libpkgconf-pkg
    libpkgconf-queue
    libpkgconf-tuple

libpkgconf.pc.in

@@ -5,7 +5,8 @@ libdir=@libdir@
 
 Name: libpkgconf
 Description: a library for accessing and manipulating development framework configuration
-URL: http://github.com/pkgconf/pkgconf
+URL: https://gitea.treehouse.systems/ariadne/pkgconf
+License: ISC
 Version: @PACKAGE_VERSION@
 CFlags: -I${includedir}/pkgconf
 Libs: -L${libdir} -lpkgconf

libpkgconf/argvsplit.c

@@ -72,7 +72,7 @@ pkgconf_argv_split(const char *src, int *argc, char ***argv)
 
 	memset(buf, 0, strlen(src) + 1);
 
-	*argv = calloc(sizeof (void *), argv_size);
+	*argv = calloc(argv_size, sizeof (void *));
 	(*argv)[argc_count] = dst_iter;
 
 	while (*src_iter)
@@ -80,7 +80,7 @@ pkgconf_argv_split(const char *src, int *argc, char ***argv)
 		if (escaped)
 		{
 			/* POSIX: only \CHAR is special inside a double quote if CHAR is {$, `, ", \, newline}. */
-			if (quote == '\"')
+			if (quote == '"')
 			{
 				if (!(*src_iter == '$' || *src_iter == '`' || *src_iter == '"' || *src_iter == '\\'))
 					*dst_iter++ = '\\';
@@ -88,7 +88,9 @@ pkgconf_argv_split(const char *src, int *argc, char ***argv)
 				*dst_iter++ = *src_iter;
 			}
 			else
+			{
 				*dst_iter++ = *src_iter;
+			}
 
 			escaped = false;
 		}
@@ -101,7 +103,7 @@ pkgconf_argv_split(const char *src, int *argc, char ***argv)
 			else
 				*dst_iter++ = *src_iter;
 		}
-		else if (isspace((unsigned int)*src_iter))
+		else if (isspace((unsigned char)*src_iter))
 		{
 			if ((*argv)[argc_count] != NULL)
 			{
@@ -118,11 +120,9 @@ pkgconf_argv_split(const char *src, int *argc, char ***argv)
 		}
 		else switch(*src_iter)
 		{
-#ifndef _WIN32
 			case '\\':
 				escaped = true;
 				break;
-#endif
 
 			case '\"':
 			case '\'':

libpkgconf/bsdstubs.c

@@ -25,7 +25,7 @@
 #include <libpkgconf/bsdstubs.h>
 #include <libpkgconf/config.h>
 
-#ifndef HAVE_STRLCPY
+#if !HAVE_DECL_STRLCPY
 /*
  * Copy src to string dst of size siz.  At most siz-1 characters
  * will be copied.  Always NUL terminates (unless siz == 0).
@@ -58,7 +58,7 @@ strlcpy(char *dst, const char *src, size_t siz)
 }
 #endif
 
-#ifndef HAVE_STRLCAT
+#if !HAVE_DECL_STRLCAT
 /*
  * Appends src to string dst of size siz (unlike strncat, siz is the
  * full size of dst, not space left).  At most siz-1 characters
@@ -107,7 +107,7 @@ strlcat(char *dst, const char *src, size_t siz)
  * from the use of this software.
  */
 
-#ifndef HAVE_STRNDUP
+#if !HAVE_DECL_STRNDUP
 /*
  * Creates a memory buffer and copies at most 'len' characters to it.
  * If 'len' is less than the length of the source string, truncation occured.
@@ -139,7 +139,7 @@ pkgconf_strndup(const char *src, size_t len)
 	return strndup(src, len);
 }
 
-#ifndef HAVE_REALLOCARRAY
+#if !HAVE_DECL_REALLOCARRAY
 void *
 reallocarray(void *ptr, size_t m, size_t n)
 {

libpkgconf/cache.c

@@ -66,7 +66,7 @@ cache_dump(const pkgconf_client_t *client)
 	{
 		const pkgconf_pkg_t *pkg = client->cache_table[i];
 
-		PKGCONF_TRACE(client, "%zu: %p(%s)",
+		PKGCONF_TRACE(client, SIZE_FMT_SPECIFIER": %p(%s)",
 			i, pkg, pkg == NULL ? "NULL" : pkg->id);
 	}
 }

libpkgconf/client.c

@@ -161,7 +161,7 @@ pkgconf_client_init(pkgconf_client_t *client, pkgconf_error_handler_func_t error
 pkgconf_client_t *
 pkgconf_client_new(pkgconf_error_handler_func_t error_handler, void *error_handler_data, const pkgconf_cross_personality_t *personality)
 {
-	pkgconf_client_t *out = calloc(sizeof(pkgconf_client_t), 1);
+	pkgconf_client_t *out = calloc(1, sizeof(pkgconf_client_t));
 	pkgconf_client_init(out, error_handler, error_handler_data, personality);
 	return out;
 }

libpkgconf/config.h.meson

@@ -12,6 +12,18 @@
 /* Define to 1 if you have the `reallocarray' function. */
 #mesondefine HAVE_REALLOCARRAY
 
+/* Define to 1 if you have the `strlcat' function. */
+#mesondefine HAVE_DECL_STRLCAT
+
+/* Define to 1 if you have the `strlcpy' function. */
+#mesondefine HAVE_DECL_STRLCPY
+
+/* Define to 1 if you have the `strndup' function. */
+#mesondefine HAVE_DECL_STRNDUP
+
+/* Define to 1 if you have the `reallocarray' function. */
+#mesondefine HAVE_DECL_REALLOCARRAY
+
 /* Name of package */
 #mesondefine PACKAGE
 
@@ -54,3 +66,8 @@
 #mesondefine SYSTEM_INCLUDEDIR
 #mesondefine SYSTEM_LIBDIR
 #mesondefine PERSONALITY_PATH
+
+/* Enable Solaris extensions. */
+#ifndef __EXTENSIONS__
+# define __EXTENSIONS__ 1
+#endif

libpkgconf/dependency.c

@@ -130,7 +130,7 @@ pkgconf_dependency_addraw(pkgconf_client_t *client, pkgconf_list_t *list, const
 {
 	pkgconf_dependency_t *dep;
 
-	dep = calloc(sizeof(pkgconf_dependency_t), 1);
+	dep = calloc(1, sizeof(pkgconf_dependency_t));
 	dep->package = pkgconf_strndup(package, package_sz);
 
 	if (version_sz != 0)
@@ -262,7 +262,7 @@ pkgconf_dependency_unref(pkgconf_client_t *client, pkgconf_dependency_t *dep)
  *
  * .. c:function:: void pkgconf_dependency_free(pkgconf_list_t *list)
  *
- *    Release a dependency list and it's child dependency nodes.
+ *    Release a dependency list and its child dependency nodes.
  *
  *    :param pkgconf_list_t* list: The dependency list to release.
  *    :return: nothing
@@ -329,11 +329,11 @@ pkgconf_dependency_parse_str(pkgconf_client_t *client, pkgconf_list_t *deplist_h
 			break;
 
 		case INSIDE_MODULE_NAME:
-			if (isspace((unsigned int)*ptr))
+			if (isspace((unsigned char)*ptr))
 			{
 				const char *sptr = ptr;
 
-				while (*sptr && isspace((unsigned int)*sptr))
+				while (*sptr && isspace((unsigned char)*sptr))
 					sptr++;
 
 				if (*sptr == '\0')
@@ -386,18 +386,19 @@ pkgconf_dependency_parse_str(pkgconf_client_t *client, pkgconf_list_t *deplist_h
 			break;
 
 		case INSIDE_OPERATOR:
-			if (!PKGCONF_IS_OPERATOR_CHAR(*ptr))
+			if (PKGCONF_IS_OPERATOR_CHAR(*ptr))
 			{
-				state = AFTER_OPERATOR;
-				compare = pkgconf_pkg_comparator_lookup_by_name(cmpname);
+				if (cnameptr < cnameend)
+					*cnameptr++ = *ptr;
+				break;
 			}
-			else if (cnameptr < cnameend)
-				*cnameptr++ = *ptr;
 
-			break;
+			state = AFTER_OPERATOR;
+			compare = pkgconf_pkg_comparator_lookup_by_name(cmpname);
+			// fallthrough
 
 		case AFTER_OPERATOR:
-			if (!isspace((unsigned int)*ptr))
+			if (!isspace((unsigned char)*ptr))
 			{
 				vstart = ptr;
 				state = INSIDE_VERSION;
@@ -469,7 +470,7 @@ pkgconf_dependency_copy(pkgconf_client_t *client, const pkgconf_dependency_t *de
 {
 	pkgconf_dependency_t *new_dep;
 
-	new_dep = calloc(sizeof(pkgconf_dependency_t), 1);
+	new_dep = calloc(1, sizeof(pkgconf_dependency_t));
 	new_dep->package = strdup(dep->package);
 
 	if (dep->version != NULL)

libpkgconf/fragment.c

@@ -120,6 +120,38 @@ pkgconf_fragment_copy_munged(const pkgconf_client_t *client, const char *source,
 	return strdup(mungebuf);
 }
 
+/*
+ * !doc
+ *
+ * .. c:function:: void pkgconf_fragment_insert(const pkgconf_client_t *client, pkgconf_list_t *list, char type, const char *data, bool tail)
+ *
+ *    Adds a `fragment` of text to a `fragment list` directly without interpreting it.
+ *
+ *    :param pkgconf_client_t* client: The pkgconf client being accessed.
+ *    :param pkgconf_list_t* list: The fragment list.
+ *    :param char type: The type of the fragment.
+ *    :param char* data: The data of the fragment.
+ *    :param bool tail: Whether to place the fragment at the beginning of the list or the end.
+ *    :return: nothing
+ */
+void
+pkgconf_fragment_insert(const pkgconf_client_t *client, pkgconf_list_t *list, char type, const char *data, bool tail)
+{
+	pkgconf_fragment_t *frag;
+
+	frag = calloc(1, sizeof(pkgconf_fragment_t));
+	frag->type = type;
+	frag->data = pkgconf_fragment_copy_munged(client, data, 0);
+
+	if (tail)
+	{
+		pkgconf_node_insert_tail(&frag->iter, frag, list);
+		return;
+	}
+
+	pkgconf_node_insert(&frag->iter, frag, list);
+}
+
 /*
  * !doc
  *
@@ -143,7 +175,7 @@ pkgconf_fragment_add(const pkgconf_client_t *client, pkgconf_list_t *list, const
 
 	if (strlen(string) > 1 && !pkgconf_fragment_is_special(string))
 	{
-		frag = calloc(sizeof(pkgconf_fragment_t), 1);
+		frag = calloc(1, sizeof(pkgconf_fragment_t));
 
 		frag->type = *(string + 1);
 		frag->data = pkgconf_fragment_copy_munged(client, string + 2, flags);
@@ -160,7 +192,7 @@ pkgconf_fragment_add(const pkgconf_client_t *client, pkgconf_list_t *list, const
 			pkgconf_fragment_t *parent = list->tail->data;
 
 			/* only attempt to merge 'special' fragments together */
-			if (!parent->type && pkgconf_fragment_is_unmergeable(parent->data))
+			if (!parent->type && parent->data != NULL && pkgconf_fragment_is_unmergeable(parent->data))
 			{
 				size_t len;
 				char *newdata;
@@ -192,7 +224,7 @@ pkgconf_fragment_add(const pkgconf_client_t *client, pkgconf_list_t *list, const
 			}
 		}
 
-		frag = calloc(sizeof(pkgconf_fragment_t), 1);
+		frag = calloc(1, sizeof(pkgconf_fragment_t));
 
 		frag->type = 0;
 		frag->data = strdup(string);
@@ -353,7 +385,7 @@ pkgconf_fragment_copy(const pkgconf_client_t *client, pkgconf_list_t *list, cons
 	else if (!is_private && !pkgconf_fragment_can_merge_back(base, client->flags, is_private) && (pkgconf_fragment_lookup(list, base) != NULL))
 		return;
 
-	frag = calloc(sizeof(pkgconf_fragment_t), 1);
+	frag = calloc(1, sizeof(pkgconf_fragment_t));
 
 	frag->type = base->type;
 	frag->merged = base->merged;
@@ -427,7 +459,7 @@ fragment_quote(const pkgconf_fragment_t *frag)
 	if (frag->data == NULL)
 		return NULL;
 
-	out = dst = calloc(outlen, 1);
+	out = dst = calloc(1, outlen);
 
 	for (; *src; src++)
 	{
@@ -531,7 +563,8 @@ fragment_render_buf(const pkgconf_list_t *list, char *buf, size_t buflen, bool e
 			free(quoted);
 		}
 
-		*bptr++ = ' ';
+		if (node->next != NULL)
+			*bptr++ = ' ';
 	}
 
 	*bptr = '\0';

libpkgconf/libpkgconf.h

@@ -16,6 +16,7 @@
 #ifndef LIBPKGCONF__LIBPKGCONF_H
 #define LIBPKGCONF__LIBPKGCONF_H
 
+#include <inttypes.h>
 #include <stdio.h>
 #include <stdarg.h>
 #include <stddef.h>
@@ -67,6 +68,7 @@ typedef struct pkgconf_fragment_ pkgconf_fragment_t;
 typedef struct pkgconf_path_ pkgconf_path_t;
 typedef struct pkgconf_client_ pkgconf_client_t;
 typedef struct pkgconf_cross_personality_ pkgconf_cross_personality_t;
+typedef struct pkgconf_queue_ pkgconf_queue_t;
 
 #define PKGCONF_ARRAY_SIZE(x) (sizeof(x) / sizeof(*(x)))
 
@@ -79,8 +81,13 @@ typedef struct pkgconf_cross_personality_ pkgconf_cross_personality_t;
 #define PKGCONF_FOREACH_LIST_ENTRY_REVERSE(tail, value) \
 	for ((value) = (tail); (value) != NULL; (value) = (value)->prev)
 
-#define LIBPKGCONF_VERSION	10900
-#define LIBPKGCONF_VERSION_STR	"1.9.0"
+#define LIBPKGCONF_VERSION	20300
+#define LIBPKGCONF_VERSION_STR	"2.3.0"
+
+struct pkgconf_queue_ {
+	pkgconf_node_t iter;
+	char *package;
+};
 
 struct pkgconf_fragment_ {
 	pkgconf_node_t iter;
@@ -111,8 +118,12 @@ struct pkgconf_tuple_ {
 
 	char *key;
 	char *value;
+
+	unsigned int flags;
 };
 
+#define PKGCONF_PKG_TUPLEF_OVERRIDE		0x1
+
 struct pkgconf_path_ {
 	pkgconf_node_t lnode;
 
@@ -126,6 +137,8 @@ struct pkgconf_path_ {
 #define PKGCONF_PKG_PROPF_CACHED		0x02
 #define PKGCONF_PKG_PROPF_UNINSTALLED		0x08
 #define PKGCONF_PKG_PROPF_VIRTUAL		0x10
+#define PKGCONF_PKG_PROPF_ANCESTOR		0x20
+#define PKGCONF_PKG_PROPF_VISITED_PRIVATE	0x40
 
 struct pkgconf_pkg_ {
 	int refcount;
@@ -137,6 +150,9 @@ struct pkgconf_pkg_ {
 	char *url;
 	char *pc_filedir;
 	char *license;
+	char *maintainer;
+	char *copyright;
+	char *why;
 
 	pkgconf_list_t libs;
 	pkgconf_list_t libs_private;
@@ -161,8 +177,7 @@ struct pkgconf_pkg_ {
 	pkgconf_tuple_t *prefix;
 
 	uint64_t serial;
-
-	size_t hits;
+	uint64_t identifier;
 };
 
 typedef bool (*pkgconf_pkg_iteration_func_t)(const pkgconf_pkg_t *pkg, void *data);
@@ -198,6 +213,7 @@ struct pkgconf_client_ {
 	bool already_sent_notice;
 
 	uint64_t serial;
+	uint64_t identifier;
 
 	pkgconf_pkg_t **cache_table;
 	size_t cache_count;
@@ -243,7 +259,7 @@ PKGCONF_API pkgconf_cross_personality_t *pkgconf_cross_personality_default(void)
 PKGCONF_API pkgconf_cross_personality_t *pkgconf_cross_personality_find(const char *triplet);
 PKGCONF_API void pkgconf_cross_personality_deinit(pkgconf_cross_personality_t *personality);
 
-#define PKGCONF_IS_MODULE_SEPARATOR(c) ((c) == ',' || isspace ((unsigned int)(c)))
+#define PKGCONF_IS_MODULE_SEPARATOR(c) ((c) == ',' || isspace ((unsigned char)(c)))
 #define PKGCONF_IS_OPERATOR_CHAR(c) ((c) == '<' || (c) == '>' || (c) == '!' || (c) == '=')
 
 #define PKGCONF_PKG_PKGF_NONE				0x0000
@@ -266,6 +282,8 @@ PKGCONF_API void pkgconf_cross_personality_deinit(pkgconf_cross_personality_t *p
 #define PKGCONF_PKG_PKGF_PKGCONF1_SYSROOT_RULES         0x10000
 
 #define PKGCONF_PKG_DEPF_INTERNAL		0x1
+#define PKGCONF_PKG_DEPF_PRIVATE		0x2
+#define PKGCONF_PKG_DEPF_QUERY			0x4
 
 #define PKGCONF_PKG_ERRF_OK			0x0
 #define PKGCONF_PKG_ERRF_PACKAGE_NOT_FOUND	0x1
@@ -349,6 +367,7 @@ typedef struct pkgconf_fragment_render_ops_ {
 
 typedef bool (*pkgconf_fragment_filter_func_t)(const pkgconf_client_t *client, const pkgconf_fragment_t *frag, void *data);
 PKGCONF_API bool pkgconf_fragment_parse(const pkgconf_client_t *client, pkgconf_list_t *list, pkgconf_list_t *vars, const char *value, unsigned int flags);
+PKGCONF_API void pkgconf_fragment_insert(const pkgconf_client_t *client, pkgconf_list_t *list, char type, const char *data, bool tail);
 PKGCONF_API void pkgconf_fragment_add(const pkgconf_client_t *client, pkgconf_list_t *list, const char *string, unsigned int flags);
 PKGCONF_API void pkgconf_fragment_copy(const pkgconf_client_t *client, pkgconf_list_t *list, const pkgconf_fragment_t *base, bool is_private);
 PKGCONF_API void pkgconf_fragment_copy_list(const pkgconf_client_t *client, pkgconf_list_t *list, const pkgconf_list_t *base);
@@ -377,9 +396,11 @@ PKGCONF_API void pkgconf_tuple_define_global(pkgconf_client_t *client, const cha
 /* queue.c */
 PKGCONF_API void pkgconf_queue_push(pkgconf_list_t *list, const char *package);
 PKGCONF_API bool pkgconf_queue_compile(pkgconf_client_t *client, pkgconf_pkg_t *world, pkgconf_list_t *list);
+PKGCONF_API bool pkgconf_queue_solve(pkgconf_client_t *client, pkgconf_list_t *list, pkgconf_pkg_t *world, int maxdepth);
 PKGCONF_API void pkgconf_queue_free(pkgconf_list_t *list);
 PKGCONF_API bool pkgconf_queue_apply(pkgconf_client_t *client, pkgconf_list_t *list, pkgconf_queue_apply_func_t func, int maxdepth, void *data);
 PKGCONF_API bool pkgconf_queue_validate(pkgconf_client_t *client, pkgconf_list_t *list, int maxdepth);
+PKGCONF_API void pkgconf_solution_free(pkgconf_client_t *client, pkgconf_pkg_t *world);
 
 /* cache.c */
 PKGCONF_API pkgconf_pkg_t *pkgconf_cache_lookup(pkgconf_client_t *client, const char *id);
@@ -394,6 +415,7 @@ PKGCONF_API void pkgconf_audit_log_dependency(pkgconf_client_t *client, const pk
 
 /* path.c */
 PKGCONF_API void pkgconf_path_add(const char *text, pkgconf_list_t *dirlist, bool filter);
+PKGCONF_API void pkgconf_path_prepend(const char *text, pkgconf_list_t *dirlist, bool filter);
 PKGCONF_API size_t pkgconf_path_split(const char *text, pkgconf_list_t *dirlist, bool filter);
 PKGCONF_API size_t pkgconf_path_build_from_environ(const char *envvarname, const char *fallback, pkgconf_list_t *dirlist, bool filter);
 PKGCONF_API bool pkgconf_path_match_list(const char *path, const pkgconf_list_t *dirlist);

libpkgconf/parser.c

@@ -44,14 +44,23 @@ pkgconf_parser_parse(FILE *f, void *data, const pkgconf_parser_operand_func_t *o
 		lineno++;
 
 		p = readbuf;
-		while (*p && (isalpha((unsigned int)*p) || isdigit((unsigned int)*p) || *p == '_' || *p == '.'))
+		while (*p && isspace((unsigned char)*p))
+			p++;
+		if (*p && p != readbuf)
+		{
+			warnfunc(data, "%s:" SIZE_FMT_SPECIFIER ": warning: whitespace encountered while parsing key section\n",
+				filename, lineno);
+			warned_key_whitespace = true;
+		}
+		key = p;
+		while (*p && (isalpha((unsigned char)*p) || isdigit((unsigned char)*p) || *p == '_' || *p == '.'))
 			p++;
 
-		key = readbuf;
-		if (!isalpha((unsigned int)*key) && !isdigit((unsigned int)*p))
+		if (!isalpha((unsigned char)*key) &&
+		    !isdigit((unsigned char)*p))
 			continue;
 
-		while (*p && isspace((unsigned int)*p))
+		while (*p && isspace((unsigned char)*p))
 		{
 			if (!warned_key_whitespace)
 			{
@@ -72,12 +81,12 @@ pkgconf_parser_parse(FILE *f, void *data, const pkgconf_parser_operand_func_t *o
 			p++;
 		}
 
-		while (*p && isspace((unsigned int)*p))
+		while (*p && isspace((unsigned char)*p))
 			p++;
 
 		value = p;
 		p = value + (strlen(value) - 1);
-		while (*p && isspace((unsigned int) *p) && p > value)
+		while (*p && isspace((unsigned char) *p) && p > value)
 		{
 			if (!warned_value_whitespace && op == '=')
 			{
@@ -89,7 +98,6 @@ pkgconf_parser_parse(FILE *f, void *data, const pkgconf_parser_operand_func_t *o
 			*p = '\0';
 			p--;
 		}
-
 		if (ops[(unsigned char) op])
 			ops[(unsigned char) op](data, lineno, key, value);
 	}

libpkgconf/path.c

@@ -58,6 +58,51 @@ path_list_contains_entry(const char *text, pkgconf_list_t *dirlist)
  * variables.
  */
 
+static pkgconf_path_t *
+prepare_path_node(const char *text, pkgconf_list_t *dirlist, bool filter)
+{
+	pkgconf_path_t *node;
+	char path[PKGCONF_ITEM_SIZE];
+
+	pkgconf_strlcpy(path, text, sizeof path);
+	pkgconf_path_relocate(path, sizeof path);
+
+#ifdef PKGCONF_CACHE_INODES
+	struct stat st;
+
+	if (filter)
+	{
+		if (lstat(path, &st) == -1)
+			return NULL;
+		if (S_ISLNK(st.st_mode))
+		{
+			char pathbuf[PKGCONF_ITEM_SIZE * 4];
+			char *linkdest = realpath(path, pathbuf);
+
+			if (linkdest != NULL && stat(linkdest, &st) == -1)
+				return NULL;
+		}
+		if (path_list_contains_entry(path, dirlist, &st))
+			return NULL;
+	}
+#else
+	if (filter && path_list_contains_entry(path, dirlist))
+		return NULL;
+#endif
+
+	node = calloc(1, sizeof(pkgconf_path_t));
+	node->path = strdup(path);
+
+#ifdef PKGCONF_CACHE_INODES
+	if (filter) {
+		node->handle_path = (void *)(intptr_t) st.st_ino;
+		node->handle_device = (void *)(intptr_t) st.st_dev;
+	}
+#endif
+
+	return node;
+}
+
 /*
  * !doc
  *
@@ -73,48 +118,35 @@ path_list_contains_entry(const char *text, pkgconf_list_t *dirlist)
 void
 pkgconf_path_add(const char *text, pkgconf_list_t *dirlist, bool filter)
 {
-	pkgconf_path_t *node;
-	char path[PKGCONF_ITEM_SIZE];
-
-	pkgconf_strlcpy(path, text, sizeof path);
-	pkgconf_path_relocate(path, sizeof path);
-
-#ifdef PKGCONF_CACHE_INODES
-	struct stat st;
-
-	if (filter)
-	{
-		if (lstat(path, &st) == -1)
-			return;
-		if (S_ISLNK(st.st_mode))
-		{
-			char pathbuf[PKGCONF_ITEM_SIZE * 4];
-			char *linkdest = realpath(path, pathbuf);
-
-			if (linkdest != NULL && stat(linkdest, &st) == -1)
-				return;
-		}
-		if (path_list_contains_entry(path, dirlist, &st))
-			return;
-	}
-#else
-	if (filter && path_list_contains_entry(path, dirlist))
+	pkgconf_path_t *node = prepare_path_node(text, dirlist, filter);
+	if (node == NULL)
 		return;
-#endif
-
-	node = calloc(sizeof(pkgconf_path_t), 1);
-	node->path = strdup(path);
-
-#ifdef PKGCONF_CACHE_INODES
-	if (filter) {
-		node->handle_path = (void *)(intptr_t) st.st_ino;
-		node->handle_device = (void *)(intptr_t) st.st_dev;
-	}
-#endif
 
 	pkgconf_node_insert_tail(&node->lnode, node, dirlist);
 }
 
+/*
+ * !doc
+ *
+ * .. c:function:: void pkgconf_path_prepend(const char *text, pkgconf_list_t *dirlist)
+ *
+ *    Prepends a path node to a path list.  If the path is already in the list, do nothing.
+ *
+ *    :param char* text: The path text to add as a path node.
+ *    :param pkgconf_list_t* dirlist: The path list to add the path node to.
+ *    :param bool filter: Whether to perform duplicate filtering.
+ *    :return: nothing
+ */
+void
+pkgconf_path_prepend(const char *text, pkgconf_list_t *dirlist, bool filter)
+{
+	pkgconf_path_t *node = prepare_path_node(text, dirlist, filter);
+	if (node == NULL)
+		return;
+
+	pkgconf_node_insert(&node->lnode, node, dirlist);
+}
+
 /*
  * !doc
  *
@@ -234,7 +266,7 @@ pkgconf_path_copy_list(pkgconf_list_t *dst, const pkgconf_list_t *src)
 	{
 		pkgconf_path_t *srcpath = n->data, *path;
 
-		path = calloc(sizeof(pkgconf_path_t), 1);
+		path = calloc(1, sizeof(pkgconf_path_t));
 		path->path = strdup(srcpath->path);
 
 #ifdef PKGCONF_CACHE_INODES

libpkgconf/personality.c

@@ -17,6 +17,13 @@
 #include <libpkgconf/stdinc.h>
 #include <libpkgconf/libpkgconf.h>
 
+/*
+ * !doc
+ *
+ * libpkgconf `personality` module
+ * =========================
+ */
+
 #ifdef _WIN32
 #	define strcasecmp _stricmp
 #endif
@@ -31,8 +38,13 @@ static unsigned default_personality_init = 0;
 static pkgconf_cross_personality_t default_personality = {
 	.name = "default",
 #ifdef _WIN32
+	/* PE/COFF uses a different linking model than ELF and Mach-O, where
+	 * all transitive dependency references must be processed by the linker
+	 * when linking the final executable image, even if those dependencies
+	 * are pulled in as DLLs.
+	 * This translates to always using --static on Windows targets.
+	 */
 	.want_default_static = true,
-	.want_default_pure = true,
 #endif
 };
 
@@ -141,7 +153,7 @@ valid_triplet(const char *triplet)
 	const char *c = triplet;
 
 	for (; *c; c++)
-		if (!isalnum(*c) && *c != '-' && *c != '_')
+		if (!isalnum((unsigned char)*c) && *c != '-' && *c != '_')
 			return false;
 
 	return true;
@@ -234,23 +246,25 @@ personality_warn_func(void *p, const char *fmt, ...)
 }
 
 static pkgconf_cross_personality_t *
-load_personality_with_path(const char *path, const char *triplet)
+load_personality_with_path(const char *path, const char *triplet, bool datadir)
 {
 	char pathbuf[PKGCONF_ITEM_SIZE];
 	FILE *f;
 	pkgconf_cross_personality_t *p;
 
 	/* if triplet is null, assume that path is a direct path to the personality file */
-	if (triplet != NULL)
-		snprintf(pathbuf, sizeof pathbuf, "%s/%s.personality", path, triplet);
-	else
+	if (triplet == NULL)
 		pkgconf_strlcpy(pathbuf, path, sizeof pathbuf);
+	else if (datadir)
+		snprintf(pathbuf, sizeof pathbuf, "%s/pkgconfig/personality.d/%s.personality", path, triplet);
+	else
+		snprintf(pathbuf, sizeof pathbuf, "%s/%s.personality", path, triplet);
 
 	f = fopen(pathbuf, "r");
 	if (f == NULL)
 		return NULL;
 
-	p = calloc(sizeof(pkgconf_cross_personality_t), 1);
+	p = calloc(1, sizeof(pkgconf_cross_personality_t));
 	if (triplet != NULL)
 		p->name = strdup(triplet);
 	pkgconf_parser_parse(f, p, personality_parser_ops, personality_warn_func, pathbuf);
@@ -274,21 +288,51 @@ pkgconf_cross_personality_find(const char *triplet)
 	pkgconf_list_t plist = PKGCONF_LIST_INITIALIZER;
 	pkgconf_node_t *n;
 	pkgconf_cross_personality_t *out = NULL;
+#if ! defined(_WIN32) && ! defined(__HAIKU__)
+	char pathbuf[PKGCONF_ITEM_SIZE];
+	const char *envvar;
+#endif
 
-	out = load_personality_with_path(triplet, NULL);
+	out = load_personality_with_path(triplet, NULL, false);
 	if (out != NULL)
 		return out;
 
 	if (!valid_triplet(triplet))
 		return NULL;
 
+#if ! defined(_WIN32) && ! defined(__HAIKU__)
+	envvar = getenv("XDG_DATA_HOME");
+	if (envvar != NULL)
+		pkgconf_path_add(envvar, &plist, true);
+	else {
+		envvar = getenv("HOME");
+		if (envvar != NULL) {
+			pkgconf_strlcpy(pathbuf, envvar, sizeof pathbuf);
+			pkgconf_strlcat(pathbuf, "/.local/share", sizeof pathbuf);
+			pkgconf_path_add(pathbuf, &plist, true);
+		}
+	}
+
+	pkgconf_path_build_from_environ("XDG_DATA_DIRS", "/usr/local/share" PKG_CONFIG_PATH_SEP_S "/usr/share", &plist, true);
+
+	PKGCONF_FOREACH_LIST_ENTRY(plist.head, n)
+	{
+		pkgconf_path_t *pn = n->data;
+
+		out = load_personality_with_path(pn->path, triplet, true);
+		if (out != NULL)
+			goto finish;
+	}
+	pkgconf_path_free(&plist);
+#endif
+
 	pkgconf_path_split(PERSONALITY_PATH, &plist, true);
 
 	PKGCONF_FOREACH_LIST_ENTRY(plist.head, n)
 	{
 		pkgconf_path_t *pn = n->data;
 
-		out = load_personality_with_path(pn->path, triplet);
+		out = load_personality_with_path(pn->path, triplet, false);
 		if (out != NULL)
 			goto finish;
 	}

libpkgconf/pkg.c

@@ -154,20 +154,34 @@ pkgconf_pkg_parser_internal_dependency_func(pkgconf_client_t *client, pkgconf_pk
 	pkgconf_dependency_parse(client, pkg, dest, value, PKGCONF_PKG_DEPF_INTERNAL);
 }
 
+/* a variant of pkgconf_pkg_parser_dependency_func which colors the dependency node as a "private" dependency. */
+static void
+pkgconf_pkg_parser_private_dependency_func(pkgconf_client_t *client, pkgconf_pkg_t *pkg, const char *keyword, const size_t lineno, const ptrdiff_t offset, const char *value)
+{
+	(void) keyword;
+	(void) lineno;
+
+	pkgconf_list_t *dest = (pkgconf_list_t *)((char *) pkg + offset);
+	pkgconf_dependency_parse(client, pkg, dest, value, PKGCONF_PKG_DEPF_PRIVATE);
+}
+
 /* keep this in alphabetical order */
 static const pkgconf_pkg_parser_keyword_pair_t pkgconf_pkg_parser_keyword_funcs[] = {
 	{"CFLAGS", pkgconf_pkg_parser_fragment_func, offsetof(pkgconf_pkg_t, cflags)},
 	{"CFLAGS.private", pkgconf_pkg_parser_fragment_func, offsetof(pkgconf_pkg_t, cflags_private)},
 	{"Conflicts", pkgconf_pkg_parser_dependency_func, offsetof(pkgconf_pkg_t, conflicts)},
+	{"Copyright", pkgconf_pkg_parser_tuple_func, offsetof(pkgconf_pkg_t, copyright)},
 	{"Description", pkgconf_pkg_parser_tuple_func, offsetof(pkgconf_pkg_t, description)},
 	{"LIBS", pkgconf_pkg_parser_fragment_func, offsetof(pkgconf_pkg_t, libs)},
 	{"LIBS.private", pkgconf_pkg_parser_fragment_func, offsetof(pkgconf_pkg_t, libs_private)},
 	{"License", pkgconf_pkg_parser_tuple_func, offsetof(pkgconf_pkg_t, license)},
+	{"Maintainer", pkgconf_pkg_parser_tuple_func, offsetof(pkgconf_pkg_t, maintainer)},
 	{"Name", pkgconf_pkg_parser_tuple_func, offsetof(pkgconf_pkg_t, realname)},
 	{"Provides", pkgconf_pkg_parser_dependency_func, offsetof(pkgconf_pkg_t, provides)},
 	{"Requires", pkgconf_pkg_parser_dependency_func, offsetof(pkgconf_pkg_t, required)},
 	{"Requires.internal", pkgconf_pkg_parser_internal_dependency_func, offsetof(pkgconf_pkg_t, requires_private)},
-	{"Requires.private", pkgconf_pkg_parser_dependency_func, offsetof(pkgconf_pkg_t, requires_private)},
+	{"Requires.private", pkgconf_pkg_parser_private_dependency_func, offsetof(pkgconf_pkg_t, requires_private)},
+	{"URL", pkgconf_pkg_parser_tuple_func, offsetof(pkgconf_pkg_t, url)},
 	{"Version", pkgconf_pkg_parser_version_func, offsetof(pkgconf_pkg_t, version)},
 };
 
@@ -236,7 +250,7 @@ determine_prefix(const pkgconf_pkg_t *pkg, char *buf, size_t buflen)
 static char *
 convert_path_to_value(const char *path)
 {
-	char *buf = calloc((strlen(path) + 1) * 2, 1);
+	char *buf = calloc(1, (strlen(path) + 1) * 2);
 	char *bptr = buf;
 	const char *i;
 
@@ -405,7 +419,7 @@ pkgconf_pkg_new_from_file(pkgconf_client_t *client, const char *filename, FILE *
 	pkgconf_pkg_t *pkg;
 	char *idptr;
 
-	pkg = calloc(sizeof(pkgconf_pkg_t), 1);
+	pkg = calloc(1, sizeof(pkgconf_pkg_t));
 	pkg->owner = client;
 	pkg->filename = strdup(filename);
 	pkg->pc_filedir = pkg_get_parent_dir(pkg);
@@ -443,6 +457,13 @@ pkgconf_pkg_new_from_file(pkgconf_client_t *client, const char *filename, FILE *
 	if (idptr)
 		*idptr = '\0';
 
+	if (pkg->flags & PKGCONF_PKG_PROPF_UNINSTALLED)
+	{
+		idptr = strrchr(pkg->id, '-');
+		if (idptr)
+			*idptr = '\0';
+	}
+
 	pkgconf_parser_parse(f, pkg, pkg_parser_funcs, (pkgconf_parser_warn_func_t) pkg_warn_func, pkg->filename);
 
 	if (!pkgconf_pkg_validate(client, pkg))
@@ -516,6 +537,18 @@ pkgconf_pkg_free(pkgconf_client_t *client, pkgconf_pkg_t *pkg)
 	if (pkg->pc_filedir != NULL)
 		free(pkg->pc_filedir);
 
+	if (pkg->license != NULL)
+		free(pkg->license);
+
+	if (pkg->maintainer != NULL)
+		free(pkg->maintainer);
+
+	if (pkg->copyright != NULL)
+		free(pkg->copyright);
+
+	if (pkg->why != NULL)
+		free(pkg->why);
+
 	free(pkg);
 }
 
@@ -742,15 +775,13 @@ pkgconf_pkg_find(pkgconf_client_t *client, const char *name)
 	{
 		if ((f = fopen(name, "r")) != NULL)
 		{
-			pkgconf_pkg_t *pkg;
-
 			PKGCONF_TRACE(client, "%s is a file", name);
 
 			pkg = pkgconf_pkg_new_from_file(client, name, f, 0);
 			if (pkg != NULL)
 			{
 				pkgconf_path_add(pkg->pc_filedir, &client->dir_list, true);
-				return pkg;
+				goto out;
 			}
 		}
 	}
@@ -803,7 +834,7 @@ out:
  *
  *    :param char* a: The first version to compare in the pair.
  *    :param char* b: The second version to compare in the pair.
- *    :return: -1 if the first version is greater, 0 if both versions are equal, 1 if the second version is greater.
+ *    :return: -1 if the first version is less than, 0 if both versions are equal, 1 if the second version is less than.
  *    :rtype: int
  */
 int
@@ -818,10 +849,10 @@ pkgconf_compare_version(const char *a, const char *b)
 
 	/* optimization: if version matches then it's the same version. */
 	if (a == NULL)
-		return 1;
+		return -1;
 
 	if (b == NULL)
-		return -1;
+		return 1;
 
 	if (!strcasecmp(a, b))
 		return 0;
@@ -829,22 +860,22 @@ pkgconf_compare_version(const char *a, const char *b)
 	pkgconf_strlcpy(buf1, a, sizeof buf1);
 	pkgconf_strlcpy(buf2, b, sizeof buf2);
 
-	one = str1 = buf1;
-	two = str2 = buf2;
+	one = buf1;
+	two = buf2;
 
 	while (*one || *two)
 	{
-		while (*one && !isalnum((unsigned int)*one) && *one != '~')
+		while (*one && !isalnum((unsigned char)*one) && *one != '~')
 			one++;
-		while (*two && !isalnum((unsigned int)*two) && *two != '~')
+		while (*two && !isalnum((unsigned char)*two) && *two != '~')
 			two++;
 
 		if (*one == '~' || *two == '~')
 		{
 			if (*one != '~')
-				return -1;
-			if (*two != '~')
 				return 1;
+			if (*two != '~')
+				return -1;
 
 			one++;
 			two++;
@@ -857,22 +888,22 @@ pkgconf_compare_version(const char *a, const char *b)
 		str1 = one;
 		str2 = two;
 
-		if (isdigit((unsigned int)*str1))
+		if (isdigit((unsigned char)*str1))
 		{
-			while (*str1 && isdigit((unsigned int)*str1))
+			while (*str1 && isdigit((unsigned char)*str1))
 				str1++;
 
-			while (*str2 && isdigit((unsigned int)*str2))
+			while (*str2 && isdigit((unsigned char)*str2))
 				str2++;
 
 			isnum = true;
 		}
 		else
 		{
-			while (*str1 && isalpha((unsigned int)*str1))
+			while (*str1 && isalpha((unsigned char)*str1))
 				str1++;
 
-			while (*str2 && isalpha((unsigned int)*str2))
+			while (*str2 && isalpha((unsigned char)*str2))
 				str2++;
 
 			isnum = false;
@@ -1368,19 +1399,24 @@ pkgconf_pkg_verify_dependency(pkgconf_client_t *client, pkgconf_dependency_t *pk
 			return NULL;
 		}
 
-		return pkgconf_pkg_scan_providers(client, pkgdep, eflags);
-	}
-
-	if (pkg->id == NULL)
-		pkg->id = strdup(pkgdep->package);
-
-	if (pkgconf_pkg_comparator_impls[pkgdep->compare](pkg->version, pkgdep->version) != true)
-	{
-		if (eflags != NULL)
-			*eflags |= PKGCONF_PKG_ERRF_PACKAGE_VER_MISMATCH;
+		pkg = pkgconf_pkg_scan_providers(client, pkgdep, eflags);
 	}
 	else
-		pkgdep->match = pkgconf_pkg_ref(client, pkg);
+	{
+		if (pkg->id == NULL)
+			pkg->id = strdup(pkgdep->package);
+
+		if (pkgconf_pkg_comparator_impls[pkgdep->compare](pkg->version, pkgdep->version) != true)
+		{
+			if (eflags != NULL)
+				*eflags |= PKGCONF_PKG_ERRF_PACKAGE_VER_MISMATCH;
+		}
+		else
+			pkgdep->match = pkgconf_pkg_ref(client, pkg);
+	}
+
+	if (pkg != NULL && pkg->why == NULL)
+		pkg->why = strdup(pkgdep->package);
 
 	return pkg;
 }
@@ -1418,7 +1454,11 @@ pkgconf_pkg_report_graph_error(pkgconf_client_t *client, pkgconf_pkg_t *parent,
 			client->already_sent_notice = true;
 		}
 
-		pkgconf_error(client, "Package '%s', required by '%s', not found\n", node->package, parent->id);
+		if (parent->flags & PKGCONF_PKG_PROPF_VIRTUAL)
+			pkgconf_error(client, "Package '%s' not found\n", node->package);
+		else
+			pkgconf_error(client, "Package '%s', required by '%s', not found\n", node->package, parent->id);
+
 		pkgconf_audit_log(client, "%s NOT-FOUND\n", node->package);
 	}
 	else if (eflags & PKGCONF_PKG_ERRF_PACKAGE_VER_MISMATCH)
@@ -1449,6 +1489,8 @@ pkgconf_pkg_walk_list(pkgconf_client_t *client,
 	unsigned int eflags = PKGCONF_PKG_ERRF_OK;
 	pkgconf_node_t *node, *next;
 
+	parent->flags |= PKGCONF_PKG_PROPF_ANCESTOR;
+
 	PKGCONF_FOREACH_LIST_ENTRY_SAFE(deplist->head, next, node)
 	{
 		unsigned int eflags_local = PKGCONF_PKG_ERRF_OK;
@@ -1469,21 +1511,27 @@ pkgconf_pkg_walk_list(pkgconf_client_t *client,
 		if (pkgdep == NULL)
 			continue;
 
-		if (pkgdep->serial == client->serial)
+		if((pkgdep->flags & PKGCONF_PKG_PROPF_ANCESTOR) != 0)
 		{
-			pkgdep->hits++;
-
 			/* In this case we have a circular reference.
 			 * We break that by deleteing the circular node from the
 			 * the list, so that we dont create a situation where
 			 * memory is leaked due to circular ownership.
 			 * i.e: A owns B owns A
+			 *
+			 * TODO(ariadne): Breaking circular references between Requires and Requires.private
+			 * lists causes problems.  Find a way to refactor the Requires.private list out.
 			 */
-			pkgconf_warn(client, "%s: breaking circular reference (%s -> %s -> %s)\n",
-				     parent->id, parent->id, pkgdep->id, parent->id);
+			if (!(depnode->flags & PKGCONF_PKG_DEPF_PRIVATE) &&
+			    !(parent->flags & PKGCONF_PKG_PROPF_VIRTUAL))
+			{
+				pkgconf_warn(client, "%s: breaking circular reference (%s -> %s -> %s)\n",
+					     parent->id, parent->id, pkgdep->id, parent->id);
+
+				pkgconf_node_delete(node, deplist);
+				pkgconf_dependency_unref(client, depnode);
+			}
 
-			pkgconf_node_delete(node, deplist);
-			pkgconf_dependency_unref(client, depnode);
 			goto next;
 		}
 
@@ -1492,13 +1540,13 @@ pkgconf_pkg_walk_list(pkgconf_client_t *client,
 
 		pkgconf_audit_log_dependency(client, pkgdep, depnode);
 
-		pkgdep->hits++;
-		pkgdep->serial = client->serial;
 		eflags |= pkgconf_pkg_traverse_main(client, pkgdep, func, data, depth - 1, skip_flags);
 next:
 		pkgconf_pkg_unref(client, pkgdep);
 	}
 
+	parent->flags &= ~PKGCONF_PKG_PROPF_ANCESTOR;
+
 	return eflags;
 }
 
@@ -1578,7 +1626,17 @@ pkgconf_pkg_traverse_main(pkgconf_client_t *client,
 	if (maxdepth == 0)
 		return eflags;
 
-	PKGCONF_TRACE(client, "%s: level %d, serial %lu", root->id, maxdepth, client->serial);
+	/* Short-circuit if we have already visited this node.
+	 */
+	if (root->serial == client->serial)
+		return eflags;
+
+	root->serial = client->serial;
+
+	if (root->identifier == 0)
+		root->identifier = ++client->identifier;
+
+	PKGCONF_TRACE(client, "%s: level %d, serial %"PRIu64, root->id, maxdepth, client->serial);
 
 	if ((root->flags & PKGCONF_PKG_PROPF_VIRTUAL) != PKGCONF_PKG_PROPF_VIRTUAL || (client->flags & PKGCONF_PKG_PKGF_SKIP_ROOT_VIRTUAL) != PKGCONF_PKG_PKGF_SKIP_ROOT_VIRTUAL)
 	{
@@ -1586,21 +1644,23 @@ pkgconf_pkg_traverse_main(pkgconf_client_t *client,
 			func(client, root, data);
 	}
 
-	if (!(client->flags & PKGCONF_PKG_PKGF_SKIP_CONFLICTS))
+	if (!(client->flags & PKGCONF_PKG_PKGF_SKIP_CONFLICTS) && root->conflicts.head != NULL)
 	{
+		PKGCONF_TRACE(client, "%s: walking 'Conflicts' list", root->id);
+
 		eflags = pkgconf_pkg_walk_conflicts_list(client, root, &root->conflicts);
 		if (eflags != PKGCONF_PKG_ERRF_OK)
 			return eflags;
 	}
 
-	PKGCONF_TRACE(client, "%s: walking requires list", root->id);
+	PKGCONF_TRACE(client, "%s: walking 'Requires' list", root->id);
 	eflags = pkgconf_pkg_walk_list(client, root, &root->required, func, data, maxdepth, skip_flags);
 	if (eflags != PKGCONF_PKG_ERRF_OK)
 		return eflags;
 
 	if (client->flags & PKGCONF_PKG_PKGF_SEARCH_PRIVATE)
 	{
-		PKGCONF_TRACE(client, "%s: walking requires.private list", root->id);
+		PKGCONF_TRACE(client, "%s: walking 'Requires.private' list", root->id);
 
 		/* XXX: ugly */
 		client->flags |= PKGCONF_PKG_PKGF_ITER_PKG_IS_PRIVATE;
@@ -1622,7 +1682,11 @@ pkgconf_pkg_traverse(pkgconf_client_t *client,
 	int maxdepth,
 	unsigned int skip_flags)
 {
-	client->serial++;
+	if (root->flags & PKGCONF_PKG_PROPF_VIRTUAL)
+		client->serial++;
+
+	if ((client->flags & PKGCONF_PKG_PKGF_SEARCH_PRIVATE) == 0)
+		skip_flags |= PKGCONF_PKG_DEPF_PRIVATE;
 
 	return pkgconf_pkg_traverse_main(client, root, func, data, maxdepth, skip_flags);
 }

libpkgconf/queue.c

@@ -29,11 +29,6 @@
  * Using the `queue` module functions is the recommended way of working with dependency graphs.
  */
 
-typedef struct {
-	pkgconf_node_t iter;
-	char *package;
-} pkgconf_queue_t;
-
 /*
  * !doc
  *
@@ -48,10 +43,10 @@ typedef struct {
 void
 pkgconf_queue_push(pkgconf_list_t *list, const char *package)
 {
-	pkgconf_queue_t *pkgq = calloc(sizeof(pkgconf_queue_t), 1);
+	pkgconf_queue_t *pkgq = calloc(1, sizeof(pkgconf_queue_t));
 
 	pkgq->package = strdup(package);
-	pkgconf_node_insert(&pkgq->iter, pkgq, list);
+	pkgconf_node_insert_tail(&pkgq->iter, pkgq, list);
 }
 
 /*
@@ -77,7 +72,7 @@ pkgconf_queue_compile(pkgconf_client_t *client, pkgconf_pkg_t *world, pkgconf_li
 		pkgconf_queue_t *pkgq;
 
 		pkgq = iter->data;
-		pkgconf_dependency_parse(client, world, &world->required, pkgq->package, 0);
+		pkgconf_dependency_parse(client, world, &world->required, pkgq->package, PKGCONF_PKG_DEPF_QUERY);
 	}
 
 	return (world->required.head != NULL);
@@ -108,152 +103,226 @@ pkgconf_queue_free(pkgconf_list_t *list)
 }
 
 static void
-pkgconf_queue_collect_dependents(pkgconf_client_t *client, pkgconf_pkg_t *pkg, void *data)
+pkgconf_queue_mark_public(pkgconf_client_t *client, pkgconf_pkg_t *pkg, void *data)
 {
+	if (pkg->flags & PKGCONF_PKG_PROPF_VISITED_PRIVATE)
+	{
+		pkgconf_list_t *list = data;
+		pkgconf_node_t *node;
+
+		PKGCONF_FOREACH_LIST_ENTRY(list->head, node)
+		{
+			pkgconf_dependency_t *dep = node->data;
+			if (dep->match == pkg)
+				dep->flags &= ~PKGCONF_PKG_DEPF_PRIVATE;
+		}
+
+		pkg->flags &= ~PKGCONF_PKG_PROPF_VISITED_PRIVATE;
+
+		PKGCONF_TRACE(client, "%s: updated, public", pkg->id);
+	}
+}
+
+static unsigned int
+pkgconf_queue_collect_dependencies_main(pkgconf_client_t *client,
+	pkgconf_pkg_t *root,
+	void *data,
+	int maxdepth);
+
+static inline unsigned int
+pkgconf_queue_collect_dependencies_walk(pkgconf_client_t *client,
+	pkgconf_list_t *deplist,
+	void *data,
+	int depth)
+{
+	unsigned int eflags = PKGCONF_PKG_ERRF_OK;
 	pkgconf_node_t *node;
 	pkgconf_pkg_t *world = data;
 
-	if (pkg == world)
-		return;
-
-	if (!(pkg->flags & PKGCONF_PKG_PKGF_SEARCH_PRIVATE))
-	{
-		PKGCONF_FOREACH_LIST_ENTRY(pkg->required.head, node)
-		{
-			pkgconf_dependency_t *flattened_dep;
-
-			flattened_dep = pkgconf_dependency_copy(client, node->data);
-
-			pkgconf_node_insert(&flattened_dep->iter, flattened_dep, &world->required);
-		}
-	}
-	else
-	{
-		PKGCONF_FOREACH_LIST_ENTRY(pkg->requires_private.head, node)
-		{
-			pkgconf_dependency_t *flattened_dep;
-
-			flattened_dep = pkgconf_dependency_copy(client, node->data);
-
-			pkgconf_node_insert(&flattened_dep->iter, flattened_dep, &world->requires_private);
-		}
-	}
-}
-
-static int
-dep_sort_cmp(const void *a, const void *b)
-{
-	const pkgconf_dependency_t *depA = *(void **) a;
-	const pkgconf_dependency_t *depB = *(void **) b;
-
-	return depB->match->hits - depA->match->hits;
-}
-
-static inline void
-flatten_dependency_set(pkgconf_client_t *client, pkgconf_list_t *list)
-{
-	pkgconf_node_t *node, *next;
-	pkgconf_dependency_t **deps = NULL;
-	size_t dep_count = 0, i;
-
-	PKGCONF_FOREACH_LIST_ENTRY_SAFE(list->head, next, node)
+	PKGCONF_FOREACH_LIST_ENTRY_REVERSE(deplist->tail, node)
 	{
 		pkgconf_dependency_t *dep = node->data;
-		pkgconf_pkg_t *pkg = pkgconf_pkg_verify_dependency(client, dep, NULL);
+		pkgconf_dependency_t *flattened_dep;
+		pkgconf_pkg_t *pkg = dep->match;
 
-		if (pkg == NULL)
+		if (*dep->package == '\0')
 			continue;
 
-		if (pkg->serial == client->serial)
-		{
-			pkgconf_node_delete(node, list);
-			pkgconf_dependency_unref(client, dep);
-			goto next;
-		}
-
-		if (dep->match == NULL)
+		if (pkg == NULL)
 		{
 			PKGCONF_TRACE(client, "WTF: unmatched dependency %p <%s>", dep, dep->package);
 			abort();
 		}
 
-		/* for virtuals, we need to check to see if there are dupes */
-		for (i = 0; i < dep_count; i++)
-		{
-			pkgconf_dependency_t *other_dep = deps[i];
+		if (pkg->serial == client->serial)
+			continue;
 
-			PKGCONF_TRACE(client, "dedup %s = %s?", dep->package, other_dep->package);
+		if (client->flags & PKGCONF_PKG_PKGF_ITER_PKG_IS_PRIVATE)
+			pkg->flags |= PKGCONF_PKG_PROPF_VISITED_PRIVATE;
+		else
+			pkg->flags &= ~PKGCONF_PKG_PROPF_VISITED_PRIVATE;
 
-			if (!strcmp(dep->package, other_dep->package))
-			{
-				PKGCONF_TRACE(client, "skipping, %zu deps", dep_count);
-				goto next;
-			}
-		}
+		eflags |= pkgconf_queue_collect_dependencies_main(client, pkg, data, depth - 1);
 
-		pkg->serial = client->serial;
-
-		/* copy to the deps table */
-		dep_count++;
-		deps = pkgconf_reallocarray(deps, dep_count, sizeof (void *));
-		deps[dep_count - 1] = dep;
-
-		PKGCONF_TRACE(client, "added %s to dep table", dep->package);
-next:
-		pkgconf_pkg_unref(client, pkg);
+		flattened_dep = pkgconf_dependency_copy(client, dep);
+		pkgconf_node_insert(&flattened_dep->iter, flattened_dep, &world->required);
 	}
 
-	if (deps == NULL)
-		return;
+	return eflags;
+}
 
-	qsort(deps, dep_count, sizeof (void *), dep_sort_cmp);
+static unsigned int
+pkgconf_queue_collect_dependencies_main(pkgconf_client_t *client,
+	pkgconf_pkg_t *root,
+	void *data,
+	int maxdepth)
+{
+	unsigned int eflags = PKGCONF_PKG_ERRF_OK;
 
-	/* zero the list and start readding */
-	pkgconf_list_zero(list);
+	if (maxdepth == 0)
+		return eflags;
 
-	for (i = 0; i < dep_count; i++)
+	/* Short-circuit if we have already visited this node.
+	 */
+	if (root->serial == client->serial)
+		return eflags;
+
+	root->serial = client->serial;
+
+	if (client->flags & PKGCONF_PKG_PKGF_SEARCH_PRIVATE)
 	{
-		pkgconf_dependency_t *dep = deps[i];
+		PKGCONF_TRACE(client, "%s: collecting private dependencies, level %d", root->id, maxdepth);
 
-		memset(&dep->iter, '\0', sizeof (dep->iter));
-		pkgconf_node_insert(&dep->iter, dep, list);
-
-		PKGCONF_TRACE(client, "slot %zu: dep %s matched to %p<%s> hits %lu", i, dep->package, dep->match, dep->match == NULL ? "NULL" : dep->match->id, dep->match->hits);
+		/* XXX: ugly */
+		const unsigned int saved_flags = client->flags;
+		client->flags |= PKGCONF_PKG_PKGF_ITER_PKG_IS_PRIVATE;
+		eflags = pkgconf_queue_collect_dependencies_walk(client, &root->requires_private, data, maxdepth);
+		client->flags = saved_flags;
+		if (eflags != PKGCONF_PKG_ERRF_OK)
+			return eflags;
 	}
 
-	free(deps);
+	PKGCONF_TRACE(client, "%s: collecting public dependencies, level %d", root->id, maxdepth);
+
+	eflags = pkgconf_queue_collect_dependencies_walk(client, &root->required, data, maxdepth);
+	if (eflags != PKGCONF_PKG_ERRF_OK)
+		return eflags;
+
+	PKGCONF_TRACE(client, "%s: finished, %s", root->id, (root->flags & PKGCONF_PKG_PROPF_VISITED_PRIVATE) ? "private" : "public");
+
+	return eflags;
+}
+
+static inline unsigned int
+pkgconf_queue_collect_dependencies(pkgconf_client_t *client,
+	pkgconf_pkg_t *root,
+	void *data,
+	int maxdepth)
+{
+	++client->serial;
+	return pkgconf_queue_collect_dependencies_main(client, root, data, maxdepth);
 }
 
 static inline unsigned int
 pkgconf_queue_verify(pkgconf_client_t *client, pkgconf_pkg_t *world, pkgconf_list_t *list, int maxdepth)
 {
 	unsigned int result;
+	const unsigned int saved_flags = client->flags;
+	pkgconf_pkg_t initial_world = {
+		.id = "user:request",
+		.realname = "virtual world package",
+		.flags = PKGCONF_PKG_PROPF_STATIC | PKGCONF_PKG_PROPF_VIRTUAL,
+	};
 
-	if (!pkgconf_queue_compile(client, world, list))
+	if (!pkgconf_queue_compile(client, &initial_world, list))
+	{
+		pkgconf_solution_free(client, &initial_world);
 		return PKGCONF_PKG_ERRF_DEPGRAPH_BREAK;
+	}
 
-	/* collect all the dependencies */
-	result = pkgconf_pkg_traverse(client, world, pkgconf_queue_collect_dependents, world, maxdepth, 0);
+	PKGCONF_TRACE(client, "solving");
+	result = pkgconf_pkg_traverse(client, &initial_world, NULL, NULL, maxdepth, 0);
 	if (result != PKGCONF_PKG_ERRF_OK)
+	{
+		pkgconf_solution_free(client, &initial_world);
 		return result;
+	}
 
-	/* flatten the dependency set using serials.
-	 * we copy the dependencies to a vector, and then erase the list.
-	 * then we copy them back to the list.
-	 */
-	++client->serial;
+	PKGCONF_TRACE(client, "flattening");
+	result = pkgconf_queue_collect_dependencies(client, &initial_world, world, maxdepth);
+	if (result != PKGCONF_PKG_ERRF_OK)
+	{
+		pkgconf_solution_free(client, &initial_world);
+		return result;
+	}
 
-	PKGCONF_TRACE(client, "flattening requires deps");
-	flatten_dependency_set(client, &world->required);
+	if (client->flags & PKGCONF_PKG_PKGF_SEARCH_PRIVATE)
+	{
+		PKGCONF_TRACE(client, "marking public deps");
+		client->flags &= ~PKGCONF_PKG_PKGF_SEARCH_PRIVATE;
+		client->flags |= PKGCONF_PKG_PKGF_SKIP_CONFLICTS;
+		result = pkgconf_pkg_traverse(client, &initial_world, pkgconf_queue_mark_public, &world->required, maxdepth, 0);
+		client->flags = saved_flags;
+		if (result != PKGCONF_PKG_ERRF_OK)
+		{
+			pkgconf_solution_free(client, &initial_world);
+			return result;
+		}
+	}
 
-	++client->serial;
-
-	PKGCONF_TRACE(client, "flattening requires.private deps");
-	flatten_dependency_set(client, &world->requires_private);
+	/* free the initial solution */
+	pkgconf_solution_free(client, &initial_world);
 
 	return PKGCONF_PKG_ERRF_OK;
 }
 
+/*
+ * !doc
+ *
+ * .. c:function:: void pkgconf_solution_free(pkgconf_client_t *client, pkgconf_pkg_t *world, int maxdepth)
+ *
+ *    Removes references to package nodes contained in a solution.
+ *
+ *    :param pkgconf_client_t* client: The pkgconf client object to use for dependency resolution.
+ *    :param pkgconf_pkg_t* world: The root for the generated dependency graph.  Should have PKGCONF_PKG_PROPF_VIRTUAL flag.
+ *    :returns: nothing
+ */
+void
+pkgconf_solution_free(pkgconf_client_t *client, pkgconf_pkg_t *world)
+{
+	(void) client;
+
+	if (world->flags & PKGCONF_PKG_PROPF_VIRTUAL)
+	{
+		pkgconf_dependency_free(&world->required);
+		pkgconf_dependency_free(&world->requires_private);
+	}
+}
+
+/*
+ * !doc
+ *
+ * .. c:function:: bool pkgconf_queue_solve(pkgconf_client_t *client, pkgconf_list_t *list, pkgconf_pkg_t *world, int maxdepth)
+ *
+ *    Solves and flattens the dependency graph for the supplied dependency list.
+ *
+ *    :param pkgconf_client_t* client: The pkgconf client object to use for dependency resolution.
+ *    :param pkgconf_list_t* list: The list of dependency requests to consider.
+ *    :param pkgconf_pkg_t* world: The root for the generated dependency graph, provided by the caller.  Should have PKGCONF_PKG_PROPF_VIRTUAL flag.
+ *    :param int maxdepth: The maximum allowed depth for the dependency resolver.  A depth of -1 means unlimited.
+ *    :returns: true if the dependency resolver found a solution, otherwise false.
+ *    :rtype: bool
+ */
+bool
+pkgconf_queue_solve(pkgconf_client_t *client, pkgconf_list_t *list, pkgconf_pkg_t *world, int maxdepth)
+{
+	/* if maxdepth is one, then we will not traverse deeper than our virtual package. */
+	if (!maxdepth)
+		maxdepth = -1;
+
+	return pkgconf_queue_verify(client, world, list, maxdepth) == PKGCONF_PKG_ERRF_OK;
+}
+
 /*
  * !doc
  *
@@ -262,6 +331,8 @@ pkgconf_queue_verify(pkgconf_client_t *client, pkgconf_pkg_t *world, pkgconf_lis
  *    Attempt to compile a dependency resolution queue into a dependency resolution problem, then attempt to solve the problem and
  *    feed the solution to a callback function if a complete dependency graph is found.
  *
+ *    This function should not be used in new code.  Use pkgconf_queue_solve instead.
+ *
  *    :param pkgconf_client_t* client: The pkgconf client object to use for dependency resolution.
  *    :param pkgconf_list_t* list: The list of dependency requests to consider.
  *    :param pkgconf_queue_apply_func_t func: The callback function to call if a solution is found by the dependency resolver.
@@ -284,7 +355,7 @@ pkgconf_queue_apply(pkgconf_client_t *client, pkgconf_list_t *list, pkgconf_queu
 	if (!maxdepth)
 		maxdepth = -1;
 
-	if (pkgconf_queue_verify(client, &world, list, maxdepth) != PKGCONF_PKG_ERRF_OK)
+	if (!pkgconf_queue_solve(client, list, &world, maxdepth))
 		goto cleanup;
 
 	/* the world dependency set is flattened after it is returned from pkgconf_queue_verify */

libpkgconf/tuple.c

@@ -48,6 +48,22 @@ pkgconf_tuple_add_global(pkgconf_client_t *client, const char *key, const char *
 	pkgconf_tuple_add(client, &client->global_vars, key, value, false, 0);
 }
 
+static pkgconf_tuple_t *
+lookup_global_tuple(const pkgconf_client_t *client, const char *key)
+{
+	pkgconf_node_t *node;
+
+	PKGCONF_FOREACH_LIST_ENTRY(client->global_vars.head, node)
+	{
+		pkgconf_tuple_t *tuple = node->data;
+
+		if (!strcmp(tuple->key, key))
+			return tuple;
+	}
+
+	return NULL;
+}
+
 /*
  * !doc
  *
@@ -63,17 +79,13 @@ pkgconf_tuple_add_global(pkgconf_client_t *client, const char *key, const char *
 char *
 pkgconf_tuple_find_global(const pkgconf_client_t *client, const char *key)
 {
-	pkgconf_node_t *node;
+	pkgconf_tuple_t *tuple;
 
-	PKGCONF_FOREACH_LIST_ENTRY(client->global_vars.head, node)
-	{
-		pkgconf_tuple_t *tuple = node->data;
+	tuple = lookup_global_tuple(client, key);
+	if (tuple == NULL)
+		return NULL;
 
-		if (!strcmp(tuple->key, key))
-			return tuple->value;
-	}
-
-	return NULL;
+	return tuple->value;
 }
 
 /*
@@ -108,13 +120,18 @@ pkgconf_tuple_define_global(pkgconf_client_t *client, const char *kv)
 {
 	char *workbuf = strdup(kv);
 	char *value;
+	pkgconf_tuple_t *tuple;
 
 	value = strchr(workbuf, '=');
 	if (value == NULL)
 		goto out;
 
 	*value++ = '\0';
-	pkgconf_tuple_add_global(client, workbuf, value);
+
+	tuple = pkgconf_tuple_add(client, &client->global_vars, workbuf, value, false, 0);
+	if (tuple != NULL)
+		tuple->flags = PKGCONF_PKG_TUPLEF_OVERRIDE;
+
 out:
 	free(workbuf);
 }
@@ -139,7 +156,7 @@ pkgconf_tuple_find_delete(pkgconf_list_t *list, const char *key)
 static char *
 dequote(const char *value)
 {
-	char *buf = calloc((strlen(value) + 1) * 2, 1);
+	char *buf = calloc(1, (strlen(value) + 1) * 2);
 	char *bptr = buf;
 	const char *i;
 	char quote = 0;
@@ -219,7 +236,7 @@ pkgconf_tuple_t *
 pkgconf_tuple_add(const pkgconf_client_t *client, pkgconf_list_t *list, const char *key, const char *value, bool parse, unsigned int flags)
 {
 	char *dequote_value;
-	pkgconf_tuple_t *tuple = calloc(sizeof(pkgconf_tuple_t), 1);
+	pkgconf_tuple_t *tuple = calloc(1, sizeof(pkgconf_tuple_t));
 
 	pkgconf_tuple_find_delete(list, key);
 
@@ -257,6 +274,11 @@ char *
 pkgconf_tuple_find(const pkgconf_client_t *client, pkgconf_list_t *list, const char *key)
 {
 	pkgconf_node_t *node;
+	pkgconf_tuple_t *global_tuple;
+
+	global_tuple = lookup_global_tuple(client, key);
+	if (global_tuple != NULL && global_tuple->flags & PKGCONF_PKG_TUPLEF_OVERRIDE)
+		return global_tuple->value;
 
 	PKGCONF_FOREACH_LIST_ENTRY(list->head, node)
 	{
@@ -266,7 +288,10 @@ pkgconf_tuple_find(const pkgconf_client_t *client, pkgconf_list_t *list, const c
 			return tuple->value;
 	}
 
-	return pkgconf_tuple_find_global(client, key);
+	if (global_tuple != NULL)
+		return global_tuple->value;
+
+	return NULL;
 }
 
 /*
@@ -332,12 +357,21 @@ pkgconf_tuple_parse(const pkgconf_client_t *client, pkgconf_list_t *vars, const
 
 			PKGCONF_TRACE(client, "lookup tuple %s", varname);
 
+			size_t remain = PKGCONF_BUFSIZE - (bptr - buf);
 			ptr += (pptr - ptr);
 			kv = pkgconf_tuple_find_global(client, varname);
 			if (kv != NULL)
 			{
-				strncpy(bptr, kv, PKGCONF_BUFSIZE - (bptr - buf));
-				bptr += strlen(kv);
+				size_t nlen = pkgconf_strlcpy(bptr, kv, remain);
+				if (nlen > remain)
+				{
+					pkgconf_warn(client, "warning: truncating very long variable to 64KB\n");
+
+					bptr = buf + (PKGCONF_BUFSIZE - 1);
+					break;
+				}
+
+				bptr += nlen;
 			}
 			else
 			{
@@ -345,12 +379,21 @@ pkgconf_tuple_parse(const pkgconf_client_t *client, pkgconf_list_t *vars, const
 
 				if (kv != NULL)
 				{
+					size_t nlen;
+
 					parsekv = pkgconf_tuple_parse(client, vars, kv, flags);
-
-					strncpy(bptr, parsekv, PKGCONF_BUFSIZE - (bptr - buf));
-					bptr += strlen(parsekv);
-
+					nlen = pkgconf_strlcpy(bptr, parsekv, remain);
 					free(parsekv);
+
+					if (nlen > remain)
+					{
+						pkgconf_warn(client, "warning: truncating very long variable to 64KB\n");
+
+						bptr = buf + (PKGCONF_BUFSIZE - 1);
+						break;
+					}
+
+					bptr += nlen;
 				}
 			}
 		}

libpkgconf/win-dirent.h

@@ -912,7 +912,7 @@ static int strverscmp(const char *a, const char *b)
 
 	/* Count backwards and find the leftmost digit */
 	j = i;
-	while (j > 0 && isdigit(a[j-1])) {
+	while (j > 0 && isdigit((unsigned char)a[j-1])) {
 		--j;
 	}
 
@@ -924,23 +924,24 @@ static int strverscmp(const char *a, const char *b)
 		}
 
 		/* String with more digits is smaller, e.g 002 < 01 */
-		if (isdigit(a[j])) {
-			if (!isdigit(b[j])) {
+		if (isdigit((unsigned char)a[j])) {
+			if (!isdigit((unsigned char)b[j])) {
 				return -1;
 			}
-		} else if (isdigit(b[j])) {
+		} else if ((unsigned char)isdigit(b[j])) {
 			return 1;
 		}
-	} else if (isdigit(a[j]) && isdigit(b[j])) {
+	} else if ((unsigned char)isdigit(a[j]) &&
+	    isdigit((unsigned char)b[j])) {
 		/* Numeric comparison */
 		size_t k1 = j;
 		size_t k2 = j;
 
 		/* Compute number of digits in each string */
-		while (isdigit(a[k1])) {
+		while (isdigit((unsigned char)a[k1])) {
 			k1++;
 		}
-		while (isdigit(b[k2])) {
+		while (isdigit((unsigned char)b[k2])) {
 			k2++;
 		}
 

m4/ax_check_compile_flag.m4

@@ -29,33 +29,12 @@
 #   Copyright (c) 2008 Guido U. Draheim <guidod@gmx.de>
 #   Copyright (c) 2011 Maarten Bosmans <mkbosmans@gmail.com>
 #
-#   This program is free software: you can redistribute it and/or modify it
-#   under the terms of the GNU General Public License as published by the
-#   Free Software Foundation, either version 3 of the License, or (at your
-#   option) any later version.
-#
-#   This program is distributed in the hope that it will be useful, but
-#   WITHOUT ANY WARRANTY; without even the implied warranty of
-#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
-#   Public License for more details.
-#
-#   You should have received a copy of the GNU General Public License along
-#   with this program. If not, see <https://www.gnu.org/licenses/>.
-#
-#   As a special exception, the respective Autoconf Macro's copyright owner
-#   gives unlimited permission to copy, distribute and modify the configure
-#   scripts that are the output of Autoconf when processing the Macro. You
-#   need not follow the terms of the GNU General Public License when using
-#   or distributing such scripts, even though portions of the text of the
-#   Macro appear in them. The GNU General Public License (GPL) does govern
-#   all other use of the material that constitutes the Autoconf Macro.
-#
-#   This special exception to the GPL applies to versions of the Autoconf
-#   Macro released by the Autoconf Archive. When you make and distribute a
-#   modified version of the Autoconf Macro, you may extend this special
-#   exception to the GPL to apply to your modified version as well.
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved.  This file is offered as-is, without any
+#   warranty.
 
-#serial 5
+#serial 6
 
 AC_DEFUN([AX_CHECK_COMPILE_FLAG],
 [AC_PREREQ(2.64)dnl for _AC_LANG_PREFIX and AS_VAR_IF

man/pc.5

@@ -99,6 +99,9 @@ These flags are always used, regardless of whether static compilation is request
 .It Cflags.private
 Required compiler flags for static compilation.
 (optional; fragment list; pkgconf extension)
+.It Copyright
+A copyright attestation statement.
+(optional; literal; pkgconf extension)
 .It Libs
 Required linking flags for this package.
 Libraries this package depends on for linking against it, which are not
@@ -113,15 +116,20 @@ not described as dependencies should be specified here.
 .It License
 The asserted SPDX license tag that should be applied to the given package.
 (optional; literal; pkgconf extension)
+.It Maintainer
+The preferred contact for the maintainer.  This should be in the format of a
+name followed by an e-mail address or website.
+(optional; literal; pkgconf extension)
 .It Requires
 Required dependencies that must be met for the package to be usable.
 All dependencies must be satisfied or the pkg-config implementation must not use
 the package.
 (optional; dependency list)
 .It Requires.private
-Required dependencies that must be met for the package to be usable for static linking.
+Required dependencies that must be met for the package to be usable for header
+inclusion and static linking.
 All dependencies must be satisfied or the pkg-config implementation must not use
-the package for static linking.
+the package for header inclusion and static linking.
 (optional; dependency list)
 .It Conflicts
 Dependencies that must not be met for the package to be usable.
@@ -154,6 +162,9 @@ includedir=${prefix}/include
 
 Name: libfoo                                  # human-readable name
 Description: an example library called libfoo # human-readable description
+Copyright: Copyright (c) 2022 pkgconf project authors
+License: Apache-2.0
+Maintainer: the pkgconf project <http://www.pkgconf.org>
 Version: 1.0
 URL: http://www.pkgconf.org
 Requires: libbar > 2.0.0

man/pkgconf-personality.5

@@ -36,7 +36,7 @@ Properties are set using RFC822-style stanzas which consist of a keyword, follow
 by a colon (:) and then the value the property should be set to.
 Variable substitution is always performed regardless of property type.
 .Pp
-There are two types of property:
+There are three types of property:
 .\"
 .Bl -tag -width indent
 .\"

meson.build

@@ -1,7 +1,7 @@
 project('pkgconf', 'c',
-  version : '1.9.0',
+  version : '2.3.0',
   license : 'ISC',
-  meson_version : '>=0.47',
+  meson_version : '>=0.49',
   default_options : ['c_std=c99'],
 )
 
@@ -30,8 +30,12 @@ check_functions = [
 ]
 
 foreach f : check_functions
-  if cc.has_function(f[0], prefix : '#define _BSD_SOURCE\n#include <@0@>'.format(f[1])) and cc.has_header_symbol(f[1], f[0], prefix : '#define _BSD_SOURCE')
-    cdata.set('HAVE_@0@'.format(f[0].to_upper().underscorify()), 1)
+  name = f[0].to_upper().underscorify()
+  if cc.has_function(f[0], prefix : '#define _BSD_SOURCE\n#define _DEFAULT_SOURCE\n#include <@0@>'.format(f[1])) and cc.has_header_symbol(f[1], f[0], prefix : '#define _BSD_SOURCE\n#define _DEFAULT_SOURCE')
+    cdata.set('HAVE_@0@'.format(name), 1)
+    cdata.set('HAVE_DECL_@0@'.format(name), 1)
+  else
+    cdata.set('HAVE_DECL_@0@'.format(name), 0)
   endif
 endforeach
 
@@ -45,8 +49,18 @@ foreach f : ['libdir', 'datadir']
   personality_path += [join_paths(get_option('prefix'), get_option(f), 'pkgconfig', 'personality.d')]
 endforeach
 
-cdata.set_quoted('SYSTEM_LIBDIR', join_paths(get_option('prefix'), get_option('libdir')))
-cdata.set_quoted('SYSTEM_INCLUDEDIR', join_paths(get_option('prefix'), get_option('includedir')))
+SYSTEM_LIBDIR = get_option('with-system-libdir')
+if SYSTEM_LIBDIR != ''
+  cdata.set_quoted('SYSTEM_LIBDIR', SYSTEM_LIBDIR)
+else
+  cdata.set_quoted('SYSTEM_LIBDIR', join_paths(get_option('prefix'), get_option('libdir')))
+endif
+SYSTEM_INCLUDEDIR = get_option('with-system-includedir')
+if SYSTEM_INCLUDEDIR != ''
+  cdata.set_quoted('SYSTEM_INCLUDEDIR', SYSTEM_INCLUDEDIR)
+else
+  cdata.set_quoted('SYSTEM_INCLUDEDIR', join_paths(get_option('prefix'), get_option('includedir')))
+endif
 cdata.set_quoted('PKG_DEFAULT_PATH', ':'.join(default_path))
 cdata.set_quoted('PERSONALITY_PATH', ':'.join(personality_path))
 cdata.set_quoted('PACKAGE_NAME', meson.project_name())
@@ -82,8 +96,8 @@ libpkgconf = library('pkgconf',
   'libpkgconf/tuple.c',
   c_args: ['-DLIBPKGCONF_EXPORT', build_static],
   install : true,
-  version : '4.0.0',
-  soversion : '4',
+  version : '5.0.0',
+  soversion : '5',
 )
 
 # For other projects using libpkgconfig as a subproject
@@ -117,13 +131,12 @@ pkgconf_exe = executable('pkgconf',
   c_args: build_static,
   install : true)
 
-if get_option('tests')
-  kyua_exe = find_program('kyua')
-  atf_sh_exe = find_program('atf-sh')
-  kyuafile = configure_file(input : 'Kyuafile.in', output : 'Kyuafile', configuration : cdata)
-  test('kyua', kyua_exe, args : ['--config=none', 'test', '--kyuafile', kyuafile, '--build-root', meson.current_build_dir()])
-  subdir('tests')
-endif
+with_tests = get_option('tests')
+kyua_exe = find_program('kyua', required : with_tests, disabler : true)
+atf_sh_exe = find_program('atf-sh', required : with_tests, disabler : true)
+kyuafile = configure_file(input : 'Kyuafile.in', output : 'Kyuafile', configuration : cdata)
+test('kyua', kyua_exe, args : ['--config=none', 'test', '--kyuafile', kyuafile, '--build-root', meson.current_build_dir()])
+subdir('tests')
 
 install_man('man/pkgconf.1')
 install_man('man/pkg.m4.7')

meson_options.txt

@@ -1,3 +1,19 @@
-option('tests', type: 'boolean', value: true,
-  description: 'Build tests which depends upon the kyua framework'
-)
+option(
+  'tests',
+  type: 'feature',
+  description: 'Build tests which depends upon the kyua framework',
+)
+
+option(
+  'with-system-libdir',
+  type: 'string',
+  value: '',
+  description: 'Specify the system library directory (default {prefix}/{libdir})'
+)
+
+option(
+  'with-system-includedir',
+  type: 'string',
+  value: '',
+  description: 'Specify the system include directory (default {prefix}/{includedir})'
+)

pkg.m4

@@ -46,8 +46,8 @@ m4_if(m4_version_compare(PKG_MACROS_VERSION, [$1]), -1,
     [m4_fatal([pkg.m4 version $1 or higher is required but ]PKG_MACROS_VERSION[ found])])
 ])dnl PKG_PREREQ
 
-dnl PKG_PROG_PKG_CONFIG([MIN-VERSION])
-dnl ----------------------------------
+dnl PKG_PROG_PKG_CONFIG([MIN-VERSION], [ACTION-IF-NOT-FOUND])
+dnl ---------------------------------------------------------
 dnl Since: 0.16
 dnl
 dnl Search for the pkg-config tool and set the PKG_CONFIG variable to
@@ -55,6 +55,12 @@ dnl first found in the path. Checks that the version of pkg-config found
 dnl is at least MIN-VERSION. If MIN-VERSION is not specified, 0.9.0 is
 dnl used since that's the first version where most current features of
 dnl pkg-config existed.
+dnl
+dnl If pkg-config is not found or older than specified, it will result
+dnl in an empty PKG_CONFIG variable. To avoid widespread issues with
+dnl scripts not checking it, ACTION-IF-NOT-FOUND defaults to aborting.
+dnl You can specify [PKG_CONFIG=false] as an action instead, which would
+dnl result in pkg-config tests failing, but no bogus error messages.
 AC_DEFUN([PKG_PROG_PKG_CONFIG],
 [m4_pattern_forbid([^_?PKG_[A-Z_]+$])
 m4_pattern_allow([^PKG_CONFIG(_(PATH|LIBDIR|SYSROOT_DIR|ALLOW_SYSTEM_(CFLAGS|LIBS)))?$])
@@ -75,6 +81,9 @@ if test -n "$PKG_CONFIG"; then
 		AC_MSG_RESULT([no])
 		PKG_CONFIG=""
 	fi
+fi
+if test -z "$PKG_CONFIG"; then
+	m4_default([$2], [AC_MSG_ERROR([pkg-config not found])])
 fi[]dnl
 ])dnl PKG_PROG_PKG_CONFIG
 
@@ -146,7 +155,6 @@ AC_MSG_CHECKING([for $2])
 
 _PKG_CONFIG([$1][_CFLAGS], [cflags], [$2])
 _PKG_CONFIG([$1][_LIBS], [libs], [$2])
-_PKG_CONFIG([$1][_VERSION], [modversion], [$2])
 
 m4_define([_PKG_TEXT], [Alternatively, you may set the environment variables $1[]_CFLAGS
 and $1[]_LIBS to avoid the need to call pkg-config.
@@ -187,7 +195,6 @@ To get pkg-config, see <http://pkg-config.freedesktop.org/>.])[]dnl
 else
         $1[]_CFLAGS=$pkg_cv_[]$1[]_CFLAGS
         $1[]_LIBS=$pkg_cv_[]$1[]_LIBS
-        $1[]_VERSION=$pkg_cv_[]$1[]_VERSION
         AC_MSG_RESULT([yes])
         $3
 fi[]dnl

tests/basic.sh

@@ -11,6 +11,7 @@ tests_init \
 	libs_cflags_version_alt \
 	libs_cflags_version_different \
 	libs_cflags_version_different_bad \
+	libs_env \
 	exists_nonexitent \
 	nonexitent \
 	exists_version \
@@ -21,6 +22,8 @@ tests_init \
 	exists2 \
 	exists3 \
 	exists_version_alt \
+	exists_cflags \
+	exists_cflags_env \
 	uninstalled_bad \
 	uninstalled \
 	libs_intermediary \
@@ -29,15 +32,19 @@ tests_init \
 	libs_circular_directpc \
 	libs_static \
 	libs_static_ordering \
+	libs_metapackage \
 	license_isc \
 	license_noassertion \
+	modversion_noflatten \
 	pkg_config_path \
 	nolibs \
 	nocflags \
 	arbitary_path \
 	with_path \
 	relocatable \
-	single_depth_selectors
+	single_depth_selectors \
+	print_variables_env \
+	variable_env
 
 noargs_body()
 {
@@ -49,7 +56,7 @@ libs_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-L/test/lib -lfoo \n" \
+		-o inline:"-L/test/lib -lfoo\n" \
 		pkgconf --libs foo
 }
 
@@ -57,7 +64,7 @@ libs_cflags_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-fPIC -I/test/include/foo -L/test/lib -lfoo \n" \
+		-o inline:"-fPIC -I/test/include/foo -L/test/lib -lfoo\n" \
 		pkgconf --cflags --libs foo
 }
 
@@ -66,7 +73,7 @@ libs_cflags_version_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-fPIC -I/test/include/foo -L/test/lib -lfoo \n" \
+		-o inline:"-fPIC -I/test/include/foo -L/test/lib -lfoo\n" \
 		pkgconf --cflags --libs 'foo > 1.2'
 }
 
@@ -74,7 +81,7 @@ libs_cflags_version_multiple_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-fPIC -I/test/include/foo -L/test/lib -lbar -lfoo \n" \
+		-o inline:"-fPIC -I/test/include/foo -L/test/lib -lbar -lfoo\n" \
 		pkgconf --cflags --libs 'foo > 1.2 bar >= 1.3'
 }
 
@@ -82,7 +89,7 @@ libs_cflags_version_multiple_coma_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-fPIC -I/test/include/foo -L/test/lib -lbar -lfoo \n" \
+		-o inline:"-fPIC -I/test/include/foo -L/test/lib -lbar -lfoo\n" \
 		pkgconf --cflags --libs 'foo > 1.2,bar >= 1.3'
 }
 
@@ -90,7 +97,7 @@ libs_cflags_version_alt_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-fPIC -I/test/include/foo -L/test/lib -lfoo \n" \
+		-o inline:"-fPIC -I/test/include/foo -L/test/lib -lfoo\n" \
 		pkgconf --cflags --libs 'foo' '>' '1.2'
 }
 
@@ -98,7 +105,7 @@ libs_cflags_version_different_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-fPIC -I/test/include/foo -L/test/lib -lfoo \n" \
+		-o inline:"-fPIC -I/test/include/foo -L/test/lib -lfoo\n" \
 		pkgconf --cflags --libs 'foo' '!=' '1.3.0'
 }
 
@@ -178,7 +185,7 @@ exists_version_bad3_body()
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
 		-s exit:1 \
-		pkgconf --exists 'tilde <= 1.0.0'
+		pkgconf --exists 'tilde >= 1.0.0'
 }
 
 exists_body()
@@ -192,7 +199,7 @@ exists2_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		pkgconf --exists 'tilde >= 1.0.0'
+		pkgconf --exists 'tilde <= 1.0.0'
 }
 
 exists3_body()
@@ -206,7 +213,7 @@ libs_intermediary_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-lintermediary-1 -lintermediary-2 -lfoo -lbar -lbaz \n" \
+		-o inline:"-lintermediary-1 -lintermediary-2 -lfoo -lbar -lbaz\n" \
 		pkgconf --libs intermediary-1 intermediary-2
 }
 
@@ -229,7 +236,7 @@ libs_circular1_body()
 libs_circular_directpc_body()
 {
 	atf_check \
-		-o inline:"-lcircular-1 -lcircular-2 -lcircular-3 \n" \
+		-o inline:"-lcircular-3 -lcircular-1 -lcircular-2\n" \
 		pkgconf --libs ${selfdir}/lib1/circular-3.pc
 }
 
@@ -237,7 +244,7 @@ libs_static_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"/libfoo.a -pthread \n" \
+		-o inline:"/libfoo.a -pthread\n" \
 		pkgconf --libs static-archive-libs
 }
 
@@ -245,28 +252,36 @@ libs_static_ordering_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-L/test/lib -lbar -lfoo \n" \
+		-o inline:"-L/test/lib -lbar -lfoo\n" \
 		pkgconf --libs foo bar
 }
 
+libs_metapackage_body()
+{
+	export PKG_CONFIG_PATH="${selfdir}/lib1"
+	atf_check \
+		-o inline:"-L/test/lib -lbar -lfoo\n" \
+		pkgconf --static --libs metapackage-3
+}
+
 pkg_config_path_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1${PATH_SEP}${selfdir}/lib2"
 	atf_check \
-		-o inline:"-L/test/lib -lfoo \n" \
+		-o inline:"-L/test/lib -lfoo\n" \
 		pkgconf --libs foo
 	atf_check \
-		-o inline:"-L/test/lib -lbar -lfoo \n" \
+		-o inline:"-L/test/lib -lbar -lfoo\n" \
 		pkgconf --libs bar
 }
 
 with_path_body()
 {
 	atf_check \
-		-o inline:"-L/test/lib -lfoo \n" \
+		-o inline:"-L/test/lib -lfoo\n" \
 		pkgconf --with-path=${selfdir}/lib1 --with-path=${selfdir}/lib2 --libs foo
 	atf_check \
-		-o inline:"-L/test/lib -lbar -lfoo \n" \
+		-o inline:"-L/test/lib -lbar -lfoo\n" \
 		pkgconf --with-path=${selfdir}/lib1 --with-path=${selfdir}/lib2 --libs bar
 }
 
@@ -290,7 +305,7 @@ arbitary_path_body()
 {
 	cp ${selfdir}/lib1/foo.pc .
 	atf_check \
-		-o inline:"-L/test/lib -lfoo \n" \
+		-o inline:"-L/test/lib -lfoo\n" \
 		pkgconf --libs foo.pc
 }
 
@@ -323,3 +338,46 @@ license_noassertion_body()
 		-o inline:"bar: NOASSERTION\nfoo: ISC\n" \
 		pkgconf --with-path=${selfdir}/lib1 --license bar
 }
+
+modversion_noflatten_body()
+{
+	atf_check \
+		-o inline:"1.3\n" \
+		pkgconf --with-path=${selfdir}/lib1 --modversion bar
+}
+
+exists_cflags_body()
+{
+	atf_check \
+		-o inline:"-DHAVE_FOO\n" \
+		pkgconf --with-path=${selfdir}/lib1 --cflags --exists-cflags --fragment-filter=D foo
+}
+
+exists_cflags_env_body()
+{
+	atf_check \
+		-o inline:"FOO_CFLAGS='-DHAVE_FOO'\n" \
+		pkgconf --with-path=${selfdir}/lib1 --cflags --exists-cflags --fragment-filter=D --env=FOO foo
+}
+
+libs_env_body()
+{
+	atf_check \
+		-o inline:"FOO_LIBS='-L/test/lib -lfoo'\n" \
+		pkgconf --with-path=${selfdir}/lib1 --libs --env=FOO foo
+}
+
+print_variables_env_body()
+{
+	atf_check \
+		-o inline:"FOO_CFLAGS='-fPIC -I/test/include/foo'\nFOO_LIBS='-L/test/lib -lfoo'\nFOO_INCLUDEDIR='/test/include'\nFOO_LIBDIR='/test/lib'\nFOO_EXEC_PREFIX='/test'\nFOO_PREFIX='/test'\nFOO_PCFILEDIR='${selfdir}/lib1'\n" \
+		pkgconf --with-path=${selfdir}/lib1 --env=FOO --print-variables --cflags --libs foo
+
+}
+
+variable_env_body()
+{
+	atf_check \
+		-o inline:"FOO_INCLUDEDIR='/test/include'\n" \
+		pkgconf --with-path=${selfdir}/lib1 --env=FOO --variable=includedir foo
+}

tests/conflicts.sh

@@ -10,7 +10,7 @@ libs_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-L/test/lib -lconflicts \n" \
+		-o inline:"-L/test/lib -lconflicts\n" \
 		pkgconf --libs conflicts
 }
 
@@ -18,6 +18,6 @@ ignore_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-L/test/lib -lconflicts \n" \
+		-o inline:"-L/test/lib -lconflicts\n" \
 		pkgconf --ignore-conflicts --libs conflicts
 }

tests/framework.sh

@@ -9,12 +9,12 @@ libs_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-F/test/lib -framework framework-1 \n" \
+		-o inline:"-F/test/lib -framework framework-1\n" \
 		pkgconf --libs framework-1
 	atf_check \
-		-o inline:"-F/test/lib -framework framework-2 -framework framework-1 \n" \
+		-o inline:"-F/test/lib -framework framework-2 -framework framework-1\n" \
 		pkgconf --libs framework-2
 	atf_check \
-		-o inline:"-F/test/lib -framework framework-2 -framework framework-1 \n" \
+		-o inline:"-F/test/lib -framework framework-2 -framework framework-1\n" \
 		pkgconf --libs framework-1 framework-2
 }

tests/lib1/billion-laughs.pc

@@ -0,0 +1,13 @@
+v9=lol
+v8=${v9}${v9}${v9}${v9}${v9}${v9}${v9}${v9}${v9}${v9}
+v7=${v8}${v8}${v8}${v8}${v8}${v8}${v8}${v8}${v8}${v8}
+v6=${v7}${v7}${v7}${v7}${v7}${v7}${v7}${v7}${v7}${v7}
+v5=${v6}${v6}${v6}${v6}${v6}${v6}${v6}${v6}${v6}${v6}
+v4=${v5}${v5}${v5}${v5}${v5}${v5}${v5}${v5}${v5}${v5}
+v3=${v4}${v4}${v4}${v4}${v4}${v4}${v4}${v4}${v4}${v4}
+v2=${v3}${v3}${v3}${v3}${v3}${v3}${v3}${v3}${v3}${v3}
+v1=${v2}${v2}${v2}${v2}${v2}${v2}${v2}${v2}${v2}${v2}
+v0=${v1}${v1}${v1}${v1}${v1}${v1}${v1}${v1}${v1}${v1}
+Name: One Billion Laughs
+Version: ${v0}
+Description: Don't install this!

tests/lib1/child-prefix/pkgconfig/child-prefix-1.pc

@@ -0,0 +1,11 @@
+prefix=/usr
+exec_prefix=/usr
+libdir=${prefix}/lib64
+includedir=${prefix}/include
+
+Name: child-prefix-1
+Description: child prefix 1 test data
+Requires:
+Version: 1.0
+Libs: -L${libdir} -lchild-prefix-1
+Cflags: -I${includedir}/child-prefix-1

tests/lib1/foobar.pc

@@ -0,0 +1,12 @@
+prefix=/test
+exec_prefix=${prefix}
+libdir=${prefix}/lib
+includedir=${prefix}/include
+
+Name: foobar
+Description: A testing pkg-config file
+Version: 3.2.1
+Libs: -L${libdir} -lfoobar
+Cflags: -fPIC -I${includedir}/foobar
+Cflags.private: -DFOOBAR_STATIC
+License: ISC

tests/lib1/metapackage-1.pc

@@ -0,0 +1,6 @@
+Name: metapackage-1
+Version: 0.1
+Description: metapackage for testing purposes
+Requires.private: metapackage-2
+Libs: -lmetapackage-1
+Cflags: -I/metapackage-1

tests/lib1/metapackage-2.pc

@@ -0,0 +1,5 @@
+Name: metapackage-2
+Version: 0.1
+Description: metapackage for testing purposes
+Libs: -lmetapackage-2
+Cflags: -I/metapackage-2

tests/lib1/metapackage-3.pc

@@ -0,0 +1,4 @@
+Name: metapackage-3
+Version: 0.1
+Description: metapackage for testing purposes
+Requires.private: bar

tests/lib1/metapackage.pc

@@ -0,0 +1,4 @@
+Name: metapackage
+Version: 0.1
+Description: metapackage for testing purposes
+Requires: metapackage-1, metapackage-2

tests/lib1/quotes.pc

@@ -7,4 +7,4 @@ Name: quotes
 Description: A testing pkg-config file
 Version: 1.2.3
 Libs: -L${libdir} -lfoo
-Cflags: -DQUOTED=\"bla\"
+Cflags: -DQUOTED=\"bla\" -DA=\"escaped\ string\'\ \literal\" -DB="\1\$" -DC='bla'

tests/lib1/spaces-in-paths.pc

@@ -0,0 +1,7 @@
+prefix=/test\ with\ spaces
+includedir=${prefix}/include
+
+Name: spaces-in-paths
+Version: 1
+Description: test package for properly expanding spaces in variables
+Cflags: -I${includedir} -I${includedir}/subdir

tests/lib1/unavailable-provider.pc

@@ -0,0 +1,11 @@
+prefix=/test
+exec_prefix=${prefix}
+libdir=${prefix}/lib
+includedir=${prefix}/include
+
+Name: unavailable_provider
+Description: Provides an otherwise unavailable package
+Version: 1.2.3
+Provides: unavailable = 1.2.3
+Libs: -lunavailable
+Cflags:

tests/lib1/utf8.pc

@@ -0,0 +1,10 @@
+prefix=/tëst
+exec_prefix=${prefix}
+libdir=${prefix}/lib
+includedir=${prefix}/include
+
+Name: utf8
+Description: Library installed in a prefix with UTF-8
+Version: 0
+Libs: -L${libdir} -lutf8
+Cflags: -I${includedir}

tests/meson.build

@@ -19,5 +19,4 @@ tests = [
 # yuck
 foreach test : tests
   test_file = configure_file(input: test + '.sh', output: test, copy: true)
-  run_command('chmod', '755', test_file, check : true)
 endforeach

tests/parser.sh

@@ -41,7 +41,7 @@ comments_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-lfoo \n" \
+		-o inline:"-lfoo\n" \
 		pkgconf --libs comments
 }
 
@@ -49,7 +49,7 @@ comments_in_fields_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-lfoo \n" \
+		-o inline:"-lfoo\n" \
 		pkgconf --libs comments-in-fields
 }
 
@@ -57,7 +57,7 @@ dos_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-L/test/lib/dos-lineendings -ldos-lineendings \n" \
+		-o inline:"-L/test/lib/dos-lineendings -ldos-lineendings\n" \
 		pkgconf --libs dos-lineendings
 }
 
@@ -65,7 +65,7 @@ no_trailing_newline_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-I/test/include/no-trailing-newline \n" \
+		-o inline:"-I/test/include/no-trailing-newline\n" \
 		pkgconf --cflags no-trailing-newline
 }
 
@@ -73,7 +73,7 @@ argv_parse_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-llib-3 -llib-1 -llib-2 -lpthread \n" \
+		-o inline:"-llib-3 -llib-1 -llib-2 -lpthread\n" \
 		pkgconf --libs argv-parse
 }
 
@@ -90,7 +90,7 @@ argv_parse_3_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-llib-1 -pthread /test/lib/lib2.so \n" \
+		-o inline:"-llib-1 -pthread /test/lib/lib2.so\n" \
 		pkgconf --libs argv-parse-3
 }
 
@@ -98,10 +98,10 @@ tilde_quoting_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-L~ -ltilde \n" \
+		-o inline:"-L~ -ltilde\n" \
 		pkgconf --libs tilde-quoting
 	atf_check \
-		-o inline:"-I~ \n" \
+		-o inline:"-I~\n" \
 		pkgconf --cflags tilde-quoting
 }
 
@@ -109,7 +109,7 @@ paren_quoting_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-L\$(libdir) -ltilde \n" \
+		-o inline:"-L\$(libdir) -ltilde\n" \
 		pkgconf --libs paren-quoting
 }
 
@@ -134,7 +134,7 @@ escaped_backslash_body()
 {
 	atf_check \
 		-e ignore \
-		-o inline:"-IC:\\\\\\\\A \n" \
+		-o inline:"-IC:\\\\\\\\A\n" \
 		pkgconf --with-path=${selfdir}/lib1 --cflags escaped-backslash
 }
 
@@ -142,7 +142,7 @@ quoted_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-DQUOTED=\\\"bla\\\" \n" \
+		-o inline:"-DQUOTED=\\\"bla\\\" -DA=\\\"escaped\\ string\\\'\\ literal\\\" -DB=\\\\\\1\$ -DC=bla\n" \
 		pkgconf --cflags quotes
 }
 
@@ -150,7 +150,7 @@ flag_order_1_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-L/test/lib -Bdynamic -lfoo -Bstatic -lbar \n" \
+		-o inline:"-L/test/lib -Bdynamic -lfoo -Bstatic -lbar\n" \
 		pkgconf --libs flag-order-1
 }
 
@@ -158,7 +158,7 @@ flag_order_2_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-L/test/lib -Bdynamic -lfoo -Bstatic -lbar -lfoo \n" \
+		-o inline:"-L/test/lib -Bdynamic -lfoo -Bstatic -lbar -lfoo\n" \
 		pkgconf --libs flag-order-1 foo
 }
 
@@ -166,7 +166,7 @@ flag_order_3_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-L/test/lib -Wl,--start-group -lfoo -lbar -Wl,--end-group \n" \
+		-o inline:"-L/test/lib -Wl,--start-group -lfoo -lbar -Wl,--end-group\n" \
 		pkgconf --libs flag-order-3
 }
 
@@ -174,7 +174,7 @@ flag_order_4_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-L/test/lib -Wl,--start-group -lfoo -lbar -Wl,--end-group -lfoo \n" \
+		-o inline:"-L/test/lib -Wl,--start-group -lfoo -lbar -Wl,--end-group -lfoo\n" \
 		pkgconf --libs flag-order-3 foo
 }
 
@@ -182,7 +182,7 @@ variable_whitespace_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-I/test/include \n" \
+		-o inline:"-I/test/include\n" \
 		pkgconf --cflags variable-whitespace
 }
 
@@ -190,7 +190,7 @@ fragment_quoting_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-fPIC -I/test/include/foo -DQUOTED=\\\"/test/share/doc\\\" \n" \
+		-o inline:"-fPIC -I/test/include/foo -DQUOTED=\\\"/test/share/doc\\\"\n" \
 		pkgconf --cflags fragment-quoting
 }
 
@@ -198,7 +198,7 @@ fragment_quoting_2_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-fPIC -I/test/include/foo -DQUOTED=/test/share/doc \n" \
+		-o inline:"-fPIC -I/test/include/foo -DQUOTED=/test/share/doc\n" \
 		pkgconf --cflags fragment-quoting-2
 }
 
@@ -206,7 +206,7 @@ fragment_quoting_3_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-fPIC -I/test/include/foo -DQUOTED=\\\"/test/share/doc\\\" \n" \
+		-o inline:"-fPIC -I/test/include/foo -DQUOTED=\\\"/test/share/doc\\\"\n" \
 		pkgconf --cflags fragment-quoting-3
 }
 
@@ -214,7 +214,7 @@ fragment_quoting_5_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-fPIC -I/test/include/foo -DQUOTED=/test/share/doc \n" \
+		-o inline:"-fPIC -I/test/include/foo -DQUOTED=/test/share/doc\n" \
 		pkgconf --cflags fragment-quoting-5
 }
 
@@ -222,28 +222,28 @@ fragment_quoting_7_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-Dhello=10 -Dworld=+32 -DDEFINED_FROM_PKG_CONFIG=hello\\ world \n" \
+		-o inline:"-Dhello=10 -Dworld=+32 -DDEFINED_FROM_PKG_CONFIG=hello\\ world\n" \
 		pkgconf --cflags fragment-quoting-7
 }
 
 fragment_escaping_1_body()
 {
 	atf_check \
-		-o inline:"-IC:\\\\\\\\D\\ E \n" \
+		-o inline:"-IC:\\\\\\\\D\\ E\n" \
 		pkgconf --with-path="${selfdir}/lib1" --cflags fragment-escaping-1
 }
 
 fragment_escaping_2_body()
 {
 	atf_check \
-		-o inline:"-IC:\\\\\\\\D\\ E \n" \
+		-o inline:"-IC:\\\\\\\\D\\ E\n" \
 		pkgconf --with-path="${selfdir}/lib1" --cflags fragment-escaping-2
 }
 
 fragment_escaping_3_body()
 {
 	atf_check \
-		-o inline:"-IC:\\\\\\\\D\\ E \n" \
+		-o inline:"-IC:\\\\\\\\D\\ E\n" \
 		pkgconf --with-path="${selfdir}/lib1" --cflags fragment-escaping-3
 }
 
@@ -269,7 +269,7 @@ fragment_quoting_7a_body()
 fragment_comment_body()
 {
 	atf_check \
-		-o inline:'kuku=\#ttt \n' \
+		-o inline:'kuku=\#ttt\n' \
 		pkgconf --with-path="${selfdir}/lib1" --cflags fragment-comment
 }
 
@@ -292,7 +292,7 @@ msvc_fragment_render_cflags_body()
 tuple_dequote_body()
 {
 	atf_check \
-		-o inline:'-L/test/lib -lfoo \n' \
+		-o inline:'-L/test/lib -lfoo\n' \
 		pkgconf --with-path="${selfdir}/lib1" --libs tuple-quoting
 }
 

tests/provides.sh

@@ -27,7 +27,7 @@ provides = 1.2.3
 		-o inline:"${OUTPUT}" \
 		pkgconf --print-provides provides
 	atf_check \
-		-o inline:"-lfoo \n" \
+		-o inline:"-lfoo\n" \
 		pkgconf --libs provides-request-simple
 	atf_check \
 		-e ignore \

tests/regress.sh

@@ -8,6 +8,7 @@ tests_init \
 	depgraph_break_2 \
 	depgraph_break_3 \
 	define_variable \
+	define_variable_override \
 	variable \
 	keep_system_libs \
 	libs \
@@ -22,13 +23,26 @@ tests_init \
 	idirafter_munge_order \
 	idirafter_munge_sysroot \
 	idirafter_ordering \
+	modversion_common_prefix \
+	modversion_fullpath \
+	modversion_provides \
+	modversion_uninstalled \
+	modversion_one_word_expression \
+	modversion_two_word_expression \
+	modversion_three_word_expression \
+	modversion_one_word_expression_no_space \
+	modversion_one_word_expression_no_space_zero \
 	pcpath \
 	virtual_variable \
 	fragment_collision \
 	malformed_1 \
 	malformed_quoting \
 	explicit_sysroot \
-	empty_tuple
+	empty_tuple \
+	solver_requires_private_debounce \
+	billion_laughs \
+	define_prefix_child_prefix_1 \
+	define_prefix_child_prefix_1_env
 
 #	sysroot_munge \
 
@@ -71,6 +85,13 @@ define_variable_body()
 		pkgconf --variable=typelibdir --define-variable='libdir=\${libdir}' typelibdir
 }
 
+define_variable_override_body()
+{
+	export PKG_CONFIG_PATH="${selfdir}/lib1"
+	atf_check -o inline:"/test\n" \
+		pkgconf --variable=prefix --define-variable='prefix=/test' typelibdir
+}
+
 variable_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
@@ -88,7 +109,7 @@ keep_system_libs_body()
 		pkgconf --libs-only-L cflags-libs-only
 
 	atf_check \
-		-o inline:"-L/test/local/lib \n" \
+		-o inline:"-L/test/local/lib\n" \
 		pkgconf --libs-only-L --keep-system-libs cflags-libs-only
 }
 
@@ -96,7 +117,7 @@ libs_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-L/test/local/lib -lfoo \n" \
+		-o inline:"-L/test/local/lib -lfoo\n" \
 		pkgconf --libs cflags-libs-only
 }
 
@@ -104,7 +125,7 @@ libs_only_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-L/test/local/lib -lfoo \n" \
+		-o inline:"-L/test/local/lib -lfoo\n" \
 		pkgconf --libs-only-L --libs-only-l cflags-libs-only
 }
 
@@ -112,10 +133,10 @@ libs_never_mergeback_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-L/test/bar/lib -lfoo1 \n" \
+		-o inline:"-L/test/bar/lib -lfoo1\n" \
 		pkgconf --libs prefix-foo1
 	atf_check \
-		-o inline:"-L/test/bar/lib -lfoo1 -lfoo2 \n" \
+		-o inline:"-L/test/bar/lib -lfoo1 -lfoo2\n" \
 		pkgconf --libs prefix-foo1 prefix-foo2
 }
 
@@ -123,7 +144,7 @@ cflags_only_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-I/test/local/include/foo \n" \
+		-o inline:"-I/test/local/include/foo\n" \
 		pkgconf --cflags-only-I --cflags-only-other cflags-libs-only
 }
 
@@ -131,7 +152,7 @@ cflags_never_mergeback_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-I/test/bar/include/foo -DBAR -fPIC -DFOO \n" \
+		-o inline:"-I/test/bar/include/foo -DBAR -fPIC -DFOO\n" \
 		pkgconf --cflags prefix-foo1 prefix-foo2
 }
 
@@ -155,7 +176,7 @@ isystem_munge_order_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-isystem /opt/bad/include -isystem /opt/bad2/include \n" \
+		-o inline:"-isystem /opt/bad/include -isystem /opt/bad2/include\n" \
 		pkgconf --cflags isystem
 }
 
@@ -171,7 +192,7 @@ idirafter_munge_order_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-idirafter /opt/bad/include -idirafter /opt/bad2/include \n" \
+		-o inline:"-idirafter /opt/bad/include -idirafter /opt/bad2/include\n" \
 		pkgconf --cflags idirafter
 }
 
@@ -187,7 +208,7 @@ idirafter_ordering_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-I/opt/bad/include1 -idirafter -I/opt/bad/include2 -I/opt/bad/include3 \n" \
+		-o inline:"-I/opt/bad/include1 -idirafter -I/opt/bad/include2 -I/opt/bad/include3\n" \
 		pkgconf --cflags idirafter-ordering
 }
 
@@ -195,7 +216,7 @@ pcpath_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib2"
 	atf_check \
-		-o inline:"-fPIC -I/test/include/foo \n" \
+		-o inline:"-fPIC -I/test/include/foo\n" \
 		pkgconf --cflags ${selfdir}/lib3/bar.pc
 }
 
@@ -204,7 +225,7 @@ sysroot_munge_body()
 	sed "s|/sysroot/|${selfdir}/|g" ${selfdir}/lib1/sysroot-dir.pc > ${selfdir}/lib1/sysroot-dir-selfdir.pc
 	export PKG_CONFIG_PATH="${selfdir}/lib1" PKG_CONFIG_SYSROOT_DIR="${selfdir}"
 	atf_check \
-		-o inline:"-L${selfdir}/lib -lfoo \n" \
+		-o inline:"-L${selfdir}/lib -lfoo\n" \
 		pkgconf --libs sysroot-dir-selfdir
 }
 
@@ -223,7 +244,7 @@ virtual_variable_body()
 
 fragment_collision_body()
 {
-	atf_check -o inline:"-D_BAZ -D_FOO -D_BAR -D_THREAD_SAFE -pthread \n" \
+	atf_check -o inline:"-D_BAZ -D_BAR -D_FOO -D_THREAD_SAFE -pthread\n" \
 		pkgconf --with-path="${selfdir}/lib1" --cflags fragment-collision
 }
 
@@ -251,3 +272,83 @@ empty_tuple_body()
 	atf_check -o inline:"\n" \
 		pkgconf --with-path="${selfdir}/lib1" --cflags empty-tuple
 }
+
+solver_requires_private_debounce_body()
+{
+	atf_check -o inline:"-I/metapackage-1 -I/metapackage-2 -lmetapackage-1 -lmetapackage-2\n" \
+		pkgconf --with-path="${selfdir}/lib1" --cflags --libs metapackage
+}
+
+billion_laughs_body()
+{
+	atf_check -o inline:"warning: truncating very long variable to 64KB\nwarning: truncating very long variable to 64KB\nwarning: truncating very long variable to 64KB\nwarning: truncating very long variable to 64KB\nwarning: truncating very long variable to 64KB\n" \
+		pkgconf --with-path="${selfdir}/lib1" --validate billion-laughs
+}
+
+modversion_common_prefix_body()
+{
+	atf_check -o inline:"foo: 1.2.3\nfoobar: 3.2.1\n" \
+		pkgconf --with-path="${selfdir}/lib1" --modversion --verbose foo foobar
+}
+
+modversion_fullpath_body()
+{
+	atf_check -o inline:"1.2.3\n" \
+		pkgconf --modversion "${selfdir}/lib1/foo.pc"
+}
+
+modversion_provides_body()
+{
+	atf_check -o inline:"1.2.3\n" \
+		pkgconf --with-path="${selfdir}/lib1" --modversion unavailable
+}
+
+modversion_uninstalled_body()
+{
+	atf_check -o inline:"1.2.3\n" \
+		pkgconf --with-path="${selfdir}/lib1" --modversion omg
+}
+
+modversion_one_word_expression_body()
+{
+	atf_check -o inline:"1.2.3\n" \
+		pkgconf --with-path="${selfdir}/lib1" --modversion "foo > 1.0"
+}
+
+modversion_two_word_expression_body()
+{
+	atf_check -o inline:"1.2.3\n" \
+		pkgconf --with-path="${selfdir}/lib1" --modversion foo "> 1.0"
+}
+
+modversion_three_word_expression_body()
+{
+	atf_check -o inline:"1.2.3\n" \
+		pkgconf --with-path="${selfdir}/lib1" --modversion foo ">" 1.0
+}
+
+modversion_one_word_expression_no_space_body()
+{
+	atf_check -o inline:"1.2.3\n" \
+		pkgconf --with-path="${selfdir}/lib1" --modversion "foo >1.0"
+}
+
+modversion_one_word_expression_no_space_zero_body()
+{
+	atf_check -o inline:"1.2.3\n" \
+		pkgconf --with-path="${selfdir}/lib1" --modversion "foo >0.5"
+}
+
+define_prefix_child_prefix_1_body()
+{
+	atf_check -o inline:"-I${selfdir}/lib1/include/child-prefix-1 -L${selfdir}/lib1/lib64 -lchild-prefix-1\n" \
+		pkgconf --with-path="${selfdir}/lib1/child-prefix/pkgconfig" --define-prefix --cflags --libs child-prefix-1
+}
+
+define_prefix_child_prefix_1_env_body()
+{
+	export PKG_CONFIG_PATH="${selfdir}/lib1/child-prefix/pkgconfig"
+	export PKG_CONFIG_RELOCATE_PATHS=1
+	atf_check -o inline:"-I${selfdir}/lib1/include/child-prefix-1 -L${selfdir}/lib1/lib64 -lchild-prefix-1\n" \
+		pkgconf --cflags --libs child-prefix-1
+}

tests/requires.sh

@@ -10,6 +10,10 @@ tests_init \
 	argv_parse2 \
 	static_cflags \
 	private_duplication \
+	private_duplication_digraph \
+	foo_bar \
+	bar_foo \
+	foo_metapackage_3 \
 	libs_static2 \
 	missing \
 	requires_internal \
@@ -21,7 +25,7 @@ libs_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-L/test/lib -lbar -lfoo \n" \
+		-o inline:"-L/test/lib -lbar -lfoo\n" \
 		pkgconf --libs bar
 }
 
@@ -29,7 +33,7 @@ libs_cflags_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-fPIC -I/test/include/foo -L/test/lib -lbaz \n" \
+		-o inline:"-fPIC -I/test/include/foo -L/test/lib -lbaz\n" \
 		pkgconf --libs --cflags baz
 }
 
@@ -37,7 +41,7 @@ libs_static_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-L/test/lib -lbaz -L/test/lib -lzee -L/test/lib -lfoo \n" \
+		-o inline:"-L/test/lib -lbaz -L/test/lib -lzee -lfoo\n" \
 		pkgconf --static --libs baz
 }
 
@@ -45,7 +49,7 @@ libs_static_pure_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-L/test/lib -lbaz -L/test/lib -lfoo \n" \
+		-o inline:"-L/test/lib -lbaz -lfoo\n" \
 		pkgconf --static --pure --libs baz
 }
 
@@ -53,7 +57,7 @@ argv_parse2_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-llib-1 -pthread /test/lib/lib2.so \n" \
+		-o inline:"-llib-1 -pthread /test/lib/lib2.so\n" \
 		pkgconf --static --libs argv-parse-2
 }
 
@@ -61,7 +65,7 @@ static_cflags_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-fPIC -I/test/include/foo -DFOO_STATIC \n" \
+		-o inline:"-fPIC -I/test/include/foo -DFOO_STATIC\n" \
 		pkgconf --static --cflags baz
 }
 
@@ -69,15 +73,51 @@ private_duplication_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-lprivate -lfoo -lbaz -lzee -lfoo -lbar \n" \
+		-o inline:"-lprivate -lbaz -lzee -lbar -lfoo\n" \
 		pkgconf --static --libs-only-l private-libs-duplication
 }
 
+private_duplication_digraph_body()
+{
+	export PKG_CONFIG_PATH="${selfdir}/lib1"
+	atf_check \
+		-o 'match:"user:request" -> "private-libs-duplication"' \
+		-o 'match:"private-libs-duplication" -> "bar"' \
+		-o 'match:"private-libs-duplication" -> "baz"' \
+		-o 'match:"bar" -> "foo"' \
+		-o 'match:"baz" -> "foo"' \
+		pkgconf --static --libs-only-l private-libs-duplication --digraph
+}
+
+bar_foo_body()
+{
+	export PKG_CONFIG_PATH="${selfdir}/lib1"
+	atf_check \
+		-o inline:"-lbar -lfoo\n" \
+		pkgconf --static --libs-only-l bar foo
+}
+
+foo_bar_body()
+{
+	export PKG_CONFIG_PATH="${selfdir}/lib1"
+	atf_check \
+		-o inline:"-lbar -lfoo\n" \
+		pkgconf --static --libs-only-l foo bar
+}
+
+foo_metapackage_3_body()
+{
+	export PKG_CONFIG_PATH="${selfdir}/lib1"
+	atf_check \
+		-o inline:"-lbar -lfoo\n" \
+		pkgconf --static --libs-only-l foo metapackage-3
+}
+
 libs_static2_body()
 {
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	atf_check \
-		-o inline:"-lbar -lbar-private -L/test/lib -lfoo \n" \
+		-o inline:"-lbar -lbar-private -L/test/lib -lfoo\n" \
 		pkgconf --static --libs static-libs
 }
 
@@ -87,14 +127,14 @@ missing_body()
 	atf_check \
 		-s exit:1 \
 		-e ignore \
-		-o inline:"\n" \
+		-o ignore \
 		pkgconf --cflags missing-require
 }
 
 requires_internal_body()
 {
 	atf_check \
-		-o inline:"-lbar -lbar-private -L/test/lib -lfoo \n" \
+		-o inline:"-lbar -lbar-private -L/test/lib -lfoo\n" \
 		pkgconf --with-path="${selfdir}/lib1" --static --libs requires-internal
 }
 
@@ -110,7 +150,7 @@ requires_internal_missing_body()
 requires_internal_collision_body()
 {
 	atf_check \
-		-o inline:"-I/test/local/include/foo \n" \
+		-o inline:"-I/test/local/include/foo\n" \
 		pkgconf --with-path="${selfdir}/lib1" --cflags requires-internal-collision
 }
 

tests/sysroot.sh

@@ -17,7 +17,7 @@ do_not_eat_slash_body()
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	export PKG_CONFIG_SYSROOT_DIR="/"
 	atf_check \
-		-o inline:"-fPIC -I/test/include/foo \n" \
+		-o inline:"-fPIC -I/test/include/foo\n" \
 		pkgconf --cflags baz
 }
 
@@ -26,7 +26,7 @@ cflags_body()
 	export PKG_CONFIG_PATH="${selfdir}/lib1"
 	export PKG_CONFIG_SYSROOT_DIR="${SYSROOT_DIR}"
 	atf_check \
-		-o inline:"-fPIC -I${SYSROOT_DIR}/test/include/foo \n" \
+		-o inline:"-fPIC -I${SYSROOT_DIR}/test/include/foo\n" \
 		pkgconf --cflags baz
 }
 
@@ -48,21 +48,21 @@ do_not_duplicate_sysroot_dir_body()
 	export PKG_CONFIG_SYSROOT_DIR="/sysroot"
 
 	atf_check \
-		-o inline:"-I/sysroot/usr/include \n" \
+		-o inline:"-I/sysroot/usr/include\n" \
 		pkgconf --cflags sysroot-dir-2
 
 	atf_check \
-		-o inline:"-I/sysroot/usr/include \n" \
+		-o inline:"-I/sysroot/usr/include\n" \
 		pkgconf --cflags sysroot-dir-3
 
 	atf_check \
-		-o inline:"-I/sysroot/usr/include \n" \
+		-o inline:"-I/sysroot/usr/include\n" \
 		pkgconf --cflags sysroot-dir-5
 
 	export PKG_CONFIG_SYSROOT_DIR="${SYSROOT_DIR}"
 
 	atf_check \
-		-o inline:"-I${SYSROOT_DIR}/usr/include \n" \
+		-o inline:"-I${SYSROOT_DIR}/usr/include\n" \
 		pkgconf --cflags sysroot-dir-4
 }
 
@@ -72,7 +72,7 @@ uninstalled_body()
 	export PKG_CONFIG_SYSROOT_DIR="/sysroot"
 
 	atf_check \
-		-o inline:"-L/test/lib -lomg \n" \
+		-o inline:"-L/test/lib -lomg\n" \
 		pkgconf --libs omg
 }
 
@@ -83,7 +83,7 @@ uninstalled_pkgconf1_body()
 	export PKG_CONFIG_PKGCONF1_SYSROOT_RULES="1"
 
 	atf_check \
-		-o inline:"-L/sysroot/test/lib -lomg \n" \
+		-o inline:"-L/sysroot/test/lib -lomg\n" \
 		pkgconf --libs omg
 }
 
@@ -94,7 +94,7 @@ uninstalled_fdo_body()
 	export PKG_CONFIG_FDO_SYSROOT_RULES="1"
 
 	atf_check \
-		-o inline:"-L/test/lib -lomg \n" \
+		-o inline:"-L/test/lib -lomg\n" \
 		pkgconf --libs omg
 }
 
@@ -105,6 +105,6 @@ uninstalled_fdo_pc_sysrootdir_body()
 	export PKG_CONFIG_FDO_SYSROOT_RULES="1"
 
 	atf_check \
-		-o inline:"-L/sysroot/test/lib -lomg \n" \
+		-o inline:"-L/sysroot/test/lib -lomg\n" \
 		pkgconf --libs omg-sysroot
 }