dcbaker
/
pkgconf
forked from ariadne/pkgconf
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

libpkgconf: move pkg_node and pkg_list to pkgconf_node and pkgconf_list namespaces

feature/tap-sh
William Pitcock 2015-09-06 10:31:21 -05:00
parent 71ad982ae6
commit cc2dcc1f5d
9 changed files with 166 additions and 166 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
libpkgconf/cache.c
View File

@ -15,7 +15,7 @@
#include <libpkgconf/libpkgconf.h>
static pkg_list_t pkg_cache = PKG_LIST_INITIALIZER;
static pkgconf_list_t pkg_cache = PKGCONF_LIST_INITIALIZER;
/*
* pkg_cache_lookup(id)
@ -27,9 +27,9 @@ static pkg_list_t pkg_cache = PKG_LIST_INITIALIZER;
pkg_t *
pkg_cache_lookup(const char *id)
{
pkg_node_t *node;
pkgconf_node_t *node;
PKG_FOREACH_LIST_ENTRY(pkg_cache.head, node)
PKGCONF_FOREACH_LIST_ENTRY(pkg_cache.head, node)
{
pkg_t *pkg = node->data;
@ -54,7 +54,7 @@ pkg_cache_add(pkg_t *pkg)
pkg_ref(pkg);
pkg_node_insert(&pkg->cache_iter, pkg, &pkg_cache);
pkgconf_node_insert(&pkg->cache_iter, pkg, &pkg_cache);
}
/*
@ -68,15 +68,15 @@ pkg_cache_remove(pkg_t *pkg)
if (pkg == NULL)
return;
pkg_node_delete(&pkg->cache_iter, &pkg_cache);
pkgconf_node_delete(&pkg->cache_iter, &pkg_cache);
}
void
pkg_cache_free(void)
{
pkg_node_t *iter, *iter2;
pkgconf_node_t *iter, *iter2;
PKG_FOREACH_LIST_ENTRY_SAFE(pkg_cache.head, iter2, iter)
PKGCONF_FOREACH_LIST_ENTRY_SAFE(pkg_cache.head, iter2, iter)
{
pkg_t *pkg = iter->data;

18
libpkgconf/dependency.c
View File

@ -36,7 +36,7 @@ typedef enum {
#define DEBUG_PARSE 0
static inline pkg_dependency_t *
pkg_dependency_add(pkg_list_t *list, const char *package, size_t package_sz, const char *version, size_t version_sz, pkg_comparator_t compare)
pkg_dependency_add(pkgconf_list_t *list, const char *package, size_t package_sz, const char *version, size_t version_sz, pkg_comparator_t compare)
{
pkg_dependency_t *dep;
@ -48,7 +48,7 @@ pkg_dependency_add(pkg_list_t *list, const char *package, size_t package_sz, con
dep->compare = compare;
pkg_node_insert_tail(&dep->iter, dep, list);
pkgconf_node_insert_tail(&dep->iter, dep, list);
#if DEBUG_PARSE
fprintf(error_msgout, "--> %s %d %s\n", dep->package, dep->compare, dep->version);
@ -58,17 +58,17 @@ pkg_dependency_add(pkg_list_t *list, const char *package, size_t package_sz, con
}
void
pkg_dependency_append(pkg_list_t *list, pkg_dependency_t *tail)
pkg_dependency_append(pkgconf_list_t *list, pkg_dependency_t *tail)
{
pkg_node_insert_tail(&tail->iter, tail, list);
pkgconf_node_insert_tail(&tail->iter, tail, list);
}
void
pkg_dependency_free(pkg_list_t *list)
pkg_dependency_free(pkgconf_list_t *list)
{
pkg_node_t *node, *next;
pkgconf_node_t *node, *next;
PKG_FOREACH_LIST_ENTRY_SAFE(list->head, next, node)
PKGCONF_FOREACH_LIST_ENTRY_SAFE(list->head, next, node)
{
pkg_dependency_t *dep = node->data;
@ -83,7 +83,7 @@ pkg_dependency_free(pkg_list_t *list)
}
void
pkg_dependency_parse_str(pkg_list_t *deplist_head, const char *depends)
pkg_dependency_parse_str(pkgconf_list_t *deplist_head, const char *depends)
{
parse_state_t state = OUTSIDE_MODULE;
pkg_comparator_t compare = PKG_ANY;
@ -223,7 +223,7 @@ pkg_dependency_parse_str(pkg_list_t *deplist_head, const char *depends)
}
void
pkg_dependency_parse(pkg_t *pkg, pkg_list_t *deplist, const char *depends)
pkg_dependency_parse(pkg_t *pkg, pkgconf_list_t *deplist, const char *depends)
{
char *kvdepends = pkg_tuple_parse(&pkg->vars, depends);

28
libpkgconf/fragment.c
View File

@ -37,7 +37,7 @@ pkg_fragment_copy_munged(const char *source, unsigned int flags)
}
void
pkg_fragment_add(pkg_list_t *list, const char *string, unsigned int flags)
pkg_fragment_add(pkgconf_list_t *list, const char *string, unsigned int flags)
{
pkg_fragment_t *frag;
@ -77,15 +77,15 @@ pkg_fragment_add(pkg_list_t *list, const char *string, unsigned int flags)
frag->data = strdup(string);
}
pkg_node_insert_tail(&frag->iter, frag, list);
pkgconf_node_insert_tail(&frag->iter, frag, list);
}
static inline pkg_fragment_t *
pkg_fragment_lookup(pkg_list_t *list, pkg_fragment_t *base)
pkg_fragment_lookup(pkgconf_list_t *list, pkg_fragment_t *base)
{
pkg_node_t *node;
pkgconf_node_t *node;
PKG_FOREACH_LIST_ENTRY_REVERSE(list->tail, node)
PKGCONF_FOREACH_LIST_ENTRY_REVERSE(list->tail, node)
{
pkg_fragment_t *frag = node->data;
@ -137,7 +137,7 @@ pkg_fragment_can_merge(pkg_fragment_t *base, unsigned int flags, bool is_private
}
static inline pkg_fragment_t *
pkg_fragment_exists(pkg_list_t *list, pkg_fragment_t *base, unsigned int flags, bool is_private)
pkg_fragment_exists(pkgconf_list_t *list, pkg_fragment_t *base, unsigned int flags, bool is_private)
{
if (!pkg_fragment_can_merge_back(base, flags, is_private))
return NULL;
@ -149,7 +149,7 @@ pkg_fragment_exists(pkg_list_t *list, pkg_fragment_t *base, unsigned int flags,
}
void
pkg_fragment_copy(pkg_list_t *list, pkg_fragment_t *base, unsigned int flags, bool is_private)
pkg_fragment_copy(pkgconf_list_t *list, pkg_fragment_t *base, unsigned int flags, bool is_private)
{
pkg_fragment_t *frag;
@ -163,24 +163,24 @@ pkg_fragment_copy(pkg_list_t *list, pkg_fragment_t *base, unsigned int flags, bo
frag->type = base->type;
frag->data = strdup(base->data);
pkg_node_insert_tail(&frag->iter, frag, list);
pkgconf_node_insert_tail(&frag->iter, frag, list);
}
void
pkg_fragment_delete(pkg_list_t *list, pkg_fragment_t *node)
pkg_fragment_delete(pkgconf_list_t *list, pkg_fragment_t *node)
{
pkg_node_delete(&node->iter, list);
pkgconf_node_delete(&node->iter, list);
free(node->data);
free(node);
}
void
pkg_fragment_free(pkg_list_t *list)
pkg_fragment_free(pkgconf_list_t *list)
{
pkg_node_t *node, *next;
pkgconf_node_t *node, *next;
PKG_FOREACH_LIST_ENTRY_SAFE(list->head, next, node)
PKGCONF_FOREACH_LIST_ENTRY_SAFE(list->head, next, node)
{
pkg_fragment_t *frag = node->data;
@ -190,7 +190,7 @@ pkg_fragment_free(pkg_list_t *list)
}
void
pkg_fragment_parse(pkg_list_t *list, pkg_list_t *vars, const char *value, unsigned int flags)
pkg_fragment_parse(pkgconf_list_t *list, pkgconf_list_t *vars, const char *value, unsigned int flags)
{
int i, argc;
char **argv;

22
libpkgconf/iter.h
View File

@ -16,23 +16,23 @@
#ifndef PKGCONF__ITER_H
#define PKGCONF__ITER_H
typedef struct pkg_node_ pkg_node_t;
typedef struct pkgconf_node_ pkgconf_node_t;
struct pkg_node_ {
pkg_node_t *prev, *next;
struct pkgconf_node_ {
pkgconf_node_t *prev, *next;
void *data;
};
typedef struct {
pkg_node_t *head, *tail;
} pkg_list_t;
pkgconf_node_t *head, *tail;
} pkgconf_list_t;
#define PKG_LIST_INITIALIZER { NULL, NULL }
#define PKGCONF_LIST_INITIALIZER { NULL, NULL }
static inline void
pkg_node_insert(pkg_node_t *node, void *data, pkg_list_t *list)
pkgconf_node_insert(pkgconf_node_t *node, void *data, pkgconf_list_t *list)
{
pkg_node_t *tnode;
pkgconf_node_t *tnode;
node->data = data;
@ -52,9 +52,9 @@ pkg_node_insert(pkg_node_t *node, void *data, pkg_list_t *list)
}
static inline void
pkg_node_insert_tail(pkg_node_t *node, void *data, pkg_list_t *list)
pkgconf_node_insert_tail(pkgconf_node_t *node, void *data, pkgconf_list_t *list)
{
pkg_node_t *tnode;
pkgconf_node_t *tnode;
node->data = data;
@ -74,7 +74,7 @@ pkg_node_insert_tail(pkg_node_t *node, void *data, pkg_list_t *list)
}
static inline void
pkg_node_delete(pkg_node_t *node, pkg_list_t *list)
pkgconf_node_delete(pkgconf_node_t *node, pkgconf_list_t *list)
{
if (node->prev == NULL)
list->head = node->next;

70
libpkgconf/libpkgconf.h
View File

@ -40,27 +40,27 @@ typedef struct pkg_dependency_ pkg_dependency_t;
typedef struct pkg_tuple_ pkg_tuple_t;
typedef struct pkg_fragment_ pkg_fragment_t;
#define PKG_FOREACH_LIST_ENTRY(head, value) \
#define PKGCONF_FOREACH_LIST_ENTRY(head, value) \
for ((value) = (head); (value) != NULL; (value) = (value)->next)
#define PKG_FOREACH_LIST_ENTRY_SAFE(head, nextiter, value) \
#define PKGCONF_FOREACH_LIST_ENTRY_SAFE(head, nextiter, value) \
for ((value) = (head), (nextiter) = (head) != NULL ? (head)->next : NULL; (value) != NULL; (value) = (nextiter), (nextiter) = (nextiter) != NULL ? (nextiter)->next : NULL)
#define PKG_FOREACH_LIST_ENTRY_REVERSE(tail, value) \
#define PKGCONF_FOREACH_LIST_ENTRY_REVERSE(tail, value) \
for ((value) = (tail); (value) != NULL; (value) = (value)->prev)
#define PKG_MIN(a,b) (((a) < (b)) ? (a) : (b))
#define PKG_MAX(a,b) (((a) > (b)) ? (a) : (b))
struct pkg_fragment_ {
pkg_node_t iter;
pkgconf_node_t iter;
char type;
char *data;
};
struct pkg_dependency_ {
pkg_node_t iter;
pkgconf_node_t iter;
char *package;
pkg_comparator_t compare;
@ -69,7 +69,7 @@ struct pkg_dependency_ {
};
struct pkg_tuple_ {
pkg_node_t iter;
pkgconf_node_t iter;
char *key;
char *value;
@ -82,7 +82,7 @@ struct pkg_tuple_ {
#define PKG_PROPF_UNINSTALLED 0x8
struct pkg_ {
pkg_node_t cache_iter;
pkgconf_node_t cache_iter;
int refcount;
char *id;
@ -93,16 +93,16 @@ struct pkg_ {
char *url;
char *pc_filedir;
pkg_list_t libs;
pkg_list_t libs_private;
pkg_list_t cflags;
pkg_list_t cflags_private;
pkgconf_list_t libs;
pkgconf_list_t libs_private;
pkgconf_list_t cflags;
pkgconf_list_t cflags_private;
pkg_list_t requires;
pkg_list_t requires_private;
pkg_list_t conflicts;
pkgconf_list_t requires;
pkgconf_list_t requires_private;
pkgconf_list_t conflicts;
pkg_list_t vars;
pkgconf_list_t vars;
unsigned int flags;
};
@ -143,36 +143,36 @@ unsigned int pkg_verify_graph(pkg_t *root, int depth, unsigned int flags);
int pkg_compare_version(const char *a, const char *b);
pkg_t *pkg_verify_dependency(pkg_dependency_t *pkgdep, unsigned int flags, unsigned int *eflags);
const char *pkg_get_comparator(pkg_dependency_t *pkgdep);
int pkg_cflags(pkg_t *root, pkg_list_t *list, int maxdepth, unsigned int flags);
int pkg_libs(pkg_t *root, pkg_list_t *list, int maxdepth, unsigned int flags);
int pkg_cflags(pkg_t *root, pkgconf_list_t *list, int maxdepth, unsigned int flags);
int pkg_libs(pkg_t *root, pkgconf_list_t *list, int maxdepth, unsigned int flags);
pkg_comparator_t pkg_comparator_lookup_by_name(const char *name);
/* parse.c */
pkg_t *pkg_new_from_file(const char *path, FILE *f, unsigned int flags);
void pkg_dependency_parse_str(pkg_list_t *deplist_head, const char *depends);
void pkg_dependency_parse(pkg_t *pkg, pkg_list_t *deplist_head, const char *depends);
void pkg_dependency_append(pkg_list_t *list, pkg_dependency_t *tail);
void pkg_dependency_free(pkg_list_t *list);
void pkg_dependency_parse_str(pkgconf_list_t *deplist_head, const char *depends);
void pkg_dependency_parse(pkg_t *pkg, pkgconf_list_t *deplist_head, const char *depends);
void pkg_dependency_append(pkgconf_list_t *list, pkg_dependency_t *tail);
void pkg_dependency_free(pkgconf_list_t *list);
/* argvsplit.c */
int pkg_argv_split(const char *src, int *argc, char ***argv);
void pkg_argv_free(char **argv);
/* fragment.c */
void pkg_fragment_parse(pkg_list_t *list, pkg_list_t *vars, const char *value, unsigned int flags);
void pkg_fragment_add(pkg_list_t *list, const char *string, unsigned int flags);
void pkg_fragment_copy(pkg_list_t *list, pkg_fragment_t *base, unsigned int flags, bool is_private);
void pkg_fragment_delete(pkg_list_t *list, pkg_fragment_t *node);
void pkg_fragment_free(pkg_list_t *list);
void pkg_fragment_parse(pkgconf_list_t *list, pkgconf_list_t *vars, const char *value, unsigned int flags);
void pkg_fragment_add(pkgconf_list_t *list, const char *string, unsigned int flags);
void pkg_fragment_copy(pkgconf_list_t *list, pkg_fragment_t *base, unsigned int flags, bool is_private);
void pkg_fragment_delete(pkgconf_list_t *list, pkg_fragment_t *node);
void pkg_fragment_free(pkgconf_list_t *list);
/* fileio.c */
char *pkg_fgetline(char *line, size_t size, FILE *stream);
/* tuple.c */
pkg_tuple_t *pkg_tuple_add(pkg_list_t *parent, const char *key, const char *value);
char *pkg_tuple_find(pkg_list_t *list, const char *key);
char *pkg_tuple_parse(pkg_list_t *list, const char *value);
void pkg_tuple_free(pkg_list_t *list);
pkg_tuple_t *pkg_tuple_add(pkgconf_list_t *parent, const char *key, const char *value);
char *pkg_tuple_find(pkgconf_list_t *list, const char *key);
char *pkg_tuple_parse(pkgconf_list_t *list, const char *value);
void pkg_tuple_free(pkgconf_list_t *list);
void pkg_tuple_add_global(const char *key, const char *value);
char *pkg_tuple_find_global(const char *key);
void pkg_tuple_free_global(void);
@ -182,11 +182,11 @@ void pkg_tuple_define_global(const char *kv);
extern FILE *error_msgout;
/* queue.c */
void pkg_queue_push(pkg_list_t *list, const char *package);
bool pkg_queue_compile(pkg_t *world, pkg_list_t *list);
void pkg_queue_free(pkg_list_t *list);
bool pkg_queue_apply(pkg_list_t *list, pkg_queue_apply_func_t func, int maxdepth, unsigned int flags, void *data);
bool pkg_queue_validate(pkg_list_t *list, int maxdepth, unsigned int flags);
void pkg_queue_push(pkgconf_list_t *list, const char *package);
bool pkg_queue_compile(pkg_t *world, pkgconf_list_t *list);
void pkg_queue_free(pkgconf_list_t *list);
bool pkg_queue_apply(pkgconf_list_t *list, pkg_queue_apply_func_t func, int maxdepth, unsigned int flags, void *data);
bool pkg_queue_validate(pkgconf_list_t *list, int maxdepth, unsigned int flags);
/* cache.c */
pkg_t *pkg_cache_lookup(const char *id);

64
libpkgconf/pkg.c
View File

@ -39,22 +39,22 @@
typedef struct {
char *path;
pkg_node_t node;
pkgconf_node_t node;
} pkg_path_t;
static inline void
path_add(const char *text, pkg_list_t *dirlist)
path_add(const char *text, pkgconf_list_t *dirlist)
{
pkg_path_t *pkg_path;
pkg_path = calloc(sizeof(pkg_path_t), 1);
pkg_path->path = strdup(text);
pkg_node_insert_tail(&pkg_path->node, pkg_path, dirlist);
pkgconf_node_insert_tail(&pkg_path->node, pkg_path, dirlist);
}
static inline size_t
path_split(const char *text, pkg_list_t *dirlist)
path_split(const char *text, pkgconf_list_t *dirlist)
{
size_t count = 0;
char *workbuf, *p, *iter;
@ -75,11 +75,11 @@ path_split(const char *text, pkg_list_t *dirlist)
}
static inline void
path_free(pkg_list_t *dirlist)
path_free(pkgconf_list_t *dirlist)
{
pkg_node_t *n, *tn;
pkgconf_node_t *n, *tn;
PKG_FOREACH_LIST_ENTRY_SAFE(dirlist->head, tn, n)
PKGCONF_FOREACH_LIST_ENTRY_SAFE(dirlist->head, tn, n)
{
pkg_path_t *pkg_path = n->data;
@ -157,7 +157,7 @@ pkg_get_parent_dir(pkg_t *pkg)
return buf;
}
static pkg_list_t pkg_dir_list = PKG_LIST_INITIALIZER;
static pkgconf_list_t pkg_dir_list = PKGCONF_LIST_INITIALIZER;
void
pkg_dir_list_build(unsigned int flags)
@ -398,11 +398,11 @@ pkg_scan_dir(const char *path, pkg_iteration_func_t func)
void
pkg_scan_all(pkg_iteration_func_t func)
{
pkg_node_t *n;
pkgconf_node_t *n;
pkg_dir_list_build(0);
PKG_FOREACH_LIST_ENTRY(pkg_dir_list.head, n)
PKGCONF_FOREACH_LIST_ENTRY(pkg_dir_list.head, n)
{
pkg_path_t *pkg_path = n->data;
@ -452,7 +452,7 @@ pkg_t *
pkg_find(const char *name, unsigned int flags)
{
pkg_t *pkg = NULL;
pkg_node_t *n;
pkgconf_node_t *n;
FILE *f;
pkg_dir_list_build(flags);
@ -481,7 +481,7 @@ pkg_find(const char *name, unsigned int flags)
}
}
PKG_FOREACH_LIST_ENTRY(pkg_dir_list.head, n)
PKGCONF_FOREACH_LIST_ENTRY(pkg_dir_list.head, n)
{
pkg_path_t *pkg_path = n->data;
@ -633,7 +633,7 @@ static pkg_t pkg_config_virtual = {
.version = PACKAGE_VERSION,
.flags = PKG_PROPF_VIRTUAL,
.vars = {
.head = &(pkg_node_t){
.head = &(pkgconf_node_t){
.prev = NULL,
.next = NULL,
.data = &(pkg_tuple_t){
@ -848,16 +848,16 @@ pkg_report_graph_error(pkg_t *parent, pkg_t *pkg, pkg_dependency_t *node, unsign
static inline unsigned int
pkg_walk_list(pkg_t *parent,
pkg_list_t *deplist,
pkgconf_list_t *deplist,
pkg_traverse_func_t func,
void *data,
int depth,
unsigned int flags)
{
unsigned int eflags = PKG_ERRF_OK;
pkg_node_t *node;
pkgconf_node_t *node;
PKG_FOREACH_LIST_ENTRY(deplist->head, node)
PKGCONF_FOREACH_LIST_ENTRY(deplist->head, node)
{
unsigned int eflags_local = PKG_ERRF_OK;
pkg_dependency_t *depnode = node->data;
@ -893,19 +893,19 @@ pkg_walk_list(pkg_t *parent,
}
static inline unsigned int
pkg_walk_conflicts_list(pkg_t *root, pkg_list_t *deplist, unsigned int flags)
pkg_walk_conflicts_list(pkg_t *root, pkgconf_list_t *deplist, unsigned int flags)
{
unsigned int eflags;
pkg_node_t *node, *childnode;
pkgconf_node_t *node, *childnode;
PKG_FOREACH_LIST_ENTRY(deplist->head, node)
PKGCONF_FOREACH_LIST_ENTRY(deplist->head, node)
{
pkg_dependency_t *parentnode = node->data;
if (*parentnode->package == '\0')
continue;
PKG_FOREACH_LIST_ENTRY(root->requires.head, childnode)
PKGCONF_FOREACH_LIST_ENTRY(root->requires.head, childnode)
{
pkg_t *pkgdep;
pkg_dependency_t *depnode = childnode->data;
@ -982,11 +982,11 @@ pkg_traverse(pkg_t *root,
static void
pkg_cflags_collect(pkg_t *pkg, void *data, unsigned int flags)
{
pkg_list_t *list = data;
pkg_node_t *node;
pkgconf_list_t *list = data;
pkgconf_node_t *node;
(void) flags;
PKG_FOREACH_LIST_ENTRY(pkg->cflags.head, node)
PKGCONF_FOREACH_LIST_ENTRY(pkg->cflags.head, node)
{
pkg_fragment_t *frag = node->data;
pkg_fragment_copy(list, frag, flags, false);
@ -996,11 +996,11 @@ pkg_cflags_collect(pkg_t *pkg, void *data, unsigned int flags)
static void
pkg_cflags_private_collect(pkg_t *pkg, void *data, unsigned int flags)
{
pkg_list_t *list = data;
pkg_node_t *node;
pkgconf_list_t *list = data;
pkgconf_node_t *node;
(void) flags;
PKG_FOREACH_LIST_ENTRY(pkg->cflags_private.head, node)
PKGCONF_FOREACH_LIST_ENTRY(pkg->cflags_private.head, node)
{
pkg_fragment_t *frag = node->data;
@ -1009,7 +1009,7 @@ pkg_cflags_private_collect(pkg_t *pkg, void *data, unsigned int flags)
}
int
pkg_cflags(pkg_t *root, pkg_list_t *list, int maxdepth, unsigned int flags)
pkg_cflags(pkg_t *root, pkgconf_list_t *list, int maxdepth, unsigned int flags)
{
int eflag;
@ -1030,11 +1030,11 @@ pkg_cflags(pkg_t *root, pkg_list_t *list, int maxdepth, unsigned int flags)
static void
pkg_libs_collect(pkg_t *pkg, void *data, unsigned int flags)
{
pkg_list_t *list = data;
pkg_node_t *node;
pkgconf_list_t *list = data;
pkgconf_node_t *node;
(void) flags;
PKG_FOREACH_LIST_ENTRY(pkg->libs.head, node)
PKGCONF_FOREACH_LIST_ENTRY(pkg->libs.head, node)
{
pkg_fragment_t *frag = node->data;
pkg_fragment_copy(list, frag, flags, (flags & PKGF_ITER_PKG_IS_PRIVATE) != 0);
@ -1042,7 +1042,7 @@ pkg_libs_collect(pkg_t *pkg, void *data, unsigned int flags)
if (flags & PKGF_MERGE_PRIVATE_FRAGMENTS)
{
PKG_FOREACH_LIST_ENTRY(pkg->libs_private.head, node)
PKGCONF_FOREACH_LIST_ENTRY(pkg->libs_private.head, node)
{
pkg_fragment_t *frag = node->data;
pkg_fragment_copy(list, frag, flags, true);
@ -1051,7 +1051,7 @@ pkg_libs_collect(pkg_t *pkg, void *data, unsigned int flags)
}
int
pkg_libs(pkg_t *root, pkg_list_t *list, int maxdepth, unsigned int flags)
pkg_libs(pkg_t *root, pkgconf_list_t *list, int maxdepth, unsigned int flags)
{
int eflag;

24
libpkgconf/queue.c
View File

@ -16,25 +16,25 @@
#include <libpkgconf/libpkgconf.h>
typedef struct {
pkg_node_t iter;
pkgconf_node_t iter;
char *package;
} pkg_queue_t;
void
pkg_queue_push(pkg_list_t *list, const char *package)
pkg_queue_push(pkgconf_list_t *list, const char *package)
{
pkg_queue_t *pkgq = calloc(sizeof(pkg_queue_t), 1);
pkgq->package = strdup(package);
pkg_node_insert_tail(&pkgq->iter, pkgq, list);
pkgconf_node_insert_tail(&pkgq->iter, pkgq, list);
}
bool
pkg_queue_compile(pkg_t *world, pkg_list_t *list)
pkg_queue_compile(pkg_t *world, pkgconf_list_t *list)
{
pkg_node_t *iter;
pkgconf_node_t *iter;
PKG_FOREACH_LIST_ENTRY(list->head, iter)
PKGCONF_FOREACH_LIST_ENTRY(list->head, iter)
{
pkg_queue_t *pkgq;
@ -46,11 +46,11 @@ pkg_queue_compile(pkg_t *world, pkg_list_t *list)
}
void
pkg_queue_free(pkg_list_t *list)
pkg_queue_free(pkgconf_list_t *list)
{
pkg_node_t *node, *tnode;
pkgconf_node_t *node, *tnode;
PKG_FOREACH_LIST_ENTRY_SAFE(list->head, tnode, node)
PKGCONF_FOREACH_LIST_ENTRY_SAFE(list->head, tnode, node)
{
pkg_queue_t *pkgq = node->data;
@ -60,7 +60,7 @@ pkg_queue_free(pkg_list_t *list)
}
static inline unsigned int
pkg_queue_verify(pkg_t *world, pkg_list_t *list, int maxdepth, unsigned int flags)
pkg_queue_verify(pkg_t *world, pkgconf_list_t *list, int maxdepth, unsigned int flags)
{
if (!pkg_queue_compile(world, list))
return PKG_ERRF_DEPGRAPH_BREAK;
@ -69,7 +69,7 @@ pkg_queue_verify(pkg_t *world, pkg_list_t *list, int maxdepth, unsigned int flag
}
bool
pkg_queue_apply(pkg_list_t *list, pkg_queue_apply_func_t func, int maxdepth, unsigned int flags, void *data)
pkg_queue_apply(pkgconf_list_t *list, pkg_queue_apply_func_t func, int maxdepth, unsigned int flags, void *data)
{
pkg_t world = {
.id = "world",
@ -96,7 +96,7 @@ pkg_queue_apply(pkg_list_t *list, pkg_queue_apply_func_t func, int maxdepth, uns
}
bool
pkg_queue_validate(pkg_list_t *list, int maxdepth, unsigned int flags)
pkg_queue_validate(pkgconf_list_t *list, int maxdepth, unsigned int flags)
{
bool retval = true;
pkg_t world = {

24
libpkgconf/tuple.c
View File

@ -15,7 +15,7 @@
#include <libpkgconf/libpkgconf.h>
static pkg_list_t pkg_global_var = PKG_LIST_INITIALIZER;
static pkgconf_list_t pkg_global_var = PKGCONF_LIST_INITIALIZER;
void
pkg_tuple_add_global(const char *key, const char *value)
@ -26,9 +26,9 @@ pkg_tuple_add_global(const char *key, const char *value)
char *
pkg_tuple_find_global(const char *key)
{
pkg_node_t *node;
pkgconf_node_t *node;
PKG_FOREACH_LIST_ENTRY(pkg_global_var.head, node)
PKGCONF_FOREACH_LIST_ENTRY(pkg_global_var.head, node)
{
pkg_tuple_t *tuple = node->data;
@ -62,28 +62,28 @@ out:
}
pkg_tuple_t *
pkg_tuple_add(pkg_list_t *list, const char *key, const char *value)
pkg_tuple_add(pkgconf_list_t *list, const char *key, const char *value)
{
pkg_tuple_t *tuple = calloc(sizeof(pkg_tuple_t), 1);
tuple->key = strdup(key);
tuple->value = pkg_tuple_parse(list, value);
pkg_node_insert(&tuple->iter, tuple, list);
pkgconf_node_insert(&tuple->iter, tuple, list);
return tuple;
}
char *
pkg_tuple_find(pkg_list_t *list, const char *key)
pkg_tuple_find(pkgconf_list_t *list, const char *key)
{
pkg_node_t *node;
pkgconf_node_t *node;
char *res;
if ((res = pkg_tuple_find_global(key)) != NULL)
return res;
PKG_FOREACH_LIST_ENTRY(list->head, node)
PKGCONF_FOREACH_LIST_ENTRY(list->head, node)
{
pkg_tuple_t *tuple = node->data;
@ -95,7 +95,7 @@ pkg_tuple_find(pkg_list_t *list, const char *key)
}
char *
pkg_tuple_parse(pkg_list_t *vars, const char *value)
pkg_tuple_parse(pkgconf_list_t *vars, const char *value)
{
char buf[PKG_BUFSIZE];
const char *ptr;
@ -146,11 +146,11 @@ pkg_tuple_parse(pkg_list_t *vars, const char *value)
}
void
pkg_tuple_free(pkg_list_t *list)
pkg_tuple_free(pkgconf_list_t *list)
{
pkg_node_t *node, *next;
pkgconf_node_t *node, *next;
PKG_FOREACH_LIST_ENTRY_SAFE(list->head, next, node)
PKGCONF_FOREACH_LIST_ENTRY_SAFE(list->head, next, node)
{
pkg_tuple_t *tuple = node->data;

68
main.c
View File

@ -125,11 +125,11 @@ print_package_entry(const pkg_t *entry)
}
static void
print_cflags(pkg_list_t *list)
print_cflags(pkgconf_list_t *list)
{
pkg_node_t *node;
pkgconf_node_t *node;
PKG_FOREACH_LIST_ENTRY(list->head, node)
PKGCONF_FOREACH_LIST_ENTRY(list->head, node)
{
pkg_fragment_t *frag = node->data;
int got_flags = 0;
@ -147,11 +147,11 @@ print_cflags(pkg_list_t *list)
}
static void
print_libs(pkg_list_t *list)
print_libs(pkgconf_list_t *list)
{
pkg_node_t *node;
pkgconf_node_t *node;
PKG_FOREACH_LIST_ENTRY(list->head, node)
PKGCONF_FOREACH_LIST_ENTRY(list->head, node)
{
pkg_fragment_t *frag = node->data;
int got_flags = 0;
@ -183,11 +183,11 @@ print_modversion(pkg_t *pkg, void *unused, unsigned int flags)
static void
print_variables(pkg_t *pkg, void *unused, unsigned int flags)
{
pkg_node_t *node;
pkgconf_node_t *node;
(void) unused;
(void) flags;
PKG_FOREACH_LIST_ENTRY(pkg->vars.head, node)
PKGCONF_FOREACH_LIST_ENTRY(pkg->vars.head, node)
{
pkg_tuple_t *tuple = node->data;
@ -198,9 +198,9 @@ print_variables(pkg_t *pkg, void *unused, unsigned int flags)
static void
print_requires(pkg_t *pkg)
{
pkg_node_t *node;
pkgconf_node_t *node;
PKG_FOREACH_LIST_ENTRY(pkg->requires.head, node)
PKGCONF_FOREACH_LIST_ENTRY(pkg->requires.head, node)
{
pkg_dependency_t *dep = node->data;
@ -216,9 +216,9 @@ print_requires(pkg_t *pkg)
static void
print_requires_private(pkg_t *pkg)
{
pkg_node_t *node;
pkgconf_node_t *node;
PKG_FOREACH_LIST_ENTRY(pkg->requires_private.head, node)
PKGCONF_FOREACH_LIST_ENTRY(pkg->requires_private.head, node)
{
pkg_dependency_t *dep = node->data;
@ -234,13 +234,13 @@ print_requires_private(pkg_t *pkg)
static void
print_digraph_node(pkg_t *pkg, void *unused, unsigned int flags)
{
pkg_node_t *node;
pkgconf_node_t *node;
(void) unused;
(void) flags;
printf("\"%s\" [fontname=Sans fontsize=8]\n", pkg->id);
PKG_FOREACH_LIST_ENTRY(pkg->requires.head, node)
PKGCONF_FOREACH_LIST_ENTRY(pkg->requires.head, node)
{
pkg_dependency_t *dep = node->data;
@ -351,7 +351,7 @@ apply_variable(pkg_t *world, void *variable, int maxdepth, unsigned int flags)
static bool
apply_cflags(pkg_t *world, void *list_head, int maxdepth, unsigned int flags)
{
pkg_list_t *list = list_head;
pkgconf_list_t *list = list_head;
int eflag;
eflag = pkg_cflags(world, list, maxdepth, flags | PKGF_SEARCH_PRIVATE);
@ -371,7 +371,7 @@ apply_cflags(pkg_t *world, void *list_head, int maxdepth, unsigned int flags)
static bool
apply_libs(pkg_t *world, void *list_head, int maxdepth, unsigned int flags)
{
pkg_list_t *list = list_head;
pkgconf_list_t *list = list_head;
int eflag;
eflag = pkg_libs(world, list, maxdepth, flags);
@ -391,11 +391,11 @@ apply_libs(pkg_t *world, void *list_head, int maxdepth, unsigned int flags)
static bool
apply_requires(pkg_t *world, void *unused, int maxdepth, unsigned int flags)
{
pkg_node_t *iter;
pkgconf_node_t *iter;
(void) unused;
(void) maxdepth;
PKG_FOREACH_LIST_ENTRY(world->requires.head, iter)
PKGCONF_FOREACH_LIST_ENTRY(world->requires.head, iter)
{
pkg_t *pkg;
pkg_dependency_t *dep = iter->data;
@ -412,11 +412,11 @@ apply_requires(pkg_t *world, void *unused, int maxdepth, unsigned int flags)
static bool
apply_requires_private(pkg_t *world, void *unused, int maxdepth, unsigned int flags)
{
pkg_node_t *iter;
pkgconf_node_t *iter;
(void) unused;
(void) maxdepth;
PKG_FOREACH_LIST_ENTRY(world->requires.head, iter)
PKGCONF_FOREACH_LIST_ENTRY(world->requires.head, iter)
{
pkg_t *pkg;
pkg_dependency_t *dep = iter->data;
@ -455,7 +455,7 @@ apply_uninstalled(pkg_t *world, void *data, int maxdepth, unsigned int flags)
static void
print_graph_node(pkg_t *pkg, void *data, unsigned int flags)
{
pkg_node_t *n;
pkgconf_node_t *n;
(void) data;
(void) flags;
@ -465,7 +465,7 @@ print_graph_node(pkg_t *pkg, void *data, unsigned int flags)
if (pkg->version != NULL)
printf(" version = '%s';\n", pkg->version);
PKG_FOREACH_LIST_ENTRY(pkg->requires.head, n)
PKGCONF_FOREACH_LIST_ENTRY(pkg->requires.head, n)
{
pkg_dependency_t *dep = n->data;
printf(" dependency '%s'", dep->package);
@ -577,7 +577,7 @@ int
main(int argc, char *argv[])
{
int ret;
pkg_list_t pkgq = PKG_LIST_INITIALIZER;
pkgconf_list_t pkgq = PKGCONF_LIST_INITIALIZER;
char *builddir;
char *required_pkgconfig_version = NULL;
char *required_exact_module_version = NULL;
@ -754,8 +754,8 @@ main(int argc, char *argv[])
if (required_module_version != NULL)
{
pkg_t *pkg;
pkg_node_t *node;
pkg_list_t deplist = PKG_LIST_INITIALIZER;
pkgconf_node_t *node;
pkgconf_list_t deplist = PKGCONF_LIST_INITIALIZER;
while (argv[pkg_optind])
{
@ -763,7 +763,7 @@ main(int argc, char *argv[])
pkg_optind++;
}
PKG_FOREACH_LIST_ENTRY(deplist.head, node)
PKGCONF_FOREACH_LIST_ENTRY(deplist.head, node)
{
pkg_dependency_t *pkgiter = node->data;
@ -781,8 +781,8 @@ main(int argc, char *argv[])
if (required_exact_module_version != NULL)
{
pkg_t *pkg;
pkg_node_t *node;
pkg_list_t deplist = PKG_LIST_INITIALIZER;
pkgconf_node_t *node;
pkgconf_list_t deplist = PKGCONF_LIST_INITIALIZER;
while (argv[pkg_optind])
{
@ -790,7 +790,7 @@ main(int argc, char *argv[])
pkg_optind++;
}
PKG_FOREACH_LIST_ENTRY(deplist.head, node)
PKGCONF_FOREACH_LIST_ENTRY(deplist.head, node)
{
pkg_dependency_t *pkgiter = node->data;
@ -808,8 +808,8 @@ main(int argc, char *argv[])
if (required_max_module_version != NULL)
{
pkg_t *pkg;
pkg_node_t *node;
pkg_list_t deplist = PKG_LIST_INITIALIZER;
pkgconf_node_t *node;
pkgconf_list_t deplist = PKGCONF_LIST_INITIALIZER;
while (argv[pkg_optind])
{
@ -817,7 +817,7 @@ main(int argc, char *argv[])
pkg_optind++;
}
PKG_FOREACH_LIST_ENTRY(deplist.head, node)
PKGCONF_FOREACH_LIST_ENTRY(deplist.head, node)
{
pkg_dependency_t *pkgiter = node->data;
@ -975,7 +975,7 @@ main(int argc, char *argv[])
if ((want_flags & PKG_CFLAGS))
{
pkg_list_t frag_list = PKG_LIST_INITIALIZER;
pkgconf_list_t frag_list = PKGCONF_LIST_INITIALIZER;
if (!pkg_queue_apply(&pkgq, apply_cflags, maximum_traverse_depth, global_traverse_flags, &frag_list))
{
@ -986,7 +986,7 @@ main(int argc, char *argv[])
if ((want_flags & PKG_LIBS))
{
pkg_list_t frag_list = PKG_LIST_INITIALIZER;
pkgconf_list_t frag_list = PKGCONF_LIST_INITIALIZER;
if (!pkg_queue_apply(&pkgq, apply_libs, maximum_traverse_depth, global_traverse_flags, &frag_list))
{