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> #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) * pkg_cache_lookup(id)
@ -27,9 +27,9 @@ static pkg_list_t pkg_cache = PKG_LIST_INITIALIZER;
pkg_t * pkg_t *
pkg_cache_lookup(const char *id) 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; pkg_t *pkg = node->data;
@ -54,7 +54,7 @@ pkg_cache_add(pkg_t *pkg)
pkg_ref(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) if (pkg == NULL)
return; return;
pkg_node_delete(&pkg->cache_iter, &pkg_cache); pkgconf_node_delete(&pkg->cache_iter, &pkg_cache);
} }
void void
pkg_cache_free(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; pkg_t *pkg = iter->data;

18
libpkgconf/dependency.c
View File

@ -36,7 +36,7 @@ typedef enum {
#define DEBUG_PARSE 0 #define DEBUG_PARSE 0
static inline pkg_dependency_t * 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; 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; dep->compare = compare;
pkg_node_insert_tail(&dep->iter, dep, list); pkgconf_node_insert_tail(&dep->iter, dep, list);
#if DEBUG_PARSE #if DEBUG_PARSE
fprintf(error_msgout, "--> %s %d %s\n", dep->package, dep->compare, dep->version); 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 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 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; pkg_dependency_t *dep = node->data;
@ -83,7 +83,7 @@ pkg_dependency_free(pkg_list_t *list)
} }
void 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; parse_state_t state = OUTSIDE_MODULE;
pkg_comparator_t compare = PKG_ANY; pkg_comparator_t compare = PKG_ANY;
@ -223,7 +223,7 @@ pkg_dependency_parse_str(pkg_list_t *deplist_head, const char *depends)
} }
void 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); 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 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; 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); 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 * 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; 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 * 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)) if (!pkg_fragment_can_merge_back(base, flags, is_private))
return NULL; return NULL;
@ -149,7 +149,7 @@ pkg_fragment_exists(pkg_list_t *list, pkg_fragment_t *base, unsigned int flags,
} }
void 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; 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->type = base->type;
frag->data = strdup(base->data); frag->data = strdup(base->data);
pkg_node_insert_tail(&frag->iter, frag, list); pkgconf_node_insert_tail(&frag->iter, frag, list);
} }
void 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->data);
free(node); free(node);
} }
void 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; pkg_fragment_t *frag = node->data;
@ -190,7 +190,7 @@ pkg_fragment_free(pkg_list_t *list)
} }
void 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; int i, argc;
char **argv; char **argv;

22
libpkgconf/iter.h
View File

@ -16,23 +16,23 @@
#ifndef PKGCONF__ITER_H #ifndef PKGCONF__ITER_H
#define PKGCONF__ITER_H #define PKGCONF__ITER_H
typedef struct pkg_node_ pkg_node_t; typedef struct pkgconf_node_ pkgconf_node_t;
struct pkg_node_ { struct pkgconf_node_ {
pkg_node_t *prev, *next; pkgconf_node_t *prev, *next;
void *data; void *data;
}; };
typedef struct { typedef struct {
pkg_node_t *head, *tail; pkgconf_node_t *head, *tail;
} pkg_list_t; } pkgconf_list_t;
#define PKG_LIST_INITIALIZER { NULL, NULL } #define PKGCONF_LIST_INITIALIZER { NULL, NULL }
static inline void 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; node->data = data;
@ -52,9 +52,9 @@ pkg_node_insert(pkg_node_t *node, void *data, pkg_list_t *list)
} }
static inline void 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; node->data = data;
@ -74,7 +74,7 @@ pkg_node_insert_tail(pkg_node_t *node, void *data, pkg_list_t *list)
} }
static inline void 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) if (node->prev == NULL)
list->head = node->next; 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_tuple_ pkg_tuple_t;
typedef struct pkg_fragment_ pkg_fragment_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) 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) 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) for ((value) = (tail); (value) != NULL; (value) = (value)->prev)
#define PKG_MIN(a,b) (((a) < (b)) ? (a) : (b)) #define PKG_MIN(a,b) (((a) < (b)) ? (a) : (b))
#define PKG_MAX(a,b) (((a) > (b)) ? (a) : (b)) #define PKG_MAX(a,b) (((a) > (b)) ? (a) : (b))
struct pkg_fragment_ { struct pkg_fragment_ {
pkg_node_t iter; pkgconf_node_t iter;
char type; char type;
char *data; char *data;
}; };
struct pkg_dependency_ { struct pkg_dependency_ {
pkg_node_t iter; pkgconf_node_t iter;
char *package; char *package;
pkg_comparator_t compare; pkg_comparator_t compare;
@ -69,7 +69,7 @@ struct pkg_dependency_ {
}; };
struct pkg_tuple_ { struct pkg_tuple_ {
pkg_node_t iter; pkgconf_node_t iter;
char *key; char *key;
char *value; char *value;
@ -82,7 +82,7 @@ struct pkg_tuple_ {
#define PKG_PROPF_UNINSTALLED 0x8 #define PKG_PROPF_UNINSTALLED 0x8
struct pkg_ { struct pkg_ {
pkg_node_t cache_iter; pkgconf_node_t cache_iter;
int refcount; int refcount;
char *id; char *id;
@ -93,16 +93,16 @@ struct pkg_ {
char *url; char *url;
char *pc_filedir; char *pc_filedir;
pkg_list_t libs; pkgconf_list_t libs;
pkg_list_t libs_private; pkgconf_list_t libs_private;
pkg_list_t cflags; pkgconf_list_t cflags;
pkg_list_t cflags_private; pkgconf_list_t cflags_private;
pkg_list_t requires; pkgconf_list_t requires;
pkg_list_t requires_private; pkgconf_list_t requires_private;
pkg_list_t conflicts; pkgconf_list_t conflicts;
pkg_list_t vars; pkgconf_list_t vars;
unsigned int flags; 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); 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); pkg_t *pkg_verify_dependency(pkg_dependency_t *pkgdep, unsigned int flags, unsigned int *eflags);
const char *pkg_get_comparator(pkg_dependency_t *pkgdep); 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_cflags(pkg_t *root, pkgconf_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_libs(pkg_t *root, pkgconf_list_t *list, int maxdepth, unsigned int flags);
pkg_comparator_t pkg_comparator_lookup_by_name(const char *name); pkg_comparator_t pkg_comparator_lookup_by_name(const char *name);
/* parse.c */ /* parse.c */
pkg_t *pkg_new_from_file(const char *path, FILE *f, unsigned int flags); 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_str(pkgconf_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_parse(pkg_t *pkg, pkgconf_list_t *deplist_head, const char *depends);
void pkg_dependency_append(pkg_list_t *list, pkg_dependency_t *tail); void pkg_dependency_append(pkgconf_list_t *list, pkg_dependency_t *tail);
void pkg_dependency_free(pkg_list_t *list); void pkg_dependency_free(pkgconf_list_t *list);
/* argvsplit.c */ /* argvsplit.c */
int pkg_argv_split(const char *src, int *argc, char ***argv); int pkg_argv_split(const char *src, int *argc, char ***argv);
void pkg_argv_free(char **argv); void pkg_argv_free(char **argv);
/* fragment.c */ /* fragment.c */
void pkg_fragment_parse(pkg_list_t *list, pkg_list_t *vars, const char *value, unsigned int flags); void pkg_fragment_parse(pkgconf_list_t *list, pkgconf_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_add(pkgconf_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_copy(pkgconf_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_delete(pkgconf_list_t *list, pkg_fragment_t *node);
void pkg_fragment_free(pkg_list_t *list); void pkg_fragment_free(pkgconf_list_t *list);
/* fileio.c */ /* fileio.c */
char *pkg_fgetline(char *line, size_t size, FILE *stream); char *pkg_fgetline(char *line, size_t size, FILE *stream);
/* tuple.c */ /* tuple.c */
pkg_tuple_t *pkg_tuple_add(pkg_list_t *parent, const char *key, const char *value); pkg_tuple_t *pkg_tuple_add(pkgconf_list_t *parent, const char *key, const char *value);
char *pkg_tuple_find(pkg_list_t *list, const char *key); char *pkg_tuple_find(pkgconf_list_t *list, const char *key);
char *pkg_tuple_parse(pkg_list_t *list, const char *value); char *pkg_tuple_parse(pkgconf_list_t *list, const char *value);
void pkg_tuple_free(pkg_list_t *list); void pkg_tuple_free(pkgconf_list_t *list);
void pkg_tuple_add_global(const char *key, const char *value); void pkg_tuple_add_global(const char *key, const char *value);
char *pkg_tuple_find_global(const char *key); char *pkg_tuple_find_global(const char *key);
void pkg_tuple_free_global(void); void pkg_tuple_free_global(void);
@ -182,11 +182,11 @@ void pkg_tuple_define_global(const char *kv);
extern FILE *error_msgout; extern FILE *error_msgout;
/* queue.c */ /* queue.c */
void pkg_queue_push(pkg_list_t *list, const char *package); void pkg_queue_push(pkgconf_list_t *list, const char *package);
bool pkg_queue_compile(pkg_t *world, pkg_list_t *list); bool pkg_queue_compile(pkg_t *world, pkgconf_list_t *list);
void pkg_queue_free(pkg_list_t *list); void pkg_queue_free(pkgconf_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_apply(pkgconf_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); bool pkg_queue_validate(pkgconf_list_t *list, int maxdepth, unsigned int flags);
/* cache.c */ /* cache.c */
pkg_t *pkg_cache_lookup(const char *id); pkg_t *pkg_cache_lookup(const char *id);

64
libpkgconf/pkg.c
View File

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

24
libpkgconf/queue.c
View File

@ -16,25 +16,25 @@
#include <libpkgconf/libpkgconf.h> #include <libpkgconf/libpkgconf.h>
typedef struct { typedef struct {
pkg_node_t iter; pkgconf_node_t iter;
char *package; char *package;
} pkg_queue_t; } pkg_queue_t;
void 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); pkg_queue_t *pkgq = calloc(sizeof(pkg_queue_t), 1);
pkgq->package = strdup(package); pkgq->package = strdup(package);
pkg_node_insert_tail(&pkgq->iter, pkgq, list); pkgconf_node_insert_tail(&pkgq->iter, pkgq, list);
} }
bool 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; pkg_queue_t *pkgq;
@ -46,11 +46,11 @@ pkg_queue_compile(pkg_t *world, pkg_list_t *list)
} }
void 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; pkg_queue_t *pkgq = node->data;
@ -60,7 +60,7 @@ pkg_queue_free(pkg_list_t *list)
} }
static inline unsigned int 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)) if (!pkg_queue_compile(world, list))
return PKG_ERRF_DEPGRAPH_BREAK; 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 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 = { pkg_t world = {
.id = "world", .id = "world",
@ -96,7 +96,7 @@ pkg_queue_apply(pkg_list_t *list, pkg_queue_apply_func_t func, int maxdepth, uns
} }
bool 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; bool retval = true;
pkg_t world = { pkg_t world = {

24
libpkgconf/tuple.c
View File

@ -15,7 +15,7 @@
#include <libpkgconf/libpkgconf.h> #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 void
pkg_tuple_add_global(const char *key, const char *value) 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 * char *
pkg_tuple_find_global(const char *key) 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; pkg_tuple_t *tuple = node->data;
@ -62,28 +62,28 @@ out:
} }
pkg_tuple_t * 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); pkg_tuple_t *tuple = calloc(sizeof(pkg_tuple_t), 1);
tuple->key = strdup(key); tuple->key = strdup(key);
tuple->value = pkg_tuple_parse(list, value); tuple->value = pkg_tuple_parse(list, value);
pkg_node_insert(&tuple->iter, tuple, list); pkgconf_node_insert(&tuple->iter, tuple, list);
return tuple; return tuple;
} }
char * 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; char *res;
if ((res = pkg_tuple_find_global(key)) != NULL) if ((res = pkg_tuple_find_global(key)) != NULL)
return res; return res;
PKG_FOREACH_LIST_ENTRY(list->head, node) PKGCONF_FOREACH_LIST_ENTRY(list->head, node)
{ {
pkg_tuple_t *tuple = node->data; pkg_tuple_t *tuple = node->data;
@ -95,7 +95,7 @@ pkg_tuple_find(pkg_list_t *list, const char *key)
} }
char * 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]; char buf[PKG_BUFSIZE];
const char *ptr; const char *ptr;
@ -146,11 +146,11 @@ pkg_tuple_parse(pkg_list_t *vars, const char *value)
} }
void 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; pkg_tuple_t *tuple = node->data;

68
main.c
View File

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