static GSList*
string_list_strip_duplicates_from_back (GSList *list)
{
GHashTable *table;
GSList *tmp;
GSList *nodups = NULL;
GSList *reversed;
table = g_hash_table_new (g_str_hash, g_str_equal);
reversed = g_slist_reverse (g_slist_copy (list));
tmp = reversed;
while (tmp != NULL)
{
if (g_hash_table_lookup (table, tmp->data) == NULL)
{
/* This unreverses the reversed list */
nodups = g_slist_prepend (nodups, tmp->data);
g_hash_table_insert (table, tmp->data, tmp->data);
}
else
{
debug_spew (" removing duplicate (from back) \"%s\"\n", tmp->data);
}
tmp = g_slist_next (tmp);
}
g_slist_free (reversed);
g_hash_table_destroy (table);
return nodups;
}
static GSList*
string_list_strip_duplicates (GSList *list)
{
GHashTable *table;
GSList *tmp;
GSList *nodups = NULL;
table = g_hash_table_new (g_str_hash, g_str_equal);
tmp = list;
while (tmp != NULL)
{
if (g_hash_table_lookup (table, tmp->data) == NULL)
{
nodups = g_slist_prepend (nodups, tmp->data);
g_hash_table_insert (table, tmp->data, tmp->data);
}
else
{
debug_spew (" removing duplicate \"%s\"\n", tmp->data);
}
tmp = g_slist_next (tmp);
}
nodups = g_slist_reverse (nodups);
g_hash_table_destroy (table);
return nodups;
}
static void
init_pc_path (void)
{
#ifdef G_OS_WIN32
char *instdir, *lpath, *shpath;
instdir = g_win32_get_package_installation_directory_of_module (NULL);
if (instdir == NULL)
{
/* This only happens when GetModuleFilename() fails. If it does, that
* failure should be investigated and fixed.
*/
debug_spew ("g_win32_get_package_installation_directory_of_module failed\n");
return;
}
lpath = g_build_filename (instdir, "lib", "pkgconfig", NULL);
shpath = g_build_filename (instdir, "share", "pkgconfig", NULL);
pkg_config_pc_path = g_strconcat (lpath, G_SEARCHPATH_SEPARATOR_S, shpath,
NULL);
g_free (instdir);
g_free (lpath);
g_free (shpath);
#else
pkg_config_pc_path = PKG_CONFIG_PC_PATH;
#endif
}
static void
spew_string_list (const char *name,
GSList *list)
{
GSList *tmp;
debug_spew (" %s: ", name);
tmp = list;
while (tmp != NULL)
{
debug_spew (" %s ", tmp->data);
tmp = tmp->next;
}
debug_spew ("\n");
}
void
add_search_dirs (const char *path, const char *separator, const char *sysroot)
{
char **search_dirs;
char **iter;
GString *str = sysroot ? g_string_new("") : NULL;
search_dirs = g_strsplit (path, separator, -1);
iter = search_dirs;
while (*iter)
{
const char *dir = *iter;
if (str)
{
/* If sysroot is specified, assume search dirs are relative to it */
g_string_assign(str, sysroot);
g_string_append(str, *iter);
dir = str->str;
}
debug_spew ("Adding directory '%s' from PKG_CONFIG_PATH\n",
dir);
add_search_dir (dir);
++iter;
}
g_strfreev (search_dirs);
if (str)
{
g_string_free(str, TRUE);
}
}
static void
spew_package_list (const char *name,
GSList *list)
{
GSList *tmp;
debug_spew (" %s: ", name);
tmp = list;
while (tmp != NULL)
{
Package *pkg = tmp->data;
debug_spew (" %s ", pkg->name);
tmp = tmp->next;
}
debug_spew ("\n");
}
void
define_global_variable (const char *varname,
const char *varval)
{
if (globals == NULL)
globals = g_hash_table_new (g_str_hash, g_str_equal);
if (g_hash_table_lookup (globals, varname))
{
verbose_error ("Variable '%s' defined twice globally\n", varname);
exit (1);
}
g_hash_table_insert (globals, g_strdup (varname), g_strdup (varval));
debug_spew ("Global variable definition '%s' = '%s'\n",
varname, varval);
}
static Package *
add_virtual_pkgconfig_package (void)
{
Package *pkg = NULL;
pkg = g_new0 (Package, 1);
pkg->key = g_strdup ("pkg-config");
pkg->version = g_strdup (VERSION);
pkg->name = g_strdup ("pkg-config");
pkg->description = g_strdup ("pkg-config is a system for managing "
"compile/link flags for libraries");
pkg->url = g_strdup ("http://www.freedesktop.org/software/pkgconfig/");
debug_spew ("Adding virtual 'pkg-config' package to list of known packages\n");
g_hash_table_insert (packages, pkg->key, pkg);
return pkg;
}
static void
popt_callback (poptContext con,
enum poptCallbackReason reason,
const struct poptOption * opt,
const char * arg, void * data)
{
debug_spew ("Option --%s seen\n", opt->longName);
if (opt->val == DEFINE_VARIABLE)
{
char *varname;
char *varval;
char *tmp;
tmp = g_strdup (arg);
varname = tmp;
while (*varname && isspace ((guchar)*varname))
++varname;
varval = varname;
while (*varval && *varval != '=' && *varval != ' ')
++varval;
while (*varval && (*varval == '=' || *varval == ' '))
{
*varval = '\0';
++varval;
}
if (*varval == '\0')
{
fprintf (stderr, "--define-variable argument does not have a value for the variable\n");
exit (1);
}
define_global_variable (varname, varval);
g_free (tmp);
}
}
void
add_search_dirs (const char *path, const char *separator)
{
char **search_dirs;
char **iter;
search_dirs = g_strsplit (path, separator, -1);
iter = search_dirs;
while (*iter)
{
debug_spew ("Adding directory '%s' from PKG_CONFIG_PATH\n",
*iter);
add_search_dir (*iter);
++iter;
}
g_strfreev (search_dirs);
}
static Package *
add_virtual_pkgconfig_package (void)
{
Package *pkg = NULL;
pkg = g_new0 (Package, 1);
pkg->key = g_strdup ("pkg-config");
pkg->version = g_strdup (VERSION);
pkg->name = g_strdup ("pkg-config");
pkg->description = g_strdup ("pkg-config is a system for managing "
"compile/link flags for libraries");
pkg->url = g_strdup ("http://pkg-config.freedesktop.org/");
if (pkg->vars == NULL)
pkg->vars = g_hash_table_new (g_str_hash, g_str_equal);
g_hash_table_insert (pkg->vars, "pc_path", PKG_CONFIG_PC_PATH);
debug_spew ("Adding virtual 'pkg-config' package to list of known packages\n");
g_hash_table_insert (packages, pkg->key, pkg);
return pkg;
}
static void
verify_package (Package *pkg)
{
GSList *requires = NULL;
GSList *conflicts = NULL;
GSList *system_directories = NULL;
GSList *iter;
GSList *requires_iter;
GSList *conflicts_iter;
GSList *system_dir_iter = NULL;
int count;
gchar *c_include_path;
/* Be sure we have the required fields */
if (pkg->key == NULL)
{
fprintf (stderr,
"Internal pkg-config error, package with no key, please file a bug report\n");
exit (1);
}
if (pkg->name == NULL)
{
verbose_error ("Package '%s' has no Name: field\n",
pkg->key);
exit (1);
}
if (pkg->version == NULL)
{
verbose_error ("Package '%s' has no Version: field\n",
pkg->key);
exit (1);
}
if (pkg->description == NULL)
{
verbose_error ("Package '%s' has no Description: field\n",
pkg->key);
exit (1);
}
/* Make sure we have the right version for all requirements */
iter = pkg->requires_private;
while (iter != NULL)
{
Package *req = iter->data;
RequiredVersion *ver = NULL;
if (pkg->required_versions)
ver = g_hash_table_lookup (pkg->required_versions,
req->key);
if (ver)
{
if (!version_test (ver->comparison, req->version, ver->version))
{
verbose_error ("Package '%s' requires '%s %s %s' but version of %s is %s\n",
pkg->name, req->key,
comparison_to_str (ver->comparison),
ver->version,
req->name,
req->version);
if (req->url)
verbose_error ("You may find new versions of %s at %s\n",
req->name, req->url);
exit (1);
}
}
iter = g_slist_next (iter);
}
/* Make sure we didn't drag in any conflicts via Requires
* (inefficient algorithm, who cares)
*/
recursive_fill_list (pkg, get_requires_private, &requires);
conflicts = get_conflicts (pkg);
requires_iter = requires;
while (requires_iter != NULL)
{
Package *req = requires_iter->data;
conflicts_iter = conflicts;
while (conflicts_iter != NULL)
{
RequiredVersion *ver = conflicts_iter->data;
if (version_test (ver->comparison,
req->version,
ver->version))
{
verbose_error ("Version %s of %s creates a conflict.\n"
"(%s %s %s conflicts with %s %s)\n",
req->version, req->name,
ver->name,
comparison_to_str (ver->comparison),
ver->version ? ver->version : "(any)",
ver->owner->name,
ver->owner->version);
exit (1);
}
conflicts_iter = g_slist_next (conflicts_iter);
}
requires_iter = g_slist_next (requires_iter);
}
g_slist_free (requires);
/* We make a list of system directories that gcc expects so we can remove
* them.
*/
#ifndef G_OS_WIN32
system_directories = g_slist_append (NULL, g_strdup ("/usr/include"));
#endif
c_include_path = g_getenv ("C_INCLUDE_PATH");
if (c_include_path != NULL)
{
system_directories = add_env_variable_to_list (system_directories, c_include_path);
}
c_include_path = g_getenv ("CPLUS_INCLUDE_PATH");
if (c_include_path != NULL)
{
system_directories = add_env_variable_to_list (system_directories, c_include_path);
}
count = 0;
iter = pkg->I_cflags;
while (iter != NULL)
{
gint offset = 0;
/* we put things in canonical -I/usr/include (vs. -I /usr/include) format,
* but if someone changes it later we may as well be robust
*/
if (((strncmp (iter->data, "-I", 2) == 0) && (offset = 2))||
((strncmp (iter->data, "-I ", 3) == 0) && (offset = 3)))
{
if (offset == 0)
{
iter = iter->next;
continue;
}
system_dir_iter = system_directories;
while (system_dir_iter != NULL)
{
if (strcmp (system_dir_iter->data,
((char*)iter->data) + offset) == 0)
{
debug_spew ("Package %s has %s in Cflags\n",
pkg->name, (gchar *)iter->data);
if (g_getenv ("PKG_CONFIG_ALLOW_SYSTEM_CFLAGS") == NULL)
{
debug_spew ("Removing %s from cflags for %s\n", iter->data, pkg->key);
++count;
iter->data = NULL;
break;
}
}
system_dir_iter = system_dir_iter->next;
}
}
iter = iter->next;
}
while (count)
{
pkg->I_cflags = g_slist_remove (pkg->I_cflags, NULL);
--count;
}
g_slist_foreach (system_directories, (GFunc) g_free, NULL);
g_slist_free (system_directories);
#ifdef PREFER_LIB64
#define SYSTEM_LIBDIR "/usr/lib64"
#else
#define SYSTEM_LIBDIR "/usr/lib"
#endif
count = 0;
iter = pkg->L_libs;
while (iter != NULL)
{
if (strcmp (iter->data, "-L" SYSTEM_LIBDIR) == 0 ||
strcmp (iter->data, "-L " SYSTEM_LIBDIR) == 0)
{
debug_spew ("Package %s has -L" SYSTEM_LIBDIR " in Libs\n",
pkg->name);
if (g_getenv ("PKG_CONFIG_ALLOW_SYSTEM_LIBS") == NULL)
{
iter->data = NULL;
++count;
debug_spew ("Removing -L" SYSTEM_LIBDIR " from libs for %s\n", pkg->key);
}
}
iter = iter->next;
}
#undef SYSTEM_LIBDIR
while (count)
{
pkg->L_libs = g_slist_remove (pkg->L_libs, NULL);
--count;
}
}
Package *
get_compat_package (const char *name)
{
#ifdef G_OS_WIN32
/* There has never been any of these legacy *-config scripts on
* Windows as far as I know. No use trying to execute them, will
* only confuse users to see the "blabla is not recognized as an
* internal or external command, operable program or batch file"
* messages.
*/
return NULL;
#else
Package *pkg;
if (name_ends_in_uninstalled (name))
debug_spew ("Suspiciously looking for compat package for -uninstalled: %s\n", name);
debug_spew ("Looking for '%s' using legacy -config scripts\n", name);
pkg = g_new0 (Package, 1);
pkg->path_position = G_MAXINT;
if (strcmp (name, "glib") == 0)
{
char *output;
debug_spew ("Calling glib-config\n");
pkg->version = backticks ("glib-config --version");
if (pkg->version == NULL)
{
g_free (pkg);
return NULL;
}
pkg->name = g_strdup ("GLib");
pkg->key = g_strdup ("glib");
pkg->description = g_strdup ("C Utility Library");
output = backticks ("glib-config --libs");
parse_libs (pkg, output, "glib-config");
g_free (output);
output = backticks ("glib-config --cflags");
parse_cflags (pkg, output, "glib-config");
g_free (output);
return pkg;
}
else if (strcmp (name, "gtk+") == 0)
{
char *output;
debug_spew ("Calling gtk-config\n");
pkg->version = backticks ("gtk-config --version");
if (pkg->version == NULL)
{
g_free (pkg);
return NULL;
}
pkg->name = g_strdup ("GTK+");
pkg->key = g_strdup ("gtk+");
pkg->description = g_strdup ("GIMP Tool Kit");
output = backticks ("gtk-config --libs");
parse_libs (pkg, output, "gtk-config");
g_free (output);
output = backticks ("gtk-config --cflags");
parse_cflags (pkg, output, "gtk-config");
g_free (output);
return pkg;
}
else if (strcmp (name, "libgnomevfs") == 0)
{
char *output;
debug_spew ("Calling gnome-vfs-config\n");
pkg->version = backticks ("gnome-vfs-config --version");
if (pkg->version == NULL)
{
g_free (pkg);
return NULL;
}
pkg->name = g_strdup ("GNOME VFS");
pkg->key = g_strdup ("libgnomevfs");
pkg->description = g_strdup ("GNOME Virtual File System");
output = backticks ("gnome-vfs-config --libs");
parse_libs (pkg, output, "gnome-vfs-config");
g_free (output);
output = backticks ("gnome-vfs-config --cflags");
parse_cflags (pkg, output, "gnome-vfs-config");
g_free (output);
return pkg;
}
else if (strcmp (name, "imlib") == 0)
{
char *output;
debug_spew ("Calling imlib-config\n");
pkg->version = backticks ("imlib-config --version");
if (pkg->version == NULL)
{
g_free (pkg);
return NULL;
}
pkg->name = g_strdup ("Imlib");
pkg->key = g_strdup ("imlib");
pkg->description = g_strdup ("Imlib image loading library");
output = backticks ("imlib-config --libs-gdk");
parse_libs (pkg, output, "imlib-config");
g_free (output);
output = backticks ("imlib-config --cflags-gdk");
parse_cflags (pkg, output, "imlib-config");
g_free (output);
return pkg;
}
else if (strcmp (name, "orbit-client") == 0)
{
char *output;
char *p;
debug_spew ("Calling orbit-config\n");
output = backticks ("orbit-config --version");
if (output == NULL)
{
g_free (pkg);
return NULL;
}
p = output;
while (*p && isspace ((guchar)*p))
++p;
if (*p == '\0')
{
/* empty output */
g_free (output);
g_free (pkg);
return NULL;
}
/* only heuristic; find a number or . */
while (*p && ! (isdigit ((guchar)*p) || *p == '.'))
++p;
pkg->version = g_strdup (p);
g_free (output);
pkg->name = g_strdup ("ORBit Client");
pkg->key = g_strdup ("orbit-client");
pkg->description = g_strdup ("ORBit Client Libraries");
output = backticks ("orbit-config --libs client");
parse_libs (pkg, output, "orbit-config");
g_free (output);
output = backticks ("orbit-config --cflags client");
parse_cflags (pkg, output, "orbit-config");
g_free (output);
return pkg;
}
else if (strcmp (name, "orbit-server") == 0)
{
char *output;
char *p;
debug_spew ("Calling orbit-config\n");
output = backticks ("orbit-config --version");
if (output == NULL)
{
g_free (pkg);
return NULL;
}
p = output;
while (*p && isspace ((guchar)*p))
++p;
if (*p == '\0')
{
/* empty output */
g_free (output);
g_free (pkg);
return NULL;
}
/* only heuristic; find a number or . */
while (*p && ! (isdigit ((guchar)*p) || *p == '.'))
++p;
pkg->version = g_strdup (p);
g_free (output);
pkg->name = g_strdup ("ORBit Server");
pkg->key = g_strdup ("orbit-server");
pkg->description = g_strdup ("ORBit Server Libraries");
output = backticks ("orbit-config --libs server");
parse_libs (pkg, output, "orbit-config");
g_free (output);
output = backticks ("orbit-config --cflags server");
parse_cflags (pkg, output, "orbit-config");
g_free (output);
return pkg;
}
else
{
/* Check for the module in gnome-config */
char *output;
char *p;
char *command;
debug_spew ("Calling gnome-config\n");
/* Annoyingly, --modversion doesn't return a failure
* code if the lib is unknown, so we have to use --libs
* for that.
*/
command = g_strdup_printf ("gnome-config --libs %s",
name);
if (!try_command (command))
{
g_free (command);
g_free (pkg);
return NULL;
}
else
g_free (command);
command = g_strdup_printf ("gnome-config --modversion %s",
name);
output = backticks (command);
g_free (command);
if (output == NULL)
{
g_free (pkg);
return NULL;
}
/* Unknown modules give "Unknown library `foo'" from gnome-config
* (but on stderr so this is useless, nevermind)
*/
if (strstr (output, "Unknown") || *output == '\0')
{
g_free (output);
g_free (pkg);
return NULL;
}
/* gnome-config --modversion gnomeui outputs e.g. "gnome-libs-1.2.4"
* or libglade-0.12
*/
p = output;
while (*p && isspace ((guchar)*p))
++p;
if (*p == '\0')
{
/* empty output */
g_free (output);
g_free (pkg);
return NULL;
}
/* only heuristic; find a number or . */
while (*p && ! (isdigit ((guchar)*p) || *p == '.'))
++p;
pkg->version = g_strdup (p);
g_free (output);
/* Strip newline */
p = pkg->version;
while (*p)
{
if (*p == '\n')
*p = '\0';
++p;
}
pkg->name = g_strdup (name);
pkg->key = g_strdup (name);
pkg->description = g_strdup ("No description");
command = g_strdup_printf ("gnome-config --libs %s", name);
output = backticks (command);
g_free (command);
parse_libs (pkg, output, "gnome-config");
g_free (output);
command = g_strdup_printf ("gnome-config --cflags %s", name);
output = backticks (command);
g_free (command);
parse_cflags (pkg, output, "gnome-config");
g_free (output);
return pkg;
}
#endif
}
int
main (int argc, char **argv)
{
GString *str;
GList *packages = NULL;
char *search_path;
char *pcbuilddir;
gboolean need_newline;
FILE *log = NULL;
GError *error = NULL;
GOptionContext *opt_context;
/* This is here so that we get debug spew from the start,
* during arg parsing
*/
if (getenv ("PKG_CONFIG_DEBUG_SPEW"))
{
want_debug_spew = TRUE;
want_verbose_errors = TRUE;
want_silence_errors = FALSE;
debug_spew ("PKG_CONFIG_DEBUG_SPEW variable enabling debug spew\n");
}
/* Get the built-in search path */
init_pc_path ();
if (pkg_config_pc_path == NULL)
{
/* Even when we override the built-in search path, we still use it later
* to add pc_path to the virtual pkg-config package.
*/
verbose_error ("Failed to get default search path\n");
exit (1);
}
search_path = getenv ("PKG_CONFIG_PATH");
if (search_path)
{
add_search_dirs(search_path, G_SEARCHPATH_SEPARATOR_S);
}
if (getenv("PKG_CONFIG_LIBDIR") != NULL)
{
add_search_dirs(getenv("PKG_CONFIG_LIBDIR"), G_SEARCHPATH_SEPARATOR_S);
}
else
{
add_search_dirs(pkg_config_pc_path, G_SEARCHPATH_SEPARATOR_S);
}
pcsysrootdir = getenv ("PKG_CONFIG_SYSROOT_DIR");
if (pcsysrootdir)
{
define_global_variable ("pc_sysrootdir", pcsysrootdir);
}
else
{
define_global_variable ("pc_sysrootdir", "/");
}
pcbuilddir = getenv ("PKG_CONFIG_TOP_BUILD_DIR");
if (pcbuilddir)
{
define_global_variable ("pc_top_builddir", pcbuilddir);
}
else
{
/* Default appropriate for automake */
define_global_variable ("pc_top_builddir", "$(top_builddir)");
}
if (getenv ("PKG_CONFIG_DISABLE_UNINSTALLED"))
{
debug_spew ("disabling auto-preference for uninstalled packages\n");
disable_uninstalled = TRUE;
}
/* Parse options */
opt_context = g_option_context_new (NULL);
g_option_context_add_main_entries (opt_context, options_table, NULL);
if (!g_option_context_parse(opt_context, &argc, &argv, &error))
{
fprintf (stderr, "%s\n", error->message);
return 1;
}
/* If no output option was set, then --exists is the default. */
if (!output_opt_set)
{
debug_spew ("no output option set, defaulting to --exists\n");
want_exists = TRUE;
}
/* Error printing is determined as follows:
* - for --exists, --*-version, --list-all and no options at all,
* it's off by default and --print-errors will turn it on
* - for all other output options, it's on by default and
* --silence-errors can turn it off
*/
if (want_exists || want_list)
{
debug_spew ("Error printing disabled by default due to use of output "
"options --exists, --atleast/exact/max-version, "
"--list-all or no output option at all. Value of "
"--print-errors: %d\n",
want_verbose_errors);
/* Leave want_verbose_errors unchanged, reflecting --print-errors */
}
else
{
debug_spew ("Error printing enabled by default due to use of output "
"options besides --exists, --atleast/exact/max-version or "
"--list-all. Value of --silence-errors: %d\n",
want_silence_errors);
if (want_silence_errors && getenv ("PKG_CONFIG_DEBUG_SPEW") == NULL)
want_verbose_errors = FALSE;
else
want_verbose_errors = TRUE;
}
if (want_verbose_errors)
debug_spew ("Error printing enabled\n");
else
debug_spew ("Error printing disabled\n");
if (want_static_lib_list)
enable_private_libs();
else
disable_private_libs();
/* honor Requires.private if any Cflags are requested or any static
* libs are requested */
if (pkg_flags & CFLAGS_ANY || want_requires_private || want_exists ||
(want_static_lib_list && (pkg_flags & LIBS_ANY)))
enable_requires_private();
/* ignore Requires if no Cflags or Libs are requested */
if (pkg_flags == 0 && !want_requires && !want_exists)
disable_requires();
/* Allow errors in .pc files when listing all. */
if (want_list)
parse_strict = FALSE;
if (want_my_version)
{
printf ("%s\n", VERSION);
return 0;
}
if (required_pkgconfig_version)
{
if (compare_versions (VERSION, required_pkgconfig_version) >= 0)
return 0;
else
return 1;
}
package_init ();
if (want_list)
{
print_package_list ();
return 0;
}
/* Collect packages from remaining args */
str = g_string_new ("");
while (argc > 1)
{
argc--;
argv++;
g_string_append (str, *argv);
g_string_append (str, " ");
}
g_option_context_free (opt_context);
g_strstrip (str->str);
if (getenv("PKG_CONFIG_LOG") != NULL)
{
log = fopen (getenv ("PKG_CONFIG_LOG"), "a");
if (log == NULL)
{
fprintf (stderr, "Cannot open log file: %s\n",
getenv ("PKG_CONFIG_LOG"));
exit (1);
}
}
/* find and parse each of the packages specified */
if (!process_package_args (str->str, &packages, log))
return 1;
if (log != NULL)
fclose (log);
g_string_free (str, TRUE);
if (want_exists)
return 0; /* if we got here, all the packages existed. */
if (want_variable_list)
{
GList *tmp;
tmp = packages;
while (tmp != NULL)
{
Package *pkg = tmp->data;
if (pkg->vars != NULL)
g_hash_table_foreach(pkg->vars,
&print_hashtable_key,
NULL);
tmp = g_list_next (tmp);
if (tmp) printf ("\n");
}
need_newline = FALSE;
}
if (want_uninstalled)
{
/* See if > 0 pkgs (including dependencies recursively) were uninstalled */
GList *tmp;
tmp = packages;
while (tmp != NULL)
{
Package *pkg = tmp->data;
if (pkg_uninstalled (pkg))
return 0;
tmp = g_list_next (tmp);
}
return 1;
}
if (want_version)
{
GList *tmp;
tmp = packages;
while (tmp != NULL)
{
Package *pkg = tmp->data;
printf ("%s\n", pkg->version);
tmp = g_list_next (tmp);
}
}
if (want_provides)
{
GList *tmp;
tmp = packages;
while (tmp != NULL)
{
Package *pkg = tmp->data;
char *key;
key = pkg->key;
while (*key == '/')
key++;
if (strlen(key) > 0)
printf ("%s = %s\n", key, pkg->version);
tmp = g_list_next (tmp);
}
}
if (want_requires)
{
GList *pkgtmp;
for (pkgtmp = packages; pkgtmp != NULL; pkgtmp = g_list_next (pkgtmp))
{
Package *pkg = pkgtmp->data;
GList *reqtmp;
/* process Requires: */
for (reqtmp = pkg->requires; reqtmp != NULL; reqtmp = g_list_next (reqtmp))
{
Package *deppkg = reqtmp->data;
RequiredVersion *req;
req = g_hash_table_lookup(pkg->required_versions, deppkg->key);
if ((req == NULL) || (req->comparison == ALWAYS_MATCH))
printf ("%s\n", deppkg->key);
else
printf ("%s %s %s\n", deppkg->key,
comparison_to_str(req->comparison),
req->version);
}
}
}
if (want_requires_private)
{
GList *pkgtmp;
for (pkgtmp = packages; pkgtmp != NULL; pkgtmp = g_list_next (pkgtmp))
{
Package *pkg = pkgtmp->data;
GList *reqtmp;
/* process Requires.private: */
for (reqtmp = pkg->requires_private; reqtmp != NULL; reqtmp = g_list_next (reqtmp))
{
Package *deppkg = reqtmp->data;
RequiredVersion *req;
if (g_list_find (pkg->requires, reqtmp->data))
continue;
req = g_hash_table_lookup(pkg->required_versions, deppkg->key);
if ((req == NULL) || (req->comparison == ALWAYS_MATCH))
printf ("%s\n", deppkg->key);
else
printf ("%s %s %s\n", deppkg->key,
comparison_to_str(req->comparison),
req->version);
}
}
}
/* Print all flags; then print a newline at the end. */
need_newline = FALSE;
if (variable_name)
{
char *str = packages_get_var (packages, variable_name);
printf ("%s", str);
g_free (str);
need_newline = TRUE;
}
if (pkg_flags != 0)
{
char *str = packages_get_flags (packages, pkg_flags);
printf ("%s", str);
g_free (str);
need_newline = TRUE;
}
if (need_newline)
printf ("\n");
return 0;
}
Package*
parse_package_file (const char *path, gboolean ignore_requires,
gboolean ignore_private_libs,
gboolean ignore_requires_private)
{
FILE *f;
Package *pkg;
GString *str;
gboolean one_line = FALSE;
f = fopen (path, "r");
if (f == NULL)
{
verbose_error ("Failed to open '%s': %s\n",
path, strerror (errno));
return NULL;
}
debug_spew ("Parsing package file '%s'\n", path);
pkg = g_new0 (Package, 1);
if (path)
{
pkg->pcfiledir = g_dirname (path);
}
else
{
debug_spew ("No pcfiledir determined for package\n");
pkg->pcfiledir = g_strdup ("???????");
}
str = g_string_new ("");
while (read_one_line (f, str))
{
one_line = TRUE;
parse_line (pkg, str->str, path, ignore_requires, ignore_private_libs,
ignore_requires_private);
g_string_truncate (str, 0);
}
if (!one_line)
verbose_error ("Package file '%s' appears to be empty\n",
path);
g_string_free (str, TRUE);
fclose(f);
/* make ->requires_private include a copy of the public requires too */
pkg->requires_private = g_slist_concat(g_slist_copy (pkg->requires),
pkg->requires_private);
pkg->requires = g_slist_reverse (pkg->requires);
pkg->requires_private = g_slist_reverse (pkg->requires_private);
pkg->I_cflags = g_slist_reverse (pkg->I_cflags);
pkg->other_cflags = g_slist_reverse (pkg->other_cflags);
pkg->l_libs = g_slist_reverse (pkg->l_libs);
pkg->L_libs = g_slist_reverse (pkg->L_libs);
pkg->other_libs = g_slist_reverse (pkg->other_libs);
return pkg;
}
static void
parse_line (Package *pkg, const char *untrimmed, const char *path,
gboolean ignore_requires, gboolean ignore_private_libs,
gboolean ignore_requires_private)
{
char *str;
char *p;
char *tag;
debug_spew (" line>%s\n", untrimmed);
str = trim_string (untrimmed);
if (*str == '\0') /* empty line */
{
g_free(str);
return;
}
p = str;
/* Get first word */
while ((*p >= 'A' && *p <= 'Z') ||
(*p >= 'a' && *p <= 'z') ||
(*p >= '0' && *p <= '9') ||
*p == '_' || *p == '.')
p++;
tag = g_strndup (str, p - str);
while (*p && isspace ((guchar)*p))
++p;
if (*p == ':')
{
/* keyword */
++p;
while (*p && isspace ((guchar)*p))
++p;
if (strcmp (tag, "Name") == 0)
parse_name (pkg, p, path);
else if (strcmp (tag, "Description") == 0)
parse_description (pkg, p, path);
else if (strcmp (tag, "Version") == 0)
parse_version (pkg, p, path);
else if (strcmp (tag, "Requires.private") == 0)
{
if (!ignore_requires_private)
parse_requires_private (pkg, p, path);
}
else if (strcmp (tag, "Requires") == 0)
{
if (ignore_requires == FALSE)
parse_requires (pkg, p, path);
else
goto cleanup;
}
else if ((strcmp (tag, "Libs.private") == 0) &&
ignore_private_libs == FALSE)
parse_libs_private (pkg, p, path);
else if (strcmp (tag, "Libs") == 0)
parse_libs (pkg, p, path);
else if (strcmp (tag, "Cflags") == 0 ||
strcmp (tag, "CFlags") == 0)
parse_cflags (pkg, p, path);
else if (strcmp (tag, "Conflicts") == 0)
parse_conflicts (pkg, p, path);
else if (strcmp (tag, "URL") == 0)
parse_url (pkg, p, path);
else
{
/* we don't error out on unknown keywords because they may
* represent additions to the .pc file format from future
* versions of pkg-config. We do make a note of them in the
* debug spew though, in order to help catch mistakes in .pc
* files. */
debug_spew ("Unknown keyword '%s' in '%s'\n",
tag, path);
}
}
else if (*p == '=')
{
/* variable */
char *varname;
char *varval;
++p;
while (*p && isspace ((guchar)*p))
++p;
if (pkg->vars == NULL)
pkg->vars = g_hash_table_new (g_str_hash, g_str_equal);
#ifdef G_OS_WIN32
if (!dont_define_prefix && strcmp (tag, prefix_variable) == 0)
{
/* This is the prefix variable. Try to guesstimate a value for it
* for this package from the location of the .pc file.
*/
gchar *prefix = pkg->pcfiledir;
const int prefix_len = strlen (prefix);
const char *const lib_pkgconfig = "\\lib\\pkgconfig";
const char *const share_pkgconfig = "\\share\\pkgconfig";
const int lib_pkgconfig_len = strlen (lib_pkgconfig);
const int share_pkgconfig_len = strlen (share_pkgconfig);
if ((strlen (prefix) > lib_pkgconfig_len &&
pathnamecmp (prefix + prefix_len - lib_pkgconfig_len, lib_pkgconfig) == 0) ||
(strlen (prefix) > share_pkgconfig_len &&
pathnamecmp (prefix + prefix_len - share_pkgconfig_len, share_pkgconfig) == 0))
{
/* It ends in lib\pkgconfig or share\pkgconfig. Good. */
gchar *q;
orig_prefix = g_strdup (p);
prefix = g_strdup (prefix);
if (strlen (prefix) > lib_pkgconfig_len &&
pathnamecmp (prefix + prefix_len - lib_pkgconfig_len, lib_pkgconfig) == 0)
prefix[prefix_len - lib_pkgconfig_len] = '\0';
else
prefix[prefix_len - share_pkgconfig_len] = '\0';
/* Turn backslashes into slashes or
* poptParseArgvString() will eat them when ${prefix}
* has been expanded in parse_libs().
*/
q = prefix;
while (*q)
{
if (*q == '\\')
*q = '/';
q++;
}
varname = g_strdup (tag);
debug_spew (" Variable declaration, '%s' overridden with '%s'\n",
tag, prefix);
g_hash_table_insert (pkg->vars, varname, prefix);
goto cleanup;
}
}
else if (!dont_define_prefix &&
orig_prefix != NULL &&
strncmp (p, orig_prefix, strlen (orig_prefix)) == 0 &&
G_IS_DIR_SEPARATOR (p[strlen (orig_prefix)]))
{
char *oldstr = str;
p = str = g_strconcat (g_hash_table_lookup (pkg->vars, prefix_variable), p + strlen (orig_prefix), NULL);
g_free (oldstr);
}
#endif
if (g_hash_table_lookup (pkg->vars, tag))
{
verbose_error ("Duplicate definition of variable '%s' in '%s'\n",
tag, path);
exit (1);
}
varname = g_strdup (tag);
varval = trim_and_sub (pkg, p, path);
debug_spew (" Variable declaration, '%s' has value '%s'\n",
varname, varval);
g_hash_table_insert (pkg->vars, varname, varval);
}
cleanup:
g_free (str);
g_free (tag);
}
static Package *
internal_get_package (const char *name, gboolean warn, gboolean check_compat)
{
Package *pkg = NULL;
const char *location;
pkg = g_hash_table_lookup (packages, name);
if (pkg)
return pkg;
debug_spew ("Looking for package '%s'\n", name);
/* treat "name" as a filename if it ends in .pc and exists */
if ( ends_in_dotpc (name) )
{
debug_spew ("Considering '%s' to be a filename rather than a package name\n", name);
location = name;
}
else
{
/* See if we should auto-prefer the uninstalled version */
if (!disable_uninstalled &&
!name_ends_in_uninstalled (name))
{
char *un;
un = g_strconcat (name, "-uninstalled", NULL);
pkg = internal_get_package (un, FALSE, FALSE);
g_free (un);
if (pkg)
{
debug_spew ("Preferring uninstalled version of package '%s'\n", name);
return pkg;
}
}
location = g_hash_table_lookup (locations, name);
}
if (location == NULL && check_compat)
{
pkg = get_compat_package (name);
if (pkg)
{
debug_spew ("Returning values for '%s' from a legacy -config script\n",
name);
return pkg;
}
}
if (location == NULL)
{
if (warn)
verbose_error ("Package %s was not found in the pkg-config search path.\n"
"Perhaps you should add the directory containing `%s.pc'\n"
"to the PKG_CONFIG_PATH environment variable\n",
name, name);
return NULL;
}
debug_spew ("Reading '%s' from file '%s'\n", name, location);
pkg = parse_package_file (location, ignore_requires, ignore_private_libs);
if (pkg == NULL)
{
debug_spew ("Failed to parse '%s'\n", location);
return NULL;
}
if (strstr (location, "uninstalled.pc"))
pkg->uninstalled = TRUE;
if (location != name)
pkg->key = g_strdup (name);
else
{
/* need to strip package name out of the filename */
int len = strlen (name);
const char *end = name + (len - EXT_LEN);
const char *start = end;
while (start != name && *start != G_DIR_SEPARATOR)
--start;
g_assert (end >= start);
pkg->key = g_strndup (start, end - start);
}
pkg->path_position =
GPOINTER_TO_INT (g_hash_table_lookup (path_positions, pkg->key));
debug_spew ("Path position of '%s' is %d\n",
pkg->name, pkg->path_position);
verify_package (pkg);
debug_spew ("Adding '%s' to list of known packages, returning as package '%s'\n",
pkg->key, name);
g_hash_table_insert (packages, pkg->key, pkg);
return pkg;
}
/* Look for .pc files in the given directory and add them into
* locations, ignoring duplicates
*/
static void
scan_dir (const char *dirname)
{
DIR *dir;
struct dirent *dent;
int dirnamelen = strlen (dirname);
/* Use a copy of dirname cause Win32 opendir doesn't like
* superfluous trailing (back)slashes in the directory name.
*/
char *dirname_copy = g_strdup (dirname);
if (dirnamelen > 1 && dirname[dirnamelen-1] == G_DIR_SEPARATOR)
{
dirnamelen--;
dirname_copy[dirnamelen] = '\0';
}
#ifdef G_OS_WIN32
{
gchar *p;
/* Turn backslashes into slashes or
* poptParseArgvString() will eat them when ${prefix}
* has been expanded in parse_libs().
*/
p = dirname;
while (*p)
{
if (*p == '\\')
*p = '/';
p++;
}
}
#endif
dir = opendir (dirname_copy);
g_free (dirname_copy);
if (!dir)
{
debug_spew ("Cannot open directory '%s' in package search path: %s\n",
dirname, g_strerror (errno));
return;
}
debug_spew ("Scanning directory '%s'\n", dirname);
scanned_dir_count += 1;
while ((dent = readdir (dir)))
{
int len = strlen (dent->d_name);
if (ends_in_dotpc (dent->d_name))
{
char *pkgname = g_malloc (len - 2);
debug_spew ("File '%s' appears to be a .pc file\n", dent->d_name);
strncpy (pkgname, dent->d_name, len - EXT_LEN);
pkgname[len-EXT_LEN] = '\0';
if (g_hash_table_lookup (locations, pkgname))
{
debug_spew ("File '%s' ignored, we already know about package '%s'\n", dent->d_name, pkgname);
g_free (pkgname);
}
else
{
char *filename = g_malloc (dirnamelen + 1 + len + 1);
strncpy (filename, dirname, dirnamelen);
filename[dirnamelen] = G_DIR_SEPARATOR;
strcpy (filename + dirnamelen + 1, dent->d_name);
g_hash_table_insert (locations, pkgname, filename);
g_hash_table_insert (path_positions, pkgname,
GINT_TO_POINTER (scanned_dir_count));
debug_spew ("Will find package '%s' in file '%s'\n",
pkgname, filename);
}
}
else
{
debug_spew ("Ignoring file '%s' in search directory; not a .pc file\n",
dent->d_name);
}
}
closedir(dir);
}
int
main (int argc, char **argv)
{
static int want_my_version = 0;
static int want_version = 0;
static int want_libs = 0;
static int want_cflags = 0;
static int want_l_libs = 0;
static int want_L_libs = 0;
static int want_other_libs = 0;
static int want_I_cflags = 0;
static int want_other_cflags = 0;
static int want_list = 0;
static int want_static_lib_list = ENABLE_INDIRECT_DEPS;
static int want_short_errors = 0;
static int want_uninstalled = 0;
static char *variable_name = NULL;
static int want_exists = 0;
static int want_provides = 0;
static int want_requires = 0;
static int want_requires_private = 0;
static char *required_atleast_version = NULL;
static char *required_exact_version = NULL;
static char *required_max_version = NULL;
static char *required_pkgconfig_version = NULL;
static int want_silence_errors = 0;
static int want_variable_list = 0;
GString *str;
GSList *packages = NULL;
char *search_path;
char *pcbuilddir;
gboolean need_newline;
FILE *log = NULL;
GError *error = NULL;
GOptionContext *opt_context;
GOptionEntry options_table[] = {
{ "version", 0, 0, G_OPTION_ARG_NONE, &want_my_version,
"output version of pkg-config", NULL },
{ "modversion", 0, 0, G_OPTION_ARG_NONE, &want_version,
"output version for package", NULL },
{ "atleast-pkgconfig-version", 0, 0, G_OPTION_ARG_STRING,
&required_pkgconfig_version,
"require given version of pkg-config", "VERSION" },
{ "libs", 0, 0, G_OPTION_ARG_NONE, &want_libs,
"output all linker flags", NULL },
{ "static", 0, 0, G_OPTION_ARG_NONE, &want_static_lib_list,
"output linker flags for static linking", NULL },
{ "short-errors", 0, 0, G_OPTION_ARG_NONE, &want_short_errors,
"print short errors", NULL },
{ "libs-only-l", 0, 0, G_OPTION_ARG_NONE, &want_l_libs,
"output -l flags", NULL },
{ "libs-only-other", 0, 0, G_OPTION_ARG_NONE, &want_other_libs,
"output other libs (e.g. -pthread)", NULL },
{ "libs-only-L", 0, 0, G_OPTION_ARG_NONE, &want_L_libs,
"output -L flags", NULL },
{ "cflags", 0, 0, G_OPTION_ARG_NONE, &want_cflags,
"output all pre-processor and compiler flags", NULL },
{ "cflags-only-I", 0, 0, G_OPTION_ARG_NONE, &want_I_cflags,
"output -I flags", NULL },
{ "cflags-only-other", 0, 0, G_OPTION_ARG_NONE, &want_other_cflags,
"output cflags not covered by the cflags-only-I option", NULL },
{ "variable", 0, 0, G_OPTION_ARG_STRING, &variable_name,
"get the value of variable named NAME", "NAME" },
{ "define-variable", 0, 0, G_OPTION_ARG_CALLBACK, &define_variable_cb,
"set variable NAME to VALUE", "NAME=VALUE" },
{ "exists", 0, 0, G_OPTION_ARG_NONE, &want_exists,
"return 0 if the module(s) exist", NULL },
{ "print-variables", 0, 0, G_OPTION_ARG_NONE, &want_variable_list,
"output list of variables defined by the module", NULL },
{ "uninstalled", 0, 0, G_OPTION_ARG_NONE, &want_uninstalled,
"return 0 if the uninstalled version of one or more module(s) "
"or their dependencies will be used", NULL },
{ "atleast-version", 0, 0, G_OPTION_ARG_STRING, &required_atleast_version,
"return 0 if the module is at least version VERSION", "VERSION" },
{ "exact-version", 0, 0, G_OPTION_ARG_STRING, &required_exact_version,
"return 0 if the module is at exactly version VERSION", "VERSION" },
{ "max-version", 0, 0, G_OPTION_ARG_STRING, &required_max_version,
"return 0 if the module is at no newer than version VERSION", "VERSION" },
{ "list-all", 0, 0, G_OPTION_ARG_NONE, &want_list,
"list all known packages", NULL },
{ "debug", 0, 0, G_OPTION_ARG_NONE, &want_debug_spew,
"show verbose debug information", NULL },
{ "print-errors", 0, 0, G_OPTION_ARG_NONE, &want_verbose_errors,
"show verbose information about missing or conflicting packages,"
"default if --cflags or --libs given on the command line", NULL },
{ "silence-errors", 0, 0, G_OPTION_ARG_NONE, &want_silence_errors,
"be silent about errors (default unless --cflags or --libs"
"given on the command line)", NULL },
{ "errors-to-stdout", 0, 0, G_OPTION_ARG_NONE, &want_stdout_errors,
"print errors from --print-errors to stdout not stderr", NULL },
{ "print-provides", 0, 0, G_OPTION_ARG_NONE, &want_provides,
"print which packages the package provides", NULL },
{ "print-requires", 0, 0, G_OPTION_ARG_NONE, &want_requires,
"print which packages the package requires", NULL },
{ "print-requires-private", 0, 0, G_OPTION_ARG_NONE, &want_requires_private,
"print which packages the package requires for static linking", NULL },
#ifdef G_OS_WIN32
{ "dont-define-prefix", 0, 0, G_OPTION_ARG_NONE, &dont_define_prefix,
"don't try to override the value of prefix for each .pc file found with "
"a guesstimated value based on the location of the .pc file", NULL },
{ "prefix-variable", 0, 0, G_OPTION_ARG_STRING, &prefix_variable,
"set the name of the variable that pkg-config automatically sets",
"PREFIX" },
{ "msvc-syntax", 0, 0, G_OPTION_ARG_NONE, &msvc_syntax,
"output -l and -L flags for the Microsoft compiler (cl)", NULL },
#endif
{ NULL, 0, 0, 0, NULL, NULL, NULL }
};
/* This is here so that we get debug spew from the start,
* during arg parsing
*/
if (getenv ("PKG_CONFIG_DEBUG_SPEW"))
{
want_debug_spew = TRUE;
want_verbose_errors = TRUE;
want_silence_errors = FALSE;
debug_spew ("PKG_CONFIG_DEBUG_SPEW variable enabling debug spew\n");
}
/* Get the built-in search path */
init_pc_path ();
if (pkg_config_pc_path == NULL)
{
/* Even when we override the built-in search path, we still use it later
* to add pc_path to the virtual pkg-config package.
*/
verbose_error ("Failed to get default search path\n");
exit (1);
}
search_path = getenv ("PKG_CONFIG_PATH");
if (search_path)
{
add_search_dirs(search_path, G_SEARCHPATH_SEPARATOR_S);
}
if (getenv("PKG_CONFIG_LIBDIR") != NULL)
{
add_search_dirs(getenv("PKG_CONFIG_LIBDIR"), G_SEARCHPATH_SEPARATOR_S);
}
else
{
add_search_dirs(pkg_config_pc_path, G_SEARCHPATH_SEPARATOR_S);
}
pcsysrootdir = getenv ("PKG_CONFIG_SYSROOT_DIR");
if (pcsysrootdir)
{
define_global_variable ("pc_sysrootdir", pcsysrootdir);
}
else
{
define_global_variable ("pc_sysrootdir", "/");
}
pcbuilddir = getenv ("PKG_CONFIG_TOP_BUILD_DIR");
if (pcbuilddir)
{
define_global_variable ("pc_top_builddir", pcbuilddir);
}
else
{
/* Default appropriate for automake */
define_global_variable ("pc_top_builddir", "$(top_builddir)");
}
if (getenv ("PKG_CONFIG_DISABLE_UNINSTALLED"))
{
debug_spew ("disabling auto-preference for uninstalled packages\n");
disable_uninstalled = TRUE;
}
/* Parse options */
opt_context = g_option_context_new (NULL);
g_option_context_add_main_entries (opt_context, options_table, NULL);
if (!g_option_context_parse(opt_context, &argc, &argv, &error))
{
fprintf (stderr, "%s\n", error->message);
return 1;
}
/* Error printing is determined as follows:
* - for --cflags, --libs, etc. it's on by default
* and --silence-errors can turn it off
* - for --exists, --max-version, etc. and no options
* at all, it's off by default and --print-errors
* will turn it on
*/
if (want_my_version ||
want_version ||
want_libs ||
want_cflags ||
want_l_libs ||
want_L_libs ||
want_other_libs ||
want_I_cflags ||
want_other_cflags ||
want_list ||
want_variable_list)
{
debug_spew ("Error printing enabled by default due to use of --version, --libs, --cflags, --libs-only-l, --libs-only-L, --libs-only-other, --cflags-only-I, --cflags-only-other or --list. Value of --silence-errors: %d\n", want_silence_errors);
if (want_silence_errors && getenv ("PKG_CONFIG_DEBUG_SPEW") == NULL)
want_verbose_errors = FALSE;
else
want_verbose_errors = TRUE;
}
else
{
debug_spew ("Error printing disabled by default, value of --print-errors: %d\n",
want_verbose_errors);
/* Leave want_verbose_errors unchanged, reflecting --print-errors */
}
if (want_verbose_errors)
debug_spew ("Error printing enabled\n");
else
debug_spew ("Error printing disabled\n");
if (want_static_lib_list)
enable_private_libs();
else
disable_private_libs();
/* honor Requires.private if any Cflags are requested or any static
* libs are requested */
if (want_I_cflags || want_other_cflags || want_cflags ||
want_requires_private || want_exists ||
(want_static_lib_list && (want_libs || want_l_libs || want_L_libs)))
enable_requires_private();
/* ignore Requires if no Cflags or Libs are requested */
if (!want_I_cflags && !want_other_cflags && !want_cflags &&
!want_libs && !want_l_libs && !want_L_libs && !want_requires &&
!want_exists)
disable_requires();
if (want_my_version)
{
printf ("%s\n", VERSION);
return 0;
}
if (required_pkgconfig_version)
{
if (compare_versions (VERSION, required_pkgconfig_version) >= 0)
return 0;
else
return 1;
}
package_init ();
if (want_list)
{
print_package_list ();
return 0;
}
/* Collect packages from remaining args */
str = g_string_new ("");
while (argc > 1)
{
argc--;
argv++;
g_string_append (str, *argv);
g_string_append (str, " ");
}
g_option_context_free (opt_context);
g_strstrip (str->str);
if (getenv("PKG_CONFIG_LOG") != NULL)
{
log = fopen (getenv ("PKG_CONFIG_LOG"), "a");
if (log == NULL)
{
fprintf (stderr, "Cannot open log file: %s\n",
getenv ("PKG_CONFIG_LOG"));
exit (1);
}
}
{
gboolean failed = FALSE;
GSList *reqs;
GSList *iter;
reqs = parse_module_list (NULL, str->str,
"(command line arguments)");
iter = reqs;
while (iter != NULL)
{
Package *req;
RequiredVersion *ver = iter->data;
/* override requested versions with cmdline options */
if (required_exact_version)
{
g_free (ver->version);
ver->comparison = EQUAL;
ver->version = g_strdup (required_exact_version);
}
else if (required_atleast_version)
{
g_free (ver->version);
ver->comparison = GREATER_THAN_EQUAL;
ver->version = g_strdup (required_atleast_version);
}
else if (required_max_version)
{
g_free (ver->version);
ver->comparison = LESS_THAN_EQUAL;
ver->version = g_strdup (required_max_version);
}
if (want_short_errors)
req = get_package_quiet (ver->name);
else
req = get_package (ver->name);
if (log != NULL)
{
if (req == NULL)
fprintf (log, "%s NOT-FOUND", ver->name);
else
fprintf (log, "%s %s %s", ver->name,
comparison_to_str (ver->comparison),
(ver->version == NULL) ? "(null)" : ver->version);
fprintf (log, "\n");
}
if (req == NULL)
{
failed = TRUE;
verbose_error ("No package '%s' found\n", ver->name);
goto nextiter;
}
if (!version_test (ver->comparison, req->version, ver->version))
{
failed = TRUE;
verbose_error ("Requested '%s %s %s' but version of %s is %s\n",
ver->name,
comparison_to_str (ver->comparison),
ver->version,
req->name,
req->version);
if (req->url)
verbose_error ("You may find new versions of %s at %s\n",
req->name, req->url);
goto nextiter;
}
packages = g_slist_prepend (packages, req);
nextiter:
iter = g_slist_next (iter);
}
if (log != NULL)
{
fclose (log);
}
if (failed) {
return 1;
}
if (want_variable_list)
{
GSList *tmp;
tmp = packages;
while (tmp != NULL)
{
Package *pkg = tmp->data;
g_hash_table_foreach(pkg->vars,
&print_hashtable_key,
NULL);
tmp = g_slist_next (tmp);
if (tmp) printf ("\n");
}
need_newline = FALSE;
}
}
g_string_free (str, TRUE);
packages = g_slist_reverse (packages);
if (packages == NULL)
{
fprintf (stderr, "Must specify package names on the command line\n");
exit (1);
}
if (want_exists)
return 0; /* if we got here, all the packages existed. */
if (want_uninstalled)
{
/* See if > 0 pkgs (including dependencies recursively) were uninstalled */
GSList *tmp;
tmp = packages;
while (tmp != NULL)
{
Package *pkg = tmp->data;
if (pkg_uninstalled (pkg))
return 0;
tmp = g_slist_next (tmp);
}
return 1;
}
if (want_version)
{
GSList *tmp;
tmp = packages;
while (tmp != NULL)
{
Package *pkg = tmp->data;
printf ("%s\n", pkg->version);
tmp = g_slist_next (tmp);
}
}
if (want_provides)
{
GSList *tmp;
tmp = packages;
while (tmp != NULL)
{
Package *pkg = tmp->data;
char *key;
key = pkg->key;
while (*key == '/')
key++;
if (strlen(key) > 0)
printf ("%s = %s\n", key, pkg->version);
tmp = g_slist_next (tmp);
}
}
if (want_requires)
{
GSList *pkgtmp;
for (pkgtmp = packages; pkgtmp != NULL; pkgtmp = g_slist_next (pkgtmp))
{
Package *pkg = pkgtmp->data;
GSList *reqtmp;
/* process Requires: */
for (reqtmp = pkg->requires; reqtmp != NULL; reqtmp = g_slist_next (reqtmp))
{
Package *deppkg = reqtmp->data;
RequiredVersion *req;
req = g_hash_table_lookup(pkg->required_versions, deppkg->key);
if ((req == NULL) || (req->comparison == ALWAYS_MATCH))
printf ("%s\n", deppkg->key);
else
printf ("%s %s %s\n", deppkg->key,
comparison_to_str(req->comparison),
req->version);
}
}
}
if (want_requires_private)
{
GSList *pkgtmp;
for (pkgtmp = packages; pkgtmp != NULL; pkgtmp = g_slist_next (pkgtmp))
{
Package *pkg = pkgtmp->data;
GSList *reqtmp;
/* process Requires.private: */
for (reqtmp = pkg->requires_private; reqtmp != NULL; reqtmp = g_slist_next (reqtmp))
{
Package *deppkg = reqtmp->data;
RequiredVersion *req;
if (g_slist_find (pkg->requires, reqtmp->data))
continue;
req = g_hash_table_lookup(pkg->required_versions, deppkg->key);
if ((req == NULL) || (req->comparison == ALWAYS_MATCH))
printf ("%s\n", deppkg->key);
else
printf ("%s %s %s\n", deppkg->key,
comparison_to_str(req->comparison),
req->version);
}
}
}
/* Print all flags; then print a newline at the end. */
need_newline = FALSE;
if (variable_name)
{
char *str = packages_get_var (packages, variable_name);
printf ("%s", str);
g_free (str);
need_newline = TRUE;
}
if (want_I_cflags)
{
char *str = packages_get_I_cflags (packages);
printf ("%s ", str);
g_free (str);
need_newline = TRUE;
}
else if (want_other_cflags)
{
char *str = packages_get_other_cflags (packages);
printf ("%s ", str);
g_free (str);
need_newline = TRUE;
}
else if (want_cflags)
{
char *str = packages_get_all_cflags (packages);
printf ("%s ", str);
g_free (str);
need_newline = TRUE;
}
if (want_l_libs)
{
char *str = packages_get_l_libs (packages);
printf ("%s ", str);
g_free (str);
need_newline = TRUE;
}
else if (want_L_libs)
{
char *str = packages_get_L_libs (packages);
printf ("%s ", str);
g_free (str);
need_newline = TRUE;
}
else if (want_other_libs)
{
char *str = packages_get_other_libs (packages);
printf ("%s ", str);
g_free (str);
need_newline = TRUE;
}
else if (want_libs)
{
char *str = packages_get_all_libs (packages);
printf ("%s ", str);
g_free (str);
need_newline = TRUE;
}
if (need_newline)
printf ("\n");
return 0;
}