#include <sys/queue.h>

sys/queue.h

95 macros

macroQMD_TRACE_ELEM

#define QMD_TRACE_ELEM(elem)

macroQMD_TRACE_HEAD

#define QMD_TRACE_HEAD(head)

macroTRACEBUF

#define TRACEBUF

macroTRASHIT

#define TRASHIT(x)

macroSLIST_HEAD

Singly-linked List declarations.

#define SLIST_HEAD(name, type) __MISMATCH_TAGS_PUSH
__NULLABILITY_COMPLETENESS_PUSH
struct name {
	struct type *slh_first; /* first element */
}
__NULLABILITY_COMPLETENESS_POP
__MISMATCH_TAGS_POP

macroSLIST_HEAD_INITIALIZER

#define SLIST_HEAD_INITIALIZER(head) { NULL }

macroSLIST_ENTRY

#define SLIST_ENTRY(type) __MISMATCH_TAGS_PUSH
__NULLABILITY_COMPLETENESS_PUSH
struct {
	struct type *sle_next;  /* next element */
}
__NULLABILITY_COMPLETENESS_POP
__MISMATCH_TAGS_POP

macroSLIST_EMPTY

Singly-linked List functions.

#define SLIST_EMPTY(head) ((head)->slh_first == NULL)

macroSLIST_FIRST

#define SLIST_FIRST(head) ((head)->slh_first)

macroSLIST_FOREACH

#define SLIST_FOREACH(var, head, field) for ((var) = SLIST_FIRST((head));
	    (var);
	    (var) = SLIST_NEXT((var), field))

macroSLIST_FOREACH_SAFE

#define SLIST_FOREACH_SAFE(var, head, field, tvar) for ((var) = SLIST_FIRST((head));
	    (var) && ((tvar) = SLIST_NEXT((var), field), 1);
	    (var) = (tvar))

macroSLIST_FOREACH_PREVPTR

#define SLIST_FOREACH_PREVPTR(var, varp, head, field) for ((varp) = &SLIST_FIRST((head));
	    ((var) = *(varp)) != NULL;
	    (varp) = &SLIST_NEXT((var), field))

macroSLIST_INIT

#define SLIST_INIT(head) do {
	SLIST_FIRST((head)) = NULL;
} while (0)

macroSLIST_INSERT_AFTER

#define SLIST_INSERT_AFTER(slistelm, elm, field) do {
	SLIST_NEXT((elm), field) = SLIST_NEXT((slistelm), field);
	SLIST_NEXT((slistelm), field) = (elm);
} while (0)

macroSLIST_INSERT_HEAD

#define SLIST_INSERT_HEAD(head, elm, field) do {
	SLIST_NEXT((elm), field) = SLIST_FIRST((head));
	SLIST_FIRST((head)) = (elm);
} while (0)

macroSLIST_NEXT

#define SLIST_NEXT(elm, field) ((elm)->field.sle_next)

macroSLIST_REMOVE

#define SLIST_REMOVE(head, elm, type, field) __MISMATCH_TAGS_PUSH
__NULLABILITY_COMPLETENESS_PUSH
do {
	if (SLIST_FIRST((head)) == (elm)) {
	        SLIST_REMOVE_HEAD((head), field);
	}
	else {
	        struct type *curelm = SLIST_FIRST((head));
	        while (SLIST_NEXT(curelm, field) != (elm))
	                curelm = SLIST_NEXT(curelm, field);
	        SLIST_REMOVE_AFTER(curelm, field);
	}
	TRASHIT((elm)->field.sle_next);
} while (0)
__NULLABILITY_COMPLETENESS_POP
__MISMATCH_TAGS_POP

macroSLIST_REMOVE_AFTER

#define SLIST_REMOVE_AFTER(elm, field) do {
	SLIST_NEXT(elm, field) =
	    SLIST_NEXT(SLIST_NEXT(elm, field), field);
} while (0)

macroSLIST_REMOVE_HEAD

#define SLIST_REMOVE_HEAD(head, field) do {
	SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field);
} while (0)

macroSTAILQ_HEAD

Singly-linked Tail queue declarations.

#define STAILQ_HEAD(name, type) __MISMATCH_TAGS_PUSH
__NULLABILITY_COMPLETENESS_PUSH
struct name {
	struct type *stqh_first;/* first element */
	struct type **stqh_last;/* addr of last next element */
}
__NULLABILITY_COMPLETENESS_POP
__MISMATCH_TAGS_POP

macroSTAILQ_HEAD_INITIALIZER

#define STAILQ_HEAD_INITIALIZER(head) { NULL, &(head).stqh_first }

macroSTAILQ_ENTRY

#define STAILQ_ENTRY(type) __MISMATCH_TAGS_PUSH
__NULLABILITY_COMPLETENESS_PUSH
struct {
	struct type *stqe_next; /* next element */
}
__NULLABILITY_COMPLETENESS_POP
__MISMATCH_TAGS_POP

macroSTAILQ_CONCAT

Singly-linked Tail queue functions.

#define STAILQ_CONCAT(head1, head2) do {
	if (!STAILQ_EMPTY((head2))) {
	        *(head1)->stqh_last = (head2)->stqh_first;
	        (head1)->stqh_last = (head2)->stqh_last;
	        STAILQ_INIT((head2));
	}
} while (0)

macroSTAILQ_EMPTY

#define STAILQ_EMPTY(head) ((head)->stqh_first == NULL)

macroSTAILQ_FIRST

#define STAILQ_FIRST(head) ((head)->stqh_first)

macroSTAILQ_FOREACH

#define STAILQ_FOREACH(var, head, field) for((var) = STAILQ_FIRST((head));
	   (var);
	   (var) = STAILQ_NEXT((var), field))

macroSTAILQ_FOREACH_SAFE

#define STAILQ_FOREACH_SAFE(var, head, field, tvar) for ((var) = STAILQ_FIRST((head));
	    (var) && ((tvar) = STAILQ_NEXT((var), field), 1);
	    (var) = (tvar))

macroSTAILQ_INIT

#define STAILQ_INIT(head) do {
	STAILQ_FIRST((head)) = NULL;
	(head)->stqh_last = &STAILQ_FIRST((head));
} while (0)

macroSTAILQ_INSERT_AFTER

#define STAILQ_INSERT_AFTER(head, tqelm, elm, field) do {
	if ((STAILQ_NEXT((elm), field) = STAILQ_NEXT((tqelm), field)) == NULL)
	        (head)->stqh_last = &STAILQ_NEXT((elm), field);
	STAILQ_NEXT((tqelm), field) = (elm);
} while (0)

macroSTAILQ_INSERT_HEAD

#define STAILQ_INSERT_HEAD(head, elm, field) do {
	if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL)
	        (head)->stqh_last = &STAILQ_NEXT((elm), field);
	STAILQ_FIRST((head)) = (elm);
} while (0)

macroSTAILQ_INSERT_TAIL

#define STAILQ_INSERT_TAIL(head, elm, field) do {
	STAILQ_NEXT((elm), field) = NULL;
	*(head)->stqh_last = (elm);
	(head)->stqh_last = &STAILQ_NEXT((elm), field);
} while (0)

macroSTAILQ_LAST

#define STAILQ_LAST(head, type, field) __MISMATCH_TAGS_PUSH
__NULLABILITY_COMPLETENESS_PUSH
	(STAILQ_EMPTY((head)) ?
	        NULL :
	        ((struct type *)(void *)
	        ((char *)((head)->stqh_last) - __offsetof(struct type, field))))
__NULLABILITY_COMPLETENESS_POP
__MISMATCH_TAGS_POP

macroSTAILQ_NEXT

#define STAILQ_NEXT(elm, field) ((elm)->field.stqe_next)

macroSTAILQ_REMOVE

#define STAILQ_REMOVE(head, elm, type, field) __MISMATCH_TAGS_PUSH
__NULLABILITY_COMPLETENESS_PUSH
do {
	if (STAILQ_FIRST((head)) == (elm)) {
	        STAILQ_REMOVE_HEAD((head), field);
	}
	else {
	        struct type *curelm = STAILQ_FIRST((head));
	        while (STAILQ_NEXT(curelm, field) != (elm))
	                curelm = STAILQ_NEXT(curelm, field);
	        STAILQ_REMOVE_AFTER(head, curelm, field);
	}
	TRASHIT((elm)->field.stqe_next);
} while (0)
__NULLABILITY_COMPLETENESS_POP
__MISMATCH_TAGS_POP

macroSTAILQ_REMOVE_HEAD

#define STAILQ_REMOVE_HEAD(head, field) do {
	if ((STAILQ_FIRST((head)) =
	     STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL)
	        (head)->stqh_last = &STAILQ_FIRST((head));
} while (0)

macroSTAILQ_REMOVE_HEAD_UNTIL

#define STAILQ_REMOVE_HEAD_UNTIL(head, elm, field) do {
       if ((STAILQ_FIRST((head)) = STAILQ_NEXT((elm), field)) == NULL)
	       (head)->stqh_last = &STAILQ_FIRST((head));
} while (0)

macroSTAILQ_REMOVE_AFTER

#define STAILQ_REMOVE_AFTER(head, elm, field) do {
	if ((STAILQ_NEXT(elm, field) =
	     STAILQ_NEXT(STAILQ_NEXT(elm, field), field)) == NULL)
	        (head)->stqh_last = &STAILQ_NEXT((elm), field);
} while (0)

macroSTAILQ_SWAP

#define STAILQ_SWAP(head1, head2, type) __MISMATCH_TAGS_PUSH
__NULLABILITY_COMPLETENESS_PUSH
do {
	struct type *swap_first = STAILQ_FIRST(head1);
	struct type **swap_last = (head1)->stqh_last;
	STAILQ_FIRST(head1) = STAILQ_FIRST(head2);
	(head1)->stqh_last = (head2)->stqh_last;
	STAILQ_FIRST(head2) = swap_first;
	(head2)->stqh_last = swap_last;
	if (STAILQ_EMPTY(head1))
	        (head1)->stqh_last = &STAILQ_FIRST(head1);
	if (STAILQ_EMPTY(head2))
	        (head2)->stqh_last = &STAILQ_FIRST(head2);
} while (0)
__NULLABILITY_COMPLETENESS_POP
__MISMATCH_TAGS_POP

macroLIST_HEAD

List declarations.

#define LIST_HEAD(name, type) __MISMATCH_TAGS_PUSH
__NULLABILITY_COMPLETENESS_PUSH
struct name {
	struct type *lh_first;  /* first element */
}
__NULLABILITY_COMPLETENESS_POP
__MISMATCH_TAGS_POP

macroLIST_HEAD_INITIALIZER

#define LIST_HEAD_INITIALIZER(head) { NULL }

macroLIST_ENTRY

#define LIST_ENTRY(type) __MISMATCH_TAGS_PUSH
__NULLABILITY_COMPLETENESS_PUSH
struct {
	struct type *le_next;   /* next element */
	struct type **le_prev;  /* address of previous next element */
}
__NULLABILITY_COMPLETENESS_POP
__MISMATCH_TAGS_POP

macroLIST_CHECK_HEAD

#define LIST_CHECK_HEAD(head, field)

macroLIST_CHECK_NEXT

#define LIST_CHECK_NEXT(elm, field)

macroLIST_CHECK_PREV

#define LIST_CHECK_PREV(elm, field)

macroLIST_EMPTY

#define LIST_EMPTY(head) ((head)->lh_first == NULL)

macroLIST_FIRST

#define LIST_FIRST(head) ((head)->lh_first)

macroLIST_FOREACH

#define LIST_FOREACH(var, head, field) for ((var) = LIST_FIRST((head));
	    (var);
	    (var) = LIST_NEXT((var), field))

macroLIST_FOREACH_SAFE

#define LIST_FOREACH_SAFE(var, head, field, tvar) for ((var) = LIST_FIRST((head));
	    (var) && ((tvar) = LIST_NEXT((var), field), 1);
	    (var) = (tvar))

macroLIST_INIT

#define LIST_INIT(head) do {
	LIST_FIRST((head)) = NULL;
} while (0)

macroLIST_INSERT_AFTER

#define LIST_INSERT_AFTER(listelm, elm, field) do {
	LIST_CHECK_NEXT(listelm, field);
	if ((LIST_NEXT((elm), field) = LIST_NEXT((listelm), field)) != NULL)
	        LIST_NEXT((listelm), field)->field.le_prev =
	            &LIST_NEXT((elm), field);
	LIST_NEXT((listelm), field) = (elm);
	(elm)->field.le_prev = &LIST_NEXT((listelm), field);
} while (0)

macroLIST_INSERT_BEFORE

#define LIST_INSERT_BEFORE(listelm, elm, field) do {
	LIST_CHECK_PREV(listelm, field);
	(elm)->field.le_prev = (listelm)->field.le_prev;
	LIST_NEXT((elm), field) = (listelm);
	*(listelm)->field.le_prev = (elm);
	(listelm)->field.le_prev = &LIST_NEXT((elm), field);
} while (0)

macroLIST_INSERT_HEAD

#define LIST_INSERT_HEAD(head, elm, field) do {
	LIST_CHECK_HEAD((head), field);
	if ((LIST_NEXT((elm), field) = LIST_FIRST((head))) != NULL)
	        LIST_FIRST((head))->field.le_prev = &LIST_NEXT((elm), field);
	LIST_FIRST((head)) = (elm);
	(elm)->field.le_prev = &LIST_FIRST((head));
} while (0)

macroLIST_NEXT

#define LIST_NEXT(elm, field) ((elm)->field.le_next)

macroLIST_REMOVE

#define LIST_REMOVE(elm, field) do {
	LIST_CHECK_NEXT(elm, field);
	LIST_CHECK_PREV(elm, field);
	if (LIST_NEXT((elm), field) != NULL)
	        LIST_NEXT((elm), field)->field.le_prev =
	            (elm)->field.le_prev;
	*(elm)->field.le_prev = LIST_NEXT((elm), field);
	TRASHIT((elm)->field.le_next);
	TRASHIT((elm)->field.le_prev);
} while (0)

macroLIST_SWAP

#define LIST_SWAP(head1, head2, type, field) __MISMATCH_TAGS_PUSH
__NULLABILITY_COMPLETENESS_PUSH
do {
	struct type *swap_tmp = LIST_FIRST((head1));
	LIST_FIRST((head1)) = LIST_FIRST((head2));
	LIST_FIRST((head2)) = swap_tmp;
	if ((swap_tmp = LIST_FIRST((head1))) != NULL)
	        swap_tmp->field.le_prev = &LIST_FIRST((head1));
	if ((swap_tmp = LIST_FIRST((head2))) != NULL)
	        swap_tmp->field.le_prev = &LIST_FIRST((head2));
} while (0)
__NULLABILITY_COMPLETENESS_POP
__MISMATCH_TAGS_POP

macroTAILQ_HEAD

Tail queue declarations.

#define TAILQ_HEAD(name, type) __MISMATCH_TAGS_PUSH
__NULLABILITY_COMPLETENESS_PUSH
struct name {
	struct type *tqh_first; /* first element */
	struct type **tqh_last; /* addr of last next element */
	TRACEBUF
}
__NULLABILITY_COMPLETENESS_POP
__MISMATCH_TAGS_POP

macroTAILQ_HEAD_INITIALIZER

#define TAILQ_HEAD_INITIALIZER(head) { NULL, &(head).tqh_first }

macroTAILQ_ENTRY

#define TAILQ_ENTRY(type) __MISMATCH_TAGS_PUSH
__NULLABILITY_COMPLETENESS_PUSH
struct {
	struct type *tqe_next;  /* next element */
	struct type **tqe_prev; /* address of previous next element */
	TRACEBUF
}
__NULLABILITY_COMPLETENESS_POP
__MISMATCH_TAGS_POP

macroTAILQ_CHECK_HEAD

Tail queue functions.

#define TAILQ_CHECK_HEAD(head, field)

macroTAILQ_CHECK_NEXT

#define TAILQ_CHECK_NEXT(elm, field)

macroTAILQ_CHECK_PREV

#define TAILQ_CHECK_PREV(elm, field)

macroTAILQ_CONCAT

#define TAILQ_CONCAT(head1, head2, field) do {
	if (!TAILQ_EMPTY(head2)) {
	        *(head1)->tqh_last = (head2)->tqh_first;
	        (head2)->tqh_first->field.tqe_prev = (head1)->tqh_last;
	        (head1)->tqh_last = (head2)->tqh_last;
	        TAILQ_INIT((head2));
	        QMD_TRACE_HEAD(head1);
	        QMD_TRACE_HEAD(head2);
	}
} while (0)

macroTAILQ_EMPTY

#define TAILQ_EMPTY(head) ((head)->tqh_first == NULL)

macroTAILQ_FIRST

#define TAILQ_FIRST(head) ((head)->tqh_first)

macroTAILQ_FOREACH

#define TAILQ_FOREACH(var, head, field) for ((var) = TAILQ_FIRST((head));
	    (var);
	    (var) = TAILQ_NEXT((var), field))

macroTAILQ_FOREACH_SAFE

#define TAILQ_FOREACH_SAFE(var, head, field, tvar) for ((var) = TAILQ_FIRST((head));
	    (var) && ((tvar) = TAILQ_NEXT((var), field), 1);
	    (var) = (tvar))

macroTAILQ_FOREACH_REVERSE

#define TAILQ_FOREACH_REVERSE(var, head, headname, field) for ((var) = TAILQ_LAST((head), headname);
	    (var);
	    (var) = TAILQ_PREV((var), headname, field))

macroTAILQ_FOREACH_REVERSE_SAFE

#define TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar) for ((var) = TAILQ_LAST((head), headname);
	    (var) && ((tvar) = TAILQ_PREV((var), headname, field), 1);
	    (var) = (tvar))

macroTAILQ_INIT

#define TAILQ_INIT(head) do {
	TAILQ_FIRST((head)) = NULL;
	(head)->tqh_last = &TAILQ_FIRST((head));
	QMD_TRACE_HEAD(head);
} while (0)

macroTAILQ_INSERT_AFTER

#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do {
	TAILQ_CHECK_NEXT(listelm, field);
	if ((TAILQ_NEXT((elm), field) = TAILQ_NEXT((listelm), field)) != NULL)
	        TAILQ_NEXT((elm), field)->field.tqe_prev =
	            &TAILQ_NEXT((elm), field);
	else {
	        (head)->tqh_last = &TAILQ_NEXT((elm), field);
	        QMD_TRACE_HEAD(head);
	}
	TAILQ_NEXT((listelm), field) = (elm);
	(elm)->field.tqe_prev = &TAILQ_NEXT((listelm), field);
	QMD_TRACE_ELEM(&(elm)->field);
	QMD_TRACE_ELEM(&listelm->field);
} while (0)

macroTAILQ_INSERT_BEFORE

#define TAILQ_INSERT_BEFORE(listelm, elm, field) do {
	TAILQ_CHECK_PREV(listelm, field);
	(elm)->field.tqe_prev = (listelm)->field.tqe_prev;
	TAILQ_NEXT((elm), field) = (listelm);
	*(listelm)->field.tqe_prev = (elm);
	(listelm)->field.tqe_prev = &TAILQ_NEXT((elm), field);
	QMD_TRACE_ELEM(&(elm)->field);
	QMD_TRACE_ELEM(&listelm->field);
} while (0)

macroTAILQ_INSERT_HEAD

#define TAILQ_INSERT_HEAD(head, elm, field) do {
	TAILQ_CHECK_HEAD(head, field);
	if ((TAILQ_NEXT((elm), field) = TAILQ_FIRST((head))) != NULL)
	        TAILQ_FIRST((head))->field.tqe_prev =
	            &TAILQ_NEXT((elm), field);
	else
	        (head)->tqh_last = &TAILQ_NEXT((elm), field);
	TAILQ_FIRST((head)) = (elm);
	(elm)->field.tqe_prev = &TAILQ_FIRST((head));
	QMD_TRACE_HEAD(head);
	QMD_TRACE_ELEM(&(elm)->field);
} while (0)

macroTAILQ_INSERT_TAIL

#define TAILQ_INSERT_TAIL(head, elm, field) do {
	TAILQ_NEXT((elm), field) = NULL;
	(elm)->field.tqe_prev = (head)->tqh_last;
	*(head)->tqh_last = (elm);
	(head)->tqh_last = &TAILQ_NEXT((elm), field);
	QMD_TRACE_HEAD(head);
	QMD_TRACE_ELEM(&(elm)->field);
} while (0)

macroTAILQ_LAST

#define TAILQ_LAST(head, headname) __MISMATCH_TAGS_PUSH
__NULLABILITY_COMPLETENESS_PUSH
	(*(((struct headname *)((head)->tqh_last))->tqh_last))
__NULLABILITY_COMPLETENESS_POP
__MISMATCH_TAGS_POP

macroTAILQ_NEXT

#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next)

macroTAILQ_PREV

#define TAILQ_PREV(elm, headname, field) __MISMATCH_TAGS_PUSH
__NULLABILITY_COMPLETENESS_PUSH
	(*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
__NULLABILITY_COMPLETENESS_POP
__MISMATCH_TAGS_POP

macroTAILQ_REMOVE

#define TAILQ_REMOVE(head, elm, field) do {
	TAILQ_CHECK_NEXT(elm, field);
	TAILQ_CHECK_PREV(elm, field);
	if ((TAILQ_NEXT((elm), field)) != NULL)
	        TAILQ_NEXT((elm), field)->field.tqe_prev =
	            (elm)->field.tqe_prev;
	else {
	        (head)->tqh_last = (elm)->field.tqe_prev;
	        QMD_TRACE_HEAD(head);
	}
	*(elm)->field.tqe_prev = TAILQ_NEXT((elm), field);
	TRASHIT((elm)->field.tqe_next);
	TRASHIT((elm)->field.tqe_prev);
	QMD_TRACE_ELEM(&(elm)->field);
} while (0)

macroTAILQ_SWAP

Why did they switch to spaces for this one macro?

#define TAILQ_SWAP(head1, head2, type, field) __MISMATCH_TAGS_PUSH
__NULLABILITY_COMPLETENESS_PUSH
do {
	struct type *swap_first = (head1)->tqh_first;
	struct type **swap_last = (head1)->tqh_last;
	(head1)->tqh_first = (head2)->tqh_first;
	(head1)->tqh_last = (head2)->tqh_last;
	(head2)->tqh_first = swap_first;
	(head2)->tqh_last = swap_last;
	if ((swap_first = (head1)->tqh_first) != NULL)
	        swap_first->field.tqe_prev = &(head1)->tqh_first;
	else
	        (head1)->tqh_last = &(head1)->tqh_first;
	if ((swap_first = (head2)->tqh_first) != NULL)
	        swap_first->field.tqe_prev = &(head2)->tqh_first;
	else
	        (head2)->tqh_last = &(head2)->tqh_first;
} while (0)
__NULLABILITY_COMPLETENESS_POP
__MISMATCH_TAGS_POP

macroCIRCLEQ_HEAD

Circular queue definitions.

#define CIRCLEQ_HEAD(name, type) __MISMATCH_TAGS_PUSH
__NULLABILITY_COMPLETENESS_PUSH
struct name {
	struct type *cqh_first;         /* first element */
	struct type *cqh_last;          /* last element */
}
__NULLABILITY_COMPLETENESS_POP
__MISMATCH_TAGS_POP

macroCIRCLEQ_ENTRY

#define CIRCLEQ_ENTRY(type) __MISMATCH_TAGS_PUSH
__NULLABILITY_COMPLETENESS_PUSH
struct {
	struct type *cqe_next;          /* next element */
	struct type *cqe_prev;          /* previous element */
}
__NULLABILITY_COMPLETENESS_POP
__MISMATCH_TAGS_POP

macroCIRCLEQ_CHECK_HEAD

Circular queue functions.

#define CIRCLEQ_CHECK_HEAD(head, field)

macroCIRCLEQ_CHECK_NEXT

#define CIRCLEQ_CHECK_NEXT(head, elm, field)

macroCIRCLEQ_CHECK_PREV

#define CIRCLEQ_CHECK_PREV(head, elm, field)

macroCIRCLEQ_EMPTY

#define CIRCLEQ_EMPTY(head) ((head)->cqh_first == (void *)(head))

macroCIRCLEQ_FIRST

#define CIRCLEQ_FIRST(head) ((head)->cqh_first)

macroCIRCLEQ_FOREACH

#define CIRCLEQ_FOREACH(var, head, field) for((var) = (head)->cqh_first;
	    (var) != (void *)(head);
	    (var) = (var)->field.cqe_next)

macroCIRCLEQ_INIT

#define CIRCLEQ_INIT(head) do {
	(head)->cqh_first = (void *)(head);
	(head)->cqh_last = (void *)(head);
} while (0)

macroCIRCLEQ_INSERT_AFTER

#define CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do {
	CIRCLEQ_CHECK_NEXT(head, listelm, field);
	(elm)->field.cqe_next = (listelm)->field.cqe_next;
	(elm)->field.cqe_prev = (listelm);
	if ((listelm)->field.cqe_next == (void *)(head))
	        (head)->cqh_last = (elm);
	else
	        (listelm)->field.cqe_next->field.cqe_prev = (elm);
	(listelm)->field.cqe_next = (elm);
} while (0)

macroCIRCLEQ_INSERT_BEFORE

#define CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do {
	CIRCLEQ_CHECK_PREV(head, listelm, field);
	(elm)->field.cqe_next = (listelm);
	(elm)->field.cqe_prev = (listelm)->field.cqe_prev;
	if ((listelm)->field.cqe_prev == (void *)(head))
	        (head)->cqh_first = (elm);
	else
	        (listelm)->field.cqe_prev->field.cqe_next = (elm);
	(listelm)->field.cqe_prev = (elm);
} while (0)

macroCIRCLEQ_INSERT_HEAD

#define CIRCLEQ_INSERT_HEAD(head, elm, field) do {
	CIRCLEQ_CHECK_HEAD(head, field);
	(elm)->field.cqe_next = (head)->cqh_first;
	(elm)->field.cqe_prev = (void *)(head);
	if ((head)->cqh_last == (void *)(head))
	        (head)->cqh_last = (elm);
	else
	        (head)->cqh_first->field.cqe_prev = (elm);
	(head)->cqh_first = (elm);
} while (0)

macroCIRCLEQ_INSERT_TAIL

#define CIRCLEQ_INSERT_TAIL(head, elm, field) do {
	(elm)->field.cqe_next = (void *)(head);
	(elm)->field.cqe_prev = (head)->cqh_last;
	if ((head)->cqh_first == (void *)(head))
	        (head)->cqh_first = (elm);
	else
	        (head)->cqh_last->field.cqe_next = (elm);
	(head)->cqh_last = (elm);
} while (0)

macroCIRCLEQ_LAST

#define CIRCLEQ_LAST(head) ((head)->cqh_last)

macroCIRCLEQ_NEXT

#define CIRCLEQ_NEXT(elm, field) ((elm)->field.cqe_next)

macroCIRCLEQ_PREV

#define CIRCLEQ_PREV(elm, field) ((elm)->field.cqe_prev)

macroCIRCLEQ_REMOVE

#define CIRCLEQ_REMOVE(head, elm, field) do {
	CIRCLEQ_CHECK_NEXT(head, elm, field);
	CIRCLEQ_CHECK_PREV(head, elm, field);
	if ((elm)->field.cqe_next == (void *)(head))
	        (head)->cqh_last = (elm)->field.cqe_prev;
	else
	        (elm)->field.cqe_next->field.cqe_prev =
	            (elm)->field.cqe_prev;
	if ((elm)->field.cqe_prev == (void *)(head))
	        (head)->cqh_first = (elm)->field.cqe_next;
	else
	        (elm)->field.cqe_prev->field.cqe_next =
	            (elm)->field.cqe_next;
} while (0)