QUEUE(3) | Library Functions Manual | QUEUE(3) |
SLIST_HEAD
,
SLIST_HEAD_INITIALIZER
,
SLIST_ENTRY
, SLIST_FIRST
,
SLIST_EMPTY
, SLIST_NEXT
,
SLIST_FOREACH
,
SLIST_FOREACH_SAFE
,
SLIST_INIT
,
SLIST_INSERT_AFTER
,
SLIST_INSERT_HEAD
,
SLIST_REMOVE_AFTER
,
SLIST_REMOVE_HEAD
,
SLIST_REMOVE
, LIST_HEAD
,
LIST_HEAD_INITIALIZER
,
LIST_ENTRY
, LIST_FIRST
,
LIST_EMPTY
, LIST_NEXT
,
LIST_FOREACH
,
LIST_FOREACH_SAFE
, LIST_INIT
,
LIST_INSERT_AFTER
,
LIST_INSERT_BEFORE
,
LIST_INSERT_HEAD
, LIST_REMOVE
,
LIST_REPLACE
, LIST_MOVE
,
SIMPLEQ_HEAD
,
SIMPLEQ_HEAD_INITIALIZER
,
SIMPLEQ_ENTRY
, SIMPLEQ_FIRST
,
SIMPLEQ_EMPTY
, SIMPLEQ_NEXT
,
SIMPLEQ_LAST
, SIMPLEQ_FOREACH
,
SIMPLEQ_FOREACH_SAFE
,
SIMPLEQ_INIT
,
SIMPLEQ_INSERT_AFTER
,
SIMPLEQ_INSERT_HEAD
,
SIMPLEQ_INSERT_TAIL
,
SIMPLEQ_REMOVE_AFTER
,
SIMPLEQ_REMOVE_HEAD
,
SIMPLEQ_REMOVE
,
SIMPLEQ_CONCAT
, TAILQ_HEAD
,
TAILQ_HEAD_INITIALIZER
,
TAILQ_ENTRY
, TAILQ_FIRST
,
TAILQ_NEXT
, TAILQ_LAST
,
TAILQ_PREV
, TAILQ_EMPTY
,
TAILQ_FOREACH
,
TAILQ_FOREACH_SAFE
,
TAILQ_FOREACH_REVERSE
,
TAILQ_FOREACH_REVERSE_SAFE
,
TAILQ_INIT
,
TAILQ_INSERT_AFTER
,
TAILQ_INSERT_BEFORE
,
TAILQ_INSERT_HEAD
,
TAILQ_INSERT_TAIL
,
TAILQ_REMOVE
, TAILQ_REPLACE
,
TAILQ_CONCAT
, STAILQ_HEAD
,
STAILQ_HEAD_INITIALIZER
,
STAILQ_ENTRY
, STAILQ_FIRST
,
STAILQ_EMPTY
, STAILQ_NEXT
,
STAILQ_LAST
, STAILQ_FOREACH
,
STAILQ_FOREACH_SAFE
,
STAILQ_INIT
,
STAILQ_INSERT_AFTER
,
STAILQ_INSERT_HEAD
,
STAILQ_INSERT_TAIL
,
STAILQ_REMOVE_HEAD
,
STAILQ_REMOVE
, STAILQ_CONCAT
—
#include <sys/queue.h>
SLIST_HEAD
(HEADNAME,
TYPE);
SLIST_HEAD_INITIALIZER
(head);
SLIST_ENTRY
(TYPE);
TYPE *
SLIST_FIRST
(SLIST_HEAD
*head);
int
SLIST_EMPTY
(SLIST_HEAD
*head);
TYPE *
SLIST_NEXT
(TYPE
*elm, SLIST_ENTRY
NAME);
SLIST_FOREACH
(TYPE
*var, SLIST_HEAD
*head, SLIST_ENTRY
NAME);
SLIST_FOREACH_SAFE
(TYPE
*var, SLIST_HEAD
*head, SLIST_ENTRY
NAME, TYPE
*tmp);
SLIST_INIT
(SLIST_HEAD
*head);
SLIST_INSERT_HEAD
(SLIST_HEAD
*head, TYPE *elm,
SLIST_ENTRY NAME);
SLIST_INSERT_AFTER
(TYPE
*listelm, TYPE
*elm, SLIST_ENTRY
NAME);
SLIST_REMOVE
(SLIST_HEAD
*head, TYPE *elm,
TYPE,
SLIST_ENTRY NAME);
SLIST_REMOVE_HEAD
(SLIST_HEAD
*head, SLIST_ENTRY
NAME);
LIST_HEAD
(HEADNAME,
TYPE);
LIST_HEAD_INITIALIZER
(head);
LIST_ENTRY
(TYPE);
TYPE *
LIST_FIRST
(LIST_HEAD
*head);
TYPE *
LIST_NEXT
(TYPE
*elm, LIST_ENTRY
NAME);
int
LIST_EMPTY
(LIST_HEAD
*head);
LIST_FOREACH
(TYPE
*var, LIST_HEAD
*head, LIST_ENTRY
NAME);
LIST_FOREACH_SAFE
(TYPE
*var, LIST_HEAD
*head, LIST_ENTRY
NAME, TYPE
*tmp);
LIST_INIT
(LIST_HEAD
*head);
LIST_INSERT_AFTER
(TYPE
*listelm, TYPE
*elm, LIST_ENTRY
NAME);
LIST_INSERT_BEFORE
(TYPE
*listelm, TYPE
*elm, LIST_ENTRY
NAME);
LIST_INSERT_HEAD
(LIST_HEAD
*head, TYPE *elm,
LIST_ENTRY NAME);
LIST_REMOVE
(TYPE
*elm, LIST_ENTRY
NAME);
LIST_REPLACE
(TYPE
*elm, TYPE *new,
LIST_ENTRY NAME);
LIST_MOVE
(LIST_HEAD
*head1, LIST_HEAD
*head2, LIST_ENTRY
NAME);
SIMPLEQ_HEAD
(HEADNAME,
TYPE);
SIMPLEQ_HEAD_INITIALIZER
(head);
SIMPLEQ_ENTRY
(TYPE);
TYPE *
SIMPLEQ_FIRST
(SIMPLEQ_HEAD
*head);
int
SIMPLEQ_EMPTY
(SIMPLEQ_HEAD
*head);
TYPE *
SIMPLEQ_NEXT
(TYPE
*elm, SIMPLEQ_ENTRY
NAME);
TYPE *
SIMPLEQ_LAST
(SIMPLEQ_HEAD
*head, TYPE *elm,
SIMPLEQ_ENTRY NAME);
SIMPLEQ_FOREACH
(TYPE
*var, SIMPLEQ_HEAD
*head, SIMPLEQ_ENTRY
NAME);
SIMPLEQ_FOREACH_SAFE
(TYPE
*var, SIMPLEQ_HEAD
*head, SIMPLEQ_ENTRY
NAME, TYPE
*tmp);
SIMPLEQ_INIT
(SIMPLEQ_HEAD
*head);
SIMPLEQ_INSERT_HEAD
(SIMPLEQ_HEAD
*head, TYPE *elm,
SIMPLEQ_ENTRY NAME);
SIMPLEQ_INSERT_TAIL
(SIMPLEQ_HEAD
*head, TYPE *elm,
SIMPLEQ_ENTRY NAME);
SIMPLEQ_INSERT_AFTER
(SIMPLEQ_HEAD
*head, TYPE
*listelm, TYPE
*elm, SIMPLEQ_ENTRY
NAME);
SIMPLEQ_REMOVE_HEAD
(SIMPLEQ_HEAD
*head, SIMPLEQ_ENTRY
NAME);
SIMPLEQ_REMOVE_AFTER
(SIMPLEQ_HEAD
*head, TYPE *elm,
SIMPLEQ_ENTRY NAME);
SIMPLEQ_REMOVE
(SIMPLEQ_HEAD
*head, TYPE *elm,
TYPE,
SIMPLEQ_ENTRY NAME);
SIMPLEQ_CONCAT
(SIMPLEQ_HEAD
*head1, SIMPLEQ_HEAD
*head2);
TAILQ_HEAD
(HEADNAME,
TYPE);
TAILQ_HEAD_INITIALIZER
(head);
TAILQ_ENTRY
(TYPE);
TYPE *
TAILQ_FIRST
(TAILQ_HEAD
*head);
TYPE *
TAILQ_NEXT
(TYPE
*elm, TAILQ_ENTRY
NAME);
TYPE *
TAILQ_LAST
(TAILQ_HEAD
*head,
HEADNAME);
TYPE *
TAILQ_PREV
(TYPE
*elm, HEADNAME,
TAILQ_ENTRY NAME);
int
TAILQ_EMPTY
(TAILQ_HEAD
*head);
TAILQ_FOREACH
(TYPE
*var, TAILQ_HEAD
*head, TAILQ_ENTRY
NAME);
TAILQ_FOREACH_SAFE
(TYPE
*var, TAILQ_HEAD
*head, TAILQ_ENTRY
NAME, TYPE
*tmp);
TAILQ_FOREACH_REVERSE
(TYPE
*var, TAILQ_HEAD
*head, HEADNAME,
TAILQ_ENTRY NAME);
TAILQ_FOREACH_REVERSE_SAFE
(TYPE
*var, TAILQ_HEAD
*head, HEADNAME,
TAILQ_ENTRY NAME,
TYPE *tmp);
TAILQ_INIT
(TAILQ_HEAD
*head);
TAILQ_INSERT_HEAD
(TAILQ_HEAD
*head, TYPE *elm,
TAILQ_ENTRY NAME);
TAILQ_INSERT_TAIL
(TAILQ_HEAD
*head, TYPE *elm,
TAILQ_ENTRY NAME);
TAILQ_INSERT_AFTER
(TAILQ_HEAD
*head, TYPE
*listelm, TYPE
*elm, TAILQ_ENTRY
NAME);
TAILQ_INSERT_BEFORE
(TYPE
*listelm, TYPE
*elm, TAILQ_ENTRY
NAME);
TAILQ_REMOVE
(TAILQ_HEAD
*head, TYPE *elm,
TAILQ_ENTRY NAME);
TAILQ_REPLACE
(TAILQ_HEAD
*head, TYPE *elm,
TYPE *new,
TAILQ_ENTRY NAME);
TAILQ_CONCAT
(TAILQ_HEAD
*head1, TAILQ_HEAD
*head2, TAILQ_ENTRY
NAME);
STAILQ_HEAD
(HEADNAME,
TYPE);
STAILQ_HEAD_INITIALIZER
(head);
STAILQ_ENTRY
(TYPE);
TYPE *
STAILQ_FIRST
(STAILQ_HEAD
*head);
int
STAILQ_EMPTY
(STAILQ_HEAD
*head);
TYPE *
STAILQ_NEXT
(TYPE
*elm, STAILQ_ENTRY
NAME);
TYPE *
STAILQ_LAST
(STAILQ_HEAD
*head, TYPE *elm,
STAILQ_ENTRY NAME);
STAILQ_FOREACH
(TYPE
*var, STAILQ_HEAD
*head, STAILQ_ENTRY
NAME);
STAILQ_FOREACH_SAFE
(TYPE
*var, STAILQ_HEAD
*head, STAILQ_ENTRY
NAME, TYPE
*tmp);
STAILQ_INIT
(STAILQ_HEAD
*head);
STAILQ_INSERT_HEAD
(STAILQ_HEAD
*head, TYPE *elm,
STAILQ_ENTRY NAME);
STAILQ_INSERT_TAIL
(STAILQ_HEAD
*head, TYPE *elm,
STAILQ_ENTRY NAME);
STAILQ_INSERT_AFTER
(STAILQ_HEAD
*head, TYPE
*listelm, TYPE
*elm, STAILQ_ENTRY
NAME);
STAILQ_REMOVE_HEAD
(STAILQ_HEAD
*head, STAILQ_ENTRY
NAME);
STAILQ_REMOVE
(STAILQ_HEAD
*head, TYPE *elm,
TYPE,
STAILQ_ENTRY NAME);
STAILQ_CONCAT
(STAILQ_HEAD
*head1, STAILQ_HEAD
*head2);
Singly-linked lists are the simplest of the four data structures and support only the above functionality. Singly-linked lists are ideal for applications with large datasets and few or no removals, or for implementing a LIFO queue.
Simple queues add the following functionality:
Simple queues are ideal for applications with large datasets and few or no removals, or for implementing a FIFO queue.
All doubly linked types of data structures (lists and tail queues) additionally allow:
Linked lists are the simplest of the doubly linked data structures and support only the above functionality over singly-linked lists.
Tail queues add the following functionality:
Circular queues add the following functionality:
In the macro definitions, TYPE is the name
of a user defined structure, that must contain a field of type
SLIST_ENTRY
, LIST_ENTRY
,
SIMPLEQ_ENTRY
, TAILQ_ENTRY
,
or STAILQ_ENTRY
, named NAME.
The argument HEADNAME is the name of a user defined
structure that must be declared using the macros
LIST_HEAD
, SIMPLEQ_HEAD
,
SLIST_HEAD
, or TAILQ_HEAD
.
See the examples below for further explanation of how these macros are
used.
SLIST | LIST | SIMPLEQ | TAILQ | STAILQ | |
_FIRST | + | + | + | + | + |
_EMPTY | + | + | + | + | + |
_NEXT | + | + | + | + | + |
_PREV | - | - | - | + | - |
_LAST | - | - | + | + | + |
_FOREACH | + | + | + | + | + |
_FOREACH_SAFE | + | + | + | + | + |
_FOREACH_REVERSE | - | - | - | + | - |
_FOREACH_REVERSE_SAFE | - | - | - | + | - |
_INSERT_HEAD | + | + | + | + | + |
_INSERT_AFTER | + | + | + | + | + |
_INSERT_BEFORE | - | + | - | + | - |
_INSERT_TAIL | - | - | + | + | + |
_REMOVE | + | + | + | + | + |
_REMOVE_HEAD | + | - | + | - | + |
_REMOVE_AFTER | - | - | + | - | + |
_REPLACE | - | + | - | + | - |
_CONCAT | - | - | + | + | + |
SLIST_HEAD
() macro. This structure contains a single
pointer to the first element on the list. The elements are singly linked for
minimum space and pointer manipulation overhead at the expense of O(n) removal
for arbitrary elements. New elements can be added to the list after an
existing element or at the head of the list. An
SLIST_HEAD structure is declared as follows:
SLIST_HEAD(HEADNAME, TYPE) head;
where HEADNAME is the name of the structure to be defined, and TYPE is the type of the elements to be linked into the list. A pointer to the head of the list can later be declared as:
struct HEADNAME *headp;
(The names head
and
headp
are user selectable.)
The macro SLIST_HEAD_INITIALIZER
()
evaluates to an initializer for the list head.
The macro SLIST_ENTRY
() declares a
structure that connects the elements in the list.
The macro SLIST_FIRST
() returns the first
element in the list or NULL if the list is empty.
The macro SLIST_EMPTY
() evaluates to true
if there are no elements in the list.
The macro SLIST_NEXT
() returns the next
element in the list.
SLIST_FOREACH
() traverses the list
referenced by head in the forward direction, assigning
each element in turn to var.
The SAFE version uses tmp to hold the next element, so var may be freed or removed from the list.
The macro SLIST_INIT
() initializes the
list referenced by head.
The macro SLIST_INSERT_HEAD
() inserts the
new element elm at the head of the list.
The macro SLIST_INSERT_AFTER
() inserts the
new element elm after the element
listelm.
The macro SLIST_REMOVE
() removes the
element elm from the list.
The macro SLIST_REMOVE_HEAD
() removes the
first element from the head of the list. For optimum efficiency, elements
being removed from the head of the list should explicitly use this macro
instead of the generic SLIST_REMOVE
() macro.
The macro SLIST_REMOVE_AFTER
() removes the
element after the one specified. For optimum efficiency, elements being
removed after a specified one should explicitly use this macro instead of
the generic SLIST_REMOVE
()
SLIST_HEAD(slisthead, entry) head = SLIST_HEAD_INITIALIZER(head); struct slisthead *headp; /* Singly-linked List head. */ struct entry { ... SLIST_ENTRY(entry) entries; /* Singly-linked List. */ ... } *n1, *n2, *n3, *np; SLIST_INIT(&head); /* Initialize the list. */ n1 = malloc(sizeof(struct entry)); /* Insert at the head. */ SLIST_INSERT_HEAD(&head, n1, entries); n2 = malloc(sizeof(struct entry)); /* Insert after. */ SLIST_INSERT_AFTER(n1, n2, entries); SLIST_REMOVE(&head, n2, entry, entries);/* Deletion. */ free(n2); n3 = SLIST_FIRST(&head); SLIST_REMOVE_HEAD(&head, entries); /* Deletion from the head. */ free(n3); SLIST_FOREACH(np, &head, entries) /* Forward traversal. */ np-> ... while (!SLIST_EMPTY(&head)) { /* List Deletion. */ n1 = SLIST_FIRST(&head); SLIST_REMOVE_HEAD(&head, entries); free(n1); }
LIST_HEAD
() macro. This structure contains a single
pointer to the first element on the list. The elements are doubly linked so
that an arbitrary element can be removed without traversing the list. New
elements can be added to the list after an existing element, before an
existing element, or at the head of the list. A
LIST_HEAD structure is declared as follows:
LIST_HEAD(HEADNAME, TYPE) head;
where HEADNAME is the name of the structure to be defined, and TYPE is the type of the elements to be linked into the list. A pointer to the head of the list can later be declared as:
struct HEADNAME *headp;
(The names head
and
headp
are user selectable.)
The macro LIST_ENTRY
() declares a
structure that connects the elements in the list.
The macro LIST_HEAD_INITIALIZER
() provides
a value which can be used to initialize a list head at compile time, and is
used at the point that the list head variable is declared, like:
struct HEADNAME head = LIST_HEAD_INITIALIZER(head);
The macro LIST_FIRST
() returns the first
element of the list head.
The macro LIST_EMPTY
() returns true if the
list head has no elements.
The macro LIST_NEXT
() returns the element
after the element elm.
The macro LIST_FOREACH
() traverses the
list referenced by head in the forward direction,
assigning each element in turn to var.
The SAFE version uses tmp to hold the next element, so var may be freed or removed from the list.
The macro LIST_INIT
() initializes the list
referenced by head.
The macro LIST_INSERT_AFTER
() inserts the
new element elm after the element
listelm.
The macro LIST_INSERT_BEFORE
() inserts the
new element elm before the element
listelm.
The macro LIST_INSERT_HEAD
() inserts the
new element elm at the head of the list.
The macro LIST_REMOVE
() removes the
element elm from the list.
The macro LIST_REPLACE
() replaces the
element elm with new in the
list.
The macro LIST_MOVE
() moves the list
headed by head1 onto the list headed by
head2, always making the former empty.
LIST_HEAD(listhead, entry) head; struct listhead *headp; /* List head. */ struct entry { ... LIST_ENTRY(entry) entries; /* List. */ ... } *n1, *n2, *np; LIST_INIT(&head); /* Initialize the list. */ n1 = malloc(sizeof(struct entry)); /* Insert at the head. */ LIST_INSERT_HEAD(&head, n1, entries); n2 = malloc(sizeof(struct entry)); /* Insert after. */ LIST_INSERT_AFTER(n1, n2, entries); n2 = malloc(sizeof(struct entry)); /* Insert before. */ LIST_INSERT_BEFORE(n1, n2, entries); LIST_FOREACH(np, &head, entries) /* Forward traversal. */ np-> ... while (LIST_FIRST(&head) != NULL) /* Delete. */ LIST_REMOVE(LIST_FIRST(&head), entries); if (LIST_EMPTY(&head)) /* Test for emptiness. */ printf("nothing to do\n");
SIMPLEQ_HEAD
() macro. This structure contains a pair
of pointers, one to the first element in the simple queue and the other to the
last element in the simple queue. The elements are singly linked for minimum
space and pointer manipulation overhead at the expense of O(n) removal for
arbitrary elements. New elements can be added to the queue after an existing
element, at the head of the queue, or at the end of the queue. A
SIMPLEQ_HEAD structure is declared as follows:
SIMPLEQ_HEAD(HEADNAME, TYPE) head;
where HEADNAME
is the name of the
structure to be defined, and TYPE
is the type of the
elements to be linked into the simple queue. A pointer to the head of the
simple queue can later be declared as:
struct HEADNAME *headp;
(The names head
and
headp
are user selectable.)
The macro SIMPLEQ_ENTRY
() declares a
structure that connects the elements in the simple queue.
The macro SIMPLEQ_HEAD_INITIALIZER
()
provides a value which can be used to initialize a simple queue head at
compile time, and is used at the point that the simple queue head variable
is declared, like:
struct HEADNAME head = SIMPLEQ_HEAD_INITIALIZER(head);
The macro SIMPLEQ_FIRST
() returns the
first element of the simple queue head.
The macro SIMPLEQ_EMPTY
() returns true if
the simple queue head has no elements.
The macro SIMPLEQ_NEXT
() returns the
element after the element elm.
The macro SIMPLEQ_LAST
() returns the last
item on the simple queue. If the simple queue is empty the return value is
NULL
.
The macro SIMPLEQ_FOREACH
() traverses the
simple queue referenced by head in the forward
direction, assigning each element in turn to var.
The SAFE version uses tmp to hold the next element, so var may be freed or removed from the list.
The macro SIMPLEQ_INIT
() initializes the
simple queue referenced by head.
The macro SIMPLEQ_INSERT_HEAD
() inserts
the new element elm at the head of the simple
queue.
The macro SIMPLEQ_INSERT_TAIL
() inserts
the new element elm at the end of the simple
queue.
The macro SIMPLEQ_INSERT_AFTER
() inserts
the new element elm after the element
listelm.
The macro SIMPLEQ_REMOVE_HEAD
() removes
the first element from the head of the simple queue. For optimum efficiency,
elements being removed from the head of the queue should explicitly use this
macro instead of the generic SIMPLEQ_REMOVE
()
macro.
The macro SIMPLEQ_REMOVE_AFTER
() removes
the element after the one specified from the simple queue. For optimum
efficiency, elements being removed after specified elements should
explicitly use this macro instead of the generic
SIMPLEQ_REMOVE
() macro.
The macro SIMPLEQ_REMOVE
() removes
elm from the simple queue.
The macro SIMPLEQ_CONCAT
() concatenates
the simple queue headed by head2 onto the end of the
one headed by head1, removing all entries from the
former.
SIMPLEQ_HEAD(simplehead, entry) head; struct simplehead *headp; /* Simple queue head. */ struct entry { ... SIMPLEQ_ENTRY(entry) entries; /* Simple queue. */ ... } *n1, *n2, *np; SIMPLEQ_INIT(&head); /* Initialize the queue. */ n1 = malloc(sizeof(struct entry)); /* Insert at the head. */ SIMPLEQ_INSERT_HEAD(&head, n1, entries); n1 = malloc(sizeof(struct entry)); /* Insert at the tail. */ SIMPLEQ_INSERT_TAIL(&head, n1, entries); n2 = malloc(sizeof(struct entry)); /* Insert after. */ SIMPLEQ_INSERT_AFTER(&head, n1, n2, entries); SIMPLEQ_FOREACH(np, &head, entries) /* Forward traversal. */ np-> ... while (SIMPLEQ_FIRST(&head) != NULL) /* Delete. */ SIMPLEQ_REMOVE_HEAD(&head, entries); if (SIMPLEQ_EMPTY(&head)) /* Test for emptiness. */ printf("nothing to do\n");
TAILQ_HEAD
() macro. This structure contains a pair of
pointers, one to the first element in the tail queue and the other to the last
element in the tail queue. The elements are doubly linked so that an arbitrary
element can be removed without traversing the tail queue. New elements can be
added to the queue after an existing element, before an existing element, at
the head of the queue, or at the end the queue. A
TAILQ_HEAD structure is declared as follows:
TAILQ_HEAD(HEADNAME, TYPE) head;
where HEADNAME
is the name of the
structure to be defined, and TYPE
is the type of the
elements to be linked into the tail queue. A pointer to the head of the tail
queue can later be declared as:
struct HEADNAME *headp;
(The names head
and
headp
are user selectable.)
The macro TAILQ_ENTRY
() declares a
structure that connects the elements in the tail queue.
The macro TAILQ_HEAD_INITIALIZER
()
provides a value which can be used to initialize a tail queue head at
compile time, and is used at the point that the tail queue head variable is
declared, like:
struct HEADNAME head = TAILQ_HEAD_INITIALIZER(head);
The macro TAILQ_FIRST
() returns the first
element of the tail queue head.
The macro TAILQ_NEXT
() returns the element
after the element elm.
The macro TAILQ_LAST
() returns the last
item on the tail queue. If the tail queue is empty the return value is
NULL
.
The macro TAILQ_PREV
() returns the
previous item on the tail queue, from the one specified. If the tail queue
is empty the return value is NULL
.
The macro TAILQ_EMPTY
() returns true if
the tail queue head has no elements.
The macros TAILQ_FOREACH
(),
TAILQ_FOREACH_REVERSE
(),
TAILQ_FOREACH_SAFE
(), and
TAILQ_FOREACH_REVERSE_SAFE
() traverse the tail queue
referenced by head in the forward or reverse
direction, assigning each element in turn to var.
The SAFE versions use tmp to hold the next element, so var may be freed or removed from the list.
The macro TAILQ_INIT
() initializes the
tail queue referenced by head.
The macro TAILQ_INSERT_HEAD
() inserts the
new element elm at the head of the tail queue.
The macro TAILQ_INSERT_TAIL
() inserts the
new element elm at the end of the tail queue.
The macro TAILQ_INSERT_AFTER
() inserts the
new element elm after the element
listelm.
The macro TAILQ_INSERT_BEFORE
() inserts
the new element elm before the element
listelm.
The macro TAILQ_REMOVE
() removes the
element elm from the tail queue.
The macro TAILQ_REPLACE
() replaces the
element elm with the new one
specified in the tail queue.
The macro TAILQ_CONCAT
() concatenates the
tail queue headed by head2 onto the end of the one
headed by head1, removing all entries from the
former.
TAILQ_HEAD(tailhead, entry) head; struct tailhead *headp; /* Tail queue head. */ struct entry { ... TAILQ_ENTRY(entry) entries; /* Tail queue. */ ... } *n1, *n2, *np; TAILQ_INIT(&head); /* Initialize the queue. */ n1 = malloc(sizeof(struct entry)); /* Insert at the head. */ TAILQ_INSERT_HEAD(&head, n1, entries); n1 = malloc(sizeof(struct entry)); /* Insert at the tail. */ TAILQ_INSERT_TAIL(&head, n1, entries); n2 = malloc(sizeof(struct entry)); /* Insert after. */ TAILQ_INSERT_AFTER(&head, n1, n2, entries); n2 = malloc(sizeof(struct entry)); /* Insert before. */ TAILQ_INSERT_BEFORE(n1, n2, entries); TAILQ_FOREACH(np, &head, entries) /* Forward traversal. */ np-> ... /* Reverse traversal. */ TAILQ_FOREACH_REVERSE(np, &head, tailhead, entries) np-> ... while (TAILQ_FIRST(&head) != NULL) /* Delete. */ TAILQ_REMOVE(&head, TAILQ_FIRST(&head), entries); if (TAILQ_EMPTY(&head)) /* Test for emptiness. */ printf("nothing to do\n");
STAILQ_
”
(STAILQ_HEAD
(),
STAILQ_HEAD_INITIALIZER
(),
STAILQ_ENTRY
(),
STAILQ_FOREACH
(),
STAILQ_FOREACH_SAFE
(),
STAILQ_FIRST
(),
STAILQ_EMPTY
(), STAILQ_NEXT
(),
STAILQ_LAST
(), STAILQ_INIT
(),
STAILQ_INSERT_HEAD
(),
STAILQ_INSERT_TAIL
(),
STAILQ_INSERT_AFTER
(),
STAILQ_REMOVE_HEAD
(),
STAILQ_REMOVE
(), and
STAILQ_CONCAT
()) are functionally identical to these
simple queue functions, and are provided for compatibility with
FreeBSD.
queue
functions first appeared in
4.4BSD. The SIMPLEQ
functions
first appeared in NetBSD 1.2. The
SLIST
and STAILQ
functions
first appeared in FreeBSD 2.1.5.
October 1, 2017 | NetBSD 9.2 |