printf("ccan/compiler\n");
printf("ccan/hash\n");
printf("ccan/htable\n");
+ printf("ccan/list\n");
printf("ccan/read_write_all\n");
printf("ccan/str\n");
printf("ccan/time\n");
*/
struct failtest_call {
/* We're in the history list. */
- struct list_node list;
+ struct ccan_list_node list;
enum failtest_call_type type;
/* Where we were called from. */
const char *file;
--- /dev/null
+list_node_from_off_
+list_node_to_off_
+list_tail_
+list_top_
+list_del_from
+list_del
+list_empty
+list_add_tail
+list_add
+list_head_init
+list_check_node
+list_check
+list_head
+list_node
+list_off_var_
+list_off_
+list_del_from_off
+list_del_off
+list_add_off
+list_tail_off
+list_head_off
+list_entry_off
+list_for_each_safe_off
+list_for_each_off
+list_for_each_safe
+list_for_each_rev
+list_for_each
+list_tail
+list_top
+list_entry
+LIST_HEAD
+LIST_HEAD_INIT
+list_debug_node
+list_debug
#include "list.h"
static void *corrupt(const char *abortstr,
- const struct list_node *head,
- const struct list_node *node,
+ const struct ccan_list_node *head,
+ const struct ccan_list_node *node,
unsigned int count)
{
if (abortstr) {
return NULL;
}
-struct list_node *list_check_node(const struct list_node *node,
+struct ccan_list_node *ccan_list_check_node(const struct ccan_list_node *node,
const char *abortstr)
{
- const struct list_node *p, *n;
+ const struct ccan_list_node *p, *n;
int count = 0;
for (p = node, n = node->next; n != node; p = n, n = n->next) {
if (node->prev != p)
return corrupt(abortstr, node, node, 0);
- return (struct list_node *)node;
+ return (struct ccan_list_node *)node;
}
-struct list_head *list_check(const struct list_head *h, const char *abortstr)
+struct ccan_list_head *ccan_list_check(const struct ccan_list_head *h, const char *abortstr)
{
- if (!list_check_node(&h->n, abortstr))
+ if (!ccan_list_check_node(&h->n, abortstr))
return NULL;
- return (struct list_head *)h;
+ return (struct ccan_list_head *)h;
}
#include <ccan/check_type/check_type.h>
/**
- * struct list_node - an entry in a doubly-linked list
+ * struct ccan_list_node - an entry in a doubly-linked list
* @next: next entry (self if empty)
* @prev: previous entry (self if empty)
*
* struct child {
* const char *name;
* // Linked list of all us children.
- * struct list_node list;
+ * struct ccan_list_node list;
* };
*/
-struct list_node
+struct ccan_list_node
{
- struct list_node *next, *prev;
+ struct ccan_list_node *next, *prev;
};
/**
- * struct list_head - the head of a doubly-linked list
- * @h: the list_head (containing next and prev pointers)
+ * struct ccan_list_head - the head of a doubly-linked list
+ * @h: the ccan_list_head (containing next and prev pointers)
*
* This is used as the head of a linked list.
* Example:
* struct parent {
* const char *name;
- * struct list_head children;
+ * struct ccan_list_head children;
* unsigned int num_children;
* };
*/
-struct list_head
+struct ccan_list_head
{
- struct list_node n;
+ struct ccan_list_node n;
};
/**
- * list_check - check head of a list for consistency
- * @h: the list_head
+ * ccan_list_check - check head of a list for consistency
+ * @h: the ccan_list_head
* @abortstr: the location to print on aborting, or NULL.
*
* Because list_nodes have redundant information, consistency checking between
* Returns the list head if the list is consistent, NULL if not (it
* can never return NULL if @abortstr is set).
*
- * See also: list_check_node()
+ * See also: ccan_list_check_node()
*
* Example:
* static void dump_parent(struct parent *p)
* struct child *c;
*
* printf("%s (%u children):\n", p->name, p->num_children);
- * list_check(&p->children, "bad child list");
- * list_for_each(&p->children, c, list)
+ * ccan_list_check(&p->children, "bad child list");
+ * ccan_list_for_each(&p->children, c, list)
* printf(" -> %s\n", c->name);
* }
*/
-struct list_head *list_check(const struct list_head *h, const char *abortstr);
+struct ccan_list_head *ccan_list_check(const struct ccan_list_head *h, const char *abortstr);
/**
- * list_check_node - check node of a list for consistency
- * @n: the list_node
+ * ccan_list_check_node - check node of a list for consistency
+ * @n: the ccan_list_node
* @abortstr: the location to print on aborting, or NULL.
*
* Check consistency of the list node is in (it must be in one).
*
- * See also: list_check()
+ * See also: ccan_list_check()
*
* Example:
* static void dump_child(const struct child *c)
* {
- * list_check_node(&c->list, "bad child list");
+ * ccan_list_check_node(&c->list, "bad child list");
* printf("%s\n", c->name);
* }
*/
-struct list_node *list_check_node(const struct list_node *n,
+struct ccan_list_node *ccan_list_check_node(const struct ccan_list_node *n,
const char *abortstr);
#ifdef CCAN_LIST_DEBUG
-#define list_debug(h) list_check((h), __func__)
-#define list_debug_node(n) list_check_node((n), __func__)
+#define ccan_list_debug(h) ccan_list_check((h), __func__)
+#define ccan_list_debug_node(n) ccan_list_check_node((n), __func__)
#else
-#define list_debug(h) (h)
-#define list_debug_node(n) (n)
+#define ccan_list_debug(h) (h)
+#define ccan_list_debug_node(n) (n)
#endif
/**
- * LIST_HEAD_INIT - initializer for an empty list_head
+ * CCAN_LIST_HEAD_INIT - initializer for an empty ccan_list_head
* @name: the name of the list.
*
* Explicit initializer for an empty list.
*
* See also:
- * LIST_HEAD, list_head_init()
+ * CCAN_LIST_HEAD, ccan_list_head_init()
*
* Example:
- * static struct list_head my_list = LIST_HEAD_INIT(my_list);
+ * static struct ccan_list_head my_list = CCAN_LIST_HEAD_INIT(my_list);
*/
-#define LIST_HEAD_INIT(name) { { &name.n, &name.n } }
+#define CCAN_LIST_HEAD_INIT(name) { { &name.n, &name.n } }
/**
- * LIST_HEAD - define and initialize an empty list_head
+ * CCAN_LIST_HEAD - define and initialize an empty ccan_list_head
* @name: the name of the list.
*
- * The LIST_HEAD macro defines a list_head and initializes it to an empty
- * list. It can be prepended by "static" to define a static list_head.
+ * The CCAN_LIST_HEAD macro defines a ccan_list_head and initializes it to an empty
+ * list. It can be prepended by "static" to define a static ccan_list_head.
*
* See also:
- * LIST_HEAD_INIT, list_head_init()
+ * CCAN_LIST_HEAD_INIT, ccan_list_head_init()
*
* Example:
- * static LIST_HEAD(my_global_list);
+ * static CCAN_LIST_HEAD(my_global_list);
*/
-#define LIST_HEAD(name) \
- struct list_head name = LIST_HEAD_INIT(name)
+#define CCAN_LIST_HEAD(name) \
+ struct ccan_list_head name = CCAN_LIST_HEAD_INIT(name)
/**
- * list_head_init - initialize a list_head
- * @h: the list_head to set to the empty list
+ * ccan_list_head_init - initialize a ccan_list_head
+ * @h: the ccan_list_head to set to the empty list
*
* Example:
* ...
* struct parent *parent = malloc(sizeof(*parent));
*
- * list_head_init(&parent->children);
+ * ccan_list_head_init(&parent->children);
* parent->num_children = 0;
*/
-static inline void list_head_init(struct list_head *h)
+static inline void ccan_list_head_init(struct ccan_list_head *h)
{
h->n.next = h->n.prev = &h->n;
}
/**
- * list_add - add an entry at the start of a linked list.
- * @h: the list_head to add the node to
- * @n: the list_node to add to the list.
+ * ccan_list_add - add an entry at the start of a linked list.
+ * @h: the ccan_list_head to add the node to
+ * @n: the ccan_list_node to add to the list.
*
- * The list_node does not need to be initialized; it will be overwritten.
+ * The ccan_list_node does not need to be initialized; it will be overwritten.
* Example:
* struct child *child = malloc(sizeof(*child));
*
* child->name = "marvin";
- * list_add(&parent->children, &child->list);
+ * ccan_list_add(&parent->children, &child->list);
* parent->num_children++;
*/
-static inline void list_add(struct list_head *h, struct list_node *n)
+static inline void ccan_list_add(struct ccan_list_head *h, struct ccan_list_node *n)
{
n->next = h->n.next;
n->prev = &h->n;
h->n.next->prev = n;
h->n.next = n;
- (void)list_debug(h);
+ (void)ccan_list_debug(h);
}
/**
- * list_add_tail - add an entry at the end of a linked list.
- * @h: the list_head to add the node to
- * @n: the list_node to add to the list.
+ * ccan_list_add_tail - add an entry at the end of a linked list.
+ * @h: the ccan_list_head to add the node to
+ * @n: the ccan_list_node to add to the list.
*
- * The list_node does not need to be initialized; it will be overwritten.
+ * The ccan_list_node does not need to be initialized; it will be overwritten.
* Example:
- * list_add_tail(&parent->children, &child->list);
+ * ccan_list_add_tail(&parent->children, &child->list);
* parent->num_children++;
*/
-static inline void list_add_tail(struct list_head *h, struct list_node *n)
+static inline void ccan_list_add_tail(struct ccan_list_head *h, struct ccan_list_node *n)
{
n->next = &h->n;
n->prev = h->n.prev;
h->n.prev->next = n;
h->n.prev = n;
- (void)list_debug(h);
+ (void)ccan_list_debug(h);
}
/**
- * list_empty - is a list empty?
- * @h: the list_head
+ * ccan_list_empty - is a list empty?
+ * @h: the ccan_list_head
*
* If the list is empty, returns true.
*
* Example:
- * assert(list_empty(&parent->children) == (parent->num_children == 0));
+ * assert(ccan_list_empty(&parent->children) == (parent->num_children == 0));
*/
-static inline bool list_empty(const struct list_head *h)
+static inline bool ccan_list_empty(const struct ccan_list_head *h)
{
- (void)list_debug(h);
+ (void)ccan_list_debug(h);
return h->n.next == &h->n;
}
/**
- * list_del - delete an entry from an (unknown) linked list.
- * @n: the list_node to delete from the list.
+ * ccan_list_del - delete an entry from an (unknown) linked list.
+ * @n: the ccan_list_node to delete from the list.
*
* Note that this leaves @n in an undefined state; it can be added to
* another list, but not deleted again.
*
* See also:
- * list_del_from()
+ * ccan_list_del_from()
*
* Example:
- * list_del(&child->list);
+ * ccan_list_del(&child->list);
* parent->num_children--;
*/
-static inline void list_del(struct list_node *n)
+static inline void ccan_list_del(struct ccan_list_node *n)
{
- (void)list_debug_node(n);
+ (void)ccan_list_debug_node(n);
n->next->prev = n->prev;
n->prev->next = n->next;
#ifdef CCAN_LIST_DEBUG
}
/**
- * list_del_from - delete an entry from a known linked list.
- * @h: the list_head the node is in.
- * @n: the list_node to delete from the list.
+ * ccan_list_del_from - delete an entry from a known linked list.
+ * @h: the ccan_list_head the node is in.
+ * @n: the ccan_list_node to delete from the list.
*
* This explicitly indicates which list a node is expected to be in,
* which is better documentation and can catch more bugs.
*
- * See also: list_del()
+ * See also: ccan_list_del()
*
* Example:
- * list_del_from(&parent->children, &child->list);
+ * ccan_list_del_from(&parent->children, &child->list);
* parent->num_children--;
*/
-static inline void list_del_from(struct list_head *h, struct list_node *n)
+static inline void ccan_list_del_from(struct ccan_list_head *h, struct ccan_list_node *n)
{
#ifdef CCAN_LIST_DEBUG
{
/* Thorough check: make sure it was in list! */
- struct list_node *i;
+ struct ccan_list_node *i;
for (i = h->n.next; i != n; i = i->next)
assert(i != &h->n);
}
#endif /* CCAN_LIST_DEBUG */
/* Quick test that catches a surprising number of bugs. */
- assert(!list_empty(h));
- list_del(n);
+ assert(!ccan_list_empty(h));
+ ccan_list_del(n);
}
/**
- * list_entry - convert a list_node back into the structure containing it.
- * @n: the list_node
+ * ccan_list_entry - convert a ccan_list_node back into the structure containing it.
+ * @n: the ccan_list_node
* @type: the type of the entry
- * @member: the list_node member of the type
+ * @member: the ccan_list_node member of the type
*
* Example:
* // First list entry is children.next; convert back to child.
- * child = list_entry(parent->children.n.next, struct child, list);
+ * child = ccan_list_entry(parent->children.n.next, struct child, list);
*
* See Also:
- * list_top(), list_for_each()
+ * ccan_list_top(), ccan_list_for_each()
*/
-#define list_entry(n, type, member) container_of(n, type, member)
+#define ccan_list_entry(n, type, member) container_of(n, type, member)
/**
- * list_top - get the first entry in a list
- * @h: the list_head
+ * ccan_list_top - get the first entry in a list
+ * @h: the ccan_list_head
* @type: the type of the entry
- * @member: the list_node member of the type
+ * @member: the ccan_list_node member of the type
*
* If the list is empty, returns NULL.
*
* Example:
* struct child *first;
- * first = list_top(&parent->children, struct child, list);
+ * first = ccan_list_top(&parent->children, struct child, list);
*/
-#define list_top(h, type, member) \
- ((type *)list_top_((h), list_off_(type, member)))
+#define ccan_list_top(h, type, member) \
+ ((type *)ccan_list_top_((h), ccan_list_off_(type, member)))
-static inline const void *list_top_(const struct list_head *h, size_t off)
+static inline const void *ccan_list_top_(const struct ccan_list_head *h, size_t off)
{
- if (list_empty(h))
+ if (ccan_list_empty(h))
return NULL;
return (const char *)h->n.next - off;
}
/**
- * list_tail - get the last entry in a list
- * @h: the list_head
+ * ccan_list_tail - get the last entry in a list
+ * @h: the ccan_list_head
* @type: the type of the entry
- * @member: the list_node member of the type
+ * @member: the ccan_list_node member of the type
*
* If the list is empty, returns NULL.
*
* Example:
* struct child *last;
- * last = list_tail(&parent->children, struct child, list);
+ * last = ccan_list_tail(&parent->children, struct child, list);
*/
-#define list_tail(h, type, member) \
- ((type *)list_tail_((h), list_off_(type, member)))
+#define ccan_list_tail(h, type, member) \
+ ((type *)ccan_list_tail_((h), ccan_list_off_(type, member)))
-static inline const void *list_tail_(const struct list_head *h, size_t off)
+static inline const void *ccan_list_tail_(const struct ccan_list_head *h, size_t off)
{
- if (list_empty(h))
+ if (ccan_list_empty(h))
return NULL;
return (const char *)h->n.prev - off;
}
/**
- * list_for_each - iterate through a list.
- * @h: the list_head (warning: evaluated multiple times!)
- * @i: the structure containing the list_node
- * @member: the list_node member of the structure
+ * ccan_list_for_each - iterate through a list.
+ * @h: the ccan_list_head (warning: evaluated multiple times!)
+ * @i: the structure containing the ccan_list_node
+ * @member: the ccan_list_node member of the structure
*
* This is a convenient wrapper to iterate @i over the entire list. It's
* a for loop, so you can break and continue as normal.
*
* Example:
- * list_for_each(&parent->children, child, list)
+ * ccan_list_for_each(&parent->children, child, list)
* printf("Name: %s\n", child->name);
*/
-#define list_for_each(h, i, member) \
- list_for_each_off(h, i, list_off_var_(i, member))
+#define ccan_list_for_each(h, i, member) \
+ ccan_list_for_each_off(h, i, ccan_list_off_var_(i, member))
/**
- * list_for_each_rev - iterate through a list backwards.
- * @h: the list_head
- * @i: the structure containing the list_node
- * @member: the list_node member of the structure
+ * ccan_list_for_each_rev - iterate through a list backwards.
+ * @h: the ccan_list_head
+ * @i: the structure containing the ccan_list_node
+ * @member: the ccan_list_node member of the structure
*
* This is a convenient wrapper to iterate @i over the entire list. It's
* a for loop, so you can break and continue as normal.
*
* Example:
- * list_for_each_rev(&parent->children, child, list)
+ * ccan_list_for_each_rev(&parent->children, child, list)
* printf("Name: %s\n", child->name);
*/
-#define list_for_each_rev(h, i, member) \
- for (i = container_of_var(list_debug(h)->n.prev, i, member); \
+#define ccan_list_for_each_rev(h, i, member) \
+ for (i = container_of_var(ccan_list_debug(h)->n.prev, i, member); \
&i->member != &(h)->n; \
i = container_of_var(i->member.prev, i, member))
/**
- * list_for_each_safe - iterate through a list, maybe during deletion
- * @h: the list_head
- * @i: the structure containing the list_node
- * @nxt: the structure containing the list_node
- * @member: the list_node member of the structure
+ * ccan_list_for_each_safe - iterate through a list, maybe during deletion
+ * @h: the ccan_list_head
+ * @i: the structure containing the ccan_list_node
+ * @nxt: the structure containing the ccan_list_node
+ * @member: the ccan_list_node member of the structure
*
* This is a convenient wrapper to iterate @i over the entire list. It's
* a for loop, so you can break and continue as normal. The extra variable
*
* Example:
* struct child *next;
- * list_for_each_safe(&parent->children, child, next, list) {
- * list_del(&child->list);
+ * ccan_list_for_each_safe(&parent->children, child, next, list) {
+ * ccan_list_del(&child->list);
* parent->num_children--;
* }
*/
-#define list_for_each_safe(h, i, nxt, member) \
- list_for_each_safe_off(h, i, nxt, list_off_var_(i, member))
+#define ccan_list_for_each_safe(h, i, nxt, member) \
+ ccan_list_for_each_safe_off(h, i, nxt, ccan_list_off_var_(i, member))
/**
- * list_for_each_off - iterate through a list of memory regions.
- * @h: the list_head
+ * ccan_list_for_each_off - iterate through a list of memory regions.
+ * @h: the ccan_list_head
* @i: the pointer to a memory region wich contains list node data.
* @off: offset(relative to @i) at which list node data resides.
*
* caveat emptor.
*
* It is worth mentioning that one of legitimate use-cases for that wrapper
- * is operation on opaque types with known offset for `struct list_node'
+ * is operation on opaque types with known offset for `struct ccan_list_node'
* member(preferably 0), because it allows you not to disclose the type of
* @i.
*
* Example:
- * list_for_each_off(&parent->children, child,
+ * ccan_list_for_each_off(&parent->children, child,
* offsetof(struct child, list))
* printf("Name: %s\n", child->name);
*/
-#define list_for_each_off(h, i, off) \
- for (i = list_node_to_off_(list_debug(h)->n.next, (off)); \
- list_node_from_off_((void *)i, (off)) != &(h)->n; \
- i = list_node_to_off_(list_node_from_off_((void *)i, (off))->next, \
+#define ccan_list_for_each_off(h, i, off) \
+ for (i = ccan_list_node_to_off_(ccan_list_debug(h)->n.next, (off)); \
+ ccan_list_node_from_off_((void *)i, (off)) != &(h)->n; \
+ i = ccan_list_node_to_off_(ccan_list_node_from_off_((void *)i, (off))->next, \
(off)))
/**
- * list_for_each_safe_off - iterate through a list of memory regions, maybe
+ * ccan_list_for_each_safe_off - iterate through a list of memory regions, maybe
* during deletion
- * @h: the list_head
+ * @h: the ccan_list_head
* @i: the pointer to a memory region wich contains list node data.
- * @nxt: the structure containing the list_node
+ * @nxt: the structure containing the ccan_list_node
* @off: offset(relative to @i) at which list node data resides.
*
- * For details see `list_for_each_off' and `list_for_each_safe'
+ * For details see `ccan_list_for_each_off' and `ccan_list_for_each_safe'
* descriptions.
*
* Example:
- * list_for_each_safe_off(&parent->children, child,
+ * ccan_list_for_each_safe_off(&parent->children, child,
* next, offsetof(struct child, list))
* printf("Name: %s\n", child->name);
*/
-#define list_for_each_safe_off(h, i, nxt, off) \
- for (i = list_node_to_off_(list_debug(h)->n.next, (off)), \
- nxt = list_node_to_off_(list_node_from_off_(i, (off))->next, \
+#define ccan_list_for_each_safe_off(h, i, nxt, off) \
+ for (i = ccan_list_node_to_off_(ccan_list_debug(h)->n.next, (off)), \
+ nxt = ccan_list_node_to_off_(ccan_list_node_from_off_(i, (off))->next, \
(off)); \
- list_node_from_off_(i, (off)) != &(h)->n; \
+ ccan_list_node_from_off_(i, (off)) != &(h)->n; \
i = nxt, \
- nxt = list_node_to_off_(list_node_from_off_(i, (off))->next, \
+ nxt = ccan_list_node_to_off_(ccan_list_node_from_off_(i, (off))->next, \
(off)))
/* Other -off variants. */
-#define list_entry_off(n, type, off) \
- ((type *)list_node_from_off_((n), (off)))
+#define ccan_list_entry_off(n, type, off) \
+ ((type *)ccan_list_node_from_off_((n), (off)))
-#define list_head_off(h, type, off) \
- ((type *)list_head_off((h), (off)))
+#define ccan_list_head_off(h, type, off) \
+ ((type *)ccan_list_head_off((h), (off)))
-#define list_tail_off(h, type, off) \
- ((type *)list_tail_((h), (off)))
+#define ccan_list_tail_off(h, type, off) \
+ ((type *)ccan_list_tail_((h), (off)))
-#define list_add_off(h, n, off) \
- list_add((h), list_node_from_off_((n), (off)))
+#define ccan_list_add_off(h, n, off) \
+ ccan_list_add((h), ccan_list_node_from_off_((n), (off)))
-#define list_del_off(n, off) \
- list_del(list_node_from_off_((n), (off)))
+#define ccan_list_del_off(n, off) \
+ ccan_list_del(ccan_list_node_from_off_((n), (off)))
-#define list_del_from_off(h, n, off) \
- list_del_from(h, list_node_from_off_((n), (off)))
+#define ccan_list_del_from_off(h, n, off) \
+ ccan_list_del_from(h, ccan_list_node_from_off_((n), (off)))
/* Offset helper functions so we only single-evaluate. */
-static inline void *list_node_to_off_(struct list_node *node, size_t off)
+static inline void *ccan_list_node_to_off_(struct ccan_list_node *node, size_t off)
{
return (void *)((char *)node - off);
}
-static inline struct list_node *list_node_from_off_(void *ptr, size_t off)
+static inline struct ccan_list_node *ccan_list_node_from_off_(void *ptr, size_t off)
{
- return (struct list_node *)((char *)ptr + off);
+ return (struct ccan_list_node *)((char *)ptr + off);
}
-/* Get the offset of the member, but make sure it's a list_node. */
-#define list_off_(type, member) \
+/* Get the offset of the member, but make sure it's a ccan_list_node. */
+#define ccan_list_off_(type, member) \
(container_off(type, member) + \
- check_type(((type *)0)->member, struct list_node))
+ check_type(((type *)0)->member, struct ccan_list_node))
-#define list_off_var_(var, member) \
+#define ccan_list_off_var_(var, member) \
(container_off_var(var, member) + \
- check_type(var->member, struct list_node))
+ check_type(var->member, struct ccan_list_node))
#endif /* CCAN_LIST_H */
struct child {
const char *name;
- struct list_node list;
+ struct ccan_list_node list;
};
-static bool children(const struct list_head *list)
+static bool children(const struct ccan_list_head *list)
{
- return !list_empty(list);
+ return !ccan_list_empty(list);
}
-static const struct child *first_child(const struct list_head *list)
+static const struct child *first_child(const struct ccan_list_head *list)
{
- return list_top(list, struct child, list);
+ return ccan_list_top(list, struct child, list);
}
-static const struct child *last_child(const struct list_head *list)
+static const struct child *last_child(const struct ccan_list_head *list)
{
- return list_tail(list, struct child, list);
+ return ccan_list_tail(list, struct child, list);
}
-static void check_children(const struct list_head *list)
+static void check_children(const struct ccan_list_head *list)
{
- list_check(list, "bad child list");
+ ccan_list_check(list, "bad child list");
}
-static void print_children(const struct list_head *list)
+static void print_children(const struct ccan_list_head *list)
{
const struct child *c;
- list_for_each(list, c, list)
+ ccan_list_for_each(list, c, list)
printf("%s\n", c->name);
}
int main(void)
{
- LIST_HEAD(h);
+ CCAN_LIST_HEAD(h);
children(&h);
first_child(&h);
(42)
struct opaque {
- struct list_node list;
+ struct ccan_list_node list;
size_t secret_offset;
char secret_drawer[42];
};
int main(int argc, char *argv[])
{
- struct list_head list;
- struct list_node n1;
+ struct ccan_list_head list;
+ struct ccan_list_node n1;
char expect[100];
plan_tests(9);
/* Empty list. */
list.n.next = &list.n;
list.n.prev = &list.n;
- ok1(list_check(&list, NULL) == &list);
+ ok1(ccan_list_check(&list, NULL) == &list);
/* Bad back ptr */
list.n.prev = &n1;
/* Non-aborting version. */
- ok1(list_check(&list, NULL) == NULL);
+ ok1(ccan_list_check(&list, NULL) == NULL);
/* Aborting version. */
sprintf(expect, "test message: prev corrupt in node %p (0) of %p\n",
&list, &list);
if (setjmp(aborted) == 0) {
- list_check(&list, "test message");
- fail("list_check on empty with bad back ptr didn't fail!");
+ ccan_list_check(&list, "test message");
+ fail("ccan_list_check on empty with bad back ptr didn't fail!");
} else {
ok1(strcmp(printf_buffer, expect) == 0);
}
list.n.prev = &n1;
n1.prev = &list.n;
n1.next = &list.n;
- ok1(list_check(&list, NULL) == &list);
- ok1(list_check_node(&n1, NULL) == &n1);
+ ok1(ccan_list_check(&list, NULL) == &list);
+ ok1(ccan_list_check_node(&n1, NULL) == &n1);
/* Bad back ptr */
n1.prev = &n1;
- ok1(list_check(&list, NULL) == NULL);
- ok1(list_check_node(&n1, NULL) == NULL);
+ ok1(ccan_list_check(&list, NULL) == NULL);
+ ok1(ccan_list_check_node(&n1, NULL) == NULL);
/* Aborting version. */
sprintf(expect, "test message: prev corrupt in node %p (1) of %p\n",
&n1, &list);
if (setjmp(aborted) == 0) {
- list_check(&list, "test message");
- fail("list_check on n1 bad back ptr didn't fail!");
+ ccan_list_check(&list, "test message");
+ fail("ccan_list_check on n1 bad back ptr didn't fail!");
} else {
ok1(strcmp(printf_buffer, expect) == 0);
}
sprintf(expect, "test message: prev corrupt in node %p (0) of %p\n",
&n1, &n1);
if (setjmp(aborted) == 0) {
- list_check_node(&n1, "test message");
- fail("list_check_node on n1 bad back ptr didn't fail!");
+ ccan_list_check_node(&n1, "test message");
+ fail("ccan_list_check_node on n1 bad back ptr didn't fail!");
} else {
ok1(strcmp(printf_buffer, expect) == 0);
}
int main(int argc, char *argv[])
{
- struct list_head list1, list2;
- struct list_node n1, n2, n3;
+ struct ccan_list_head list1, list2;
+ struct ccan_list_node n1, n2, n3;
pid_t child;
int status;
plan_tests(1);
- list_head_init(&list1);
- list_head_init(&list2);
- list_add(&list1, &n1);
- list_add(&list2, &n2);
- list_add_tail(&list2, &n3);
+ ccan_list_head_init(&list1);
+ ccan_list_head_init(&list2);
+ ccan_list_add(&list1, &n1);
+ ccan_list_add(&list2, &n2);
+ ccan_list_add_tail(&list2, &n3);
child = fork();
if (child) {
wait(&status);
} else {
/* This should abort. */
- list_del_from(&list1, &n3);
+ ccan_list_del_from(&list1, &n3);
exit(0);
}
ok1(WIFSIGNALED(status) && WTERMSIG(status) == SIGABRT);
- list_del_from(&list2, &n3);
+ ccan_list_del_from(&list2, &n3);
return exit_status();
}
struct parent {
const char *name;
- struct list_head children;
+ struct ccan_list_head children;
unsigned int num_children;
int eval_count;
};
struct child {
const char *name;
- struct list_node list;
+ struct ccan_list_node list;
};
-static LIST_HEAD(static_list);
+static CCAN_LIST_HEAD(static_list);
#define ref(obj, counter) ((counter)++, (obj))
unsigned int i;
unsigned int static_count = 0, parent_count = 0, list_count = 0,
node_count = 0;
- struct list_head list = LIST_HEAD_INIT(list);
+ struct ccan_list_head list = CCAN_LIST_HEAD_INIT(list);
plan_tests(74);
- /* Test LIST_HEAD, LIST_HEAD_INIT, list_empty and check_list */
- ok1(list_empty(ref(&static_list, static_count)));
+ /* Test CCAN_LIST_HEAD, CCAN_LIST_HEAD_INIT, ccan_list_empty and check_list */
+ ok1(ccan_list_empty(ref(&static_list, static_count)));
ok1(static_count == 1);
- ok1(list_check(ref(&static_list, static_count), NULL));
+ ok1(ccan_list_check(ref(&static_list, static_count), NULL));
ok1(static_count == 2);
- ok1(list_empty(ref(&list, list_count)));
+ ok1(ccan_list_empty(ref(&list, list_count)));
ok1(list_count == 1);
- ok1(list_check(ref(&list, list_count), NULL));
+ ok1(ccan_list_check(ref(&list, list_count), NULL));
ok1(list_count == 2);
parent.num_children = 0;
- list_head_init(ref(&parent.children, parent_count));
+ ccan_list_head_init(ref(&parent.children, parent_count));
ok1(parent_count == 1);
- /* Test list_head_init */
- ok1(list_empty(ref(&parent.children, parent_count)));
+ /* Test ccan_list_head_init */
+ ok1(ccan_list_empty(ref(&parent.children, parent_count)));
ok1(parent_count == 2);
- ok1(list_check(ref(&parent.children, parent_count), NULL));
+ ok1(ccan_list_check(ref(&parent.children, parent_count), NULL));
ok1(parent_count == 3);
c2.name = "c2";
- list_add(ref(&parent.children, parent_count), &c2.list);
+ ccan_list_add(ref(&parent.children, parent_count), &c2.list);
ok1(parent_count == 4);
- /* Test list_add and !list_empty. */
- ok1(!list_empty(ref(&parent.children, parent_count)));
+ /* Test ccan_list_add and !ccan_list_empty. */
+ ok1(!ccan_list_empty(ref(&parent.children, parent_count)));
ok1(parent_count == 5);
ok1(c2.list.next == &parent.children.n);
ok1(c2.list.prev == &parent.children.n);
ok1(parent.children.n.next == &c2.list);
ok1(parent.children.n.prev == &c2.list);
- /* Test list_check */
- ok1(list_check(ref(&parent.children, parent_count), NULL));
+ /* Test ccan_list_check */
+ ok1(ccan_list_check(ref(&parent.children, parent_count), NULL));
ok1(parent_count == 6);
c1.name = "c1";
- list_add(ref(&parent.children, parent_count), &c1.list);
+ ccan_list_add(ref(&parent.children, parent_count), &c1.list);
ok1(parent_count == 7);
- /* Test list_add and !list_empty. */
- ok1(!list_empty(ref(&parent.children, parent_count)));
+ /* Test ccan_list_add and !ccan_list_empty. */
+ ok1(!ccan_list_empty(ref(&parent.children, parent_count)));
ok1(parent_count == 8);
ok1(c2.list.next == &parent.children.n);
ok1(c2.list.prev == &c1.list);
ok1(parent.children.n.prev == &c2.list);
ok1(c1.list.next == &c2.list);
ok1(c1.list.prev == &parent.children.n);
- /* Test list_check */
- ok1(list_check(ref(&parent.children, parent_count), NULL));
+ /* Test ccan_list_check */
+ ok1(ccan_list_check(ref(&parent.children, parent_count), NULL));
ok1(parent_count == 9);
c3.name = "c3";
- list_add_tail(ref(&parent.children, parent_count), &c3.list);
+ ccan_list_add_tail(ref(&parent.children, parent_count), &c3.list);
ok1(parent_count == 10);
- /* Test list_add_tail and !list_empty. */
- ok1(!list_empty(ref(&parent.children, parent_count)));
+ /* Test ccan_list_add_tail and !ccan_list_empty. */
+ ok1(!ccan_list_empty(ref(&parent.children, parent_count)));
ok1(parent_count == 11);
ok1(parent.children.n.next == &c1.list);
ok1(parent.children.n.prev == &c3.list);
ok1(c2.list.prev == &c1.list);
ok1(c3.list.next == &parent.children.n);
ok1(c3.list.prev == &c2.list);
- /* Test list_check */
- ok1(list_check(ref(&parent.children, parent_count), NULL));
+ /* Test ccan_list_check */
+ ok1(ccan_list_check(ref(&parent.children, parent_count), NULL));
ok1(parent_count == 12);
- /* Test list_check_node */
- ok1(list_check_node(&c1.list, NULL));
- ok1(list_check_node(&c2.list, NULL));
- ok1(list_check_node(&c3.list, NULL));
+ /* Test ccan_list_check_node */
+ ok1(ccan_list_check_node(&c1.list, NULL));
+ ok1(ccan_list_check_node(&c2.list, NULL));
+ ok1(ccan_list_check_node(&c3.list, NULL));
- /* Test list_top */
- ok1(list_top(ref(&parent.children, parent_count), struct child, list) == &c1);
+ /* Test ccan_list_top */
+ ok1(ccan_list_top(ref(&parent.children, parent_count), struct child, list) == &c1);
ok1(parent_count == 13);
- /* Test list_tail */
- ok1(list_tail(ref(&parent.children, parent_count), struct child, list) == &c3);
+ /* Test ccan_list_tail */
+ ok1(ccan_list_tail(ref(&parent.children, parent_count), struct child, list) == &c3);
ok1(parent_count == 14);
- /* Test list_for_each. */
+ /* Test ccan_list_for_each. */
i = 0;
- list_for_each(&parent.children, c, list) {
+ ccan_list_for_each(&parent.children, c, list) {
switch (i++) {
case 0:
ok1(c == &c1);
}
ok1(i == 3);
- /* Test list_for_each_safe, list_del and list_del_from. */
+ /* Test ccan_list_for_each_safe, ccan_list_del and ccan_list_del_from. */
i = 0;
- list_for_each_safe(&parent.children, c, n, list) {
+ ccan_list_for_each_safe(&parent.children, c, n, list) {
switch (i++) {
case 0:
ok1(c == &c1);
- list_del(ref(&c->list, node_count));
+ ccan_list_del(ref(&c->list, node_count));
ok1(node_count == 1);
break;
case 1:
ok1(c == &c2);
- list_del_from(ref(&parent.children, parent_count),
+ ccan_list_del_from(ref(&parent.children, parent_count),
ref(&c->list, node_count));
ok1(node_count == 2);
break;
case 2:
ok1(c == &c3);
- list_del_from(ref(&parent.children, parent_count),
+ ccan_list_del_from(ref(&parent.children, parent_count),
ref(&c->list, node_count));
ok1(node_count == 3);
break;
}
- ok1(list_check(ref(&parent.children, parent_count), NULL));
+ ok1(ccan_list_check(ref(&parent.children, parent_count), NULL));
if (i > 2)
break;
}
ok1(i == 3);
ok1(parent_count == 19);
- ok1(list_empty(ref(&parent.children, parent_count)));
+ ok1(ccan_list_empty(ref(&parent.children, parent_count)));
ok1(parent_count == 20);
- /* Test list_top/list_tail on empty list. */
- ok1(list_top(ref(&parent.children, parent_count), struct child, list) == NULL);
+ /* Test ccan_list_top/ccan_list_tail on empty list. */
+ ok1(ccan_list_top(ref(&parent.children, parent_count), struct child, list) == NULL);
ok1(parent_count == 21);
- ok1(list_tail(ref(&parent.children, parent_count), struct child, list) == NULL);
+ ok1(ccan_list_tail(ref(&parent.children, parent_count), struct child, list) == NULL);
ok1(parent_count == 22);
return exit_status();
}
struct parent {
const char *name;
- struct list_head children;
+ struct ccan_list_head children;
unsigned int num_children;
};
struct child {
const char *name;
- struct list_node list;
+ struct ccan_list_node list;
};
-static LIST_HEAD(static_list);
+static CCAN_LIST_HEAD(static_list);
int main(int argc, char *argv[])
{
struct parent parent;
struct child c1, c2, c3, *c, *n;
unsigned int i;
- struct list_head list = LIST_HEAD_INIT(list);
+ struct ccan_list_head list = CCAN_LIST_HEAD_INIT(list);
opaque_t *q, *nq;
- struct list_head opaque_list = LIST_HEAD_INIT(opaque_list);
+ struct ccan_list_head opaque_list = CCAN_LIST_HEAD_INIT(opaque_list);
plan_tests(65);
- /* Test LIST_HEAD, LIST_HEAD_INIT, list_empty and check_list */
- ok1(list_empty(&static_list));
- ok1(list_check(&static_list, NULL));
- ok1(list_empty(&list));
- ok1(list_check(&list, NULL));
+ /* Test CCAN_LIST_HEAD, CCAN_LIST_HEAD_INIT, ccan_list_empty and check_list */
+ ok1(ccan_list_empty(&static_list));
+ ok1(ccan_list_check(&static_list, NULL));
+ ok1(ccan_list_empty(&list));
+ ok1(ccan_list_check(&list, NULL));
parent.num_children = 0;
- list_head_init(&parent.children);
- /* Test list_head_init */
- ok1(list_empty(&parent.children));
- ok1(list_check(&parent.children, NULL));
+ ccan_list_head_init(&parent.children);
+ /* Test ccan_list_head_init */
+ ok1(ccan_list_empty(&parent.children));
+ ok1(ccan_list_check(&parent.children, NULL));
c2.name = "c2";
- list_add(&parent.children, &c2.list);
- /* Test list_add and !list_empty. */
- ok1(!list_empty(&parent.children));
+ ccan_list_add(&parent.children, &c2.list);
+ /* Test ccan_list_add and !ccan_list_empty. */
+ ok1(!ccan_list_empty(&parent.children));
ok1(c2.list.next == &parent.children.n);
ok1(c2.list.prev == &parent.children.n);
ok1(parent.children.n.next == &c2.list);
ok1(parent.children.n.prev == &c2.list);
- /* Test list_check */
- ok1(list_check(&parent.children, NULL));
+ /* Test ccan_list_check */
+ ok1(ccan_list_check(&parent.children, NULL));
c1.name = "c1";
- list_add(&parent.children, &c1.list);
- /* Test list_add and !list_empty. */
- ok1(!list_empty(&parent.children));
+ ccan_list_add(&parent.children, &c1.list);
+ /* Test ccan_list_add and !ccan_list_empty. */
+ ok1(!ccan_list_empty(&parent.children));
ok1(c2.list.next == &parent.children.n);
ok1(c2.list.prev == &c1.list);
ok1(parent.children.n.next == &c1.list);
ok1(parent.children.n.prev == &c2.list);
ok1(c1.list.next == &c2.list);
ok1(c1.list.prev == &parent.children.n);
- /* Test list_check */
- ok1(list_check(&parent.children, NULL));
+ /* Test ccan_list_check */
+ ok1(ccan_list_check(&parent.children, NULL));
c3.name = "c3";
- list_add_tail(&parent.children, &c3.list);
- /* Test list_add_tail and !list_empty. */
- ok1(!list_empty(&parent.children));
+ ccan_list_add_tail(&parent.children, &c3.list);
+ /* Test ccan_list_add_tail and !ccan_list_empty. */
+ ok1(!ccan_list_empty(&parent.children));
ok1(parent.children.n.next == &c1.list);
ok1(parent.children.n.prev == &c3.list);
ok1(c1.list.next == &c2.list);
ok1(c2.list.prev == &c1.list);
ok1(c3.list.next == &parent.children.n);
ok1(c3.list.prev == &c2.list);
- /* Test list_check */
- ok1(list_check(&parent.children, NULL));
+ /* Test ccan_list_check */
+ ok1(ccan_list_check(&parent.children, NULL));
- /* Test list_check_node */
- ok1(list_check_node(&c1.list, NULL));
- ok1(list_check_node(&c2.list, NULL));
- ok1(list_check_node(&c3.list, NULL));
+ /* Test ccan_list_check_node */
+ ok1(ccan_list_check_node(&c1.list, NULL));
+ ok1(ccan_list_check_node(&c2.list, NULL));
+ ok1(ccan_list_check_node(&c3.list, NULL));
- /* Test list_top */
- ok1(list_top(&parent.children, struct child, list) == &c1);
+ /* Test ccan_list_top */
+ ok1(ccan_list_top(&parent.children, struct child, list) == &c1);
- /* Test list_tail */
- ok1(list_tail(&parent.children, struct child, list) == &c3);
+ /* Test ccan_list_tail */
+ ok1(ccan_list_tail(&parent.children, struct child, list) == &c3);
- /* Test list_for_each. */
+ /* Test ccan_list_for_each. */
i = 0;
- list_for_each(&parent.children, c, list) {
+ ccan_list_for_each(&parent.children, c, list) {
switch (i++) {
case 0:
ok1(c == &c1);
}
ok1(i == 3);
- /* Test list_for_each_rev. */
+ /* Test ccan_list_for_each_rev. */
i = 0;
- list_for_each_rev(&parent.children, c, list) {
+ ccan_list_for_each_rev(&parent.children, c, list) {
switch (i++) {
case 0:
ok1(c == &c3);
}
ok1(i == 3);
- /* Test list_for_each_safe, list_del and list_del_from. */
+ /* Test ccan_list_for_each_safe, ccan_list_del and ccan_list_del_from. */
i = 0;
- list_for_each_safe(&parent.children, c, n, list) {
+ ccan_list_for_each_safe(&parent.children, c, n, list) {
switch (i++) {
case 0:
ok1(c == &c1);
- list_del(&c->list);
+ ccan_list_del(&c->list);
break;
case 1:
ok1(c == &c2);
- list_del_from(&parent.children, &c->list);
+ ccan_list_del_from(&parent.children, &c->list);
break;
case 2:
ok1(c == &c3);
- list_del_from(&parent.children, &c->list);
+ ccan_list_del_from(&parent.children, &c->list);
break;
}
- ok1(list_check(&parent.children, NULL));
+ ok1(ccan_list_check(&parent.children, NULL));
if (i > 2)
break;
}
ok1(i == 3);
- ok1(list_empty(&parent.children));
+ ok1(ccan_list_empty(&parent.children));
- /* Test list_for_each_off. */
- list_add_tail(&opaque_list,
- (struct list_node *)create_opaque_blob());
- list_add_tail(&opaque_list,
- (struct list_node *)create_opaque_blob());
- list_add_tail(&opaque_list,
- (struct list_node *)create_opaque_blob());
+ /* Test ccan_list_for_each_off. */
+ ccan_list_add_tail(&opaque_list,
+ (struct ccan_list_node *)create_opaque_blob());
+ ccan_list_add_tail(&opaque_list,
+ (struct ccan_list_node *)create_opaque_blob());
+ ccan_list_add_tail(&opaque_list,
+ (struct ccan_list_node *)create_opaque_blob());
i = 0;
- list_for_each_off(&opaque_list, q, 0) {
+ ccan_list_for_each_off(&opaque_list, q, 0) {
i++;
ok1(if_blobs_know_the_secret(q));
}
ok1(i == 3);
- /* Test list_for_each_safe_off, list_del_off and list_del_from_off. */
+ /* Test ccan_list_for_each_safe_off, ccan_list_del_off and ccan_list_del_from_off. */
i = 0;
- list_for_each_safe_off(&opaque_list, q, nq, 0) {
+ ccan_list_for_each_safe_off(&opaque_list, q, nq, 0) {
switch (i++) {
case 0:
ok1(if_blobs_know_the_secret(q));
- list_del_off(q, 0);
+ ccan_list_del_off(q, 0);
destroy_opaque_blob(q);
break;
case 1:
ok1(if_blobs_know_the_secret(q));
- list_del_from_off(&opaque_list, q, 0);
+ ccan_list_del_from_off(&opaque_list, q, 0);
destroy_opaque_blob(q);
break;
case 2:
ok1(c == &c3);
- list_del_from_off(&opaque_list, q, 0);
+ ccan_list_del_from_off(&opaque_list, q, 0);
destroy_opaque_blob(q);
break;
}
- ok1(list_check(&opaque_list, NULL));
+ ok1(ccan_list_check(&opaque_list, NULL));
if (i > 2)
break;
}
ok1(i == 3);
- ok1(list_empty(&opaque_list));
+ ok1(ccan_list_empty(&opaque_list));
- /* Test list_top/list_tail on empty list. */
- ok1(list_top(&parent.children, struct child, list) == NULL);
- ok1(list_tail(&parent.children, struct child, list) == NULL);
+ /* Test ccan_list_top/ccan_list_tail on empty list. */
+ ok1(ccan_list_top(&parent.children, struct child, list) == NULL);
+ ok1(ccan_list_tail(&parent.children, struct child, list) == NULL);
return exit_status();
}
struct child {
const char *name;
- struct list_node list;
+ struct ccan_list_node list;
};
struct cousin {
const char *name;
- struct list_node list;
+ struct ccan_list_node list;
};
int main(int argc, char *argv[])
struct child {
const char *name;
- struct list_node list;
+ struct ccan_list_node list;
};
struct cousin {
const char *name;
- struct list_node list;
+ struct ccan_list_node list;
};
int main(int argc, char *argv[])
struct child {
const char *name;
- struct list_node list;
+ struct ccan_list_node list;
};
struct cousin {
const char *name;
- struct list_node list;
+ struct ccan_list_node list;
};
int main(int argc, char *argv[])
struct child {
const char *name;
- struct list_node list;
+ struct ccan_list_node list;
};
struct cousin {
const char *name;
- struct list_node list;
+ struct ccan_list_node list;
};
int main(int argc, char *argv[])
struct child {
const char *name;
- struct list_node list;
+ struct ccan_list_node list;
};
struct cousin {
const char *name;
- struct list_node list;
+ struct ccan_list_node list;
};
int main(int argc, char *argv[])
struct child {
const char *name;
- struct list_node list;
+ struct ccan_list_node list;
};
struct cousin {
const char *name;
- struct list_node list;
+ struct ccan_list_node list;
};
int main(int argc, char *argv[])
struct child {
const char *name;
- struct list_node list;
+ struct ccan_list_node list;
};
struct cousin {
const char *name;
- struct list_node list;
+ struct ccan_list_node list;
};
int main(int argc, char *argv[])
struct child {
const char *name;
- struct list_node list;
+ struct ccan_list_node list;
};
int main(int argc, char *argv[])
c1.name = "c1";
tlist_add(&parent.children, &c1, list);
- /* Test list_add and !list_empty. */
+ /* Test ccan_list_add and !ccan_list_empty. */
ok1(!tlist_empty(&parent.children));
ok1(c2.list.next == &parent.children.raw.n);
ok1(c2.list.prev == &c1.list);
c3.name = "c3";
tlist_add_tail(&parent.children, &c3, list);
- /* Test list_add_tail and !list_empty. */
+ /* Test ccan_list_add_tail and !ccan_list_empty. */
ok1(!tlist_empty(&parent.children));
ok1(parent.children.raw.n.next == &c1.list);
ok1(parent.children.raw.n.prev == &c3.list);
/* Test tlist_top */
ok1(tlist_top(&parent.children, list) == &c1);
- /* Test list_tail */
+ /* Test ccan_list_tail */
ok1(tlist_tail(&parent.children, list) == &c3);
/* Test tlist_for_each. */
ok1(i == 3);
ok1(tlist_empty(&parent.children));
- /* Test list_top/list_tail on empty list. */
+ /* Test ccan_list_top/ccan_list_tail on empty list. */
ok1(tlist_top(&parent.children, list) == (struct child *)NULL);
ok1(tlist_tail(&parent.children, list) == (struct child *)NULL);
return exit_status();
*
* struct child {
* const char *name;
- * struct list_node list;
+ * struct ccan_list_node list;
* };
*/
#define TLIST_TYPE(suffix, type) \
struct tlist_##suffix { \
- struct list_head raw; \
+ struct ccan_list_head raw; \
TCON(type *canary); \
}
* Example:
* static struct tlist_children my_list = TLIST_INIT(my_list);
*/
-#define TLIST_INIT(name) { LIST_HEAD_INIT(name.raw) }
+#define TLIST_INIT(name) { CCAN_LIST_HEAD_INIT(name.raw) }
/**
* tlist_check - check head of a list for consistency
* Returns non-NULL if the list is consistent, NULL otherwise (it
* can never return NULL if @abortstr is set).
*
- * See also: list_check()
+ * See also: ccan_list_check()
*
* Example:
* static void dump_parent(struct parent *p)
* }
*/
#define tlist_check(h, abortstr) \
- list_check(&(h)->raw, (abortstr))
+ ccan_list_check(&(h)->raw, (abortstr))
/**
* tlist_init - initialize a tlist
* tlist_init(&parent->children);
* parent->num_children = 0;
*/
-#define tlist_init(h) list_head_init(&(h)->raw)
+#define tlist_init(h) ccan_list_head_init(&(h)->raw)
/**
* tlist_raw - unwrap the typed list and check the type
* @n: the entry to add to the list.
* @member: the member of n to add to the list.
*
- * The entry's list_node does not need to be initialized; it will be
+ * The entry's ccan_list_node does not need to be initialized; it will be
* overwritten.
* Example:
* struct child *child = malloc(sizeof(*child));
* tlist_add(&parent->children, child, list);
* parent->num_children++;
*/
-#define tlist_add(h, n, member) list_add(tlist_raw((h), (n)), &(n)->member)
+#define tlist_add(h, n, member) ccan_list_add(tlist_raw((h), (n)), &(n)->member)
/**
* tlist_add_tail - add an entry at the end of a linked list.
* @n: the entry to add to the list.
* @member: the member of n to add to the list.
*
- * The list_node does not need to be initialized; it will be overwritten.
+ * The ccan_list_node does not need to be initialized; it will be overwritten.
* Example:
* tlist_add_tail(&parent->children, child, list);
* parent->num_children++;
*/
#define tlist_add_tail(h, n, member) \
- list_add_tail(tlist_raw((h), (n)), &(n)->member)
+ ccan_list_add_tail(tlist_raw((h), (n)), &(n)->member)
/**
* tlist_del_from - delete an entry from a linked list.
* parent->num_children--;
*/
#define tlist_del_from(h, n, member) \
- list_del_from(tlist_raw((h), (n)), &(n)->member)
+ ccan_list_del_from(tlist_raw((h), (n)), &(n)->member)
/**
* tlist_del - delete an entry from an unknown linked list.
* parent->num_children--;
*/
#define tlist_del(n, member) \
- list_del(&(n)->member)
+ ccan_list_del(&(n)->member)
/**
* tlist_empty - is a list empty?
* Example:
* assert(tlist_empty(&parent->children) == (parent->num_children == 0));
*/
-#define tlist_empty(h) list_empty(&(h)->raw)
+#define tlist_empty(h) ccan_list_empty(&(h)->raw)
/**
* tlist_top - get the first entry in a list
* @h: the tlist
- * @member: the list_node member of the type
+ * @member: the ccan_list_node member of the type
*
* If the list is empty, returns NULL.
*
*/
#define tlist_top(h, member) \
((tcon_type((h), canary)) \
- list_top_(&(h)->raw, \
+ ccan_list_top_(&(h)->raw, \
(char *)(&(h)->_tcon[0].canary->member) - \
(char *)((h)->_tcon[0].canary)))
/**
* tlist_tail - get the last entry in a list
* @h: the tlist
- * @member: the list_node member of the type
+ * @member: the ccan_list_node member of the type
*
* If the list is empty, returns NULL.
*
*/
#define tlist_tail(h, member) \
((tcon_type((h), canary)) \
- list_tail_(&(h)->raw, \
+ ccan_list_tail_(&(h)->raw, \
(char *)(&(h)->_tcon[0].canary->member) - \
(char *)((h)->_tcon[0].canary)))
* tlist_for_each - iterate through a list.
* @h: the tlist
* @i: an iterator of suitable type for this list.
- * @member: the list_node member of @i
+ * @member: the ccan_list_node member of @i
*
* This is a convenient wrapper to iterate @i over the entire list. It's
* a for loop, so you can break and continue as normal.
* printf("Name: %s\n", child->name);
*/
#define tlist_for_each(h, i, member) \
- list_for_each(tlist_raw((h), (i)), (i), member)
+ ccan_list_for_each(tlist_raw((h), (i)), (i), member)
/**
* tlist_for_each - iterate through a list backwards.
* @h: the tlist
* @i: an iterator of suitable type for this list.
- * @member: the list_node member of @i
+ * @member: the ccan_list_node member of @i
*
* This is a convenient wrapper to iterate @i over the entire list. It's
* a for loop, so you can break and continue as normal.
* printf("Name: %s\n", child->name);
*/
#define tlist_for_each_rev(h, i, member) \
- list_for_each_rev(tlist_raw((h), (i)), (i), member)
+ ccan_list_for_each_rev(tlist_raw((h), (i)), (i), member)
/**
* tlist_for_each_safe - iterate through a list, maybe during deletion
* @h: the tlist
* @i: an iterator of suitable type for this list.
* @nxt: another iterator to store the next entry.
- * @member: the list_node member of the structure
+ * @member: the ccan_list_node member of the structure
*
* This is a convenient wrapper to iterate @i over the entire list. It's
* a for loop, so you can break and continue as normal. The extra variable
* }
*/
#define tlist_for_each_safe(h, i, nxt, member) \
- list_for_each_safe(tlist_raw((h), (i)), (i), (nxt), member)
+ ccan_list_for_each_safe(tlist_raw((h), (i)), (i), (nxt), member)
#endif /* CCAN_TLIST_H */
git.samba.org / ddiss / samba.git / commitdiff