Lines Matching refs:head
110 #define QMD_TRACE_HEAD(head) do { \ argument
111 (head)->trace.prevline = (head)->trace.lastline; \
112 (head)->trace.prevfile = (head)->trace.lastfile; \
113 (head)->trace.lastline = __LINE__; \
114 (head)->trace.lastfile = __FILE__; \
128 #define QMD_TRACE_HEAD(head)
169 #define SLIST_HEAD_INITIALIZER(head) \ argument
185 #define SLIST_FIRST(head) ((head)->slh_first) argument
186 #define SLIST_END(head) NULL argument
188 #define SLIST_EMPTY(head) ((head)->slh_first == SLIST_END(head)) argument
190 #define SLIST_FOREACH(var, head, field) \ argument
191 for ((var) = SLIST_FIRST((head)); \
192 (var) != SLIST_END(head); \
195 #define SLIST_FOREACH_FROM(var, head, field) \ argument
196 for ((var) = ((var) != SLIST_END(head) ? (var) : SLIST_FIRST((head))); \
197 (var) != SLIST_END(head); \
200 #define SLIST_FOREACH_SAFE(var, head, field, tvar) \ argument
201 for ((var) = SLIST_FIRST((head)); \
202 (var) != SLIST_END(head) && \
206 #define SLIST_FOREACH_FROM_SAFE(var, head, field, tvar) \ argument
207 for ((var) = ((var) != SLIST_END(head) ? (var) : SLIST_FIRST((head))); \
208 (var) != SLIST_END(head) && \
215 #define SLIST_INIT(head) do { \ argument
216 (head)->slh_first = SLIST_END(head); \
241 #define SLIST_INSERT_HEAD(head, elm, field) do { \ argument
242 SLIST_NEXT((elm), field) = SLIST_FIRST((head)); \
243 SLIST_FIRST((head)) = (elm); \
247 #define SLIST_REMOVE_HEAD(head, field) do { \ argument
248 SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field); \
258 #define SLIST_REMOVE(head, elm, type, field) do { \ argument
260 if (SLIST_FIRST((head)) == (elm)) { \
261 SLIST_REMOVE_HEAD((head), field); \
264 QUEUE_TYPEOF(type) *curelm = SLIST_FIRST((head)); \
294 #define STAILQ_HEAD_INITIALIZER(head) \ argument
295 { NULL, &(head).stqh_first }
310 #define STAILQ_FIRST(head) ((head)->stqh_first) argument
311 #define STAILQ_END(head) NULL argument
313 #define STAILQ_EMPTY(head) ((head)->stqh_first == STAILQ_END(head)) argument
315 #define STAILQ_FOREACH(var, head, field) \ argument
316 for ((var) = STAILQ_FIRST(head); \
317 (var) != STAILQ_END(head); \
320 #define STAILQ_FOREACH_FROM(var, head, field) \ argument
322 ((var) != STAILQ_END(head) ? (var) : STAILQ_FIRST((head))); \
323 (var) != STAILQ_END(head); \
326 #define STAILQ_FOREACH_SAFE(var, head, field, tvar) \ argument
327 for ((var) = STAILQ_FIRST(head); \
328 (var) != STAILQ_END(head) && \
332 #define STAILQ_FOREACH_FROM_SAFE(var, head, field, tvar) \ argument
334 ((var) != STAILQ_END(head) ? (var) : STAILQ_FIRST((head))); \
335 (var) != STAILQ_END(head) && \
342 #define STAILQ_INIT(head) do { \ argument
343 STAILQ_FIRST(head) = STAILQ_END(head); \
344 (head)->stqh_last = &STAILQ_FIRST((head)); \
357 #define STAILQ_INSERT_AFTER(head, tqelm, elm, field) do { \ argument
359 (head)->stqh_last = &STAILQ_NEXT((elm), field); \
364 #define STAILQ_INSERT_HEAD(head, elm, field) do { \ argument
365 if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL) \
366 (head)->stqh_last = &STAILQ_NEXT((elm), field); \
367 STAILQ_FIRST((head)) = (elm); \
371 #define STAILQ_INSERT_TAIL(head, elm, field) do { \ argument
373 *(head)->stqh_last = (elm); \
374 (head)->stqh_last = &STAILQ_NEXT((elm), field); \
378 #define STAILQ_LAST(head, type, field) \ argument
379 (STAILQ_EMPTY((head)) ? NULL : \
380 __containerof((head)->stqh_last, \
383 #define STAILQ_REMOVE_HEAD(head, field) do { \ argument
384 if ((STAILQ_FIRST((head)) = \
385 STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL) \
386 (head)->stqh_last = &STAILQ_FIRST((head)); \
390 #define STAILQ_REMOVE_AFTER(head, elm, field) do { \ argument
393 (head)->stqh_last = &STAILQ_NEXT((elm), field); \
397 #define STAILQ_REMOVE(head, elm, type, field) do { \ argument
399 if (STAILQ_FIRST((head)) == (elm)) { \
400 STAILQ_REMOVE_HEAD((head), field); \
402 QUEUE_TYPEOF(type) *curelm = STAILQ_FIRST(head); \
405 STAILQ_REMOVE_AFTER(head, curelm, field); \
438 #define LIST_HEAD_INITIALIZER(head) \ argument
456 #define LIST_FIRST(head) ((head)->lh_first) argument
457 #define LIST_END(head) NULL argument
458 #define LIST_EMPTY(head) ((head)->lh_first == LIST_END(head)) argument
460 #define LIST_PREV(elm, head, type, field) \ argument
461 ((elm)->field.le_prev == &LIST_FIRST((head)) ? NULL : \
464 #define LIST_FOREACH(var, head, field) \ argument
465 for ((var) = LIST_FIRST((head)); \
466 (var) != LIST_END(head); \
469 #define LIST_FOREACH_FROM(var, head, field) \ argument
470 for ((var) = ((var) != LIST_END(head) ? (var) : LIST_FIRST((head));\
471 (var) != LIST_END(head); \
474 #define LIST_FOREACH_SAFE(var, head, field, tvar) \ argument
475 for ((var) = LIST_FIRST((head)); \
476 (var) != LIST_END(head) && \
480 #define LIST_FOREACH_FROM_SAFE(var, head, field, tvar) \ argument
481 for ((var) = ((var) != LIST_END(head) ? (var) : LIST_FIRST((head));\
482 (var) != LIST_END(head) && \
490 #define QUEUEDEBUG_LIST_INSERT_HEAD(head, elm, field) \ argument
491 if ((head)->lh_first && \
492 (head)->lh_first->field.le_prev != &(head)->lh_first) \
493 panic("LIST_INSERT_HEAD %p %s:%d", (head), __FILE__, __LINE__);
505 #define QUEUEDEBUG_LIST_INSERT_HEAD(head, elm, field) argument
510 #define LIST_INIT(head) do { \ argument
511 LIST_FIRST((head)) = LIST_END(head); \
534 #define LIST_INSERT_HEAD(head, elm, field) do { \ argument
535 QUEUEDEBUG_LIST_INSERT_HEAD((head), (elm), field) \
536 if ((LIST_NEXT((elm), field) = LIST_FIRST((head))) != NULL) \
537 LIST_FIRST((head))->field.le_prev = &LIST_NEXT((elm), field);\
538 LIST_FIRST((head)) = (elm); \
539 (elm)->field.le_prev = &LIST_FIRST((head)); \
579 #define SIMPLEQ_HEAD_INITIALIZER(head) \ argument
580 { NULL, &(head).sqh_first }
595 #define SIMPLEQ_FIRST(head) ((head)->sqh_first) argument
596 #define SIMPLEQ_END(head) NULL argument
597 #define SIMPLEQ_EMPTY(head) ((head)->sqh_first == SIMPLEQ_END(head)) argument
600 #define SIMPLEQ_FOREACH(var, head, field) \ argument
601 for ((var) = SIMPLEQ_FIRST((head)); \
602 (var) != SIMPLEQ_END(head); \
605 #define SIMPLEQ_FOREACH_FROM(var, head, field) \ argument
607 ((var) != SIMPLEQ_END(head) ? (var) : SIMPLEQ_FIRST((head)));\
608 (var) != SIMPLEQ_END(head); \
611 #define SIMPLEQ_FOREACH_SAFE(var, head, field, tvar) \ argument
612 for ((var) = SIMPLEQ_FIRST((head)); \
613 (var) != SIMPLEQ_END(head) && \
617 #define SIMPLEQ_FOREACH_FROM_SAFE(var, head, field, tvar) \ argument
619 ((var) != SIMPLEQ_END(head) ? (var) : SIMPLEQ_FIRST((head)));\
620 (var) != SIMPLEQ_END(head) && \
627 #define SIMPLEQ_INIT(head) do { \ argument
628 SIMPLEQ_FIRST((head)) = NULL; \
629 (head)->sqh_last = &SIMPLEQ_FIRST((head)); \
633 #define SIMPLEQ_INSERT_HEAD(head, elm, field) do { \ argument
634 if ((SIMPLEQ_NEXT((elm), field) = SIMPLEQ_FIRST((head))) == NULL)\
635 (head)->sqh_last = &SIMPLEQ_NEXT((elm), field); \
636 SIMPLEQ_FIRST((head)) = (elm); \
640 #define SIMPLEQ_INSERT_TAIL(head, elm, field) do { \ argument
642 *(head)->sqh_last = (elm); \
643 (head)->sqh_last = &SIMPLEQ_NEXT((elm), field); \
647 #define SIMPLEQ_INSERT_AFTER(head, listelm, elm, field) do { \ argument
650 (head)->sqh_last = &SIMPLEQ_NEXT((elm), field); \
655 #define SIMPLEQ_REMOVE_HEAD(head, field) do { \ argument
656 if ((SIMPLEQ_FIRST((head)) = \
657 SIMPLEQ_NEXT(SIMPLEQ_FIRST((head)), field)) == NULL) \
658 (head)->sqh_last = &SIMPLEQ_FIRST((head)); \
662 #define SIMPLEQ_REMOVE_AFTER(head, elm, field) do { \ argument
665 (head)->sqh_last = &SIMPLEQ_NEXT((elm), field); \
669 #define SIMPLEQ_REMOVE(head, elm, type, field) do { \ argument
670 if (SIMPLEQ_FIRST((head)) == (elm)) { \
671 SIMPLEQ_REMOVE_HEAD((head), field); \
673 QUEUE_TYPEOF(type) *curelm = SIMPLEQ_FIRST((head)); \
676 SIMPLEQ_REMOVE_AFTER((head), curelm, field); \
690 #define SIMPLEQ_LAST(head, type, field) \ argument
691 (SIMPLEQ_EMPTY((head)) ? \
694 ((char *)((head)->sqh_last) - offsetof(QUEUE_TYPEOF(type), field))))
713 #define TAILQ_HEAD_INITIALIZER(head) \ argument
714 { NULL, &(head).tqh_first }
733 #define TAILQ_FIRST(head) ((head)->tqh_first) argument
734 #define TAILQ_END(head) NULL argument
736 #define TAILQ_LAST(head, headname) \ argument
737 (*(((struct headname *)((head)->tqh_last))->tqh_last))
740 #define TAILQ_EMPTY(head) ((head)->tqh_first == TAILQ_END(head)) argument
743 #define TAILQ_FOREACH(var, head, field) \ argument
744 for ((var) = TAILQ_FIRST((head)); \
745 (var) != TAILQ_END(head); \
748 #define TAILQ_FOREACH_FROM(var, head, field) \ argument
749 for ((var) = ((var) != TAILQ_END((head)) ? \
750 (var) : TAILQ_FIRST((head))); \
751 (var) != TAILQ_END(head); \
754 #define TAILQ_FOREACH_SAFE(var, head, field, tvar) \ argument
755 for ((var) = TAILQ_FIRST((head)); \
756 (var) != TAILQ_END(head) && \
760 #define TAILQ_FOREACH_FROM_SAFE(var, head, field, tvar) \ argument
761 for ((var) = ((var) != TAILQ_END((head)) ? \
762 (var) : TAILQ_FIRST((head))); \
763 (var) != TAILQ_END(head) && \
767 #define TAILQ_FOREACH_REVERSE(var, head, headname, field) \ argument
768 for ((var) = TAILQ_LAST((head), headname); \
769 (var) != TAILQ_END(head); \
772 #define TAILQ_FOREACH_REVERSE_FROM(var, head, headname, field) \ argument
773 for ((var) = ((var) != TAILQ_END((head)) ? \
774 (var) : TAILQ_LAST((head), headname)); \
775 (var) != TAILQ_END(head); \
778 #define TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar) \ argument
779 for ((var) = TAILQ_LAST((head), headname); \
780 (var) != TAILQ_END(head) && \
784 #define TAILQ_FOREACH_REVERSE_FROM_SAFE(var, head, headname, field, tvar)\ argument
785 for ((var) = ((var) != TAILQ_END((head)) ? \
786 (var) : TAILQ_LAST((head), headname)); \
787 (var) != TAILQ_END(head) && \
795 #define QUEUEDEBUG_TAILQ_INSERT_HEAD(head, elm, field) \ argument
796 if ((head)->tqh_first && \
797 (head)->tqh_first->field.tqe_prev != &(head)->tqh_first) \
798 panic("TAILQ_INSERT_HEAD %p %s:%d", (void *)(head), \
800 #define QUEUEDEBUG_TAILQ_INSERT_TAIL(head, elm, field) \ argument
801 if (*(head)->tqh_last != NULL) \
802 panic("TAILQ_INSERT_TAIL %p %s:%d", (void *)(head), \
813 #define QUEUEDEBUG_TAILQ_PREREMOVE(head, elm, field) \ argument
815 (head)->tqh_last != &(elm)->field.tqe_next) \
817 (void *)(head), (void *)(elm), __FILE__, __LINE__);
822 #define QUEUEDEBUG_TAILQ_INSERT_HEAD(head, elm, field) argument
823 #define QUEUEDEBUG_TAILQ_INSERT_TAIL(head, elm, field) argument
825 #define QUEUEDEBUG_TAILQ_PREREMOVE(head, elm, field) argument
829 #define TAILQ_INIT(head) do { \ argument
830 TAILQ_FIRST((head)) = TAILQ_END((head)); \
831 (head)->tqh_last = &TAILQ_FIRST((head)); \
835 #define TAILQ_INSERT_HEAD(head, elm, field) do { \ argument
836 QUEUEDEBUG_TAILQ_INSERT_HEAD((head), (elm), field) \
837 if ((TAILQ_NEXT((elm), field) = TAILQ_FIRST((head))) != NULL) \
838 TAILQ_FIRST((head))->field.tqe_prev = \
841 (head)->tqh_last = &TAILQ_NEXT((elm), field); \
842 TAILQ_FIRST((head)) = (elm); \
843 (elm)->field.tqe_prev = &TAILQ_FIRST((head)); \
847 #define TAILQ_INSERT_TAIL(head, elm, field) do { \ argument
848 QUEUEDEBUG_TAILQ_INSERT_TAIL((head), (elm), field) \
850 (elm)->field.tqe_prev = (head)->tqh_last; \
851 *(head)->tqh_last = (elm); \
852 (head)->tqh_last = &TAILQ_NEXT((elm), field); \
856 #define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \ argument
862 (head)->tqh_last = &TAILQ_NEXT((elm), field); \
877 #define TAILQ_REMOVE(head, elm, field) do { \ argument
878 QUEUEDEBUG_TAILQ_PREREMOVE((head), (elm), field) \
884 (head)->tqh_last = (elm)->field.tqe_prev; \
919 #define CIRCLEQ_HEAD_INITIALIZER(head) \ argument
920 { (void *)&head, (void *)&head }
931 #define CIRCLEQ_EMPTY(head) ((head)->cqh_first == (void *)(head)) argument
932 #define CIRCLEQ_FIRST(head) ((head)->cqh_first) argument
933 #define CIRCLEQ_LAST(head) ((head)->cqh_last) argument
937 #define CIRCLEQ_LOOP_NEXT(head, elm, field) \ argument
938 (((elm)->field.cqe_next == (void *)(head)) \
939 ? ((head)->cqh_first) \
941 #define CIRCLEQ_LOOP_PREV(head, elm, field) \ argument
942 (((elm)->field.cqe_prev == (void *)(head)) \
943 ? ((head)->cqh_last) \
946 #define CIRCLEQ_FOREACH(var, head, field) \ argument
947 for ((var) = CIRCLEQ_FIRST((head)); \
948 (var) != (void *)(head); \
951 #define CIRCLEQ_FOREACH_REVERSE(var, head, field) \ argument
952 for ((var) = CIRCLEQ_LAST((head)); \
953 (var) != (void *)(head); \
959 #define CIRCLEQ_INIT(head) do { \ argument
960 (head)->cqh_first = (void *)(head); \
961 (head)->cqh_last = (void *)(head); \
965 #define CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do { \ argument
968 if ((listelm)->field.cqe_next == (void *)(head)) \
969 (head)->cqh_last = (elm); \
976 #define CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do { \ argument
979 if ((listelm)->field.cqe_prev == (void *)(head)) \
980 (head)->cqh_first = (elm); \
987 #define CIRCLEQ_INSERT_HEAD(head, elm, field) do { \ argument
988 (elm)->field.cqe_next = (head)->cqh_first; \
989 (elm)->field.cqe_prev = (void *)(head); \
990 if ((head)->cqh_last == (void *)(head)) \
991 (head)->cqh_last = (elm); \
993 (head)->cqh_first->field.cqe_prev = (elm); \
994 (head)->cqh_first = (elm); \
998 #define CIRCLEQ_INSERT_TAIL(head, elm, field) do { \ argument
999 (elm)->field.cqe_next = (void *)(head); \
1000 (elm)->field.cqe_prev = (head)->cqh_last; \
1001 if ((head)->cqh_first == (void *)(head)) \
1002 (head)->cqh_first = (elm); \
1004 (head)->cqh_last->field.cqe_next = (elm); \
1005 (head)->cqh_last = (elm); \
1009 #define CIRCLEQ_REMOVE(head, elm, field) do { \ argument
1010 if ((elm)->field.cqe_next == (void *)(head)) \
1011 (head)->cqh_last = (elm)->field.cqe_prev; \
1015 if ((elm)->field.cqe_prev == (void *)(head)) \
1016 (head)->cqh_first = (elm)->field.cqe_next; \