Go to the documentation of this file.
85#ifdef QUEUE_MACRO_DEBUG
86#define _Q_INVALIDATE(a) (a) = ((void *)-1)
88#define _Q_INVALIDATE(a)
94#define SLIST_HEAD(name, type) \
96 struct type *slh_first; \
99#define SLIST_HEAD_INITIALIZER(head) \
106#define SLIST_ENTRY(type) \
108 struct type *sle_next; \
114#define SLIST_FIRST(head) ((head)->slh_first)
115#define SLIST_END(head) NULL
116#define SLIST_EMPTY(head) (SLIST_FIRST(head) == SLIST_END(head))
117#define SLIST_NEXT(elm, field) ((elm)->field.sle_next)
119#define SLIST_FOREACH(var, head, field) \
120 for((var) = SLIST_FIRST(head); \
121 (var) != SLIST_END(head); \
122 (var) = SLIST_NEXT(var, field))
124#define SLIST_FOREACH_PREVPTR(var, varp, head, field) \
125 for ((varp) = &SLIST_FIRST((head)); \
126 ((var) = *(varp)) != SLIST_END(head); \
127 (varp) = &SLIST_NEXT((var), field))
132#define SLIST_INIT(head) { \
133 SLIST_FIRST(head) = SLIST_END(head); \
136#define SLIST_INSERT_AFTER(slistelm, elm, field) do { \
137 (elm)->field.sle_next = (slistelm)->field.sle_next; \
138 (slistelm)->field.sle_next = (elm); \
141#define SLIST_INSERT_HEAD(head, elm, field) do { \
142 (elm)->field.sle_next = (head)->slh_first; \
143 (head)->slh_first = (elm); \
146#define SLIST_REMOVE_NEXT(head, elm, field) do { \
147 (elm)->field.sle_next = (elm)->field.sle_next->field.sle_next; \
150#define SLIST_REMOVE_HEAD(head, field) do { \
151 (head)->slh_first = (head)->slh_first->field.sle_next; \
154#define SLIST_REMOVE(head, elm, type, field) do { \
155 if ((head)->slh_first == (elm)) { \
156 SLIST_REMOVE_HEAD((head), field); \
158 struct type *curelm = (head)->slh_first; \
160 while (curelm->field.sle_next != (elm)) \
161 curelm = curelm->field.sle_next; \
162 curelm->field.sle_next = \
163 curelm->field.sle_next->field.sle_next; \
164 _Q_INVALIDATE((elm)->field.sle_next); \
171#define LIST_HEAD(name, type) \
173 struct type *lh_first; \
176#define LIST_HEAD_INITIALIZER(head) \
179#define LIST_ENTRY(type) \
181 struct type *le_next; \
182 struct type **le_prev; \
188#define LIST_FIRST(head) ((head)->lh_first)
189#define LIST_END(head) NULL
190#define LIST_EMPTY(head) (LIST_FIRST(head) == LIST_END(head))
191#define LIST_NEXT(elm, field) ((elm)->field.le_next)
193#define LIST_FOREACH(var, head, field) \
194 for((var) = LIST_FIRST(head); \
195 (var)!= LIST_END(head); \
196 (var) = LIST_NEXT(var, field))
201#define LIST_INIT(head) do { \
202 LIST_FIRST(head) = LIST_END(head); \
205#define LIST_INSERT_AFTER(listelm, elm, field) do { \
206 if (((elm)->field.le_next = (listelm)->field.le_next) != NULL) \
207 (listelm)->field.le_next->field.le_prev = \
208 &(elm)->field.le_next; \
209 (listelm)->field.le_next = (elm); \
210 (elm)->field.le_prev = &(listelm)->field.le_next; \
213#define LIST_INSERT_BEFORE(listelm, elm, field) do { \
214 (elm)->field.le_prev = (listelm)->field.le_prev; \
215 (elm)->field.le_next = (listelm); \
216 *(listelm)->field.le_prev = (elm); \
217 (listelm)->field.le_prev = &(elm)->field.le_next; \
220#define LIST_INSERT_HEAD(head, elm, field) do { \
221 if (((elm)->field.le_next = (head)->lh_first) != NULL) \
222 (head)->lh_first->field.le_prev = &(elm)->field.le_next;\
223 (head)->lh_first = (elm); \
224 (elm)->field.le_prev = &(head)->lh_first; \
227#define LIST_REMOVE(elm, field) do { \
228 if ((elm)->field.le_next != NULL) \
229 (elm)->field.le_next->field.le_prev = \
230 (elm)->field.le_prev; \
231 *(elm)->field.le_prev = (elm)->field.le_next; \
232 _Q_INVALIDATE((elm)->field.le_prev); \
233 _Q_INVALIDATE((elm)->field.le_next); \
236#define LIST_REPLACE(elm, elm2, field) do { \
237 if (((elm2)->field.le_next = (elm)->field.le_next) != NULL) \
238 (elm2)->field.le_next->field.le_prev = \
239 &(elm2)->field.le_next; \
240 (elm2)->field.le_prev = (elm)->field.le_prev; \
241 *(elm2)->field.le_prev = (elm2); \
242 _Q_INVALIDATE((elm)->field.le_prev); \
243 _Q_INVALIDATE((elm)->field.le_next); \
249#define SIMPLEQ_HEAD(name, type) \
251 struct type *sqh_first; \
252 struct type **sqh_last; \
255#define SIMPLEQ_HEAD_INITIALIZER(head) \
256 { NULL, &(head).sqh_first }
258#define SIMPLEQ_ENTRY(type) \
260 struct type *sqe_next; \
266#define SIMPLEQ_FIRST(head) ((head)->sqh_first)
267#define SIMPLEQ_END(head) NULL
268#define SIMPLEQ_EMPTY(head) (SIMPLEQ_FIRST(head) == SIMPLEQ_END(head))
269#define SIMPLEQ_NEXT(elm, field) ((elm)->field.sqe_next)
271#define SIMPLEQ_FOREACH(var, head, field) \
272 for((var) = SIMPLEQ_FIRST(head); \
273 (var) != SIMPLEQ_END(head); \
274 (var) = SIMPLEQ_NEXT(var, field))
279#define SIMPLEQ_INIT(head) do { \
280 (head)->sqh_first = NULL; \
281 (head)->sqh_last = &(head)->sqh_first; \
284#define SIMPLEQ_INSERT_HEAD(head, elm, field) do { \
285 if (((elm)->field.sqe_next = (head)->sqh_first) == NULL) \
286 (head)->sqh_last = &(elm)->field.sqe_next; \
287 (head)->sqh_first = (elm); \
290#define SIMPLEQ_INSERT_TAIL(head, elm, field) do { \
291 (elm)->field.sqe_next = NULL; \
292 *(head)->sqh_last = (elm); \
293 (head)->sqh_last = &(elm)->field.sqe_next; \
296#define SIMPLEQ_INSERT_AFTER(head, listelm, elm, field) do { \
297 if (((elm)->field.sqe_next = (listelm)->field.sqe_next) == NULL)\
298 (head)->sqh_last = &(elm)->field.sqe_next; \
299 (listelm)->field.sqe_next = (elm); \
302#define SIMPLEQ_REMOVE_HEAD(head, field) do { \
303 if (((head)->sqh_first = (head)->sqh_first->field.sqe_next) == NULL) \
304 (head)->sqh_last = &(head)->sqh_first; \
310#define TAILQ_HEAD(name, type) \
312 struct type *tqh_first; \
313 struct type **tqh_last; \
316#define TAILQ_HEAD_INITIALIZER(head) \
317 { NULL, &(head).tqh_first }
319#define TAILQ_ENTRY(type) \
321 struct type *tqe_next; \
322 struct type **tqe_prev; \
328#define TAILQ_FIRST(head) ((head)->tqh_first)
329#define TAILQ_END(head) NULL
330#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next)
331#define TAILQ_LAST(head, headname) \
332 (*(((struct headname *)((head)->tqh_last))->tqh_last))
334#define TAILQ_PREV(elm, headname, field) \
335 (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
336#define TAILQ_EMPTY(head) \
337 (TAILQ_FIRST(head) == TAILQ_END(head))
339#define TAILQ_FOREACH(var, head, field) \
340 for((var) = TAILQ_FIRST(head); \
341 (var) != TAILQ_END(head); \
342 (var) = TAILQ_NEXT(var, field))
344#define TAILQ_FOREACH_REVERSE(var, head, headname, field) \
345 for((var) = TAILQ_LAST(head, headname); \
346 (var) != TAILQ_END(head); \
347 (var) = TAILQ_PREV(var, headname, field))
352#define TAILQ_INIT(head) do { \
353 (head)->tqh_first = NULL; \
354 (head)->tqh_last = &(head)->tqh_first; \
357#define TAILQ_INSERT_HEAD(head, elm, field) do { \
358 if (((elm)->field.tqe_next = (head)->tqh_first) != NULL) \
359 (head)->tqh_first->field.tqe_prev = \
360 &(elm)->field.tqe_next; \
362 (head)->tqh_last = &(elm)->field.tqe_next; \
363 (head)->tqh_first = (elm); \
364 (elm)->field.tqe_prev = &(head)->tqh_first; \
367#define TAILQ_INSERT_TAIL(head, elm, field) do { \
368 (elm)->field.tqe_next = NULL; \
369 (elm)->field.tqe_prev = (head)->tqh_last; \
370 *(head)->tqh_last = (elm); \
371 (head)->tqh_last = &(elm)->field.tqe_next; \
374#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \
375 if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != NULL)\
376 (elm)->field.tqe_next->field.tqe_prev = \
377 &(elm)->field.tqe_next; \
379 (head)->tqh_last = &(elm)->field.tqe_next; \
380 (listelm)->field.tqe_next = (elm); \
381 (elm)->field.tqe_prev = &(listelm)->field.tqe_next; \
384#define TAILQ_INSERT_BEFORE(listelm, elm, field) do { \
385 (elm)->field.tqe_prev = (listelm)->field.tqe_prev; \
386 (elm)->field.tqe_next = (listelm); \
387 *(listelm)->field.tqe_prev = (elm); \
388 (listelm)->field.tqe_prev = &(elm)->field.tqe_next; \
391#define TAILQ_REMOVE(head, elm, field) do { \
392 if (((elm)->field.tqe_next) != NULL) \
393 (elm)->field.tqe_next->field.tqe_prev = \
394 (elm)->field.tqe_prev; \
396 (head)->tqh_last = (elm)->field.tqe_prev; \
397 *(elm)->field.tqe_prev = (elm)->field.tqe_next; \
398 _Q_INVALIDATE((elm)->field.tqe_prev); \
399 _Q_INVALIDATE((elm)->field.tqe_next); \
402#define TAILQ_REPLACE(head, elm, elm2, field) do { \
403 if (((elm2)->field.tqe_next = (elm)->field.tqe_next) != NULL) \
404 (elm2)->field.tqe_next->field.tqe_prev = \
405 &(elm2)->field.tqe_next; \
407 (head)->tqh_last = &(elm2)->field.tqe_next; \
408 (elm2)->field.tqe_prev = (elm)->field.tqe_prev; \
409 *(elm2)->field.tqe_prev = (elm2); \
410 _Q_INVALIDATE((elm)->field.tqe_prev); \
411 _Q_INVALIDATE((elm)->field.tqe_next); \
417#define CIRCLEQ_HEAD(name, type) \
419 struct type *cqh_first; \
420 struct type *cqh_last; \
423#define CIRCLEQ_HEAD_INITIALIZER(head) \
424 { CIRCLEQ_END(&head), CIRCLEQ_END(&head) }
426#define CIRCLEQ_ENTRY(type) \
428 struct type *cqe_next; \
429 struct type *cqe_prev; \
435#define CIRCLEQ_FIRST(head) ((head)->cqh_first)
436#define CIRCLEQ_LAST(head) ((head)->cqh_last)
437#define CIRCLEQ_END(head) ((void *)(head))
438#define CIRCLEQ_NEXT(elm, field) ((elm)->field.cqe_next)
439#define CIRCLEQ_PREV(elm, field) ((elm)->field.cqe_prev)
440#define CIRCLEQ_EMPTY(head) \
441 (CIRCLEQ_FIRST(head) == CIRCLEQ_END(head))
443#define CIRCLEQ_FOREACH(var, head, field) \
444 for((var) = CIRCLEQ_FIRST(head); \
445 (var) != CIRCLEQ_END(head); \
446 (var) = CIRCLEQ_NEXT(var, field))
448#define CIRCLEQ_FOREACH_REVERSE(var, head, field) \
449 for((var) = CIRCLEQ_LAST(head); \
450 (var) != CIRCLEQ_END(head); \
451 (var) = CIRCLEQ_PREV(var, field))
456#define CIRCLEQ_INIT(head) do { \
457 (head)->cqh_first = CIRCLEQ_END(head); \
458 (head)->cqh_last = CIRCLEQ_END(head); \
461#define CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do { \
462 (elm)->field.cqe_next = (listelm)->field.cqe_next; \
463 (elm)->field.cqe_prev = (listelm); \
464 if ((listelm)->field.cqe_next == CIRCLEQ_END(head)) \
465 (head)->cqh_last = (elm); \
467 (listelm)->field.cqe_next->field.cqe_prev = (elm); \
468 (listelm)->field.cqe_next = (elm); \
471#define CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do { \
472 (elm)->field.cqe_next = (listelm); \
473 (elm)->field.cqe_prev = (listelm)->field.cqe_prev; \
474 if ((listelm)->field.cqe_prev == CIRCLEQ_END(head)) \
475 (head)->cqh_first = (elm); \
477 (listelm)->field.cqe_prev->field.cqe_next = (elm); \
478 (listelm)->field.cqe_prev = (elm); \
481#define CIRCLEQ_INSERT_HEAD(head, elm, field) do { \
482 (elm)->field.cqe_next = (head)->cqh_first; \
483 (elm)->field.cqe_prev = CIRCLEQ_END(head); \
484 if ((head)->cqh_last == CIRCLEQ_END(head)) \
485 (head)->cqh_last = (elm); \
487 (head)->cqh_first->field.cqe_prev = (elm); \
488 (head)->cqh_first = (elm); \
491#define CIRCLEQ_INSERT_TAIL(head, elm, field) do { \
492 (elm)->field.cqe_next = CIRCLEQ_END(head); \
493 (elm)->field.cqe_prev = (head)->cqh_last; \
494 if ((head)->cqh_first == CIRCLEQ_END(head)) \
495 (head)->cqh_first = (elm); \
497 (head)->cqh_last->field.cqe_next = (elm); \
498 (head)->cqh_last = (elm); \
501#define CIRCLEQ_REMOVE(head, elm, field) do { \
502 if ((elm)->field.cqe_next == CIRCLEQ_END(head)) \
503 (head)->cqh_last = (elm)->field.cqe_prev; \
505 (elm)->field.cqe_next->field.cqe_prev = \
506 (elm)->field.cqe_prev; \
507 if ((elm)->field.cqe_prev == CIRCLEQ_END(head)) \
508 (head)->cqh_first = (elm)->field.cqe_next; \
510 (elm)->field.cqe_prev->field.cqe_next = \
511 (elm)->field.cqe_next; \
512 _Q_INVALIDATE((elm)->field.cqe_prev); \
513 _Q_INVALIDATE((elm)->field.cqe_next); \
516#define CIRCLEQ_REPLACE(head, elm, elm2, field) do { \
517 if (((elm2)->field.cqe_next = (elm)->field.cqe_next) == \
519 (head).cqh_last = (elm2); \
521 (elm2)->field.cqe_next->field.cqe_prev = (elm2); \
522 if (((elm2)->field.cqe_prev = (elm)->field.cqe_prev) == \
524 (head).cqh_first = (elm2); \
526 (elm2)->field.cqe_prev->field.cqe_next = (elm2); \
527 _Q_INVALIDATE((elm)->field.cqe_prev); \
528 _Q_INVALIDATE((elm)->field.cqe_next); \