/* * Copyright ( c ) 1991 , 1993 * The Regents of the University of California . All rights reserved . * * Redistribution and use in source and binary forms , with or without * modification , are permitted provided that the following conditions * are met : * 1 . Redistributions of source code must retain the above copyright * notice , this list of conditions and the following disclaimer . * 2 . Redistributions in binary form must reproduce the above copyright * notice , this list of conditions and the following disclaimer in the * documentation and / or other materials provided with the distribution . * 3 . Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission . * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ` ` AS IS ' ' AND * ANY EXPRESS OR IMPLIED WARRANTIES , INCLUDING , BUT NOT LIMITED TO , THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED . IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT , INDIRECT , INCIDENTAL , SPECIAL , EXEMPLARY , OR CONSEQUENTIAL * DAMAGES ( INCLUDING , BUT NOT LIMITED TO , PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES ; LOSS OF USE , DATA , OR PROFITS ; OR BUSINESS INTERRUPTION ) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY , WHETHER IN CONTRACT , STRICT * LIABILITY , OR TORT ( INCLUDING NEGLIGENCE OR OTHERWISE ) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE , EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE . * * @ ( # ) queue . h 8 . 5 ( Berkeley ) 8 / 20 / 94 #ifndef _SYS_QUEUE_H_#define _SYS_QUEUE_H_#include <sys/cdefs.h>/* * This file defines five types of data structures : singly - linked lists , * lists , simple queues , tail queues , and circular queues . * * A singly - linked list is headed by a single forward pointer . 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 . Elements being removed from the head of the list * should use the explicit macro for this purpose for optimum * efficiency . A singly - linked list may only be traversed in the forward * direction . Singly - linked lists are ideal for applications with large * datasets and few or no removals or for implementing a LIFO queue . * * A list is headed by a single forward pointer ( or an array of forward * pointers for a hash table header ) . The elements are doubly linked * so that an arbitrary element can be removed without a need to * traverse the list . New elements can be added to the list before * or after an existing element or at the head of the list . A list * may only be traversed in the forward direction . * * A simple queue is headed by a pair of pointers , one the head of the * list and the other to the tail of the list . The elements are singly * linked to save space , so elements can only be removed from the * head of the list . New elements can be added to the list after * an existing element , at the head of the list , or at the end of the * list . A simple queue may only be traversed in the forward direction . * * A tail queue is headed by a pair of pointers , one to the head of the * list and the other to the tail of the list . The elements are doubly * linked so that an arbitrary element can be removed without a need to * traverse the list . New elements can be added to the list before or * after an existing element , at the head of the list , or at the end of * the list . A tail queue may be traversed in either direction . * * A circle queue is headed by a pair of pointers , one to the head of the * list and the other to the tail of the list . The elements are doubly * linked so that an arbitrary element can be removed without a need to * traverse the list . New elements can be added to the list before or after * an existing element , at the head of the list , or at the end of the list . * A circle queue may be traversed in either direction , but has a more * complex end of list detection . * * For details on the use of these macros , see the queue ( 3 ) manual page . /* * List definitions . #define LIST_HEAD(name, type) \struct name { \struct type *lh_first; /* first element */ \ #define LIST_HEAD_INITIALIZER(head) \#define LIST_ENTRY(type) \struct { \struct type *le_next; /* next element */ \ struct type **le_prev; /* address of previous next element */ \ /* * List functions . #define LIST_INIT(head) do { \while (/*CONSTCOND*/0) #define LIST_INSERT_AFTER(listelm, elm, field) do { \if (((elm)->field.le_next = (listelm)->field.le_next) != NULL) \while (/*CONSTCOND*/0) #define LIST_INSERT_BEFORE(listelm, elm, field) do { \while (/*CONSTCOND*/0) #define LIST_INSERT_HEAD(head, elm, field) do { \if (((elm)->field.le_next = (head)->lh_first) != NULL) \while (/*CONSTCOND*/0) #define LIST_REMOVE(elm, field) do { \if ((elm)->field.le_next != NULL) \while (/*CONSTCOND*/0) #define LIST_FOREACH(var, head, field) \for ((var) = ((head)->lh_first); \/* * List access methods . #define LIST_EMPTY(head) ((head)->lh_first == NULL)#define LIST_FIRST(head) ((head)->lh_first)#define LIST_NEXT(elm, field) ((elm)->field.le_next)/* * Singly - linked List definitions . #define SLIST_HEAD(name, type) \struct name { \struct type *slh_first; /* first element */ \ #define SLIST_HEAD_INITIALIZER(head) \#define SLIST_ENTRY(type) \struct { \struct type *sle_next; /* next element */ \ /* * Singly - linked List functions . #define SLIST_INIT(head) do { \while (/*CONSTCOND*/0) #define SLIST_INSERT_AFTER(slistelm, elm, field) do { \while (/*CONSTCOND*/0) #define SLIST_INSERT_HEAD(head, elm, field) do { \while (/*CONSTCOND*/0) #define SLIST_REMOVE_HEAD(head, field) do { \while (/*CONSTCOND*/0) #define SLIST_REMOVE(head, elm, type, field) do { \if ((head)->slh_first == (elm)) { \else { \struct type *curelm = (head)->slh_first; \while (curelm->field.sle_next != (elm)) \while (/*CONSTCOND*/0) #define SLIST_FOREACH(var, head, field) \for ((var) = (head)->slh_first; (var); (var) = (var)->field.sle_next)/* * Singly - linked List access methods . #define SLIST_EMPTY(head) ((head)->slh_first == NULL)#define SLIST_FIRST(head) ((head)->slh_first)#define SLIST_NEXT(elm, field) ((elm)->field.sle_next)/* * Singly - linked Tail queue declarations . #define STAILQ_HEAD(name, type) \struct name { \struct type *stqh_first; /* first element */ \ struct type **stqh_last; /* addr of last next element */ \ #define STAILQ_HEAD_INITIALIZER(head) \#define STAILQ_ENTRY(type) \struct { \struct type *stqe_next; /* next element */ \ /* * Singly - linked Tail queue functions . #define STAILQ_INIT(head) do { \while (/*CONSTCOND*/0) #define STAILQ_INSERT_HEAD(head, elm, field) do { \if (((elm)->field.stqe_next = (head)->stqh_first) == NULL) \while (/*CONSTCOND*/0) #define STAILQ_INSERT_TAIL(head, elm, field) do { \while (/*CONSTCOND*/0) #define STAILQ_INSERT_AFTER(head, listelm, elm, field) do { \if (((elm)->field.stqe_next = (listelm)->field.stqe_next) == NULL)\while (/*CONSTCOND*/0) #define STAILQ_REMOVE_HEAD(head, field) do { \if (((head)->stqh_first = (head)->stqh_first->field.stqe_next) == NULL) \while (/*CONSTCOND*/0) #define STAILQ_REMOVE(head, elm, type, field) do { \if ((head)->stqh_first == (elm)) { \else { \struct type *curelm = (head)->stqh_first; \while (curelm->field.stqe_next != (elm)) \if ((curelm->field.stqe_next = \while (/*CONSTCOND*/0) #define STAILQ_FOREACH(var, head, field) \for ((var) = ((head)->stqh_first); \/* * Singly - linked Tail queue access methods . #define STAILQ_EMPTY(head) ((head)->stqh_first == NULL)#define STAILQ_FIRST(head) ((head)->stqh_first)#define STAILQ_NEXT(elm, field) ((elm)->field.stqe_next)/* * Simple queue definitions . #define SIMPLEQ_HEAD(name, type) \struct name { \struct type *sqh_first; /* first element */ \ struct type **sqh_last; /* addr of last next element */ \ #define SIMPLEQ_HEAD_INITIALIZER(head) \#define SIMPLEQ_ENTRY(type) \struct { \struct type *sqe_next; /* next element */ \ /* * Simple queue functions . #define SIMPLEQ_INIT(head) do { \while (/*CONSTCOND*/0) #define SIMPLEQ_INSERT_HEAD(head, elm, field) do { \if (((elm)->field.sqe_next = (head)->sqh_first) == NULL) \while (/*CONSTCOND*/0) #define SIMPLEQ_INSERT_TAIL(head, elm, field) do { \while (/*CONSTCOND*/0) #define SIMPLEQ_INSERT_AFTER(head, listelm, elm, field) do { \if (((elm)->field.sqe_next = (listelm)->field.sqe_next) == NULL)\while (/*CONSTCOND*/0) #define SIMPLEQ_REMOVE_HEAD(head, field) do { \if (((head)->sqh_first = (head)->sqh_first->field.sqe_next) == NULL) \while (/*CONSTCOND*/0) #define SIMPLEQ_REMOVE(head, elm, type, field) do { \if ((head)->sqh_first == (elm)) { \else { \struct type *curelm = (head)->sqh_first; \while (curelm->field.sqe_next != (elm)) \if ((curelm->field.sqe_next = \while (/*CONSTCOND*/0) #define SIMPLEQ_FOREACH(var, head, field) \for ((var) = ((head)->sqh_first); \/* * Simple queue access methods . #define SIMPLEQ_EMPTY(head) ((head)->sqh_first == NULL)#define SIMPLEQ_FIRST(head) ((head)->sqh_first)#define SIMPLEQ_NEXT(elm, field) ((elm)->field.sqe_next)/* * Tail queue definitions . #define _TAILQ_HEAD(name, type, qual) \struct name { \/* first element */ \ /* addr of last next element */ \ #define TAILQ_HEAD(name, type) _TAILQ_HEAD(name, struct type,)#define TAILQ_HEAD_INITIALIZER(head) \#define _TAILQ_ENTRY(type, qual) \struct { \/* next element */ \ /* address of previous next element */\ #define TAILQ_ENTRY(type) _TAILQ_ENTRY(struct type,)/* * Tail queue functions . #define TAILQ_INIT(head) do { \while (/*CONSTCOND*/0) #define TAILQ_INSERT_HEAD(head, elm, field) do { \if (((elm)->field.tqe_next = (head)->tqh_first) != NULL) \else \while (/*CONSTCOND*/0) #define TAILQ_INSERT_TAIL(head, elm, field) do { \while (/*CONSTCOND*/0) #define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != NULL)\else \while (/*CONSTCOND*/0) #define TAILQ_INSERT_BEFORE(listelm, elm, field) do { \while (/*CONSTCOND*/0) #define TAILQ_REMOVE(head, elm, field) do { \if (((elm)->field.tqe_next) != NULL) \else \while (/*CONSTCOND*/0) #define TAILQ_FOREACH(var, head, field) \for ((var) = ((head)->tqh_first); \#define TAILQ_FOREACH_REVERSE(var, head, headname, field) \for ((var) = (*(((struct headname *)((head)->tqh_last))->tqh_last)); \struct headname *)((var)->field.tqe_prev))->tqh_last)))/* * Tail queue access methods . #define TAILQ_EMPTY(head) ((head)->tqh_first == NULL)#define TAILQ_FIRST(head) ((head)->tqh_first)#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next)#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))/* * Circular queue definitions . #define CIRCLEQ_HEAD(name, type) \struct name { \struct type *cqh_first; /* first element */ \ struct type *cqh_last; /* last element */ \ #define CIRCLEQ_HEAD_INITIALIZER(head) \void *)&head, (void *)&head }#define CIRCLEQ_ENTRY(type) \struct { \struct type *cqe_next; /* next element */ \ struct type *cqe_prev; /* previous element */ \ /* * Circular queue functions . #define CIRCLEQ_INIT(head) do { \void *)(head); \void *)(head); \while (/*CONSTCOND*/0) #define CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do { \if ((listelm)->field.cqe_next == (void *)(head)) \else \while (/*CONSTCOND*/0) #define CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do { \if ((listelm)->field.cqe_prev == (void *)(head)) \else \while (/*CONSTCOND*/0) #define CIRCLEQ_INSERT_HEAD(head, elm, field) do { \void *)(head); \if ((head)->cqh_last == (void *)(head)) \else \while (/*CONSTCOND*/0) #define CIRCLEQ_INSERT_TAIL(head, elm, field) do { \void *)(head); \if ((head)->cqh_first == (void *)(head)) \else \while (/*CONSTCOND*/0) #define CIRCLEQ_REMOVE(head, elm, field) do { \if ((elm)->field.cqe_next == (void *)(head)) \else \if ((elm)->field.cqe_prev == (void *)(head)) \else \while (/*CONSTCOND*/0) #define CIRCLEQ_FOREACH(var, head, field) \for ((var) = ((head)->cqh_first); \const void *)(head); \#define CIRCLEQ_FOREACH_REVERSE(var, head, field) \for ((var) = ((head)->cqh_last); \const void *)(head); \/* * Circular queue access methods . #define CIRCLEQ_EMPTY(head) ((head)->cqh_first == (void *)(head))#define CIRCLEQ_FIRST(head) ((head)->cqh_first)#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_LOOP_NEXT(head, elm, field) \void *)(head)) \#define CIRCLEQ_LOOP_PREV(head, elm, field) \void *)(head)) \#endif /* sys/queue.h */
Messung V0.5 in Prozent C=89 H=84 G=86
¤ Dauer der Verarbeitung: 0.13 Sekunden
(vorverarbeitet am 2026-06-28)
¤ *© Formatika GbR, Deutschland
