#ifndef QUEUEUTIL_H
#define QUEUEUTIL_H

#include <stdarg.h>
#include <stddef.h>

/*
 * Set HAVE_BSD_SYS_QUEUE_H to 0 if you have an incompatible
 * <sys/queue.h> implementation. This will fallback to using the API
 * only, which leads to some suboptimal algorithms.
 *
 * What "incompatible" means here is that the internal data structures
 * (heads and entries) differ from what is traditionally found in BSD
 * <sys/queue.h>. At least on all BSD flavors that I've worked with,
 * plus GNU/Linux, the implementation *is* compatible; I suspect that
 * all platforms that actually provide a <sys/queue.h> implementation
 * use the BSD one so this is 1 by default.
 */
#ifndef HAVE_BSD_SYS_QUEUE_H
#define HAVE_BSD_SYS_QUEUE_H 1
#endif


/*
 * Helper macros.
 */

#define QHELPER_EXTRA(a)
#define QHELPER_EXTRA(a) , a
#define QHELPER_EXTRA(c, a) QHELPER_EXTRA_##c(a)

#define QHELPER_EVAL(f, args) f args
#define QHELPER_EVAL_CMP(cmp, x, y, c, a)				    \
	QHELPER_EVAL(cmp, (x, y QHELPER_EXTRA(c, a)))


/*
 * End-of-list markers.
 */

#ifndef SLIST_END
#define SLIST_END(head) NULL
#endif

#ifndef LIST_END
#define LIST_END(head) NULL
#endif

#ifndef SIMPLEQ_END
#define SIMPLEQ_END(head) NULL
#endif

#ifndef STAILQ_END
#define STAILQ_END(head) NULL
#endif

#ifndef TAILQ_END
#define TAILQ_END(head) NULL
#endif

#ifndef CIRCLEQ_END
#define CIRCLEQ_END(head) ((void *)(head))
#endif


/*
 * Normalized 4-argument _INSERT_AFTER macros.
 */

#define SLIST_INSERT_AFTER_4(head, listelm, elm, field)			    \
	SLIST_INSERT_AFTER((listelm), (elm), field)

#define LIST_INSERT_AFTER_4(head, listelm, elm, field)			    \
	LIST_INSERT_AFTER((listelm), (elm), field)

#define SIMPLEQ_INSERT_AFTER_4(head, listelm, elm, field)		    \
	SIMPLEQ_INSERT_AFTER((head), (listelm), (elm), field)

#define STAILQ_INSERT_AFTER_4(head, listelm, elm, field)		    \
	STAILQ_INSERT_AFTER((head), (listelm), (elm), field)

#define TAILQ_INSERT_AFTER_4(head, listelm, elm, field)			    \
	TAILQ_INSERT_AFTER((head), (listelm), (elm), field)

#define CIRCLEQ_INSERT_AFTER_4(head, listelm, elm, field)		    \
	CIRCLEQ_INSERT_AFTER((head), (listelm), (elm), field)


/*
 * Missing _REMOVE_HEAD macros.
 *
 * These assume it is safe to call _FIRST inside a _REMOVE call.
 */

#define LIST_REMOVE_HEAD(head, field)					    \
	LIST_REMOVE(LIST_FIRST(head), field)

#define TAIlQ_REMOVE_HEAD(head, field)					    \
	TAIlQ_REMOVE((head), TAILQ_FIRST(head), field)

#define CIRCLEQ_REMOVE_HEAD(head, field)				    \
	CIRCLEQ_REMOVE((head), CIRCLEQ_FIRST(head), field)


/*
 * Concatenation.
 *
 * If HAVE_BSD_SYS_QUEUE_H is 0, the generic implementation is
 * used. It always traverses the second list entirely, which is very
 * inefficient.
 */

#if HAVE_BSD_SYS_QUEUE_H
#ifndef SIMPLEQ_CONCAT
#define SIMPLEQ_CONCAT(head1, head2) do {				    \
	if (!SIMPLEQ_EMPTY((head2))) {					    \
		*(head1)->sqh_last = (head2)->sqh_first;		    \
		(head1)->sqh_last = (head2)->sqh_last;			    \
		SIMPLEQ_INIT((head2));					    \
	}								    \
} while (/*CONSTCOND*/ 0)
#endif

#ifndef CIRCLEQ_CONCAT
#define CIRCLEQ_CONCAT(head1, head2, field) do {			    \
	if (!CIRCLEQ_EMPTY((head2))) {					    \
		if (CIRCLEQ_EMPTY(head1)) {				    \
			(head1)->cqh_first = (head2)->cqh_first;	    \
			(head1)->cqh_last = (head2)->cqh_last;		    \
		} else {						    \
			(head1)->cqh_last->field.cqe_next =		    \
			    (head2)->cqh_first;				    \
			(head1)->cqh_last = (head2)->cqh_last;		    \
		}							    \
		CIRCLEQ_INIT((head2));					    \
	}								    \
} while (/*CONSTCOND*/ 0)
#endif
#endif	/* HAVE_BSD_SYS_QUEUE_H */

#define QHELPER_APPEND_PROTOTYPE(ns, name, type, field, attr)		    \
attr void name##_APPEND(struct name *, struct name *);

#define QHELPER_APPEND_GENERATE(ns, name, type, field, attr)		    \
attr void								    \
name##_APPEND(struct name *_head1, struct name *_head2)			    \
{									    \
	struct type *_last, *_p;					    \
									    \
	_last = NULL;							    \
	if (!ns##_EMPTY(_head1)) {					    \
		ns##_FOREACH (_p, _head1, field)			    \
			_last = _p;					    \
	}								    \
									    \
	if (_last == NULL && !ns##_EMPTY(_head2)) {			    \
		_p = ns##_FIRST(_head2);				    \
		ns##_REMOVE_HEAD(_head2, field);			    \
		ns##_INSERT_HEAD(_head1, _last, _p, field);		    \
		_last = _p;						    \
	}								    \
	while (!ns##_EMPTY(_head2)) {					    \
		_p = ns##_FIRST(_head2);				    \
		ns##_REMOVE_HEAD(_head2, field);			    \
		ns##_INSERT_AFTER_4(_head1, _last, _p, field);		    \
		_last = _p;						    \
	}								    \
}

#define QHELPER_APPEND_GENERATE_WITH_TAIL(ns, name, type, field, attr)	    \
attr void								    \
name##_APPEND(struct name *_head1, struct name *_head2)			    \
{									    \
	struct type *_p;						    \
									    \
	while (!ns##_EMPTY(_head2)) {					    \
		_p = ns##_FIRST(_head2);				    \
		ns##_REMOVE_HEAD(_head2, field);			    \
		ns##_INSERT_TAIL(_head1, _p, field);			    \
	}								    \
}

#define QHELPER_APPEND(name, head1, head2)				    \
	name##_APPEND((head1), (head2))


/*
 * Reversing.
 */

#define QHELPER_REVERSE_PROTOTYPE(ns, name, type, field, attr)		    \
attr void name##_REVERSE(struct name *);

#define QHELPER_REVERSE_GENERATE(ns, name, type, field, attr)
attr void
name##_REVERSE(struct name *_head)
{
	struct type *_elm;

	_elm = name##_FIRST(_head);
	name##_INIT(_head);
	for (; _elm != name##_END(_head); _elm = name##_NEXT(_elm, field))
		name##_INSERT_HEAD(_head, _elm, field);
}

#define QHELPER_REVERSE(name, head)					    \
	name##_REVERSE(head)


/*
 * Counting.
 */

#define QHELPER_COUNT_PROTOTYPE(ns, name, type, field, attr)		    \
attr size_t name##_COUNT_RANGE(struct type *, struct type *);		    \
									    \
static __inline size_t							    \
name##_COUNT(struct name *_head)					    \
{									    \
	return name##_COUNT_RANGE(ns##_FIRST(_head), ns##_END(_head));	    \
}									    \
									    \
static __inline size_t							    \
name##_COUNT_HEAD(struct name *_head, struct type *_elm)		    \
{									    \
	return name##_COUNT_RANGE(ns##_FIRST(_head), _elm);		    \
}

#define QHELPER_COUNT_GENERATE(ns, name, type, field, attr)		    \
attr size_t								    \
name##_COUNT_RANGE(struct type *_elm, struct type *_end)		    \
{									    \
	size_t _n;							    \
									    \
	_n = 0;								    \
	while (_elm != _end) {						    \
		++_n;							    \
		_elm = ns##_NEXT(_elm, field);				    \
	}								    \
	return _n;							    \
}

#define QHELPER_NTH_PROTOTYPE(ns, name, type, field, attr)		    \
attr struct type *name##_NTH_RANGE(struct type *, size_t, struct type *);   \
									    \
static __inline size_t							    \
name##_NTH(struct name *_head, size_t _n)				    \
{									    \
	return name##_NTH_RANGE(ns##_FIRST(_head), ns##_END(_head));	    \
}

#define QHELPER_NTH_GENERATE(ns, name, type, field, attr)		    \
attr struct type *							    \
name##_NTH_RANGE(struct type *_elm, struct type *_end, size_t _n)	    \
{									    \
	while (_n-- > 0 && _elm != _end)				    \
		_elm = ns##_NEXT(_elm, field);				    \
	return _elm;							    \
}

#define QHELPER_COUNT_RANGE(name, elm, end)				    \
	name##_COUNT_RANGE((elm), (end))
#define QHELPER_COUNT_HEAD(name, elm)					    \
	name##_COUNT_HEAD((head), (elm))
#define QHELPER_COUNT(name, head)					    \
	name##_COUNT(head)

#define QHELPER_NTH_RANGE(name, elm, end, n)				    \
	name##_NTH_RANGE((elm), (end), (n))
#define QHELPER_NTH(name, head, n)					    \
	name##_NTH((head), (n))


/*
 * Linear search.
 */

#define QHELPER_FIND_PROTOTYPE(ns, name, type, field,			    \
    cmp, xa, xtype, attr)						    \
attr struct type *name##_FIND_RANGE(struct type *, struct type *,	    \
    struct type *							    \
    QHELPER_EXTRA(xa, xtype));						    \
									    \
static __inline struct type *						    \
name##_FIND_##cmp(struct name *_head, struct type *_elm)		    \
{									    \
	return name##_FIND_RANGE_##cmp(ns##_FIRST(_head), _elm,		    \
	    ns##_END(_head));						    \
}

#define QHELPER_FIND_GENERATE(ns, name, type, field,			    \
    cmp, xa, xtype, attr)						    \
attr struct type *							    \
name##_FIND_RANGE(struct type *_listelm, struct type *_elm,		    \
    struct type *_end							    \
    QHELPER_EXTRA(xa, xtype _arg))					    \
{									    \
	QHELPER_VA_LIST (va, _ap)					    \
									    \
	while (_listelm != _end) {					    \
		if (QHELPER_EVAL_CMP(cmp, _listelm, _elm, xa, _arg) == 0)   \
			return _listelm;				    \
		_listelm = ns##_NEXT(_listelm, field);			    \
	}								    \
	return NULL;							    \
}

#define QHELPER_MEMBER_PROTOTYPE(ns, name, type, field, attr)		    \
attr struct type *name##_MEMBER_RANGE(struct type *, struct type *,	    \
    struct type *);							    \
									    \
static __inline struct type *						    \
name##_MEMBER(struct name *_head, struct type *_elm)			    \
{									    \
	return name##_MEMBER_RANGE(ns##_FIRST(_head), _elm,		    \
	    ns##_END(_head));						    \
}

#define QHELPER_MEMBER_GENERATE(ns, name, type, field, attr)		    \
attr struct type *							    \
name##_MEMBER_RANGE(struct type *_listelm, struct type *_elm,		    \
    struct type *_end)							    \
{									    \
	while (_listelm != _end && _listelm != _elm)			    \
		_listelm = ns##_NEXT(_listelm, field);			    \
	return _listelm == _end ? NULL : _listelm;			    \
}

#define QHELPER_FIND_RANGE(name, head, elm, end, cmp)			    \
	name##_FIND_RANGE_##cmp(head, elm, end)
#define QHELPER_FIND(name, head, elm, end, cmp)				    \
	name##_FIND_##cmp(head, elm, end)

#define QHELPER_MEMBER_RANGE(name, head, elm, end)			    \
	name##_MEMBER_RANGE(head, elm, end)
#define QHELPER_MEMBER(name, head, elm, end)				    \
	name##_MEMBER(head, elm, end)


/*
 * Bottom-up non-recursive merge sort for linked lists.
 */

#define QHELPER_SORT_PROTOTYPE(ns, name, type, field,			    \
    cmp, xa, xtype, attr)						    \
attr void name##_SORT_##cmp(struct name *, struct type *, struct type *	    \
    QHELPER_EXTRA(xa, xtype));

#define QHELPER_SORT_GENERATE(ns, name, type, field,			    \
    cmp, xa, xtype, attr)						    \
attr void								    \
name##_SORT_##cmp(struct name *_head					    \
    QHELPER_EXTRA(xa, xtype _arg))					    \
{									    \
	struct int_item *_a, *_b, *_prev, *_start, *_tmp;		    \
	size_t _i, _k, _n, _na, _nb;					    \
									    \
	if (ns##_EMPTY(_head))						    \
		return;							    \
									    \
	_n = 0;								    \
	for (_k = 1; _n != 1; _k *= 2) {				    \
		_start = ns##_FIRST(_head);				    \
		ns##_INIT(_head);					    \
		_prev = NULL;						    \
		for (_n = 0; _start != NULL; ++_n) {			    \
			/* First half. */				    \
			_tmp = _a = _start;				    \
			for (_i = 0; _i < _k; ++_i) {			    \
				if (_tmp == NULL)			    \
					break;				    \
				_tmp = ns##_NEXT(_tmp, field);		    \
			}						    \
			_b = _tmp;					    \
			_na = _i;					    \
									    \
			/* Second half. */				    \
			_tmp = _b;					    \
			for (_i = 0; _i < _k; ++_i) {			    \
				if (_tmp == NULL)			    \
					break;				    \
				_tmp = ns##_NEXT(_tmp, field);		    \
			}						    \
			_start = _tmp;					    \
			_nb = _i;					    \
									    \
			/* Merge. */					    \
			if (_prev == NULL && (_na != 0 || _nb != 0)) {	    \
				if (_na != 0 &&				    \
				    (_nb == 0 ||			    \
					QHELPER_EVAL_CMP(cmp, _a, _b,	    \
					    xa, _arg) < 0)) {		    \
					_prev = _tmp = _a;		    \
					_a = ns##_NEXT(_a, field);	    \
					--_na;				    \
				} else {				    \
					_prev = _tmp = _b;		    \
					_b = ns##_NEXT(_b, field);	    \
					--_nb;				    \
				}					    \
				ns##_INSERT_HEAD(_head, _prev,		    \
				    _tmp, field);			    \
			}						    \
			while (_na != 0 || _nb != 0) {			    \
				if (_na != 0 &&				    \
				    (_nb == 0 ||			    \
					QHELPER_EVAL_CMP(cmp, _a, _b,	    \
					    xa, _arg) < 0)) {		    \
					_prev = _tmp = _a;		    \
					_a = ns##_NEXT(_a, field);	    \
					--_na;				    \
				} else {				    \
					_prev = _tmp = _b;		    \
					_b = ns##_NEXT(_b, field);	    \
					--_nb;				    \
				}					    \
				ns##_INSERT_AFTER_4(_head, _prev,	    \
				    _tmp, field);			    \
			}						    \
		}							    \
	}								    \
}

#define QHELPER_SORT(name, _head, cmp) name##_SORT_##cmp(_head)


/*
 * SLIST helpers.
 */

#define SLIST_APPEND_PROTOTYPE(name, type, field)			    \
	QHELPER_APPEND_PROTOTYPE(SLIST, name, type, field)
#define SLIST_APPEND_GENERATE(name, type, field)			    \
	QHELPER_APPEND_GENERATE(SLIST, name, type, field)
#define SLIST_APPEND QHELPER_APPEND

#define SLIST_REVERSE_PROTOTYPE(name, type, field)			    \
	QHELPER_REVERSE_PROTOTYPE(SLIST, name, type, field)
#define SLIST_REVERSE_GENERATE(name, type, field)			    \
	QHELPER_REVERSE_GENERATE(SLIST, name, type, field)
#define SLIST_REVERSE QHELPER_REVERSE

#define SLIST_COUNT_PROTOTYPE(name, type, field)			    \
	QHELPER_COUNT_PROTOTYPE(SLIST, name, type, field)
#define SLIST_COUNT_GENERATE(name, type, field)				    \
	QHELPER_COUNT_GENERATE(SLIST, name, type, field)
#define SLIST_COUNT_RANGE QHELPER_COUNT_RANGE
#define SLIST_COUNT_HEAD QHELPER_COUNT_HEAD
#define SLIST_COUNT QHELPER_COUNT

#define SLIST_NTH_PROTOTYPE(name, type, field)				    \
	QHELPER_NTH_PROTOTYPE(SLIST, name, type, field)
#define SLIST_NTH_GENERATE(name, type, field)				    \
	QHELPER_NTH_GENERATE(SLIST, name, type, field)
#define SLIST_NTH_RANGE QHELPER_NTH_RANGE
#define SLIST_NTH QHELPER_NTH

#define SLIST_FIND_PROTOTYPE(name, type, field, cmp)			    \
	QHELPER_FIND_PROTOTYPE(SLIST, name, type, field, cmp)
#define SLIST_FIND_GENERATE(name, type, field, cmp)			    \
	QHELPER_FIND_GENERATE(SLIST, name, type, field, cmp)
#define SLIST_FIND_RANGE QHELPER_FIND_RANGE
#define SLIST_FIND QHELPER_FIND

#define SLIST_MEMBER_PROTOTYPE(name, type, field, cmp)			    \
	QHELPER_MEMBER_PROTOTYPE(SLIST, name, type, field, cmp)
#define SLIST_MEMBER_GENERATE(name, type, field, cmp)			    \
	QHELPER_MEMBER_GENERATE(SLIST, name, type, field, cmp)
#define SLIST_MEMBER_RANGE QHELPER_MEMBER_RANGE
#define SLIST_MEMBER QHELPER_MEMBER

#define SLIST_SORT_PROTOTYPE(name, type, field, cmp)			    \
	QHELPER_SORT_PROTOTYPE(SLIST, name, type, field, cmp)
#define SLIST_SORT_GENERATE(name, type, field, cmp)			    \
	QHELPER_SORT_GENERATE(SLIST, name, type, field, cmp)
#define SLIST_SORT QHELPER_SORT


/*
 * LIST helpers.
 */

#define LIST_APPEND_PROTOTYPE(name, type, field)			    \
	QHELPER_APPEND_PROTOTYPE(LIST, name, type, field)
#define LIST_APPEND_GENERATE(name, type, field)				    \
	QHELPER_APPEND_GENERATE(LIST, name, type, field)
#define LIST_APPEND QHELPER_APPEND

#define LIST_REVERSE_PROTOTYPE(name, type, field)			    \
	QHELPER_REVERSE_PROTOTYPE(LIST, name, type, field)
#define LIST_REVERSE_GENERATE(name, type, field)			    \
	QHELPER_REVERSE_GENERATE(LIST, name, type, field)
#define LIST_REVERSE QHELPER_REVERSE

#define LIST_COUNT_PROTOTYPE(name, type, field)			    \
	QHELPER_COUNT_PROTOTYPE(LIST, name, type, field)
#define LIST_COUNT_GENERATE(name, type, field)				    \
	QHELPER_COUNT_GENERATE(LIST, name, type, field)
#define LIST_COUNT_RANGE QHELPER_COUNT_RANGE
#define LIST_COUNT_HEAD QHELPER_COUNT_HEAD
#define LIST_COUNT QHELPER_COUNT

#define LIST_NTH_PROTOTYPE(name, type, field)				    \
	QHELPER_NTH_PROTOTYPE(LIST, name, type, field)
#define LIST_NTH_GENERATE(name, type, field)				    \
	QHELPER_NTH_GENERATE(LIST, name, type, field)
#define LIST_NTH_RANGE QHELPER_NTH_RANGE
#define LIST_NTH QHELPER_NTH

#define LIST_FIND_PROTOTYPE(name, type, field, cmp)			    \
	QHELPER_FIND_PROTOTYPE(LIST, name, type, field, cmp)
#define LIST_FIND_GENERATE(name, type, field, cmp)			    \
	QHELPER_FIND_GENERATE(LIST, name, type, field, cmp)
#define LIST_FIND_RANGE QHELPER_FIND_RANGE
#define LIST_FIND QHELPER_FIND

#define LIST_MEMBER_PROTOTYPE(name, type, field)			    \
	QHELPER_MEMBER_PROTOTYPE(LIST, name, type, field)
#define LIST_MEMBER_GENERATE(name, type, field)				    \
	QHELPER_MEMBER_GENERATE(LIST, name, type, field)
#define LIST_MEMBER_RANGE QHELPER_MEMBER_RANGE
#define LIST_MEMBER QHELPER_MEMBER

#define LIST_SORT_PROTOTYPE(name, type, field, cmp)			    \
	QHELPER_SORT_PROTOTYPE(LIST, name, type, field, cmp)
#define LIST_SORT_GENERATE(name, type, field, cmp)			    \
	QHELPER_SORT_GENERATE(LIST, name, type, field, cmp)
#define LIST_SORT QHELPER_SORT


/*
 * SIMPLEQ helpers.
 */

#define SIMPLEQ_APPEND_PROTOTYPE(name, type, field)			    \
	QHELPER_APPEND_PROTOTYPE(SIMPLEQ, name, type, field)
#define SIMPLEQ_APPEND QHELPER_APPEND

#ifdef SIMPLEQ_CONCAT
#define SIMPLEQ_APPEND_GENERATE(name, type, field)			    \
void									    \
name##_APPEND(struct name *_head1, struct name *_head2)			    \
{									    \
	SIMPLEQ_CONCAT(_head1, _head2);					    \
}
#else
#define SIMPLEQ_CONCAT_GENERATE(name, type, field)			    \
	QHELPER_APPEND_WITH_TAIL_GENERATE(SIMPLEQ, name, type, field)
#endif

#define CIRCLEQ_APPEND_PROTOTYPE(name, type, field)			    \
	QHELPER_APPEND_PROTOTYPE(CIRCLEQ, name, type, field)
#define CIRCLEQ_APPEND QHELPER_APPEND

#ifdef CIRCLEQ_CONCAT
#define CIRCLEQ_APPEND_GENERATE(name, type, field)			    \
void									    \
name##_APPEND(struct name *_head1, struct name *_head2)			    \
{									    \
	CIRCLEQ_CONCAT(_head1, _head2, field);				    \
}
#else
#define CIRCLEQ_CONCAT_GENERATE(name, type, field)			    \
	QHELPER_APPEND_WITH_TAIL_GENERATE(CIRCLEQ, name, type, field)
#endif

#define LIST_COUNT_PROTOTYPE(name, type, field)				    \
	QHELPER_COUNT_PROTOTYPE(LIST, name, type, field)
#define LIST_COUNT_GENERATE(name, type, field)				    \
	QHELPER_COUNT_GENERATE(LIST, name, type, field)
#define LIST_COUNT_RANGE QHELPER_COUNT_RANGE
#define LIST_COUNT_HEAD QHELPER_COUNT_HEAD
#define LIST_COUNT QHELPER_COUNT

#define SIMPLEQ_COUNT_PROTOTYPE(name, type, field)			    \
	QHELPER_COUNT_PROTOTYPE(SIMPLEQ, name, type, field)
#define SIMPLEQ_COUNT_GENERATE(name, type, field)			    \
	QHELPER_COUNT_GENERATE(SIMPLEQ, name, type, field)
#define SIMPLEQ_COUNT_RANGE QHELPER_COUNT_RANGE
#define SIMPLEQ_COUNT_HEAD QHELPER_COUNT_HEAD
#define SIMPLEQ_COUNT QHELPER_COUNT

#define STAILQ_COUNT_PROTOTYPE(name, type, field)			    \
	QHELPER_COUNT_PROTOTYPE(STAILQ, name, type, field)
#define STAILQ_COUNT_GENERATE(name, type, field)			    \
	QHELPER_COUNT_GENERATE(STAILQ, name, type, field)
#define STAILQ_COUNT_RANGE QHELPER_COUNT_RANGE
#define STAILQ_COUNT_HEAD QHELPER_COUNT_HEAD
#define STAILQ_COUNT QHELPER_COUNT

#define TAILQ_COUNT_PROTOTYPE(name, PORT, field)			    \
	QHELPER_COUNT_GENERATE(TAILQ, name, type, field)
#define TAILQ_COUNT_GENERATE(name, type, field)				    \
	QHELPER_COUNT_GENERATE(TAILQ, name, type, field)
#define TAILQ_COUNT_RANGE QHELPER_COUNT_RANGE
#define TAILQ_COUNT_HEAD QHELPER_COUNT_HEAD
#define TAILQ_COUNT QHELPER_COUNT

#define CIRCLEQ_COUNT_PROTOTYPE(name, type, field)			    \
	QHELPER_COUNT_PROTOTYPE(CIRCLEQ, name, type, field)
#define CIRCLEQ_COUNT_GENERATE(name, type, field)			    \
	QHELPER_COUNT_GENERATE(CIRCLEQ, name, type, field)
#define CIRCLEQ_COUNT_RANGE QHELPER_COUNT_RANGE
#define CIRCLEQ_COUNT_HEAD QHELPER_COUNT_HEAD
#define CIRCLEQ_COUNT QHELPER_COUNT

#define SIMPLEQ_NTH_PROTOTYPE(name, type, field)			    \
	QHELPER_NTH_PROTOTYPE(SIMPLEQ, name, type, field)
#define SIMPLEQ_NTH_GENERATE(name, type, field)				    \
	QHELPER_NTH_GENERATE(SIMPLEQ, name, type, field)
#define SIMPLEQ_NTH_RANGE QHELPER_NTH_RANGE
#define SIMPLEQ_NTH QHELPER_NTH

#define STAILQ_NTH_PROTOTYPE(name, type, field)				    \
	QHELPER_NTH_PROTOTYPE(STAILQ, name, type, field)
#define STAILQ_NTH_GENERATE(name, type, field)				    \
	QHELPER_NTH_GENERATE(STAILQ, name, type, field)
#define STAILQ_NTH_RANGE QHELPER_NTH_RANGE
#define STAILQ_NTH QHELPER_NTH

#define TAILQ_NTH_PROTOTYPE(name, PORT, field)				    \
	QHELPER_NTH_GENERATE(TAILQ, name, type, field)
#define TAILQ_NTH_GENERATE(name, type, field)				    \
	QHELPER_NTH_GENERATE(TAILQ, name, type, field)
#define TAILQ_NTH_RANGE QHELPER_NTH_RANGE
#define TAILQ_NTH QHELPER_NTH

#define CIRCLEQ_NTH_PROTOTYPE(name, type, field)			    \
	QHELPER_NTH_PROTOTYPE(CIRCLEQ, name, type, field)
#define CIRCLEQ_NTH_GENERATE(name, type, field)				    \
	QHELPER_NTH_GENERATE(CIRCLEQ, name, type, field)
#define CIRCLEQ_NTH_RANGE QHELPER_NTH_RANGE
#define CIRCLEQ_NTH QHELPER_NTH

#define SIMPLEQ_FIND_PROTOTYPE(name, type, field, cmp)			    \
	QHELPER_FIND_PROTOTYPE(SIMPLEQ, name, type, field, cmp)
#define SIMPLEQ_FIND_GENERATE(name, type, field, cmp)			    \
	QHELPER_FIND_GENERATE(SIMPLEQ, name, type, field, cmp)
#define SIMPLEQ_FIND_RANGE QHELPER_FIND_RANGE
#define SIMPLEQ_FIND QHELPER_FIND
#define SIMPLEQ_MEMBER_RANGE QHELPER_MEMBER_RANGE
#define SIMPLEQ_MEMBER QHELPER_MEMBER

#define STAILQ_FIND_PROTOTYPE(name, type, field, cmp)			    \
	QHELPER_FIND_PROTOTYPE(STAILQ, name, type, field, cmp)
#define STAILQ_FIND_GENERATE(name, type, field, cmp)			    \
	QHELPER_FIND_GENERATE(STAILQ, name, type, field, cmp)
#define STAILQ_FIND_RANGE QHELPER_FIND_RANGE
#define STAILQ_FIND QHELPER_FIND
#define STAILQ_MEMBER_RANGE QHELPER_MEMBER_RANGE
#define STAILQ_MEMBER QHELPER_MEMBER

#define TAILQ_FIND_PROTOTYPE(name, PORT, field, cmp)			    \
	QHELPER_FIND_GENERATE(TAILQ, name, type, field, cmp)
#define TAILQ_FIND_GENERATE(name, type, field, cmp)			    \
	QHELPER_FIND_GENERATE(TAILQ, name, type, field, cmp)
#define TAILQ_FIND_RANGE QHELPER_FIND_RANGE
#define TAILQ_FIND QHELPER_FIND
#define TAILQ_MEMBER_RANGE QHELPER_MEMBER_RANGE
#define TAILQ_MEMBER QHELPER_MEMBER

#define CIRCLEQ_FIND_PROTOTYPE(name, type, field, cmp)			    \
	QHELPER_FIND_PROTOTYPE(CIRCLEQ, name, type, field, cmp)
#define CIRCLEQ_FIND_GENERATE(name, type, field, cmp)			    \
	QHELPER_FIND_GENERATE(CIRCLEQ, name, type, field, cmp)
#define CIRCLEQ_FIND_RANGE QHELPER_FIND_RANGE
#define CIRCLEQ_FIND QHELPER_FIND
#define CIRCLEQ_MEMBER_RANGE QHELPER_MEMBER_RANGE
#define CIRCLEQ_MEMBER QHELPER_MEMBER

#define SIMPLEQ_SORT_PROTOTYPE(name, type, field, cmp)			    \
	QHELPER_SORT_PROTOTYPE(SIMPLEQ, name, type, field, cmp)
#define SIMPLEQ_SORT_GENERATE(name, type, field, cmp)			    \
	QHELPER_SORT_GENERATE(SIMPLEQ, name, type, field, cmp)
#define SIMPLEQ_SORT QHELPER_SORT

#define STAILQ_SORT_PROTOTYPE(name, type, field, cmp)			    \
	QHELPER_SORT_PROTOTYPE(STAILQ, name, type, field, cmp)
#define STAILQ_SORT_GENERATE(name, type, field, cmp)			    \
	QHELPER_SORT_GENERATE(STAILQ, name, type, field, cmp)
#define STAILQ_SORT QHELPER_SORT

#define TAILQ_SORT_PROTOTYPE(name, PORT, field, cmp)			    \
	QHELPER_SORT_GENERATE(TAILQ, name, type, field, cmp)
#define TAILQ_SORT_GENERATE(name, type, field, cmp)			    \
	QHELPER_SORT_GENERATE(TAILQ, name, type, field, cmp)
#define TAILQ_SORT QHELPER_SORT

#define CIRCLEQ_SORT_PROTOTYPE(name, type, field, cmp)			    \
	QHELPER_SORT_PROTOTYPE(CIRCLEQ, name, type, field, cmp)
#define CIRCLEQ_SORT_GENERATE(name, type, field, cmp)			    \
	QHELPER_SORT_GENERATE(CIRCLEQ, name, type, field, cmp)
#define CIRCLEQ_SORT QHELPER_SORT

#endif	/* !QUEUEUTIL_H */