ext/libelf/elf_queue.h

43  * added to the list after an existing element or at the head of the list.
44  * Elements being removed from the head of the list should use the explicit
51  * head of the list and the other to the tail of the list. The elements are
54  * to the list after an existing element, at the head of the list, or at the
55  * end of the list. Elements being removed from the head of the tail queue
65  * or after an existing element or at the head of the list. A list
68  * A tail queue is headed by a pair of pointers, one to the head of the
72  * after an existing element, at the head of the list, or at the end of
102 /* Store the last 2 places the queue element or head was altered */
113 #define	QMD_TRACE_HEAD(head) do {					\
114         (head)->trace.prevline = (head)->trace.lastline;		\
115         (head)->trace.prevfile = (head)->trace.lastfile;		\
116         (head)->trace.lastline = __LINE__;				\
117         (head)->trace.lastfile = __FILE__;				\
129 #define	QMD_TRACE_HEAD(head)
142 #define	SLIST_HEAD_INITIALIZER(head)					\
153 #define	SLIST_EMPTY(head)	((head)->slh_first == NULL)
155 #define	SLIST_FIRST(head)	((head)->slh_first)
157 #define	SLIST_FOREACH(var, head, field)					\
158         for ((var) = SLIST_FIRST((head));				\
162 #define	SLIST_FOREACH_SAFE(var, head, field, tvar)			\
163         for ((var) = SLIST_FIRST((head));				\
167 #define	SLIST_FOREACH_PREVPTR(var, varp, head, field)			\
168         for ((varp) = &SLIST_FIRST((head));				\
172 #define	SLIST_INIT(head) do {						\
173         SLIST_FIRST((head)) = NULL;					\
181 #define	SLIST_INSERT_HEAD(head, elm, field) do {			\
182         SLIST_NEXT((elm), field) = SLIST_FIRST((head));			\
183         SLIST_FIRST((head)) = (elm);					\
188 #define	SLIST_REMOVE(head, elm, type, field) do {			\
189         if (SLIST_FIRST((head)) == (elm)) {				\
190                 SLIST_REMOVE_HEAD((head), field);			\
193                 struct type *curelm = SLIST_FIRST((head));		\
202 #define	SLIST_REMOVE_HEAD(head, field) do {				\
203         SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field);	\
215 #define	STAILQ_HEAD_INITIALIZER(head)					\
216         { NULL, &(head).stqh_first }
234 #define	STAILQ_EMPTY(head)	((head)->stqh_first == NULL)
236 #define	STAILQ_FIRST(head)	((head)->stqh_first)
238 #define	STAILQ_FOREACH(var, head, field)				\
239         for((var) = STAILQ_FIRST((head));				\
244 #define	STAILQ_FOREACH_SAFE(var, head, field, tvar)			\
245         for ((var) = STAILQ_FIRST((head));				\
249 #define	STAILQ_INIT(head) do {						\
250         STAILQ_FIRST((head)) = NULL;					\
251         (head)->stqh_last = &STAILQ_FIRST((head));			\
254 #define	STAILQ_INSERT_AFTER(head, tqelm, elm, field) do {		\
256                 (head)->stqh_last = &STAILQ_NEXT((elm), field);		\
260 #define	STAILQ_INSERT_HEAD(head, elm, field) do {			\
261         if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL)	\
262                 (head)->stqh_last = &STAILQ_NEXT((elm), field);		\
263         STAILQ_FIRST((head)) = (elm);					\
266 #define	STAILQ_INSERT_TAIL(head, elm, field) do {			\
268         *(head)->stqh_last = (elm);					\
269         (head)->stqh_last = &STAILQ_NEXT((elm), field);			\
272 #define	STAILQ_LAST(head, type, field)					\
273         (STAILQ_EMPTY((head)) ?						\
276                 ((char *)((head)->stqh_last) - offsetof(struct type, field))))
280 #define	STAILQ_REMOVE(head, elm, type, field) do {			\
281         if (STAILQ_FIRST((head)) == (elm)) {				\
282                 STAILQ_REMOVE_HEAD((head), field);			\
285                 struct type *curelm = STAILQ_FIRST((head));		\
290                         (head)->stqh_last = &STAILQ_NEXT((curelm), field);\
295 #define	STAILQ_REMOVE_HEAD(head, field) do {				\
296         if ((STAILQ_FIRST((head)) =					\
297              STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL)		\
298                 (head)->stqh_last = &STAILQ_FIRST((head));		\
309 #define	LIST_HEAD_INITIALIZER(head)					\
323 #define	QMD_LIST_CHECK_HEAD(head, field) do {				\
324         if (LIST_FIRST((head)) != NULL &&				\
325             LIST_FIRST((head))->field.le_prev !=			\
326              &LIST_FIRST((head)))					\
327                 panic("Bad list head %p first->prev != head", (head));	\
342 #define	QMD_LIST_CHECK_HEAD(head, field)
347 #define	LIST_EMPTY(head)	((head)->lh_first == NULL)
349 #define	LIST_FIRST(head)	((head)->lh_first)
351 #define	LIST_FOREACH(var, head, field)					\
352         for ((var) = LIST_FIRST((head));				\
356 #define	LIST_FOREACH_SAFE(var, head, field, tvar)			\
357         for ((var) = LIST_FIRST((head));				\
361 #define	LIST_INIT(head) do {						\
362         LIST_FIRST((head)) = NULL;					\
382 #define	LIST_INSERT_HEAD(head, elm, field) do {				\
383         QMD_LIST_CHECK_HEAD((head), field);				\
384         if ((LIST_NEXT((elm), field) = LIST_FIRST((head))) != NULL)	\
385                 LIST_FIRST((head))->field.le_prev = &LIST_NEXT((elm), field);\
386         LIST_FIRST((head)) = (elm);					\
387         (elm)->field.le_prev = &LIST_FIRST((head));			\
413 #define	TAILQ_HEAD_INITIALIZER(head)					\
414         { NULL, &(head).tqh_first }
427 #define	QMD_TAILQ_CHECK_HEAD(head, field) do {				\
428         if (!TAILQ_EMPTY(head) &&					\
429             TAILQ_FIRST((head))->field.tqe_prev !=			\
430              &TAILQ_FIRST((head)))					\
431                 panic("Bad tailq head %p first->prev != head", (head));	\
434 #define	QMD_TAILQ_CHECK_TAIL(head, field) do {				\
435         if (*(head)->tqh_last != NULL)					\
436                 panic("Bad tailq NEXT(%p->tqh_last) != NULL", (head)); 	\
451 #define	QMD_TAILQ_CHECK_HEAD(head, field)
452 #define	QMD_TAILQ_CHECK_TAIL(head, headname)
468 #define	TAILQ_EMPTY(head)	((head)->tqh_first == NULL)
470 #define	TAILQ_FIRST(head)	((head)->tqh_first)
472 #define	TAILQ_FOREACH(var, head, field)					\
473         for ((var) = TAILQ_FIRST((head));				\
477 #define	TAILQ_FOREACH_SAFE(var, head, field, tvar)			\
478         for ((var) = TAILQ_FIRST((head));				\
482 #define	TAILQ_FOREACH_REVERSE(var, head, headname, field)		\
483         for ((var) = TAILQ_LAST((head), headname);			\
487 #define	TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar)	\
488         for ((var) = TAILQ_LAST((head), headname);			\
492 #define	TAILQ_INIT(head) do {						\
493         TAILQ_FIRST((head)) = NULL;					\
494         (head)->tqh_last = &TAILQ_FIRST((head));			\
495         QMD_TRACE_HEAD(head);						\
498 #define	TAILQ_INSERT_AFTER(head, listelm, elm, field) do {		\
504                 (head)->tqh_last = &TAILQ_NEXT((elm), field);		\
505                 QMD_TRACE_HEAD(head);					\
523 #define	TAILQ_INSERT_HEAD(head, elm, field) do {			\
524         QMD_TAILQ_CHECK_HEAD(head, field);				\
525         if ((TAILQ_NEXT((elm), field) = TAILQ_FIRST((head))) != NULL)	\
526                 TAILQ_FIRST((head))->field.tqe_prev =			\
529                 (head)->tqh_last = &TAILQ_NEXT((elm), field);		\
530         TAILQ_FIRST((head)) = (elm);					\
531         (elm)->field.tqe_prev = &TAILQ_FIRST((head));			\
532         QMD_TRACE_HEAD(head);						\
536 #define	TAILQ_INSERT_TAIL(head, elm, field) do {			\
537         QMD_TAILQ_CHECK_TAIL(head, field);				\
539         (elm)->field.tqe_prev = (head)->tqh_last;			\
540         *(head)->tqh_last = (elm);					\
541         (head)->tqh_last = &TAILQ_NEXT((elm), field);			\
542         QMD_TRACE_HEAD(head);						\
546 #define	TAILQ_LAST(head, headname)					\
547         (*(((struct headname *)((head)->tqh_last))->tqh_last))
554 #define	TAILQ_REMOVE(head, elm, field) do {				\
561                 (head)->tqh_last = (elm)->field.tqe_prev;		\
562                 QMD_TRACE_HEAD(head);					\
589                  *head = (struct quehead *)b;
591         element->qh_link = head->qh_link;
592         element->qh_rlink = head;
593         head->qh_link = element;