Lines Matching refs:head
45 * added to the list after an existing element or at the head of the list.
46 * Elements being removed from the head of the list should use the explicit
53 * head of the list and the other to the tail of the list. The elements are
56 * to the list after an existing element, at the head of the list, or at the
57 * end of the list. Elements being removed from the head of the tail queue
67 * or after an existing element or at the head of the list. A list
70 * A tail queue is headed by a pair of pointers, one to the head of the
74 * after an existing element, at the head of the list, or at the end of
110 /* Store the last 2 places the queue element or head was altered */
123 #define QMD_TRACE_HEAD(head) do { \
124 (head)->trace.prevline = (head)->trace.lastline; \
125 (head)->trace.prevfile = (head)->trace.lastfile; \
126 (head)->trace.lastline = __LINE__; \
127 (head)->trace.lastfile = __FILE__; \
139 #define QMD_TRACE_HEAD(head)
154 #define SLIST_HEAD_INITIALIZER(head) \
165 #define SLIST_EMPTY(head) ((head)->slh_first == NULL)
167 #define SLIST_FIRST(head) ((head)->slh_first)
169 #define SLIST_FOREACH(var, head, field) \
170 for ((var) = SLIST_FIRST((head)); \
174 #define SLIST_FOREACH_FROM(var, head, field) \
175 for ((var) = ((var) ? (var) : SLIST_FIRST((head))); \
179 #define SLIST_FOREACH_SAFE(var, head, field, tvar) \
180 for ((var) = SLIST_FIRST((head)); \
184 #define SLIST_FOREACH_FROM_SAFE(var, head, field, tvar) \
185 for ((var) = ((var) ? (var) : SLIST_FIRST((head))); \
189 #define SLIST_FOREACH_PREVPTR(var, varp, head, field) \
190 for ((varp) = &SLIST_FIRST((head)); \
194 #define SLIST_INIT(head) do { \
195 SLIST_FIRST((head)) = NULL; \
203 #define SLIST_INSERT_HEAD(head, elm, field) do { \
204 SLIST_NEXT((elm), field) = SLIST_FIRST((head)); \
205 SLIST_FIRST((head)) = (elm); \
210 #define SLIST_REMOVE(head, elm, type, field) do { \
212 if (SLIST_FIRST((head)) == (elm)) { \
213 SLIST_REMOVE_HEAD((head), field); \
216 struct type *curelm = SLIST_FIRST((head)); \
229 #define SLIST_REMOVE_HEAD(head, field) do { \
230 SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field); \
248 #define STAILQ_HEAD_INITIALIZER(head) \
249 { NULL, &(head).stqh_first }
267 #define STAILQ_EMPTY(head) ((head)->stqh_first == NULL)
269 #define STAILQ_FIRST(head) ((head)->stqh_first)
271 #define STAILQ_FOREACH(var, head, field) \
272 for((var) = STAILQ_FIRST((head)); \
276 #define STAILQ_FOREACH_FROM(var, head, field) \
277 for ((var) = ((var) ? (var) : STAILQ_FIRST((head))); \
281 #define STAILQ_FOREACH_SAFE(var, head, field, tvar) \
282 for ((var) = STAILQ_FIRST((head)); \
286 #define STAILQ_FOREACH_FROM_SAFE(var, head, field, tvar) \
287 for ((var) = ((var) ? (var) : STAILQ_FIRST((head))); \
291 #define STAILQ_INIT(head) do { \
292 STAILQ_FIRST((head)) = NULL; \
293 (head)->stqh_last = &STAILQ_FIRST((head)); \
296 #define STAILQ_INSERT_AFTER(head, tqelm, elm, field) do { \
298 (head)->stqh_last = &STAILQ_NEXT((elm), field); \
302 #define STAILQ_INSERT_HEAD(head, elm, field) do { \
303 if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL) \
304 (head)->stqh_last = &STAILQ_NEXT((elm), field); \
305 STAILQ_FIRST((head)) = (elm); \
308 #define STAILQ_INSERT_TAIL(head, elm, field) do { \
310 *(head)->stqh_last = (elm); \
311 (head)->stqh_last = &STAILQ_NEXT((elm), field); \
314 #define STAILQ_LAST(head, type, field) \
315 (STAILQ_EMPTY((head)) ? NULL : \
316 __containerof((head)->stqh_last, struct type, field.stqe_next))
320 #define STAILQ_REMOVE(head, elm, type, field) do { \
322 if (STAILQ_FIRST((head)) == (elm)) { \
323 STAILQ_REMOVE_HEAD((head), field); \
326 struct type *curelm = STAILQ_FIRST((head)); \
329 STAILQ_REMOVE_AFTER(head, curelm, field); \
334 #define STAILQ_REMOVE_AFTER(head, elm, field) do { \
337 (head)->stqh_last = &STAILQ_NEXT((elm), field); \
340 #define STAILQ_REMOVE_HEAD(head, field) do { \
341 if ((STAILQ_FIRST((head)) = \
342 STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL) \
343 (head)->stqh_last = &STAILQ_FIRST((head)); \
368 #define LIST_HEAD_INITIALIZER(head) \
382 #define QMD_LIST_CHECK_HEAD(head, field) do { \
383 if (LIST_FIRST((head)) != NULL && \
384 LIST_FIRST((head))->field.le_prev != \
385 &LIST_FIRST((head))) \
386 panic("Bad list head %p first->prev != head", (head)); \
401 #define QMD_LIST_CHECK_HEAD(head, field)
406 #define LIST_EMPTY(head) ((head)->lh_first == NULL)
408 #define LIST_FIRST(head) ((head)->lh_first)
410 #define LIST_FOREACH(var, head, field) \
411 for ((var) = LIST_FIRST((head)); \
415 #define LIST_FOREACH_FROM(var, head, field) \
416 for ((var) = ((var) ? (var) : LIST_FIRST((head))); \
420 #define LIST_FOREACH_SAFE(var, head, field, tvar) \
421 for ((var) = LIST_FIRST((head)); \
425 #define LIST_FOREACH_FROM_SAFE(var, head, field, tvar) \
426 for ((var) = ((var) ? (var) : LIST_FIRST((head))); \
430 #define LIST_INIT(head) do { \
431 LIST_FIRST((head)) = NULL; \
451 #define LIST_INSERT_HEAD(head, elm, field) do { \
452 QMD_LIST_CHECK_HEAD((head), field); \
453 if ((LIST_NEXT((elm), field) = LIST_FIRST((head))) != NULL) \
454 LIST_FIRST((head))->field.le_prev = &LIST_NEXT((elm), field);\
455 LIST_FIRST((head)) = (elm); \
456 (elm)->field.le_prev = &LIST_FIRST((head)); \
461 #define LIST_PREV(elm, head, type, field) \
462 ((elm)->field.le_prev == &LIST_FIRST((head)) ? NULL : \
498 #define TAILQ_HEAD_INITIALIZER(head) \
499 { NULL, &(head).tqh_first, TRACEBUF_INITIALIZER }
512 #define QMD_TAILQ_CHECK_HEAD(head, field) do { \
513 if (!TAILQ_EMPTY(head) && \
514 TAILQ_FIRST((head))->field.tqe_prev != \
515 &TAILQ_FIRST((head))) \
516 panic("Bad tailq head %p first->prev != head", (head)); \
519 #define QMD_TAILQ_CHECK_TAIL(head, field) do { \
520 if (*(head)->tqh_last != NULL) \
521 panic("Bad tailq NEXT(%p->tqh_last) != NULL", (head)); \
536 #define QMD_TAILQ_CHECK_HEAD(head, field)
537 #define QMD_TAILQ_CHECK_TAIL(head, headname)
553 #define TAILQ_EMPTY(head) ((head)->tqh_first == NULL)
555 #define TAILQ_FIRST(head) ((head)->tqh_first)
557 #define TAILQ_FOREACH(var, head, field) \
558 for ((var) = TAILQ_FIRST((head)); \
562 #define TAILQ_FOREACH_FROM(var, head, field) \
563 for ((var) = ((var) ? (var) : TAILQ_FIRST((head))); \
567 #define TAILQ_FOREACH_SAFE(var, head, field, tvar) \
568 for ((var) = TAILQ_FIRST((head)); \
572 #define TAILQ_FOREACH_FROM_SAFE(var, head, field, tvar) \
573 for ((var) = ((var) ? (var) : TAILQ_FIRST((head))); \
577 #define TAILQ_FOREACH_REVERSE(var, head, headname, field) \
578 for ((var) = TAILQ_LAST((head), headname); \
582 #define TAILQ_FOREACH_REVERSE_FROM(var, head, headname, field) \
583 for ((var) = ((var) ? (var) : TAILQ_LAST((head), headname)); \
587 #define TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar) \
588 for ((var) = TAILQ_LAST((head), headname); \
592 #define TAILQ_FOREACH_REVERSE_FROM_SAFE(var, head, headname, field, tvar) \
593 for ((var) = ((var) ? (var) : TAILQ_LAST((head), headname)); \
597 #define TAILQ_INIT(head) do { \
598 TAILQ_FIRST((head)) = NULL; \
599 (head)->tqh_last = &TAILQ_FIRST((head)); \
600 QMD_TRACE_HEAD(head); \
603 #define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \
609 (head)->tqh_last = &TAILQ_NEXT((elm), field); \
610 QMD_TRACE_HEAD(head); \
628 #define TAILQ_INSERT_HEAD(head, elm, field) do { \
629 QMD_TAILQ_CHECK_HEAD(head, field); \
630 if ((TAILQ_NEXT((elm), field) = TAILQ_FIRST((head))) != NULL) \
631 TAILQ_FIRST((head))->field.tqe_prev = \
634 (head)->tqh_last = &TAILQ_NEXT((elm), field); \
635 TAILQ_FIRST((head)) = (elm); \
636 (elm)->field.tqe_prev = &TAILQ_FIRST((head)); \
637 QMD_TRACE_HEAD(head); \
641 #define TAILQ_INSERT_TAIL(head, elm, field) do { \
642 QMD_TAILQ_CHECK_TAIL(head, field); \
644 (elm)->field.tqe_prev = (head)->tqh_last; \
645 *(head)->tqh_last = (elm); \
646 (head)->tqh_last = &TAILQ_NEXT((elm), field); \
647 QMD_TRACE_HEAD(head); \
651 #define TAILQ_LAST(head, headname) \
652 (*(((struct headname *)((head)->tqh_last))->tqh_last))
659 #define TAILQ_REMOVE(head, elm, field) do { \
668 (head)->tqh_last = (elm)->field.tqe_prev; \
669 QMD_TRACE_HEAD(head); \