NeoMutt  2025-09-05-43-g177ed6
Teaching an old dog new tricks
 		DOXYGEN
Loading...
Searching...
No Matches
Macros
queue.h File Reference
+ This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros

#define QMD_TRACE_ELEM(elem)
 
#define QMD_TRACE_HEAD(head)
 
#define TRACEBUF
 
#define TRACEBUF_INITIALIZER
 
#define QMD_SAVELINK(name, link)
 
#define TRASHIT(x)
 
#define QMD_IS_TRASHED(x)
 
#define QUEUE_TYPEOF(type)
 
#define SLIST_HEAD(name, type)
 
#define SLIST_CLASS_HEAD(name, type)
 
#define SLIST_HEAD_INITIALIZER(head)
 
#define SLIST_ENTRY(type)
 
#define SLIST_CLASS_ENTRY(type)
 
#define QMD_SLIST_CHECK_PREVPTR(prevp, elm)
 
#define SLIST_CONCAT(head1, head2, type, field)
 
#define SLIST_EMPTY(head)
 
#define SLIST_FIRST(head)
 
#define SLIST_FOREACH(var, head, field)
 
#define SLIST_FOREACH_FROM(var, head, field)
 
#define SLIST_FOREACH_SAFE(var, head, field, tvar)
 
#define SLIST_FOREACH_FROM_SAFE(var, head, field, tvar)
 
#define SLIST_FOREACH_PREVPTR(var, varp, head, field)
 
#define SLIST_INIT(head)
 
#define SLIST_INSERT_AFTER(slistelm, elm, field)
 
#define SLIST_INSERT_HEAD(head, elm, field)
 
#define SLIST_NEXT(elm, field)
 
#define SLIST_REMOVE(head, elm, type, field)
 
#define SLIST_REMOVE_AFTER(elm, field)
 
#define SLIST_REMOVE_HEAD(head, field)
 
#define SLIST_REMOVE_PREVPTR(prevp, elm, field)
 
#define SLIST_SWAP(head1, head2, type)
 
#define SLIST_END(head)
 
#define STAILQ_HEAD(name, type)
 
#define STAILQ_CLASS_HEAD(name, type)
 
#define STAILQ_HEAD_INITIALIZER(head)
 
#define STAILQ_ENTRY(type)
 
#define STAILQ_CLASS_ENTRY(type)
 
#define QMD_STAILQ_CHECK_EMPTY(head)
 
#define STAILQ_ASSERT_EMPTY(head)
 
#define QMD_STAILQ_CHECK_TAIL(head)
 
#define STAILQ_CONCAT(head1, head2)
 
#define STAILQ_EMPTY(head)
 
#define STAILQ_FIRST(head)
 
#define STAILQ_FOREACH(var, head, field)
 
#define STAILQ_FOREACH_FROM(var, head, field)
 
#define STAILQ_FOREACH_SAFE(var, head, field, tvar)
 
#define STAILQ_FOREACH_FROM_SAFE(var, head, field, tvar)
 
#define STAILQ_INIT(head)
 
#define STAILQ_INSERT_AFTER(head, tqelm, elm, field)
 
#define STAILQ_INSERT_HEAD(head, elm, field)
 
#define STAILQ_INSERT_TAIL(head, elm, field)
 
#define STAILQ_LAST(head, type, field)
 
#define STAILQ_NEXT(elm, field)
 
#define STAILQ_REMOVE(head, elm, type, field)
 
#define STAILQ_REMOVE_AFTER(head, elm, field)
 
#define STAILQ_REMOVE_HEAD(head, field)
 
#define STAILQ_SWAP(head1, head2, type)
 
#define STAILQ_END(head)
 
#define LIST_HEAD(name, type)
 
#define LIST_CLASS_HEAD(name, type)
 
#define LIST_HEAD_INITIALIZER(head)
 
#define LIST_ENTRY(type)
 
#define LIST_CLASS_ENTRY(type)
 
#define QMD_LIST_CHECK_HEAD(head, field)
 
#define QMD_LIST_CHECK_NEXT(elm, field)
 
#define QMD_LIST_CHECK_PREV(elm, field)
 
#define LIST_CONCAT(head1, head2, type, field)
 
#define LIST_EMPTY(head)
 
#define LIST_FIRST(head)
 
#define LIST_FOREACH(var, head, field)
 
#define LIST_FOREACH_FROM(var, head, field)
 
#define LIST_FOREACH_SAFE(var, head, field, tvar)
 
#define LIST_FOREACH_FROM_SAFE(var, head, field, tvar)
 
#define LIST_INIT(head)
 
#define LIST_INSERT_AFTER(listelm, elm, field)
 
#define LIST_INSERT_BEFORE(listelm, elm, field)
 
#define LIST_INSERT_HEAD(head, elm, field)
 
#define LIST_NEXT(elm, field)
 
#define LIST_PREV(elm, head, type, field)
 
#define LIST_REMOVE_HEAD(head, field)
 
#define LIST_REMOVE(elm, field)
 
#define LIST_REPLACE(elm, elm2, field)
 
#define LIST_SWAP(head1, head2, type, field)
 
#define LIST_END(head)
 
#define TAILQ_HEAD(name, type)
 
#define TAILQ_CLASS_HEAD(name, type)
 
#define TAILQ_HEAD_INITIALIZER(head)
 
#define TAILQ_ENTRY(type)
 
#define TAILQ_CLASS_ENTRY(type)
 
#define QMD_TAILQ_CHECK_HEAD(head, field)
 
#define QMD_TAILQ_CHECK_TAIL(head, headname)
 
#define QMD_TAILQ_CHECK_NEXT(elm, field)
 
#define QMD_TAILQ_CHECK_PREV(elm, field)
 
#define TAILQ_CONCAT(head1, head2, field)
 
#define TAILQ_EMPTY(head)
 
#define TAILQ_FIRST(head)
 
#define TAILQ_FOREACH(var, head, field)
 
#define TAILQ_FOREACH_FROM(var, head, field)
 
#define TAILQ_FOREACH_SAFE(var, head, field, tvar)
 
#define TAILQ_FOREACH_FROM_SAFE(var, head, field, tvar)
 
#define TAILQ_FOREACH_REVERSE(var, head, headname, field)
 
#define TAILQ_FOREACH_REVERSE_FROM(var, head, headname, field)
 
#define TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar)
 
#define TAILQ_FOREACH_REVERSE_FROM_SAFE(var, head, headname, field, tvar)
 
#define TAILQ_INIT(head)
 
#define TAILQ_INSERT_AFTER(head, listelm, elm, field)
 
#define TAILQ_INSERT_BEFORE(listelm, elm, field)
 
#define TAILQ_INSERT_HEAD(head, elm, field)
 
#define TAILQ_INSERT_TAIL(head, elm, field)
 
#define TAILQ_LAST(head, headname)
 
#define TAILQ_LAST_FAST(head, type, field)
 
#define TAILQ_NEXT(elm, field)
 
#define TAILQ_PREV(elm, headname, field)
 
#define TAILQ_PREV_FAST(elm, head, type, field)
 
#define TAILQ_REMOVE_HEAD(head, field)
 
#define TAILQ_REMOVE(head, elm, field)
 
#define TAILQ_REPLACE(head, elm, elm2, field)
 
#define TAILQ_SWAP(head1, head2, type, field)
 
#define TAILQ_END(head)
 

Macro Definition Documentation

◆ QMD_TRACE_ELEM

#define QMD_TRACE_ELEM ( elem)

Definition at line 148 of file queue.h.

◆ QMD_TRACE_HEAD

#define QMD_TRACE_HEAD ( head)

Definition at line 149 of file queue.h.

◆ TRACEBUF

#define TRACEBUF

Definition at line 150 of file queue.h.

◆ TRACEBUF_INITIALIZER

#define TRACEBUF_INITIALIZER

Definition at line 151 of file queue.h.

◆ QMD_SAVELINK

#define QMD_SAVELINK ( name,
link )

Definition at line 159 of file queue.h.

◆ TRASHIT

#define TRASHIT ( x)

Definition at line 160 of file queue.h.

◆ QMD_IS_TRASHED

#define QMD_IS_TRASHED ( x)
Value:
0

Definition at line 161 of file queue.h.

◆ QUEUE_TYPEOF

#define QUEUE_TYPEOF ( type)
Value:
struct type

Definition at line 170 of file queue.h.

◆ SLIST_HEAD

#define SLIST_HEAD ( name,
type )
Value:
struct name { \
struct type *slh_first; /* first element */ \
}

Definition at line 176 of file queue.h.

176#define SLIST_HEAD(name, type) \
177struct name { \
178 struct type *slh_first; /* first element */ \
179}

◆ SLIST_CLASS_HEAD

#define SLIST_CLASS_HEAD ( name,
type )
Value:
struct name { \
class type *slh_first; /* first element */ \
}

Definition at line 181 of file queue.h.

181#define SLIST_CLASS_HEAD(name, type) \
182struct name { \
183 class type *slh_first; /* first element */ \
184}

◆ SLIST_HEAD_INITIALIZER

#define SLIST_HEAD_INITIALIZER ( head)
Value:
{ NULL }

Definition at line 186 of file queue.h.

186#define SLIST_HEAD_INITIALIZER(head) \
187 { NULL }

◆ SLIST_ENTRY

#define SLIST_ENTRY ( type)
Value:
struct { \
struct type *sle_next; /* next element */ \
}

Definition at line 189 of file queue.h.

189#define SLIST_ENTRY(type) \
190struct { \
191 struct type *sle_next; /* next element */ \
192}

◆ SLIST_CLASS_ENTRY

#define SLIST_CLASS_ENTRY ( type)
Value:
struct { \
class type *sle_next; /* next element */ \
}

Definition at line 194 of file queue.h.

194#define SLIST_CLASS_ENTRY(type) \
195struct { \
196 class type *sle_next; /* next element */ \
197}

◆ QMD_SLIST_CHECK_PREVPTR

#define QMD_SLIST_CHECK_PREVPTR ( prevp,
elm )

Definition at line 209 of file queue.h.

◆ SLIST_CONCAT

#define SLIST_CONCAT ( head1,
head2,
type,
field )
Value:
do { \
QUEUE_TYPEOF(type) *curelm = SLIST_FIRST(head1); \
if (curelm == NULL) { \
if ((SLIST_FIRST(head1) = SLIST_FIRST(head2)) != NULL) \
SLIST_INIT(head2); \
} else if (SLIST_FIRST(head2) != NULL) { \
while (SLIST_NEXT(curelm, field) != NULL) \
curelm = SLIST_NEXT(curelm, field); \
SLIST_NEXT(curelm, field) = SLIST_FIRST(head2); \
SLIST_INIT(head2); \
} \
} while (0)
SLIST_NEXT
#define SLIST_NEXT(elm, field)
Definition queue.h:268
SLIST_FIRST
#define SLIST_FIRST(head)
Definition queue.h:227

Definition at line 212 of file queue.h.

212#define SLIST_CONCAT(head1, head2, type, field) do { \
213 QUEUE_TYPEOF(type) *curelm = SLIST_FIRST(head1); \
214 if (curelm == NULL) { \
215 if ((SLIST_FIRST(head1) = SLIST_FIRST(head2)) != NULL) \
216 SLIST_INIT(head2); \
217 } else if (SLIST_FIRST(head2) != NULL) { \
218 while (SLIST_NEXT(curelm, field) != NULL) \
219 curelm = SLIST_NEXT(curelm, field); \
220 SLIST_NEXT(curelm, field) = SLIST_FIRST(head2); \
221 SLIST_INIT(head2); \
222 } \
223} while (0)

◆ SLIST_EMPTY

#define SLIST_EMPTY ( head)
Value:
((head)->slh_first == NULL)

Definition at line 225 of file queue.h.

◆ SLIST_FIRST

#define SLIST_FIRST ( head)
Value:
((head)->slh_first)

Definition at line 227 of file queue.h.

◆ SLIST_FOREACH

#define SLIST_FOREACH ( var,
head,
field )
Value:
for ((var) = SLIST_FIRST((head)); \
(var); \
(var) = SLIST_NEXT((var), field))

Definition at line 229 of file queue.h.

229#define SLIST_FOREACH(var, head, field) \
230 for ((var) = SLIST_FIRST((head)); \
231 (var); \
232 (var) = SLIST_NEXT((var), field))

◆ SLIST_FOREACH_FROM

#define SLIST_FOREACH_FROM ( var,
head,
field )
Value:
for ((var) = ((var) ? (var) : SLIST_FIRST((head))); \
(var); \
(var) = SLIST_NEXT((var), field))

Definition at line 234 of file queue.h.

234#define SLIST_FOREACH_FROM(var, head, field) \
235 for ((var) = ((var) ? (var) : SLIST_FIRST((head))); \
236 (var); \
237 (var) = SLIST_NEXT((var), field))

◆ SLIST_FOREACH_SAFE

#define SLIST_FOREACH_SAFE ( var,
head,
field,
tvar )
Value:
for ((var) = SLIST_FIRST((head)); \
(var) && ((tvar) = SLIST_NEXT((var), field), 1); \
(var) = (tvar))

Definition at line 239 of file queue.h.

239#define SLIST_FOREACH_SAFE(var, head, field, tvar) \
240 for ((var) = SLIST_FIRST((head)); \
241 (var) && ((tvar) = SLIST_NEXT((var), field), 1); \
242 (var) = (tvar))

◆ SLIST_FOREACH_FROM_SAFE

#define SLIST_FOREACH_FROM_SAFE ( var,
head,
field,
tvar )
Value:
for ((var) = ((var) ? (var) : SLIST_FIRST((head))); \
(var) && ((tvar) = SLIST_NEXT((var), field), 1); \
(var) = (tvar))

Definition at line 244 of file queue.h.

244#define SLIST_FOREACH_FROM_SAFE(var, head, field, tvar) \
245 for ((var) = ((var) ? (var) : SLIST_FIRST((head))); \
246 (var) && ((tvar) = SLIST_NEXT((var), field), 1); \
247 (var) = (tvar))

◆ SLIST_FOREACH_PREVPTR

#define SLIST_FOREACH_PREVPTR ( var,
varp,
head,
field )
Value:
for ((varp) = &SLIST_FIRST((head)); \
((var) = *(varp)) != NULL; \
(varp) = &SLIST_NEXT((var), field))

Definition at line 249 of file queue.h.

249#define SLIST_FOREACH_PREVPTR(var, varp, head, field) \
250 for ((varp) = &SLIST_FIRST((head)); \
251 ((var) = *(varp)) != NULL; \
252 (varp) = &SLIST_NEXT((var), field))

◆ SLIST_INIT

#define SLIST_INIT ( head)
Value:
do { \
SLIST_FIRST((head)) = NULL; \
} while (0)

Definition at line 254 of file queue.h.

254#define SLIST_INIT(head) do { \
255 SLIST_FIRST((head)) = NULL; \
256} while (0)

◆ SLIST_INSERT_AFTER

#define SLIST_INSERT_AFTER ( slistelm,
elm,
field )
Value:
do { \
SLIST_NEXT((elm), field) = SLIST_NEXT((slistelm), field); \
SLIST_NEXT((slistelm), field) = (elm); \
} while (0)

Definition at line 258 of file queue.h.

258#define SLIST_INSERT_AFTER(slistelm, elm, field) do { \
259 SLIST_NEXT((elm), field) = SLIST_NEXT((slistelm), field); \
260 SLIST_NEXT((slistelm), field) = (elm); \
261} while (0)

◆ SLIST_INSERT_HEAD

#define SLIST_INSERT_HEAD ( head,
elm,
field )
Value:
do { \
SLIST_NEXT((elm), field) = SLIST_FIRST((head)); \
SLIST_FIRST((head)) = (elm); \
} while (0)

Definition at line 263 of file queue.h.

263#define SLIST_INSERT_HEAD(head, elm, field) do { \
264 SLIST_NEXT((elm), field) = SLIST_FIRST((head)); \
265 SLIST_FIRST((head)) = (elm); \
266} while (0)

◆ SLIST_NEXT

#define SLIST_NEXT ( elm,
field )
Value:
((elm)->field.sle_next)

Definition at line 268 of file queue.h.

◆ SLIST_REMOVE

#define SLIST_REMOVE ( head,
elm,
type,
field )
Value:
do { \
if (SLIST_FIRST((head)) == (elm)) { \
SLIST_REMOVE_HEAD((head), field); \
} \
else { \
QUEUE_TYPEOF(type) *curelm = SLIST_FIRST(head); \
while (SLIST_NEXT(curelm, field) != (elm)) \
curelm = SLIST_NEXT(curelm, field); \
SLIST_REMOVE_AFTER(curelm, field); \
} \
} while (0)

Definition at line 270 of file queue.h.

270#define SLIST_REMOVE(head, elm, type, field) do { \
271 if (SLIST_FIRST((head)) == (elm)) { \
272 SLIST_REMOVE_HEAD((head), field); \
273 } \
274 else { \
275 QUEUE_TYPEOF(type) *curelm = SLIST_FIRST(head); \
276 while (SLIST_NEXT(curelm, field) != (elm)) \
277 curelm = SLIST_NEXT(curelm, field); \
278 SLIST_REMOVE_AFTER(curelm, field); \
279 } \
280} while (0)

◆ SLIST_REMOVE_AFTER

#define SLIST_REMOVE_AFTER ( elm,
field )
Value:
do { \
QMD_SAVELINK(oldnext, SLIST_NEXT(elm, field)->field.sle_next); \
SLIST_NEXT(elm, field) = \
SLIST_NEXT(SLIST_NEXT(elm, field), field); \
TRASHIT(*oldnext); \
} while (0)

Definition at line 282 of file queue.h.

282#define SLIST_REMOVE_AFTER(elm, field) do { \
283 QMD_SAVELINK(oldnext, SLIST_NEXT(elm, field)->field.sle_next); \
284 SLIST_NEXT(elm, field) = \
285 SLIST_NEXT(SLIST_NEXT(elm, field), field); \
286 TRASHIT(*oldnext); \
287} while (0)

◆ SLIST_REMOVE_HEAD

#define SLIST_REMOVE_HEAD ( head,
field )
Value:
do { \
QMD_SAVELINK(oldnext, SLIST_FIRST(head)->field.sle_next); \
SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field); \
TRASHIT(*oldnext); \
} while (0)

Definition at line 289 of file queue.h.

289#define SLIST_REMOVE_HEAD(head, field) do { \
290 QMD_SAVELINK(oldnext, SLIST_FIRST(head)->field.sle_next); \
291 SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field); \
292 TRASHIT(*oldnext); \
293} while (0)

◆ SLIST_REMOVE_PREVPTR

#define SLIST_REMOVE_PREVPTR ( prevp,
elm,
field )
Value:
do { \
QMD_SLIST_CHECK_PREVPTR(prevp, elm); \
*(prevp) = SLIST_NEXT(elm, field); \
TRASHIT((elm)->field.sle_next); \
} while (0)

Definition at line 295 of file queue.h.

295#define SLIST_REMOVE_PREVPTR(prevp, elm, field) do { \
296 QMD_SLIST_CHECK_PREVPTR(prevp, elm); \
297 *(prevp) = SLIST_NEXT(elm, field); \
298 TRASHIT((elm)->field.sle_next); \
299} while (0)

◆ SLIST_SWAP

#define SLIST_SWAP ( head1,
head2,
type )
Value:
do { \
QUEUE_TYPEOF(type) *swap_first = SLIST_FIRST(head1); \
SLIST_FIRST(head1) = SLIST_FIRST(head2); \
SLIST_FIRST(head2) = swap_first; \
} while (0)

Definition at line 301 of file queue.h.

301#define SLIST_SWAP(head1, head2, type) do { \
302 QUEUE_TYPEOF(type) *swap_first = SLIST_FIRST(head1); \
303 SLIST_FIRST(head1) = SLIST_FIRST(head2); \
304 SLIST_FIRST(head2) = swap_first; \
305} while (0)

◆ SLIST_END

#define SLIST_END ( head)
Value:
NULL

Definition at line 307 of file queue.h.

◆ STAILQ_HEAD

#define STAILQ_HEAD ( name,
type )
Value:
struct name { \
struct type *stqh_first;/* first element */ \
struct type **stqh_last;/* addr of last next element */ \
}

Definition at line 312 of file queue.h.

312#define STAILQ_HEAD(name, type) \
313struct name { \
314 struct type *stqh_first;/* first element */ \
315 struct type **stqh_last;/* addr of last next element */ \
316}

◆ STAILQ_CLASS_HEAD

#define STAILQ_CLASS_HEAD ( name,
type )
Value:
struct name { \
class type *stqh_first; /* first element */ \
class type **stqh_last; /* addr of last next element */ \
}

Definition at line 318 of file queue.h.

318#define STAILQ_CLASS_HEAD(name, type) \
319struct name { \
320 class type *stqh_first; /* first element */ \
321 class type **stqh_last; /* addr of last next element */ \
322}

◆ STAILQ_HEAD_INITIALIZER

#define STAILQ_HEAD_INITIALIZER ( head)
Value:
{ NULL, &(head).stqh_first }

Definition at line 324 of file queue.h.

324#define STAILQ_HEAD_INITIALIZER(head) \
325 { NULL, &(head).stqh_first }

◆ STAILQ_ENTRY

#define STAILQ_ENTRY ( type)
Value:
struct { \
struct type *stqe_next; /* next element */ \
}

Definition at line 327 of file queue.h.

327#define STAILQ_ENTRY(type) \
328struct { \
329 struct type *stqe_next; /* next element */ \
330}

◆ STAILQ_CLASS_ENTRY

#define STAILQ_CLASS_ENTRY ( type)
Value:
struct { \
class type *stqe_next; /* next element */ \
}

Definition at line 332 of file queue.h.

332#define STAILQ_CLASS_ENTRY(type) \
333struct { \
334 class type *stqe_next; /* next element */ \
335}

◆ QMD_STAILQ_CHECK_EMPTY

#define QMD_STAILQ_CHECK_EMPTY ( head)

Definition at line 369 of file queue.h.

◆ STAILQ_ASSERT_EMPTY

#define STAILQ_ASSERT_EMPTY ( head)

Definition at line 370 of file queue.h.

◆ QMD_STAILQ_CHECK_TAIL

#define QMD_STAILQ_CHECK_TAIL ( head)

Definition at line 371 of file queue.h.

◆ STAILQ_CONCAT

#define STAILQ_CONCAT ( head1,
head2 )
Value:
do { \
if (!STAILQ_EMPTY((head2))) { \
*(head1)->stqh_last = (head2)->stqh_first; \
(head1)->stqh_last = (head2)->stqh_last; \
STAILQ_INIT((head2)); \
} \
} while (0)
STAILQ_EMPTY
#define STAILQ_EMPTY(head)
Definition queue.h:382

Definition at line 374 of file queue.h.

374#define STAILQ_CONCAT(head1, head2) do { \
375 if (!STAILQ_EMPTY((head2))) { \
376 *(head1)->stqh_last = (head2)->stqh_first; \
377 (head1)->stqh_last = (head2)->stqh_last; \
378 STAILQ_INIT((head2)); \
379 } \
380} while (0)

◆ STAILQ_EMPTY

#define STAILQ_EMPTY ( head)
Value:
({ \
if (STAILQ_FIRST(head) == NULL) \
QMD_STAILQ_CHECK_EMPTY(head); \
STAILQ_FIRST(head) == NULL; \
})
STAILQ_FIRST
#define STAILQ_FIRST(head)
Definition queue.h:388

Definition at line 382 of file queue.h.

382#define STAILQ_EMPTY(head) ({ \
383 if (STAILQ_FIRST(head) == NULL) \
384 QMD_STAILQ_CHECK_EMPTY(head); \
385 STAILQ_FIRST(head) == NULL; \
386})

◆ STAILQ_FIRST

#define STAILQ_FIRST ( head)
Value:
((head)->stqh_first)

Definition at line 388 of file queue.h.

◆ STAILQ_FOREACH

#define STAILQ_FOREACH ( var,
head,
field )
Value:
for((var) = STAILQ_FIRST((head)); \
(var); \
(var) = STAILQ_NEXT((var), field))
STAILQ_NEXT
#define STAILQ_NEXT(elm, field)
Definition queue.h:439

Definition at line 390 of file queue.h.

390#define STAILQ_FOREACH(var, head, field) \
391 for((var) = STAILQ_FIRST((head)); \
392 (var); \
393 (var) = STAILQ_NEXT((var), field))

◆ STAILQ_FOREACH_FROM

#define STAILQ_FOREACH_FROM ( var,
head,
field )
Value:
for ((var) = ((var) ? (var) : STAILQ_FIRST((head))); \
(var); \
(var) = STAILQ_NEXT((var), field))

Definition at line 395 of file queue.h.

395#define STAILQ_FOREACH_FROM(var, head, field) \
396 for ((var) = ((var) ? (var) : STAILQ_FIRST((head))); \
397 (var); \
398 (var) = STAILQ_NEXT((var), field))

◆ STAILQ_FOREACH_SAFE

#define STAILQ_FOREACH_SAFE ( var,
head,
field,
tvar )
Value:
for ((var) = STAILQ_FIRST((head)); \
(var) && ((tvar) = STAILQ_NEXT((var), field), 1); \
(var) = (tvar))

Definition at line 400 of file queue.h.

400#define STAILQ_FOREACH_SAFE(var, head, field, tvar) \
401 for ((var) = STAILQ_FIRST((head)); \
402 (var) && ((tvar) = STAILQ_NEXT((var), field), 1); \
403 (var) = (tvar))

◆ STAILQ_FOREACH_FROM_SAFE

#define STAILQ_FOREACH_FROM_SAFE ( var,
head,
field,
tvar )
Value:
for ((var) = ((var) ? (var) : STAILQ_FIRST((head))); \
(var) && ((tvar) = STAILQ_NEXT((var), field), 1); \
(var) = (tvar))

Definition at line 405 of file queue.h.

405#define STAILQ_FOREACH_FROM_SAFE(var, head, field, tvar) \
406 for ((var) = ((var) ? (var) : STAILQ_FIRST((head))); \
407 (var) && ((tvar) = STAILQ_NEXT((var), field), 1); \
408 (var) = (tvar))

◆ STAILQ_INIT

#define STAILQ_INIT ( head)
Value:
do { \
STAILQ_FIRST((head)) = NULL; \
(head)->stqh_last = &STAILQ_FIRST((head)); \
} while (0)

Definition at line 410 of file queue.h.

410#define STAILQ_INIT(head) do { \
411 STAILQ_FIRST((head)) = NULL; \
412 (head)->stqh_last = &STAILQ_FIRST((head)); \
413} while (0)

◆ STAILQ_INSERT_AFTER

#define STAILQ_INSERT_AFTER ( head,
tqelm,
elm,
field )
Value:
do { \
if ((STAILQ_NEXT((elm), field) = STAILQ_NEXT((tqelm), field)) == NULL)\
(head)->stqh_last = &STAILQ_NEXT((elm), field); \
STAILQ_NEXT((tqelm), field) = (elm); \
} while (0)

Definition at line 415 of file queue.h.

415#define STAILQ_INSERT_AFTER(head, tqelm, elm, field) do { \
416 if ((STAILQ_NEXT((elm), field) = STAILQ_NEXT((tqelm), field)) == NULL)\
417 (head)->stqh_last = &STAILQ_NEXT((elm), field); \
418 STAILQ_NEXT((tqelm), field) = (elm); \
419} while (0)

◆ STAILQ_INSERT_HEAD

#define STAILQ_INSERT_HEAD ( head,
elm,
field )
Value:
do { \
if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL) \
(head)->stqh_last = &STAILQ_NEXT((elm), field); \
STAILQ_FIRST((head)) = (elm); \
} while (0)

Definition at line 421 of file queue.h.

421#define STAILQ_INSERT_HEAD(head, elm, field) do { \
422 if ((STAILQ_NEXT((elm), field) = STAILQ_FIRST((head))) == NULL) \
423 (head)->stqh_last = &STAILQ_NEXT((elm), field); \
424 STAILQ_FIRST((head)) = (elm); \
425} while (0)

◆ STAILQ_INSERT_TAIL

#define STAILQ_INSERT_TAIL ( head,
elm,
field )
Value:
do { \
QMD_STAILQ_CHECK_TAIL(head); \
STAILQ_NEXT((elm), field) = NULL; \
*(head)->stqh_last = (elm); \
(head)->stqh_last = &STAILQ_NEXT((elm), field); \
} while (0)

Definition at line 427 of file queue.h.

427#define STAILQ_INSERT_TAIL(head, elm, field) do { \
428 QMD_STAILQ_CHECK_TAIL(head); \
429 STAILQ_NEXT((elm), field) = NULL; \
430 *(head)->stqh_last = (elm); \
431 (head)->stqh_last = &STAILQ_NEXT((elm), field); \
432} while (0)

◆ STAILQ_LAST

#define STAILQ_LAST ( head,
type,
field )
Value:
(STAILQ_EMPTY((head)) ? NULL : \
__containerof((head)->stqh_last, \
QUEUE_TYPEOF(type), field.stqe_next))
QUEUE_TYPEOF
#define QUEUE_TYPEOF(type)
Definition queue.h:170

Definition at line 434 of file queue.h.

434#define STAILQ_LAST(head, type, field) \
435 (STAILQ_EMPTY((head)) ? NULL : \
436 __containerof((head)->stqh_last, \
437 QUEUE_TYPEOF(type), field.stqe_next))

◆ STAILQ_NEXT

#define STAILQ_NEXT ( elm,
field )
Value:
((elm)->field.stqe_next)

Definition at line 439 of file queue.h.

◆ STAILQ_REMOVE

#define STAILQ_REMOVE ( head,
elm,
type,
field )
Value:
do { \
QMD_SAVELINK(oldnext, (elm)->field.stqe_next); \
if (STAILQ_FIRST((head)) == (elm)) { \
STAILQ_REMOVE_HEAD((head), field); \
} \
else { \
QUEUE_TYPEOF(type) *curelm = STAILQ_FIRST(head); \
while (STAILQ_NEXT(curelm, field) != (elm)) \
curelm = STAILQ_NEXT(curelm, field); \
STAILQ_REMOVE_AFTER(head, curelm, field); \
} \
TRASHIT(*oldnext); \
} while (0)

Definition at line 441 of file queue.h.

441#define STAILQ_REMOVE(head, elm, type, field) do { \
442 QMD_SAVELINK(oldnext, (elm)->field.stqe_next); \
443 if (STAILQ_FIRST((head)) == (elm)) { \
444 STAILQ_REMOVE_HEAD((head), field); \
445 } \
446 else { \
447 QUEUE_TYPEOF(type) *curelm = STAILQ_FIRST(head); \
448 while (STAILQ_NEXT(curelm, field) != (elm)) \
449 curelm = STAILQ_NEXT(curelm, field); \
450 STAILQ_REMOVE_AFTER(head, curelm, field); \
451 } \
452 TRASHIT(*oldnext); \
453} while (0)

◆ STAILQ_REMOVE_AFTER

#define STAILQ_REMOVE_AFTER ( head,
elm,
field )
Value:
do { \
if ((STAILQ_NEXT(elm, field) = \
STAILQ_NEXT(STAILQ_NEXT(elm, field), field)) == NULL) \
(head)->stqh_last = &STAILQ_NEXT((elm), field); \
} while (0)

Definition at line 455 of file queue.h.

455#define STAILQ_REMOVE_AFTER(head, elm, field) do { \
456 if ((STAILQ_NEXT(elm, field) = \
457 STAILQ_NEXT(STAILQ_NEXT(elm, field), field)) == NULL) \
458 (head)->stqh_last = &STAILQ_NEXT((elm), field); \
459} while (0)

◆ STAILQ_REMOVE_HEAD

#define STAILQ_REMOVE_HEAD ( head,
field )
Value:
do { \
if ((STAILQ_FIRST((head)) = \
STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL) \
(head)->stqh_last = &STAILQ_FIRST((head)); \
} while (0)

Definition at line 461 of file queue.h.

461#define STAILQ_REMOVE_HEAD(head, field) do { \
462 if ((STAILQ_FIRST((head)) = \
463 STAILQ_NEXT(STAILQ_FIRST((head)), field)) == NULL) \
464 (head)->stqh_last = &STAILQ_FIRST((head)); \
465} while (0)

◆ STAILQ_SWAP

#define STAILQ_SWAP ( head1,
head2,
type )
Value:
do { \
QUEUE_TYPEOF(type) *swap_first = STAILQ_FIRST(head1); \
QUEUE_TYPEOF(type) **swap_last = (head1)->stqh_last; \
STAILQ_FIRST(head1) = STAILQ_FIRST(head2); \
(head1)->stqh_last = (head2)->stqh_last; \
STAILQ_FIRST(head2) = swap_first; \
(head2)->stqh_last = swap_last; \
if (STAILQ_FIRST(head1) == NULL) \
(head1)->stqh_last = &STAILQ_FIRST(head1); \
if (STAILQ_FIRST(head2) == NULL) \
(head2)->stqh_last = &STAILQ_FIRST(head2); \
} while (0)

Definition at line 467 of file queue.h.

467#define STAILQ_SWAP(head1, head2, type) do { \
468 QUEUE_TYPEOF(type) *swap_first = STAILQ_FIRST(head1); \
469 QUEUE_TYPEOF(type) **swap_last = (head1)->stqh_last; \
470 STAILQ_FIRST(head1) = STAILQ_FIRST(head2); \
471 (head1)->stqh_last = (head2)->stqh_last; \
472 STAILQ_FIRST(head2) = swap_first; \
473 (head2)->stqh_last = swap_last; \
474 if (STAILQ_FIRST(head1) == NULL) \
475 (head1)->stqh_last = &STAILQ_FIRST(head1); \
476 if (STAILQ_FIRST(head2) == NULL) \
477 (head2)->stqh_last = &STAILQ_FIRST(head2); \
478} while (0)

◆ STAILQ_END

#define STAILQ_END ( head)
Value:
NULL

Definition at line 480 of file queue.h.

◆ LIST_HEAD

#define LIST_HEAD ( name,
type )
Value:
struct name { \
struct type *lh_first; /* first element */ \
}

Definition at line 486 of file queue.h.

486#define LIST_HEAD(name, type) \
487struct name { \
488 struct type *lh_first; /* first element */ \
489}

◆ LIST_CLASS_HEAD

#define LIST_CLASS_HEAD ( name,
type )
Value:
struct name { \
class type *lh_first; /* first element */ \
}

Definition at line 491 of file queue.h.

491#define LIST_CLASS_HEAD(name, type) \
492struct name { \
493 class type *lh_first; /* first element */ \
494}

◆ LIST_HEAD_INITIALIZER

#define LIST_HEAD_INITIALIZER ( head)
Value:
{ NULL }

Definition at line 496 of file queue.h.

496#define LIST_HEAD_INITIALIZER(head) \
497 { NULL }

◆ LIST_ENTRY

#define LIST_ENTRY ( type)
Value:
struct { \
struct type *le_next; /* next element */ \
struct type **le_prev; /* address of previous next element */ \
}

Definition at line 499 of file queue.h.

499#define LIST_ENTRY(type) \
500struct { \
501 struct type *le_next; /* next element */ \
502 struct type **le_prev; /* address of previous next element */ \
503}

◆ LIST_CLASS_ENTRY

#define LIST_CLASS_ENTRY ( type)
Value:
struct { \
class type *le_next; /* next element */ \
class type **le_prev; /* address of previous next element */ \
}

Definition at line 505 of file queue.h.

505#define LIST_CLASS_ENTRY(type) \
506struct { \
507 class type *le_next; /* next element */ \
508 class type **le_prev; /* address of previous next element */ \
509}

◆ QMD_LIST_CHECK_HEAD

#define QMD_LIST_CHECK_HEAD ( head,
field )

Definition at line 552 of file queue.h.

◆ QMD_LIST_CHECK_NEXT

#define QMD_LIST_CHECK_NEXT ( elm,
field )

Definition at line 553 of file queue.h.

◆ QMD_LIST_CHECK_PREV

#define QMD_LIST_CHECK_PREV ( elm,
field )

Definition at line 554 of file queue.h.

◆ LIST_CONCAT

#define LIST_CONCAT ( head1,
head2,
type,
field )
Value:
do { \
QUEUE_TYPEOF(type) *curelm = LIST_FIRST(head1); \
if (curelm == NULL) { \
if ((LIST_FIRST(head1) = LIST_FIRST(head2)) != NULL) { \
LIST_FIRST(head2)->field.le_prev = \
&LIST_FIRST((head1)); \
LIST_INIT(head2); \
} \
} else if (LIST_FIRST(head2) != NULL) { \
while (LIST_NEXT(curelm, field) != NULL) \
curelm = LIST_NEXT(curelm, field); \
LIST_NEXT(curelm, field) = LIST_FIRST(head2); \
LIST_FIRST(head2)->field.le_prev = &LIST_NEXT(curelm, field);\
LIST_INIT(head2); \
} \
} while (0)
LIST_FIRST
#define LIST_FIRST(head)
Definition queue.h:576
LIST_NEXT
#define LIST_NEXT(elm, field)
Definition queue.h:627

Definition at line 557 of file queue.h.

557#define LIST_CONCAT(head1, head2, type, field) do { \
558 QUEUE_TYPEOF(type) *curelm = LIST_FIRST(head1); \
559 if (curelm == NULL) { \
560 if ((LIST_FIRST(head1) = LIST_FIRST(head2)) != NULL) { \
561 LIST_FIRST(head2)->field.le_prev = \
562 &LIST_FIRST((head1)); \
563 LIST_INIT(head2); \
564 } \
565 } else if (LIST_FIRST(head2) != NULL) { \
566 while (LIST_NEXT(curelm, field) != NULL) \
567 curelm = LIST_NEXT(curelm, field); \
568 LIST_NEXT(curelm, field) = LIST_FIRST(head2); \
569 LIST_FIRST(head2)->field.le_prev = &LIST_NEXT(curelm, field);\
570 LIST_INIT(head2); \
571 } \
572} while (0)

◆ LIST_EMPTY

#define LIST_EMPTY ( head)
Value:
((head)->lh_first == NULL)

Definition at line 574 of file queue.h.

◆ LIST_FIRST

#define LIST_FIRST ( head)
Value:
((head)->lh_first)

Definition at line 576 of file queue.h.

◆ LIST_FOREACH

#define LIST_FOREACH ( var,
head,
field )
Value:
for ((var) = LIST_FIRST((head)); \
(var); \
(var) = LIST_NEXT((var), field))

Definition at line 578 of file queue.h.

578#define LIST_FOREACH(var, head, field) \
579 for ((var) = LIST_FIRST((head)); \
580 (var); \
581 (var) = LIST_NEXT((var), field))

◆ LIST_FOREACH_FROM

#define LIST_FOREACH_FROM ( var,
head,
field )
Value:
for ((var) = ((var) ? (var) : LIST_FIRST((head))); \
(var); \
(var) = LIST_NEXT((var), field))

Definition at line 583 of file queue.h.

583#define LIST_FOREACH_FROM(var, head, field) \
584 for ((var) = ((var) ? (var) : LIST_FIRST((head))); \
585 (var); \
586 (var) = LIST_NEXT((var), field))

◆ LIST_FOREACH_SAFE

#define LIST_FOREACH_SAFE ( var,
head,
field,
tvar )
Value:
for ((var) = LIST_FIRST((head)); \
(var) && ((tvar) = LIST_NEXT((var), field), 1); \
(var) = (tvar))

Definition at line 588 of file queue.h.

588#define LIST_FOREACH_SAFE(var, head, field, tvar) \
589 for ((var) = LIST_FIRST((head)); \
590 (var) && ((tvar) = LIST_NEXT((var), field), 1); \
591 (var) = (tvar))

◆ LIST_FOREACH_FROM_SAFE

#define LIST_FOREACH_FROM_SAFE ( var,
head,
field,
tvar )
Value:
for ((var) = ((var) ? (var) : LIST_FIRST((head))); \
(var) && ((tvar) = LIST_NEXT((var), field), 1); \
(var) = (tvar))

Definition at line 593 of file queue.h.

593#define LIST_FOREACH_FROM_SAFE(var, head, field, tvar) \
594 for ((var) = ((var) ? (var) : LIST_FIRST((head))); \
595 (var) && ((tvar) = LIST_NEXT((var), field), 1); \
596 (var) = (tvar))

◆ LIST_INIT

#define LIST_INIT ( head)
Value:
do { \
LIST_FIRST((head)) = NULL; \
} while (0)

Definition at line 598 of file queue.h.

598#define LIST_INIT(head) do { \
599 LIST_FIRST((head)) = NULL; \
600} while (0)

◆ LIST_INSERT_AFTER

#define LIST_INSERT_AFTER ( listelm,
elm,
field )
Value:
do { \
QMD_LIST_CHECK_NEXT(listelm, field); \
if ((LIST_NEXT((elm), field) = LIST_NEXT((listelm), field)) != NULL)\
LIST_NEXT((listelm), field)->field.le_prev = \
&LIST_NEXT((elm), field); \
LIST_NEXT((listelm), field) = (elm); \
(elm)->field.le_prev = &LIST_NEXT((listelm), field); \
} while (0)

Definition at line 602 of file queue.h.

602#define LIST_INSERT_AFTER(listelm, elm, field) do { \
603 QMD_LIST_CHECK_NEXT(listelm, field); \
604 if ((LIST_NEXT((elm), field) = LIST_NEXT((listelm), field)) != NULL)\
605 LIST_NEXT((listelm), field)->field.le_prev = \
606 &LIST_NEXT((elm), field); \
607 LIST_NEXT((listelm), field) = (elm); \
608 (elm)->field.le_prev = &LIST_NEXT((listelm), field); \
609} while (0)

◆ LIST_INSERT_BEFORE

#define LIST_INSERT_BEFORE ( listelm,
elm,
field )
Value:
do { \
QMD_LIST_CHECK_PREV(listelm, field); \
(elm)->field.le_prev = (listelm)->field.le_prev; \
LIST_NEXT((elm), field) = (listelm); \
*(listelm)->field.le_prev = (elm); \
(listelm)->field.le_prev = &LIST_NEXT((elm), field); \
} while (0)

Definition at line 611 of file queue.h.

611#define LIST_INSERT_BEFORE(listelm, elm, field) do { \
612 QMD_LIST_CHECK_PREV(listelm, field); \
613 (elm)->field.le_prev = (listelm)->field.le_prev; \
614 LIST_NEXT((elm), field) = (listelm); \
615 *(listelm)->field.le_prev = (elm); \
616 (listelm)->field.le_prev = &LIST_NEXT((elm), field); \
617} while (0)

◆ LIST_INSERT_HEAD

#define LIST_INSERT_HEAD ( head,
elm,
field )
Value:
do { \
QMD_LIST_CHECK_HEAD((head), field); \
if ((LIST_NEXT((elm), field) = LIST_FIRST((head))) != NULL) \
LIST_FIRST((head))->field.le_prev = &LIST_NEXT((elm), field);\
LIST_FIRST((head)) = (elm); \
(elm)->field.le_prev = &LIST_FIRST((head)); \
} while (0)

Definition at line 619 of file queue.h.

619#define LIST_INSERT_HEAD(head, elm, field) do { \
620 QMD_LIST_CHECK_HEAD((head), field); \
621 if ((LIST_NEXT((elm), field) = LIST_FIRST((head))) != NULL) \
622 LIST_FIRST((head))->field.le_prev = &LIST_NEXT((elm), field);\
623 LIST_FIRST((head)) = (elm); \
624 (elm)->field.le_prev = &LIST_FIRST((head)); \
625} while (0)

◆ LIST_NEXT

#define LIST_NEXT ( elm,
field )
Value:
((elm)->field.le_next)

Definition at line 627 of file queue.h.

◆ LIST_PREV

#define LIST_PREV ( elm,
head,
type,
field )
Value:
((elm)->field.le_prev == &LIST_FIRST((head)) ? NULL : \
__containerof((elm)->field.le_prev, \
QUEUE_TYPEOF(type), field.le_next))

Definition at line 629 of file queue.h.

629#define LIST_PREV(elm, head, type, field) \
630 ((elm)->field.le_prev == &LIST_FIRST((head)) ? NULL : \
631 __containerof((elm)->field.le_prev, \
632 QUEUE_TYPEOF(type), field.le_next))

◆ LIST_REMOVE_HEAD

#define LIST_REMOVE_HEAD ( head,
field )
Value:
LIST_REMOVE(LIST_FIRST(head), field)
LIST_REMOVE
#define LIST_REMOVE(elm, field)
Definition queue.h:637

Definition at line 634 of file queue.h.

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

◆ LIST_REMOVE

#define LIST_REMOVE ( elm,
field )
Value:
do { \
QMD_SAVELINK(oldnext, (elm)->field.le_next); \
QMD_SAVELINK(oldprev, (elm)->field.le_prev); \
QMD_LIST_CHECK_NEXT(elm, field); \
QMD_LIST_CHECK_PREV(elm, field); \
if (LIST_NEXT((elm), field) != NULL) \
LIST_NEXT((elm), field)->field.le_prev = \
(elm)->field.le_prev; \
*(elm)->field.le_prev = LIST_NEXT((elm), field); \
TRASHIT(*oldnext); \
TRASHIT(*oldprev); \
} while (0)

Definition at line 637 of file queue.h.

637#define LIST_REMOVE(elm, field) do { \
638 QMD_SAVELINK(oldnext, (elm)->field.le_next); \
639 QMD_SAVELINK(oldprev, (elm)->field.le_prev); \
640 QMD_LIST_CHECK_NEXT(elm, field); \
641 QMD_LIST_CHECK_PREV(elm, field); \
642 if (LIST_NEXT((elm), field) != NULL) \
643 LIST_NEXT((elm), field)->field.le_prev = \
644 (elm)->field.le_prev; \
645 *(elm)->field.le_prev = LIST_NEXT((elm), field); \
646 TRASHIT(*oldnext); \
647 TRASHIT(*oldprev); \
648} while (0)

◆ LIST_REPLACE

#define LIST_REPLACE ( elm,
elm2,
field )
Value:
do { \
QMD_SAVELINK(oldnext, (elm)->field.le_next); \
QMD_SAVELINK(oldprev, (elm)->field.le_prev); \
QMD_LIST_CHECK_NEXT(elm, field); \
QMD_LIST_CHECK_PREV(elm, field); \
LIST_NEXT((elm2), field) = LIST_NEXT((elm), field); \
if (LIST_NEXT((elm2), field) != NULL) \
LIST_NEXT((elm2), field)->field.le_prev = \
&(elm2)->field.le_next; \
(elm2)->field.le_prev = (elm)->field.le_prev; \
*(elm2)->field.le_prev = (elm2); \
TRASHIT(*oldnext); \
TRASHIT(*oldprev); \
} while (0)

Definition at line 650 of file queue.h.

650#define LIST_REPLACE(elm, elm2, field) do { \
651 QMD_SAVELINK(oldnext, (elm)->field.le_next); \
652 QMD_SAVELINK(oldprev, (elm)->field.le_prev); \
653 QMD_LIST_CHECK_NEXT(elm, field); \
654 QMD_LIST_CHECK_PREV(elm, field); \
655 LIST_NEXT((elm2), field) = LIST_NEXT((elm), field); \
656 if (LIST_NEXT((elm2), field) != NULL) \
657 LIST_NEXT((elm2), field)->field.le_prev = \
658 &(elm2)->field.le_next; \
659 (elm2)->field.le_prev = (elm)->field.le_prev; \
660 *(elm2)->field.le_prev = (elm2); \
661 TRASHIT(*oldnext); \
662 TRASHIT(*oldprev); \
663} while (0)

◆ LIST_SWAP

#define LIST_SWAP ( head1,
head2,
type,
field )
Value:
do { \
QUEUE_TYPEOF(type) *swap_tmp = LIST_FIRST(head1); \
LIST_FIRST((head1)) = LIST_FIRST((head2)); \
LIST_FIRST((head2)) = swap_tmp; \
if ((swap_tmp = LIST_FIRST((head1))) != NULL) \
swap_tmp->field.le_prev = &LIST_FIRST((head1)); \
if ((swap_tmp = LIST_FIRST((head2))) != NULL) \
swap_tmp->field.le_prev = &LIST_FIRST((head2)); \
} while (0)

Definition at line 665 of file queue.h.

665#define LIST_SWAP(head1, head2, type, field) do { \
666 QUEUE_TYPEOF(type) *swap_tmp = LIST_FIRST(head1); \
667 LIST_FIRST((head1)) = LIST_FIRST((head2)); \
668 LIST_FIRST((head2)) = swap_tmp; \
669 if ((swap_tmp = LIST_FIRST((head1))) != NULL) \
670 swap_tmp->field.le_prev = &LIST_FIRST((head1)); \
671 if ((swap_tmp = LIST_FIRST((head2))) != NULL) \
672 swap_tmp->field.le_prev = &LIST_FIRST((head2)); \
673} while (0)

◆ LIST_END

#define LIST_END ( head)
Value:
NULL

Definition at line 675 of file queue.h.

◆ TAILQ_HEAD

#define TAILQ_HEAD ( name,
type )
Value:
struct name { \
struct type *tqh_first; /* first element */ \
struct type **tqh_last; /* addr of last next element */ \
TRACEBUF \
}
TRACEBUF
#define TRACEBUF
Definition queue.h:150

Definition at line 680 of file queue.h.

680#define TAILQ_HEAD(name, type) \
681struct name { \
682 struct type *tqh_first; /* first element */ \
683 struct type **tqh_last; /* addr of last next element */ \
684 TRACEBUF \
685}

◆ TAILQ_CLASS_HEAD

#define TAILQ_CLASS_HEAD ( name,
type )
Value:
struct name { \
class type *tqh_first; /* first element */ \
class type **tqh_last; /* addr of last next element */ \
TRACEBUF \
}

Definition at line 687 of file queue.h.

687#define TAILQ_CLASS_HEAD(name, type) \
688struct name { \
689 class type *tqh_first; /* first element */ \
690 class type **tqh_last; /* addr of last next element */ \
691 TRACEBUF \
692}

◆ TAILQ_HEAD_INITIALIZER

#define TAILQ_HEAD_INITIALIZER ( head)
Value:
{ NULL, &(head).tqh_first, TRACEBUF_INITIALIZER }
TRACEBUF_INITIALIZER
#define TRACEBUF_INITIALIZER
Definition queue.h:151

Definition at line 694 of file queue.h.

694#define TAILQ_HEAD_INITIALIZER(head) \
695 { NULL, &(head).tqh_first, TRACEBUF_INITIALIZER }

◆ TAILQ_ENTRY

#define TAILQ_ENTRY ( type)
Value:
struct { \
struct type *tqe_next; /* next element */ \
struct type **tqe_prev; /* address of previous next element */ \
TRACEBUF \
}

Definition at line 697 of file queue.h.

697#define TAILQ_ENTRY(type) \
698struct { \
699 struct type *tqe_next; /* next element */ \
700 struct type **tqe_prev; /* address of previous next element */ \
701 TRACEBUF \
702}

◆ TAILQ_CLASS_ENTRY

#define TAILQ_CLASS_ENTRY ( type)
Value:
struct { \
class type *tqe_next; /* next element */ \
class type **tqe_prev; /* address of previous next element */ \
TRACEBUF \
}

Definition at line 704 of file queue.h.

704#define TAILQ_CLASS_ENTRY(type) \
705struct { \
706 class type *tqe_next; /* next element */ \
707 class type **tqe_prev; /* address of previous next element */ \
708 TRACEBUF \
709}

◆ QMD_TAILQ_CHECK_HEAD

#define QMD_TAILQ_CHECK_HEAD ( head,
field )

Definition at line 761 of file queue.h.

◆ QMD_TAILQ_CHECK_TAIL

#define QMD_TAILQ_CHECK_TAIL ( head,
headname )

Definition at line 762 of file queue.h.

◆ QMD_TAILQ_CHECK_NEXT

#define QMD_TAILQ_CHECK_NEXT ( elm,
field )

Definition at line 763 of file queue.h.

◆ QMD_TAILQ_CHECK_PREV

#define QMD_TAILQ_CHECK_PREV ( elm,
field )

Definition at line 764 of file queue.h.

◆ TAILQ_CONCAT

#define TAILQ_CONCAT ( head1,
head2,
field )
Value:
do { \
if (!TAILQ_EMPTY(head2)) { \
*(head1)->tqh_last = (head2)->tqh_first; \
(head2)->tqh_first->field.tqe_prev = (head1)->tqh_last; \
(head1)->tqh_last = (head2)->tqh_last; \
TAILQ_INIT((head2)); \
QMD_TRACE_HEAD(head1); \
QMD_TRACE_HEAD(head2); \
} \
} while (0)
TAILQ_EMPTY
#define TAILQ_EMPTY(head)
Definition queue.h:778

Definition at line 767 of file queue.h.

767#define TAILQ_CONCAT(head1, head2, field) do { \
768 if (!TAILQ_EMPTY(head2)) { \
769 *(head1)->tqh_last = (head2)->tqh_first; \
770 (head2)->tqh_first->field.tqe_prev = (head1)->tqh_last; \
771 (head1)->tqh_last = (head2)->tqh_last; \
772 TAILQ_INIT((head2)); \
773 QMD_TRACE_HEAD(head1); \
774 QMD_TRACE_HEAD(head2); \
775 } \
776} while (0)

◆ TAILQ_EMPTY

#define TAILQ_EMPTY ( head)
Value:
((head)->tqh_first == NULL)

Definition at line 778 of file queue.h.

◆ TAILQ_FIRST

#define TAILQ_FIRST ( head)
Value:
((head)->tqh_first)

Definition at line 780 of file queue.h.

◆ TAILQ_FOREACH

#define TAILQ_FOREACH ( var,
head,
field )
Value:
for ((var) = TAILQ_FIRST((head)); \
(var); \
(var) = TAILQ_NEXT((var), field))
TAILQ_FIRST
#define TAILQ_FIRST(head)
Definition queue.h:780
TAILQ_NEXT
#define TAILQ_NEXT(elm, field)
Definition queue.h:889

Definition at line 782 of file queue.h.

782#define TAILQ_FOREACH(var, head, field) \
783 for ((var) = TAILQ_FIRST((head)); \
784 (var); \
785 (var) = TAILQ_NEXT((var), field))

◆ TAILQ_FOREACH_FROM

#define TAILQ_FOREACH_FROM ( var,
head,
field )
Value:
for ((var) = ((var) ? (var) : TAILQ_FIRST((head))); \
(var); \
(var) = TAILQ_NEXT((var), field))

Definition at line 787 of file queue.h.

787#define TAILQ_FOREACH_FROM(var, head, field) \
788 for ((var) = ((var) ? (var) : TAILQ_FIRST((head))); \
789 (var); \
790 (var) = TAILQ_NEXT((var), field))

◆ TAILQ_FOREACH_SAFE

#define TAILQ_FOREACH_SAFE ( var,
head,
field,
tvar )
Value:
for ((var) = TAILQ_FIRST((head)); \
(var) && ((tvar) = TAILQ_NEXT((var), field), 1); \
(var) = (tvar))

Definition at line 792 of file queue.h.

792#define TAILQ_FOREACH_SAFE(var, head, field, tvar) \
793 for ((var) = TAILQ_FIRST((head)); \
794 (var) && ((tvar) = TAILQ_NEXT((var), field), 1); \
795 (var) = (tvar))

◆ TAILQ_FOREACH_FROM_SAFE

#define TAILQ_FOREACH_FROM_SAFE ( var,
head,
field,
tvar )
Value:
for ((var) = ((var) ? (var) : TAILQ_FIRST((head))); \
(var) && ((tvar) = TAILQ_NEXT((var), field), 1); \
(var) = (tvar))

Definition at line 797 of file queue.h.

797#define TAILQ_FOREACH_FROM_SAFE(var, head, field, tvar) \
798 for ((var) = ((var) ? (var) : TAILQ_FIRST((head))); \
799 (var) && ((tvar) = TAILQ_NEXT((var), field), 1); \
800 (var) = (tvar))

◆ TAILQ_FOREACH_REVERSE

#define TAILQ_FOREACH_REVERSE ( var,
head,
headname,
field )
Value:
for ((var) = TAILQ_LAST((head), headname); \
(var); \
(var) = TAILQ_PREV((var), headname, field))
TAILQ_PREV
#define TAILQ_PREV(elm, headname, field)
Definition queue.h:891
TAILQ_LAST
#define TAILQ_LAST(head, headname)
Definition queue.h:876

Definition at line 802 of file queue.h.

802#define TAILQ_FOREACH_REVERSE(var, head, headname, field) \
803 for ((var) = TAILQ_LAST((head), headname); \
804 (var); \
805 (var) = TAILQ_PREV((var), headname, field))

◆ TAILQ_FOREACH_REVERSE_FROM

#define TAILQ_FOREACH_REVERSE_FROM ( var,
head,
headname,
field )
Value:
for ((var) = ((var) ? (var) : TAILQ_LAST((head), headname)); \
(var); \
(var) = TAILQ_PREV((var), headname, field))

Definition at line 807 of file queue.h.

807#define TAILQ_FOREACH_REVERSE_FROM(var, head, headname, field) \
808 for ((var) = ((var) ? (var) : TAILQ_LAST((head), headname)); \
809 (var); \
810 (var) = TAILQ_PREV((var), headname, field))

◆ TAILQ_FOREACH_REVERSE_SAFE

#define TAILQ_FOREACH_REVERSE_SAFE ( var,
head,
headname,
field,
tvar )
Value:
for ((var) = TAILQ_LAST((head), headname); \
(var) && ((tvar) = TAILQ_PREV((var), headname, field), 1); \
(var) = (tvar))

Definition at line 812 of file queue.h.

812#define TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar) \
813 for ((var) = TAILQ_LAST((head), headname); \
814 (var) && ((tvar) = TAILQ_PREV((var), headname, field), 1); \
815 (var) = (tvar))

◆ TAILQ_FOREACH_REVERSE_FROM_SAFE

#define TAILQ_FOREACH_REVERSE_FROM_SAFE ( var,
head,
headname,
field,
tvar )
Value:
for ((var) = ((var) ? (var) : TAILQ_LAST((head), headname)); \
(var) && ((tvar) = TAILQ_PREV((var), headname, field), 1); \
(var) = (tvar))

Definition at line 817 of file queue.h.

817#define TAILQ_FOREACH_REVERSE_FROM_SAFE(var, head, headname, field, tvar)\
818 for ((var) = ((var) ? (var) : TAILQ_LAST((head), headname)); \
819 (var) && ((tvar) = TAILQ_PREV((var), headname, field), 1); \
820 (var) = (tvar))

◆ TAILQ_INIT

#define TAILQ_INIT ( head)
Value:
do { \
TAILQ_FIRST((head)) = NULL; \
(head)->tqh_last = &TAILQ_FIRST((head)); \
QMD_TRACE_HEAD(head); \
} while (0)

Definition at line 822 of file queue.h.

822#define TAILQ_INIT(head) do { \
823 TAILQ_FIRST((head)) = NULL; \
824 (head)->tqh_last = &TAILQ_FIRST((head)); \
825 QMD_TRACE_HEAD(head); \
826} while (0)

◆ TAILQ_INSERT_AFTER

#define TAILQ_INSERT_AFTER ( head,
listelm,
elm,
field )
Value:
do { \
QMD_TAILQ_CHECK_NEXT(listelm, field); \
if ((TAILQ_NEXT((elm), field) = TAILQ_NEXT((listelm), field)) != NULL)\
TAILQ_NEXT((elm), field)->field.tqe_prev = \
&TAILQ_NEXT((elm), field); \
else { \
(head)->tqh_last = &TAILQ_NEXT((elm), field); \
QMD_TRACE_HEAD(head); \
} \
TAILQ_NEXT((listelm), field) = (elm); \
(elm)->field.tqe_prev = &TAILQ_NEXT((listelm), field); \
QMD_TRACE_ELEM(&(elm)->field); \
QMD_TRACE_ELEM(&(listelm)->field); \
} while (0)

Definition at line 828 of file queue.h.

828#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \
829 QMD_TAILQ_CHECK_NEXT(listelm, field); \
830 if ((TAILQ_NEXT((elm), field) = TAILQ_NEXT((listelm), field)) != NULL)\
831 TAILQ_NEXT((elm), field)->field.tqe_prev = \
832 &TAILQ_NEXT((elm), field); \
833 else { \
834 (head)->tqh_last = &TAILQ_NEXT((elm), field); \
835 QMD_TRACE_HEAD(head); \
836 } \
837 TAILQ_NEXT((listelm), field) = (elm); \
838 (elm)->field.tqe_prev = &TAILQ_NEXT((listelm), field); \
839 QMD_TRACE_ELEM(&(elm)->field); \
840 QMD_TRACE_ELEM(&(listelm)->field); \
841} while (0)

◆ TAILQ_INSERT_BEFORE

#define TAILQ_INSERT_BEFORE ( listelm,
elm,
field )
Value:
do { \
QMD_TAILQ_CHECK_PREV(listelm, field); \
(elm)->field.tqe_prev = (listelm)->field.tqe_prev; \
TAILQ_NEXT((elm), field) = (listelm); \
*(listelm)->field.tqe_prev = (elm); \
(listelm)->field.tqe_prev = &TAILQ_NEXT((elm), field); \
QMD_TRACE_ELEM(&(elm)->field); \
QMD_TRACE_ELEM(&(listelm)->field); \
} while (0)

Definition at line 843 of file queue.h.

843#define TAILQ_INSERT_BEFORE(listelm, elm, field) do { \
844 QMD_TAILQ_CHECK_PREV(listelm, field); \
845 (elm)->field.tqe_prev = (listelm)->field.tqe_prev; \
846 TAILQ_NEXT((elm), field) = (listelm); \
847 *(listelm)->field.tqe_prev = (elm); \
848 (listelm)->field.tqe_prev = &TAILQ_NEXT((elm), field); \
849 QMD_TRACE_ELEM(&(elm)->field); \
850 QMD_TRACE_ELEM(&(listelm)->field); \
851} while (0)

◆ TAILQ_INSERT_HEAD

#define TAILQ_INSERT_HEAD ( head,
elm,
field )
Value:
do { \
QMD_TAILQ_CHECK_HEAD(head, field); \
if ((TAILQ_NEXT((elm), field) = TAILQ_FIRST((head))) != NULL) \
TAILQ_FIRST((head))->field.tqe_prev = \
&TAILQ_NEXT((elm), field); \
else \
(head)->tqh_last = &TAILQ_NEXT((elm), field); \
TAILQ_FIRST((head)) = (elm); \
(elm)->field.tqe_prev = &TAILQ_FIRST((head)); \
QMD_TRACE_HEAD(head); \
QMD_TRACE_ELEM(&(elm)->field); \
} while (0)

Definition at line 853 of file queue.h.

853#define TAILQ_INSERT_HEAD(head, elm, field) do { \
854 QMD_TAILQ_CHECK_HEAD(head, field); \
855 if ((TAILQ_NEXT((elm), field) = TAILQ_FIRST((head))) != NULL) \
856 TAILQ_FIRST((head))->field.tqe_prev = \
857 &TAILQ_NEXT((elm), field); \
858 else \
859 (head)->tqh_last = &TAILQ_NEXT((elm), field); \
860 TAILQ_FIRST((head)) = (elm); \
861 (elm)->field.tqe_prev = &TAILQ_FIRST((head)); \
862 QMD_TRACE_HEAD(head); \
863 QMD_TRACE_ELEM(&(elm)->field); \
864} while (0)

◆ TAILQ_INSERT_TAIL

#define TAILQ_INSERT_TAIL ( head,
elm,
field )
Value:
do { \
QMD_TAILQ_CHECK_TAIL(head, field); \
TAILQ_NEXT((elm), field) = NULL; \
(elm)->field.tqe_prev = (head)->tqh_last; \
*(head)->tqh_last = (elm); \
(head)->tqh_last = &TAILQ_NEXT((elm), field); \
QMD_TRACE_HEAD(head); \
QMD_TRACE_ELEM(&(elm)->field); \
} while (0)

Definition at line 866 of file queue.h.

866#define TAILQ_INSERT_TAIL(head, elm, field) do { \
867 QMD_TAILQ_CHECK_TAIL(head, field); \
868 TAILQ_NEXT((elm), field) = NULL; \
869 (elm)->field.tqe_prev = (head)->tqh_last; \
870 *(head)->tqh_last = (elm); \
871 (head)->tqh_last = &TAILQ_NEXT((elm), field); \
872 QMD_TRACE_HEAD(head); \
873 QMD_TRACE_ELEM(&(elm)->field); \
874} while (0)

◆ TAILQ_LAST

#define TAILQ_LAST ( head,
headname )
Value:
(*(((struct headname *)((head)->tqh_last))->tqh_last))

Definition at line 876 of file queue.h.

876#define TAILQ_LAST(head, headname) \
877 (*(((struct headname *)((head)->tqh_last))->tqh_last))

◆ TAILQ_LAST_FAST

#define TAILQ_LAST_FAST ( head,
type,
field )
Value:
(TAILQ_EMPTY(head) ? NULL : __containerof((head)->tqh_last, QUEUE_TYPEOF(type), field.tqe_next))

Definition at line 886 of file queue.h.

886#define TAILQ_LAST_FAST(head, type, field) \
887 (TAILQ_EMPTY(head) ? NULL : __containerof((head)->tqh_last, QUEUE_TYPEOF(type), field.tqe_next))

◆ TAILQ_NEXT

#define TAILQ_NEXT ( elm,
field )
Value:
((elm)->field.tqe_next)

Definition at line 889 of file queue.h.

◆ TAILQ_PREV

#define TAILQ_PREV ( elm,
headname,
field )
Value:
(*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))

Definition at line 891 of file queue.h.

891#define TAILQ_PREV(elm, headname, field) \
892 (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))

◆ TAILQ_PREV_FAST

#define TAILQ_PREV_FAST ( elm,
head,
type,
field )
Value:
((elm)->field.tqe_prev == &(head)->tqh_first ? NULL : \
__containerof((elm)->field.tqe_prev, QUEUE_TYPEOF(type), field.tqe_next))

Definition at line 894 of file queue.h.

894#define TAILQ_PREV_FAST(elm, head, type, field) \
895 ((elm)->field.tqe_prev == &(head)->tqh_first ? NULL : \
896 __containerof((elm)->field.tqe_prev, QUEUE_TYPEOF(type), field.tqe_next))

◆ TAILQ_REMOVE_HEAD

#define TAILQ_REMOVE_HEAD ( head,
field )
Value:
TAILQ_REMOVE(head, TAILQ_FIRST(head), field)
TAILQ_REMOVE
#define TAILQ_REMOVE(head, elm, field)
Definition queue.h:901

Definition at line 898 of file queue.h.

898#define TAILQ_REMOVE_HEAD(head, field) \
899 TAILQ_REMOVE(head, TAILQ_FIRST(head), field)

◆ TAILQ_REMOVE

#define TAILQ_REMOVE ( head,
elm,
field )
Value:
do { \
QMD_SAVELINK(oldnext, (elm)->field.tqe_next); \
QMD_SAVELINK(oldprev, (elm)->field.tqe_prev); \
QMD_TAILQ_CHECK_NEXT(elm, field); \
QMD_TAILQ_CHECK_PREV(elm, field); \
if ((TAILQ_NEXT((elm), field)) != NULL) \
TAILQ_NEXT((elm), field)->field.tqe_prev = \
(elm)->field.tqe_prev; \
else { \
(head)->tqh_last = (elm)->field.tqe_prev; \
QMD_TRACE_HEAD(head); \
} \
*(elm)->field.tqe_prev = TAILQ_NEXT((elm), field); \
TRASHIT(*oldnext); \
TRASHIT(*oldprev); \
QMD_TRACE_ELEM(&(elm)->field); \
} while (0)

Definition at line 901 of file queue.h.

901#define TAILQ_REMOVE(head, elm, field) do { \
902 QMD_SAVELINK(oldnext, (elm)->field.tqe_next); \
903 QMD_SAVELINK(oldprev, (elm)->field.tqe_prev); \
904 QMD_TAILQ_CHECK_NEXT(elm, field); \
905 QMD_TAILQ_CHECK_PREV(elm, field); \
906 if ((TAILQ_NEXT((elm), field)) != NULL) \
907 TAILQ_NEXT((elm), field)->field.tqe_prev = \
908 (elm)->field.tqe_prev; \
909 else { \
910 (head)->tqh_last = (elm)->field.tqe_prev; \
911 QMD_TRACE_HEAD(head); \
912 } \
913 *(elm)->field.tqe_prev = TAILQ_NEXT((elm), field); \
914 TRASHIT(*oldnext); \
915 TRASHIT(*oldprev); \
916 QMD_TRACE_ELEM(&(elm)->field); \
917} while (0)

◆ TAILQ_REPLACE

#define TAILQ_REPLACE ( head,
elm,
elm2,
field )
Value:
do { \
QMD_SAVELINK(oldnext, (elm)->field.tqe_next); \
QMD_SAVELINK(oldprev, (elm)->field.tqe_prev); \
QMD_TAILQ_CHECK_NEXT(elm, field); \
QMD_TAILQ_CHECK_PREV(elm, field); \
TAILQ_NEXT((elm2), field) = TAILQ_NEXT((elm), field); \
if (TAILQ_NEXT((elm2), field) != TAILQ_END(head)) \
TAILQ_NEXT((elm2), field)->field.tqe_prev = \
&(elm2)->field.tqe_next; \
else \
(head)->tqh_last = &(elm2)->field.tqe_next; \
(elm2)->field.tqe_prev = (elm)->field.tqe_prev; \
*(elm2)->field.tqe_prev = (elm2); \
TRASHIT(*oldnext); \
TRASHIT(*oldprev); \
QMD_TRACE_ELEM(&(elm)->field); \
} while (0)
TAILQ_END
#define TAILQ_END(head)
Definition queue.h:954

Definition at line 919 of file queue.h.

919#define TAILQ_REPLACE(head, elm, elm2, field) do { \
920 QMD_SAVELINK(oldnext, (elm)->field.tqe_next); \
921 QMD_SAVELINK(oldprev, (elm)->field.tqe_prev); \
922 QMD_TAILQ_CHECK_NEXT(elm, field); \
923 QMD_TAILQ_CHECK_PREV(elm, field); \
924 TAILQ_NEXT((elm2), field) = TAILQ_NEXT((elm), field); \
925 if (TAILQ_NEXT((elm2), field) != TAILQ_END(head)) \
926 TAILQ_NEXT((elm2), field)->field.tqe_prev = \
927 &(elm2)->field.tqe_next; \
928 else \
929 (head)->tqh_last = &(elm2)->field.tqe_next; \
930 (elm2)->field.tqe_prev = (elm)->field.tqe_prev; \
931 *(elm2)->field.tqe_prev = (elm2); \
932 TRASHIT(*oldnext); \
933 TRASHIT(*oldprev); \
934 QMD_TRACE_ELEM(&(elm)->field); \
935} while (0)

◆ TAILQ_SWAP

#define TAILQ_SWAP ( head1,
head2,
type,
field )
Value:
do { \
QUEUE_TYPEOF(type) *swap_first = (head1)->tqh_first; \
QUEUE_TYPEOF(type) **swap_last = (head1)->tqh_last; \
(head1)->tqh_first = (head2)->tqh_first; \
(head1)->tqh_last = (head2)->tqh_last; \
(head2)->tqh_first = swap_first; \
(head2)->tqh_last = swap_last; \
if ((swap_first = (head1)->tqh_first) != NULL) \
swap_first->field.tqe_prev = &(head1)->tqh_first; \
else \
(head1)->tqh_last = &(head1)->tqh_first; \
if ((swap_first = (head2)->tqh_first) != NULL) \
swap_first->field.tqe_prev = &(head2)->tqh_first; \
else \
(head2)->tqh_last = &(head2)->tqh_first; \
} while (0)

Definition at line 937 of file queue.h.

937#define TAILQ_SWAP(head1, head2, type, field) do { \
938 QUEUE_TYPEOF(type) *swap_first = (head1)->tqh_first; \
939 QUEUE_TYPEOF(type) **swap_last = (head1)->tqh_last; \
940 (head1)->tqh_first = (head2)->tqh_first; \
941 (head1)->tqh_last = (head2)->tqh_last; \
942 (head2)->tqh_first = swap_first; \
943 (head2)->tqh_last = swap_last; \
944 if ((swap_first = (head1)->tqh_first) != NULL) \
945 swap_first->field.tqe_prev = &(head1)->tqh_first; \
946 else \
947 (head1)->tqh_last = &(head1)->tqh_first; \
948 if ((swap_first = (head2)->tqh_first) != NULL) \
949 swap_first->field.tqe_prev = &(head2)->tqh_first; \
950 else \
951 (head2)->tqh_last = &(head2)->tqh_first; \
952} while (0)

◆ TAILQ_END

#define TAILQ_END ( head)
Value:
NULL

Definition at line 954 of file queue.h.