Go to the source code of this file.
Defines | |
| #define | __offsetof(type, field) ((size_t)(&(type *)0)->field)) |
| #define | SLIST_HEAD(name, type) |
| #define | SLIST_HEAD_INITIALIZER(head) { NULL } |
| #define | SLIST_ENTRY(type) |
| #define | SLIST_EMPTY(head) ((head)->slh_first == NULL) |
| #define | SLIST_FIRST(head) ((head)->slh_first) |
| #define | SLIST_FOREACH(var, 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) ((elm)->field.sle_next) |
| #define | SLIST_REMOVE(head, elm, type, field) |
| #define | SLIST_REMOVE_HEAD(head, field) |
| #define | STAILQ_HEAD(name, type) |
| #define | STAILQ_HEAD_INITIALIZER(head) { NULL, &(head).stqh_first } |
| #define | STAILQ_ENTRY(type) |
| #define | STAILQ_EMPTY(head) ((head)->stqh_first == NULL) |
| #define | STAILQ_FIRST(head) ((head)->stqh_first) |
| #define | STAILQ_FOREACH(var, head, field) |
| #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) ((elm)->field.stqe_next) |
| #define | STAILQ_REMOVE(head, elm, type, field) |
| #define | STAILQ_REMOVE_HEAD(head, field) |
| #define | STAILQ_REMOVE_HEAD_UNTIL(head, elm, field) |
| #define | LIST_HEAD(name, type) |
| #define | LIST_HEAD_INITIALIZER(head) { NULL } |
| #define | LIST_ENTRY(type) |
| #define | LIST_EMPTY(head) ((head)->lh_first == NULL) |
| #define | LIST_FIRST(head) ((head)->lh_first) |
| #define | LIST_FOREACH(var, head, field) |
| #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) ((elm)->field.le_next) |
| #define | LIST_REMOVE(elm, field) |
| #define | TAILQ_HEAD(name, type) |
| #define | TAILQ_HEAD_INITIALIZER(head) { NULL, &(head).tqh_first } |
| #define | TAILQ_ENTRY(type) |
| #define | TAILQ_EMPTY(head) ((head)->tqh_first == NULL) |
| #define | TAILQ_FIRST(head) ((head)->tqh_first) |
| #define | TAILQ_FOREACH(var, head, field) |
| #define | TAILQ_FOREACH_REVERSE(var, head, headname, field) |
| #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) (*(((struct headname *)((head)->tqh_last))->tqh_last)) |
| #define | TAILQ_NEXT(elm, field) ((elm)->field.tqe_next) |
| #define | TAILQ_PREV(elm, headname, field) (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last)) |
| #define | TAILQ_REMOVE(head, elm, field) |
| #define | CIRCLEQ_HEAD(name, type) |
| #define | CIRCLEQ_HEAD_INITIALIZER(head) { (void *)&(head), (void *)&(head) } |
| #define | CIRCLEQ_ENTRY(type) |
| #define | CIRCLEQ_EMPTY(head) ((head)->cqh_first == (void *)(head)) |
| #define | CIRCLEQ_FIRST(head) ((head)->cqh_first) |
| #define | CIRCLEQ_FOREACH(var, head, field) |
| #define | CIRCLEQ_FOREACH_REVERSE(var, head, field) |
| #define | CIRCLEQ_INIT(head) |
| #define | CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) |
| #define | CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) |
| #define | CIRCLEQ_INSERT_HEAD(head, elm, field) |
| #define | CIRCLEQ_INSERT_TAIL(head, elm, field) |
| #define | CIRCLEQ_LAST(head) ((head)->cqh_last) |
| #define | CIRCLEQ_NEXT(elm, field) ((elm)->field.cqe_next) |
| #define | CIRCLEQ_PREV(elm, field) ((elm)->field.cqe_prev) |
| #define | CIRCLEQ_REMOVE(head, elm, field) |
| #define __offsetof | ( | type, | |||
| field | ) | ((size_t)(&(type *)0)->field)) |
| #define CIRCLEQ_EMPTY | ( | head | ) | ((head)->cqh_first == (void *)(head)) |
| #define CIRCLEQ_ENTRY | ( | type | ) |
| #define CIRCLEQ_FOREACH | ( | var, | |||
| head, | |||||
| field | ) |
Value:
for ((var) = CIRCLEQ_FIRST((head)); \ (var) != (void *)(head) || ((var) = NULL); \ (var) = CIRCLEQ_NEXT((var), field))
| #define CIRCLEQ_FOREACH_REVERSE | ( | var, | |||
| head, | |||||
| field | ) |
Value:
for ((var) = CIRCLEQ_LAST((head)); \ (var) != (void *)(head) || ((var) = NULL); \ (var) = CIRCLEQ_PREV((var), field))
| #define CIRCLEQ_HEAD | ( | name, | |||
| type | ) |
| #define CIRCLEQ_HEAD_INITIALIZER | ( | head | ) | { (void *)&(head), (void *)&(head) } |
| #define CIRCLEQ_INIT | ( | head | ) |
Value:
do { \ CIRCLEQ_FIRST((head)) = (void *)(head); \ CIRCLEQ_LAST((head)) = (void *)(head); \ } while (0)
| #define CIRCLEQ_INSERT_AFTER | ( | head, | |||
| listelm, | |||||
| elm, | |||||
| field | ) |
Value:
do { \ CIRCLEQ_NEXT((elm), field) = CIRCLEQ_NEXT((listelm), field); \ CIRCLEQ_PREV((elm), field) = (listelm); \ if (CIRCLEQ_NEXT((listelm), field) == (void *)(head)) \ CIRCLEQ_LAST((head)) = (elm); \ else \ CIRCLEQ_PREV(CIRCLEQ_NEXT((listelm), field), field) = (elm);\ CIRCLEQ_NEXT((listelm), field) = (elm); \ } while (0)
| #define CIRCLEQ_INSERT_BEFORE | ( | head, | |||
| listelm, | |||||
| elm, | |||||
| field | ) |
Value:
do { \ CIRCLEQ_NEXT((elm), field) = (listelm); \ CIRCLEQ_PREV((elm), field) = CIRCLEQ_PREV((listelm), field); \ if (CIRCLEQ_PREV((listelm), field) == (void *)(head)) \ CIRCLEQ_FIRST((head)) = (elm); \ else \ CIRCLEQ_NEXT(CIRCLEQ_PREV((listelm), field), field) = (elm);\ CIRCLEQ_PREV((listelm), field) = (elm); \ } while (0)
| #define CIRCLEQ_INSERT_HEAD | ( | head, | |||
| elm, | |||||
| field | ) |
Value:
do { \ CIRCLEQ_NEXT((elm), field) = CIRCLEQ_FIRST((head)); \ CIRCLEQ_PREV((elm), field) = (void *)(head); \ if (CIRCLEQ_LAST((head)) == (void *)(head)) \ CIRCLEQ_LAST((head)) = (elm); \ else \ CIRCLEQ_PREV(CIRCLEQ_FIRST((head)), field) = (elm); \ CIRCLEQ_FIRST((head)) = (elm); \ } while (0)
| #define CIRCLEQ_INSERT_TAIL | ( | head, | |||
| elm, | |||||
| field | ) |
Value:
do { \ CIRCLEQ_NEXT((elm), field) = (void *)(head); \ CIRCLEQ_PREV((elm), field) = CIRCLEQ_LAST((head)); \ if (CIRCLEQ_FIRST((head)) == (void *)(head)) \ CIRCLEQ_FIRST((head)) = (elm); \ else \ CIRCLEQ_NEXT(CIRCLEQ_LAST((head)), field) = (elm); \ CIRCLEQ_LAST((head)) = (elm); \ } while (0)
| #define CIRCLEQ_REMOVE | ( | head, | |||
| elm, | |||||
| field | ) |
Value:
do { \ if (CIRCLEQ_NEXT((elm), field) == (void *)(head)) \ CIRCLEQ_LAST((head)) = CIRCLEQ_PREV((elm), field); \ else \ CIRCLEQ_PREV(CIRCLEQ_NEXT((elm), field), field) = \ CIRCLEQ_PREV((elm), field); \ if (CIRCLEQ_PREV((elm), field) == (void *)(head)) \ CIRCLEQ_FIRST((head)) = CIRCLEQ_NEXT((elm), field); \ else \ CIRCLEQ_NEXT(CIRCLEQ_PREV((elm), field), field) = \ CIRCLEQ_NEXT((elm), field); \ } while (0)
| #define LIST_ENTRY | ( | type | ) |
| #define LIST_FOREACH | ( | var, | |||
| head, | |||||
| field | ) |
Value:
for ((var) = LIST_FIRST((head)); \ (var); \ (var) = LIST_NEXT((var), field))
| #define LIST_HEAD | ( | name, | |||
| type | ) |
| #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 | ) |
Value:
do { \ 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)
| #define LIST_REMOVE | ( | elm, | |||
| field | ) |
| #define SLIST_ENTRY | ( | type | ) |
| #define SLIST_FIRST | ( | head | ) | ((head)->slh_first) |
| #define SLIST_FOREACH | ( | var, | |||
| head, | |||||
| field | ) |
Value:
for ((var) = SLIST_FIRST((head)); \ (var); \ (var) = SLIST_NEXT((var), field))
Definition at line 138 of file queue.h.
Referenced by scheduler_interrupt().
| #define SLIST_HEAD | ( | name, | |||
| type | ) |
Value:
struct name { \ struct type *slh_first; /* first element */ \ }
Definition at line 118 of file queue.h.
Referenced by scheduler_interrupt().
| #define SLIST_INIT | ( | head | ) |
Value:
do { \ SLIST_FIRST((head)) = NULL; \ } while (0)
Definition at line 143 of file queue.h.
Referenced by scheduler_interrupt().
| #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 147 of file queue.h.
Referenced by scheduler_interrupt().
| #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 152 of file queue.h.
Referenced by scheduler_interrupt().
| #define SLIST_NEXT | ( | elm, | |||
| field | ) | ((elm)->field.sle_next) |
| #define SLIST_REMOVE | ( | head, | |||
| elm, | |||||
| type, | |||||
| field | ) |
Value:
do { \ if (SLIST_FIRST((head)) == (elm)) { \ SLIST_REMOVE_HEAD((head), field); \ } \ else { \ struct type *curelm = SLIST_FIRST((head)); \ while (SLIST_NEXT(curelm, field) != (elm)) \ curelm = SLIST_NEXT(curelm, field); \ SLIST_NEXT(curelm, field) = \ SLIST_NEXT(SLIST_NEXT(curelm, field), field); \ } \ } while (0)
| #define SLIST_REMOVE_HEAD | ( | head, | |||
| field | ) |
Value:
do { \ SLIST_FIRST((head)) = SLIST_NEXT(SLIST_FIRST((head)), field); \ } while (0)
| #define STAILQ_ENTRY | ( | type | ) |
| #define STAILQ_FOREACH | ( | var, | |||
| head, | |||||
| field | ) |
Value:
for((var) = STAILQ_FIRST((head)); \ (var); \ (var) = STAILQ_NEXT((var), field))
| #define STAILQ_HEAD | ( | name, | |||
| type | ) |
| #define STAILQ_HEAD_INITIALIZER | ( | head | ) | { NULL, &(head).stqh_first } |
| #define STAILQ_INIT | ( | head | ) |
Value:
do { \ STAILQ_FIRST((head)) = NULL; \ (head)->stqh_last = &STAILQ_FIRST((head)); \ } while (0)
| #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)
| #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)
| #define STAILQ_INSERT_TAIL | ( | head, | |||
| elm, | |||||
| field | ) |
Value:
do { \ STAILQ_NEXT((elm), field) = NULL; \ *(head)->stqh_last = (elm); \ (head)->stqh_last = &STAILQ_NEXT((elm), field); \ } while (0)
| #define STAILQ_LAST | ( | head, | |||
| type, | |||||
| field | ) |
Value:
(STAILQ_EMPTY(head) ? \ NULL : \ ((struct type *) \ ((char *)((head)->stqh_last) - __offsetof(struct type, field))))
| #define STAILQ_REMOVE | ( | head, | |||
| elm, | |||||
| type, | |||||
| field | ) |
Value:
do { \ if (STAILQ_FIRST((head)) == (elm)) { \ STAILQ_REMOVE_HEAD(head, field); \ } \ else { \ struct type *curelm = STAILQ_FIRST((head)); \ while (STAILQ_NEXT(curelm, field) != (elm)) \ curelm = STAILQ_NEXT(curelm, field); \ if ((STAILQ_NEXT(curelm, field) = \ STAILQ_NEXT(STAILQ_NEXT(curelm, field), field)) == NULL)\ (head)->stqh_last = &STAILQ_NEXT((curelm), field);\ } \ } while (0)
| #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)
| #define STAILQ_REMOVE_HEAD_UNTIL | ( | head, | |||
| elm, | |||||
| field | ) |
Value:
do { \ if ((STAILQ_FIRST((head)) = STAILQ_NEXT((elm), field)) == NULL) \ (head)->stqh_last = &STAILQ_FIRST((head)); \ } while (0)
| #define TAILQ_ENTRY | ( | type | ) |
| #define TAILQ_FOREACH | ( | var, | |||
| head, | |||||
| field | ) |
Value:
for ((var) = TAILQ_FIRST((head)); \ (var); \ (var) = TAILQ_NEXT((var), field))
| #define TAILQ_FOREACH_REVERSE | ( | var, | |||
| head, | |||||
| headname, | |||||
| field | ) |
Value:
for ((var) = TAILQ_LAST((head), headname); \ (var); \ (var) = TAILQ_PREV((var), headname, field))
| #define TAILQ_HEAD | ( | name, | |||
| type | ) |
| #define TAILQ_HEAD_INITIALIZER | ( | head | ) | { NULL, &(head).tqh_first } |
| #define TAILQ_INIT | ( | head | ) |
Value:
do { \ TAILQ_FIRST((head)) = NULL; \ (head)->tqh_last = &TAILQ_FIRST((head)); \ } while (0)
| #define TAILQ_INSERT_AFTER | ( | head, | |||
| listelm, | |||||
| elm, | |||||
| field | ) |
Value:
do { \ 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); \ TAILQ_NEXT((listelm), field) = (elm); \ (elm)->field.tqe_prev = &TAILQ_NEXT((listelm), field); \ } while (0)
| #define TAILQ_INSERT_BEFORE | ( | listelm, | |||
| elm, | |||||
| field | ) |
Value:
do { \ (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); \ } while (0)
| #define TAILQ_INSERT_HEAD | ( | head, | |||
| elm, | |||||
| field | ) |
Value:
do { \ 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)); \ } while (0)
| #define TAILQ_INSERT_TAIL | ( | head, | |||
| elm, | |||||
| field | ) |
Value:
do { \ TAILQ_NEXT((elm), field) = NULL; \ (elm)->field.tqe_prev = (head)->tqh_last; \ *(head)->tqh_last = (elm); \ (head)->tqh_last = &TAILQ_NEXT((elm), field); \ } while (0)
| #define TAILQ_LAST | ( | head, | |||
| headname | ) | (*(((struct headname *)((head)->tqh_last))->tqh_last)) |
| #define TAILQ_PREV | ( | elm, | |||
| headname, | |||||
| field | ) | (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last)) |
| #define TAILQ_REMOVE | ( | head, | |||
| elm, | |||||
| field | ) |
Value:
do { \ 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; \ *(elm)->field.tqe_prev = TAILQ_NEXT((elm), field); \ } while (0)
1.5.6