/* $OpenBSD: queue.h,v 1.16 2000/09/07 19:47:59 art Exp $ */
/* $NetBSD: queue.h,v 1.11 1996/05/16 05:17:14 mycroft Exp $ */
/*
* 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__
/*
* 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 before or 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.
*/
//===============================================================================
// Singly-linked List
//===============================================================================
// Singly-linked List Example
// SLIST_HEAD(slisthead, entry) head =
// SLIST_HEAD_INITIALIZER(head);
// 相当于:
// struct slisthead {
// struct entry *slh_first; /* first element */
// }head;
//
// struct slisthead *headp; /* Singly-linked List head. */
// struct entry {
// ...
// SLIST_ENTRY(entry) entries; /* Singly-linked List. */
// struct {
// struct entry *sle_next; /* next element */
// }entries;
// ...
// } *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);
// /* Forward traversal. */
// SLIST_FOREACH(np, &head, entries)
// np-> ...
//
// while (!SLIST_EMPTY(&head)) { /* List Deletion. */
// n1 = SLIST_FIRST(&head);
// SLIST_REMOVE_HEAD(&head, entries);
// free(n1);
// }
/*
* Singly-linked List definitions.
*/
// 定义了 struct name 的结构体，作为 简单链路 链表头；
// 每个 struct name 的结构体，包含了 struct type 类型的指针。
#define SLIST_HEAD(name, type) \
struct name { \
struct type *slh_first; /* first element */ \
}
// 初始化 struct name 的结构体对象
#define SLIST_HEAD_INITIALIZER(head) \
{ NULL }
// 简单链路 链表 的成员的实体
#ifndef _WIN32
#define SLIST_ENTRY(type) \
struct { \
struct type *sle_next; /* next element */ \
}
#endif
/*
* Singly-linked List access methods.
*/
// 取得 简单链路 的头
#define SLIST_FIRST(head) ((head)->slh_first)
// 检查 简单链路 的结尾
#define SLIST_END(head) NULL
// 检查 简单链路 中是否为空
#define SLIST_EMPTY(head) (SLIST_FIRST(head) == SLIST_END(head))
// 取得 elm 对象 field 为 简单链路 的下一个 链路对象
#define SLIST_NEXT(elm, field) ((elm)->field.sle_next)
// 简单链路，从头开始循环
// 参数:
// var: 保存 包含 SLIST_ENTRY 结构体对象 field 的结构体对象
// head: 简单链路头，指向 包含 SLIST_ENTRY 结构体对象 field 的结构体对象
// field: 为 SLIST_ENTRY 结构体对象，成员 sle_next 指向 包含 SLIST_ENTRY 结构体对象 field 的结构体对象
#define SLIST_FOREACH(var, head, field) \
for((var) = SLIST_FIRST(head); \
(var) != SLIST_END(head); \
(var) = SLIST_NEXT(var, field))
/*
* Singly-linked List functions.
*/
// 初始化 简单链路 的头
#define SLIST_INIT(head) { \
SLIST_FIRST(head) = SLIST_END(head); \
}
// 插入 elm 到 slistelm 的后面，简单链路 成员 为 field(即为 elm/slistelm 的成员)
#define SLIST_INSERT_AFTER(slistelm, elm, field) do { \
(elm)->field.sle_next = (slistelm)->field.sle_next; \
(slistelm)->field.sle_next = (elm); \
} while (0)
// 插入 elm 到 head 的后面，简单链路 成员 为 field(即为 elm 的成员)
#define SLIST_INSERT_HEAD(head, elm, field) do { \
(elm)->field.sle_next = (head)->slh_first; \
(head)->slh_first = (elm); \
} while (0)
// 从 head 中，删除一个 链路， 简单链路 成员 为 field(即 被删除简单链路 的 成员)
#define SLIST_REMOVE_HEAD(head, field) do { \
(head)->slh_first = (head)->slh_first->field.sle_next; \
} while (0)
//===============================================================================
// List
//===============================================================================
// LIST_HEAD(listhead, entry) head;
// 相当于:
// struct listhead { \
// struct entry *lh_first; /* first element */ \
// }
// struct listhead *headp; /* List head. */
// struct entry {
// ...
// LIST_ENTRY(entry) entries; /* List. */
// 相当于:
// struct {
// struct entry *le_next; /* next element */
// struct entry **le_prev; /* address of previous next element */
// }entries;
// ...
// } *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);
// /* Forward traversal. */
// LIST_FOREACH(np, &head, entries)
// np-> ...
// /* Delete. */
// while (LIST_FIRST(&head) != NULL)
// LIST_REMOVE(LIST_FIRST(&head), entries);
// if (LIST_EMPTY(&head)) /* Test for emptiness. */
// printf("nothing to do\n");
/*
* List definitions.
*/
// 定义了 struct name 的结构体，作为 链路 链表头；
// 每个 struct name 的结构体，包含了 struct type 类型的指针。
#define LIST_HEAD(name, type) \
struct name { \
struct type *lh_first; /* first element */ \
}
// 初始化 struct name 的结构体对象
#define LIST_HEAD_INITIALIZER(head) \
{ NULL }
// 定义 链路 链表 的成员的实体
// struct type *le_next 指向下一个实体
// struct type **le_prev 指向前面实体的 链路 的成员的 le_next 对象的地址
#define LIST_ENTRY(type) \
struct { \
struct type *le_next; /* next element */ \
struct type **le_prev; /* address of previous next element */ \
}
/*
* List access methods
*/
// 取得 链路 的头
#define LIST_FIRST(head) ((head)->lh_first)
// 检查 链路 的结尾
#define LIST_END(head) NULL
// 检查 链路 中是否为空
#define LIST_EMPTY(head) (LIST_FIRST(head) == LIST_END(head))
// 取得 elm 对象成员 field 为 链路 的下一个 链路对象
#define LIST_NEXT(elm, field) ((elm)->field.le_next)
// 链路，从头开始循环
// 参数:
// var: 保存 包含 LIST_ENTRY 结构体对象 field 的结构体对象
// head: 链路头，指向 包含 LIST_ENTRY 结构体对象 field 的结构体对象
// field: 为 LIST_ENTRY 结构体对象，成员 le_next 指向 包含 LIST_ENTRY 结构体对象 field 的结构体对象
#define LIST_FOREACH(var, head, field) \
for((var) = LIST_FIRST(head); \
(var)!= LIST_END(head); \
(var) = LIST_NEXT(var, field))
/*
* List functions.
*/
// 初始化 链路 的头
#define LIST_INIT(head) do { \
LIST_FIRST(head) = LIST_END(head); \
} while (0)
// 插入 elm 到 slistelm 的后面，链路 成员 为 field(即为 elm/slistelm 的成员)
#define LIST_INSERT_AFTER(listelm, elm, field) do { \
if (((elm)->field.le_next = (listelm)->field.le_next) != NULL) \
(listelm)->field.le_next->field.le_prev = \
&(elm)->field.le_next; \
(listelm)->field.le_next = (elm); \
(elm)->field.le_prev = &(listelm)->field.le_next; \
} while (0)
// 插入 elm 到 slistelm 的前面，链路 成员 为 field(即为 elm/slistelm 的成员)
// *(listelm)->field.le_prev = (elm); 为 前面一个 链路的 field.le_next = (elm)
#define LIST_INSERT_BEFORE(listelm, elm, field) do { \
(elm)->field.le_prev = (listelm)->field.le_prev; \
(elm)->field.le_next = (listelm); \
*(listelm)->field.le_prev = (elm); \
(listelm)->field.le_prev = &(elm)->field.le_next; \
} while (0)
// 插入 elm 到 head 的后面，链路 成员 为 field(即为 elm 的成员，该成员的 le_prev 也是 elm 类型的指针对象)
#define LIST_INSERT_HEAD(head, elm, field) do { \
if (((elm)->field.le_next = (head)->lh_first) != NULL) \
(head)->lh_first->field.le_prev = &(elm)->field.le_next;\
(head)->lh_first = (elm); \
(elm)->field.le_prev = &(head)->lh_first; \
} while (0)
// 删除 elm 对象，该对象在 链表 中，链路 成员 为 field(即为 elm 的成员)
#define LIST_REMOVE(elm, field) do { \
if ((elm)->field.le_next != NULL) \
(elm)->field.le_next->field.le_prev = \
(elm)->field.le_prev; \
*(elm)->field.le_prev = (elm)->field.le_next; \
} while (0)
// 使用 elm2 替代 elm，链路 成员 为 field(即为 elm/elm2 的成员)
#define LIST_REPLACE(elm, elm2, field) do { \
if (((elm2)->field.le_next = (elm)->field.le_next) != NULL) \
(elm2)->field.le_next->field.le_prev = \
&(elm2)->field.le_next; \
(elm2)->field.le_prev = (elm)->field.le_prev; \
*(elm2)->field.le_prev = (elm2); \
} while (0)
//===============================================================================
// Simple queue
//===============================================================================
// SIMPLEQ_HEAD(simplehead, entry) head;
// 相当于:
// struct simplehead { \
// struct entry *sqh_first; /* first element */ \
// struct entry **sqh_last; /* addr of last next element */ \
// }head;
// struct simplehead *headp; /* Simple queue head. */
// struct entry {
// ...
// SIMPLEQ_ENTRY(entry) entries; /* Simple queue. */
// 相当于:
// struct { \
// struct entry *sqe_next; /* next element */ \
// }entries;
// ...
// } *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);
// /* Forward traversal. */
// SIMPLEQ_FOREACH(np, &head, entries)
// np-> ...
// /* Delete. */
// while (SIMPLEQ_FIRST(&head) != NULL)
// SIMPLEQ_REMOVE_HEAD(&head, entries);
// if (SIMPLEQ_EMPTY(&head)) /* Test for emptiness. */
// printf("nothing to do\n");
/*
* Simple queue definitions.
*/
// 定义了 struct name 的结构体，作为 简单队列 的头；
// 每个 struct name 的结构体，包含了 struct type 类型的指针。
// struct type **sqh_last 为 最后一个 SIMPLEQ_ENTRY 的成员的 sqe_next 的地址
#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) \
{ NULL, &(head).sqh_first }
// 简单队列 的成员的实体
#define SIMPLEQ_ENTRY(type) \
struct { \
struct type *sqe_next; /* next element */ \
}
/*
* Simple queue access methods.
*/
// 取得 简单队列 的头
#define SIMPLEQ_FIRST(head) ((head)->sqh_first)
// 检查 简单队列 的结尾
#define SIMPLEQ_END(head) NULL
// 检查 简单队列 中是否为空
#define SIMPLEQ_EMPTY(head) (SIMPLEQ_FIRST(head) == SIMPLEQ_END(head))
// 取得 elm 对象成员 field.sqe_next 为 简单队列 的下一个 简单队列 对象
#define SIMPLEQ_NEXT(elm, field) ((elm)->field.sqe_next)
// 简单队列，从头开始循环
// 参数:
// var: 保存 包含 SIMPLEQ_ENTRY 结构体对象 field 的结构体对象
// head: 简单队列 头，指向 包含 SIMPLEQ_ENTRY 结构体对象 field 的结构体对象
// field: 为 SIMPLEQ_ENTRY 结构体对象，成员 le_next 指向 包含 SIMPLEQ_ENTRY 结构体对象 field 的结构体对象
#define SIMPLEQ_FOREACH(var, head, field) \
for((var) = SIMPLEQ_FIRST(head); \
(var) != SIMPLEQ_END(head); \
(var) = SIMPLEQ_NEXT(var, field))
/*
* Simple queue functions.
*/
// 初始化 简单队列 的头
#define SIMPLEQ_INIT(head) do { \
(head)->sqh_first = NULL; \
(head)->sqh_last = &(head)->sqh_first; \
} while (0)
// 从 简单队列 头，插入 elm 对象，简单队列 成员 为 field(即为 elm 的成员)
#define SIMPLEQ_INSERT_HEAD(head, elm, field) do { \
if (((elm)->field.sqe_next = (head)->sqh_first) == NULL) \
(head)->sqh_last = &(elm)->field.sqe_next; \
(head)->sqh_first = (elm); \
} while (0)
// 从 简单队列 尾，插入 elm 对象，简单队列 成员 为 field(即为 elm 的成员)
#define SIMPLEQ_INSERT_TAIL(head, elm, field) do { \
(elm)->field.sqe_next = NULL; \
*(head)->sqh_last = (elm); \
(head)->sqh_last = &(elm)->field.sqe_next; \
} while (0)
// 在 listelm 后面，插入 elm 对象，简单队列 成员 为 field(即为 listelm/elm 的成员)
#define SIMPLEQ_INSERT_AFTER(head, listelm, elm, field) do { \
if (((elm)->field.sqe_next = (listelm)->field.sqe_next) == NULL)\
(head)->sqh_last = &(elm)->field.sqe_next; \
(listelm)->field.sqe_next = (elm); \
} while (0)
// 从 简单队列 头，删除 elm 对象，该对象在 简单队列 中，简单队列 成员 为 field(即为 elm 的成员)
#define SIMPLEQ_REMOVE_HEAD(head, elm, field) do { \
if (((head)->sqh_first = (elm)->field.sqe_next) == NULL) \
(head)->sqh_last = &(head)->sqh_first; \
} while (0)
//===============================================================================
// Tail queue
//===============================================================================
//
// TAILQ_HEAD(tailhead, entry) head;
// 相当于
// struct tailhead { \
// struct entry *tqh_first; /* first element 指向第一个成员*/ \
// struct entry **tqh_last; /* addr of last next element 指向最后一个成员的 tqe_next*/ \
// }head;
//
// struct tailhead *headp; /* Tail queue head. */
// struct entry {
// ...
// TAILQ_ENTRY(entry) entries; /* Tail queue. */
// 相当于
// struct { \
// struct entry *tqe_next; /* next element 指向下一个成员*/ \
// struct entry **tqe_prev; /* address of previous next element 指向前一个成员的 tqe_next*/ \
// }entries;
// ...
// } *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);
// /* Forward traversal. */
// TAILQ_FOREACH(np, &head, entries)
// np-> ...
// /* Reverse traversal. */
// TAILQ_FOREACH_REVERSE(np, &head, tailhead, entries)
// np-> ...
// /* Delete. */
// while (TAILQ_FIRST(&head) != NULL)
// TAILQ_REMOVE(&head, TAILQ_FIRST(&head), entries);
// if (TAILQ_EMPTY(&head)) /* Test for emptiness. */
// printf("nothing to do\n");
/*
* Tail queue definitions.
*/
// 定义了 struct name 的结构体，作为 尾队列 的头；
// 每个 struct name 的结构体，包含了 struct type 类型的指针。
// struct type **sqh_last 为 最后一个 SIMPLEQ_ENTRY 的成员的 sqe_next 的地址
#define TAILQ_HEAD(name, type) \
struct name { \
struct type *tqh_first; /* first element 指向第一个成员*/ \
struct type **tqh_last; /* addr of last next element 指向最后一个成员的 tqe_next*/ \
}
// head 为被初始化的 尾队列(Tail queue) 对象
// &head 为被初始化的 尾队列(Tail queue) 对象的地址
// 初始化 尾队列 的头,
#define TAILQ_HEAD_INITIALIZER(head) \
{ NULL, &(head).tqh_first }
// 定义 尾队列 的成员的实体
// struct type *le_next 指向下一个实体
// struct type **le_prev 指向前面实体的 尾队列 的成员的 le_next 对象的地址
#define TAILQ_ENTRY(type) \
struct { \
struct type *tqe_next; /* next element */ \
struct type **tqe_prev; /* address of previous next element */ \
}
/*
* tail queue access methods
*/
// 取得 尾队列 的头
#define TAILQ_FIRST(head) ((head)->tqh_first)
// 检查 尾队列 的结尾
#define TAILQ_END(head) NULL
// 取得 elm 的 field 为 TAILQ_ENTRY 对象，得到下一个 elm
#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next)
// 为 得到 最后一个成员对象 的 地址
// 把 (head)->tqh_last 对象(即 最后一个 elm 的 entries 对象(相当于前面 field))，
// 然后 强转为 (struct headname *)
// (((struct headname *)((head)->tqh_last))->tqh_last) 为 指向 倒数第二个 elm 的 entries 对象的 tqe_next
// (*(((struct headname *)((head)->tqh_last))->tqh_last)) 最后得到 最后一个 elm 对象指针
#define TAILQ_LAST(head, headname) \
(*(((struct headname *)((head)->tqh_last))->tqh_last))
/* XXX */
// 为得到 elm 前一个成员对象 的地址
// (elm)->field.tqe_prev 为 当前成员 的 前一个成员中 field 的地址
// 然后 强转为 (struct headname *)
// (((struct headname *)((elm)->field.tqe_prev))->tqh_last) 为前面一个成员 再前面一个成员 field 的地址(且指向 tqe_next）
// (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last)) 为指向 前一个成员 的地址
#define TAILQ_PREV(elm, headname, field) \
(*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
// 检查 尾队列 中是否为空
#define TAILQ_EMPTY(head) \
(TAILQ_FIRST(head) == TAILQ_END(head))
// 尾队列，从头开始循环
// 参数:
// var: 保存 包含 TAILQ_ENTRY 结构体对象 field 的结构体对象
// head: 简单队列 头，指向 包含 TAILQ_ENTRY 结构体对象 field 的结构体对象
// field: 为 TAILQ_ENTRY 结构体对象，成员 le_next 指向 包含 TAILQ_ENTRY 结构体对象 field 的结构体对象
#define TAILQ_FOREACH(var, head, field) \
for((var) = TAILQ_FIRST(head); \
(var) != TAILQ_END(head); \
(var) = TAILQ_NEXT(var, field))
// 尾队列，从反向开始循环
// 参数:
// var: 保存 包含 TAILQ_ENTRY 结构体对象 field 的结构体对象
// head: 尾队列 头，指向 包含 TAILQ_ENTRY 结构体对象 field 的结构体对象
// headname: 尾队列 头 的类型名字
// field: 为 TAILQ_ENTRY 结构体对象，成员 le_next 指向 包含 TAILQ_ENTRY 结构体对象 field 的结构体对象
#define TAILQ_FOREACH_REVERSE(var, head, headname, field) \
for((var) = TAILQ_LAST(head, headname); \
(var) != TAILQ_END(head); \
(var) = TAILQ_PREV(var, headname, field))
/*
* Tail queue functions.
*/
// 初始化 尾队列 的头
// head 为被初始化的 尾队列(Tail queue) 头对象的地址；
#define TAILQ_INIT(head) do { \
(head)->tqh_first = NULL; \
(head)->tqh_last = &(head)->tqh_first; \
} while (0)
// 从 尾队列(Tail queue) 头，插入 elm 对象，尾队列(Tail queue) 成员 为 field(即为 elm 的成员)
#define TAILQ_INSERT_HEAD(head, elm, field) do { \
if (((elm)->field.tqe_next = (head)->tqh_first) != NULL) \
(head)->tqh_first->field.tqe_prev = \
&(elm)->field.tqe_next; \
else \
(head)->tqh_last = &(elm)->field.tqe_next; \
(head)->tqh_first = (elm); \
(elm)->field.tqe_prev = &(head)->tqh_first; \
} while (0)
// 从 尾队列(Tail queue) 尾，插入 elm 对象，尾队列(Tail queue) 成员 为 field(即为 elm 的成员)
#define TAILQ_INSERT_TAIL(head, elm, field) do { \
(elm)->field.tqe_next = NULL; \
(elm)->field.tqe_prev = (head)->tqh_last; \
*(head)->tqh_last = (elm); \
(head)->tqh_last = &(elm)->field.tqe_next; \
} while (0)
// 在 listelm 后面，插入 elm 对象，尾队列(Tail queue) 成员 为 field(即为 listelm/elm 的成员)
// head 为 尾队列(Tail queue) 的头的地址
#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \
if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != NULL)\
(elm)->field.tqe_next->field.tqe_prev = \
&(elm)->field.tqe_next; \
else \
(head)->tqh_last = &(elm)->field.tqe_next; \
(listelm)->field.tqe_next = (elm); \
(elm)->field.tqe_prev = &(listelm)->field.tqe_next; \
} while (0)
// 在 listelm 前面，插入 elm 对象，尾队列(Tail queue) 成员 为 field(即为 listelm/elm 的成员)
// head 为 尾队列(Tail queue) 的头的地址
#define TAILQ_INSERT_BEFORE(listelm, elm, field) do { \
(elm)->field.tqe_prev = (listelm)->field.tqe_prev; \
(elm)->field.tqe_next = (listelm); \
*(listelm)->field.tqe_prev = (elm); \
(listelm)->field.tqe_prev = &(elm)->field.tqe_next; \
} while (0)
// 从 尾队列(Tail queue) 中，删除 elm 对象，尾队列(Tail queue) 成员 为 field(即为 elm 的成员)
// elm 对象在 尾队列(Tail queue) 中
#define TAILQ_REMOVE(head, elm, field) do { \
if (((elm)->field.tqe_next) != NULL) \
(elm)->field.tqe_next->field.tqe_prev = \
(elm)->field.tqe_prev; \
else \
(head)->tqh_last = (elm)->field.tqe_prev; \
*(elm)->field.tqe_prev = (elm)->field.tqe_next; \
} while (0)
// 从 尾队列(Tail queue) 中，使用 elm2 替代 elm 对象，尾队列(Tail queue) 成员 为 field(即为 elm/elm2 的成员)
// elm 对象在 尾队列(Tail queue) 中
// elm2 对象 不在 尾队列(Tail queue) 中
#define TAILQ_REPLACE(head, elm, elm2, field) do { \
if (((elm2)->field.tqe_next = (elm)->field.tqe_next) != NULL) \
(elm2)->field.tqe_next->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); \
} while (0)
//===============================================================================
// Circular queue
//===============================================================================
// CIRCLEQ_HEAD(circleq, entry) head;
// 相当于定义了
// struct circleq { \
// struct entry *cqh_first; /* first element 第一个成员*/ \
// struct entry *cqh_last; /* last element 最后一个成员*/ \
// }head;
//
// struct circleq *headp; /* Circular queue head. */
// struct entry {
// ...
// CIRCLEQ_ENTRY(entry) entries; /* Circular queue. */
// 相当于
// struct {
// struct entry *cqe_next; /* next element */
// struct entry *cqe_prev; /* previous element */
// }entries;
// ...
// } *n1, *n2, *np;
//
// CIRCLEQ_INIT(&head); /* Initialize circular queue. */
//
//
// n1 = malloc(sizeof(struct entry)); /* Insert at the head. */
// CIRCLEQ_INSERT_HEAD(&head, n1, entries);
//
// n1 = malloc(sizeof(struct entry)); /* Insert at the tail. */
// CIRCLEQ_INSERT_TAIL(&head, n1, entries);
//
// n2 = malloc(sizeof(struct entry)); /* Insert after. */
// CIRCLEQ_INSERT_AFTER(&head, n1, n2, entries);
//
// n2 = malloc(sizeof(struct entry)); /* Insert before. */
// CIRCLEQ_INSERT_BEFORE(&head, n1, n2, entries);
// /* Forward traversal. */
// CIRCLEQ_FOREACH(np, &head, entries)
// np-> ...
// /* Reverse traversal. */
// CIRCLEQ_FOREACH_REVERSE(np, &head, entries)
// np-> ...
// /* Delete. */
// while (CIRCLEQ_FIRST(&head) != (void *)&head)
// CIRCLEQ_REMOVE(&head, CIRCLEQ_FIRST(&head), entries);
// if (CIRCLEQ_EMPTY(&head)) /* Test for emptiness. */
// printf("nothing to do\n");
/*
* Circular queue definitions.
*/
// 定义了 struct name 的结构体，作为 循环队列 的头；
// 每个 struct name 的结构体，包含了 struct type 类型的指针。
#define CIRCLEQ_HEAD(name, type) \
struct name { \
struct type *cqh_first; /* first element 第一个成员*/ \
struct type *cqh_last; /* last element 最后一个成员*/ \
}
// head 为被初始化的 循环队列(Circular queue) 对象
// &head 为被初始化的 循环队列(Circular queue) 对象的地址
// 初始化 循环队列 的头
#define CIRCLEQ_HEAD_INITIALIZER(head) \
{ CIRCLEQ_END(&head), CIRCLEQ_END(&head) }
// 定义 循环队列 的成员
// type 和 CIRCLEQ_HEAD 中 type 一样
#define CIRCLEQ_ENTRY(type) \
struct { \
struct type *cqe_next; /* next element 指向下一个成员*/ \
struct type *cqe_prev; /* previous element 指向前一个成员*/ \
}
/*
* Circular queue access methods
*/
// 得到 循环队列 的第一个成员(参数 为 循环队列 头的指针)
#define CIRCLEQ_FIRST(head) ((head)->cqh_first)
// 得到 循环队列 的最后一个成员(参数 为 循环队列 头的指针)
#define CIRCLEQ_LAST(head) ((head)->cqh_last)
// 得到 循环队列 的结束的指针值
#define CIRCLEQ_END(head) ((void *)(head))
// 得到 elm 成员的 field 域的 下一个成员 的指针
#define CIRCLEQ_NEXT(elm, field) ((elm)->field.cqe_next)
// 得到 elm 成员的 field 域的 前一个成员 的指针
#define CIRCLEQ_PREV(elm, field) ((elm)->field.cqe_prev)
// 检查 是否为 空 的 循环队列
#define CIRCLEQ_EMPTY(head) \
(CIRCLEQ_FIRST(head) == CIRCLEQ_END(head))
// 循环队列，从头开始循环
// 参数:
// var: 保存 包含 CIRCLEQ_ENTRY 结构体对象 field 的结构体对象
// head: 循环队列 头，指向 包含 CIRCLEQ_ENTRY 结构体对象 field 的结构体对象
// field: 为 CIRCLEQ_ENTRY 结构体对象，成员 le_next 指向 包含 CIRCLEQ_ENTRY 结构体对象 field 的结构体对象
#define CIRCLEQ_FOREACH(var, head, field) \
for((var) = CIRCLEQ_FIRST(head); \
(var) != CIRCLEQ_END(head); \
(var) = CIRCLEQ_NEXT(var, field))
// 循环队列，从尾开始循环
// 参数:
// var: 保存 包含 CIRCLEQ_ENTRY 结构体对象 field 的结构体对象
// head: 循环队列 头，指向 包含 CIRCLEQ_ENTRY 结构体对象 field 的结构体对象
// field: 为 CIRCLEQ_ENTRY 结构体对象，成员 le_next 指向 包含 CIRCLEQ_ENTRY 结构体对象 field 的结构体对象
#define CIRCLEQ_FOREACH_REVERSE(var, head, field) \
for((var) = CIRCLEQ_LAST(head); \
(var) != CIRCLEQ_END(head); \
(var) = CIRCLEQ_PREV(var, field))
/*
* Circular queue functions.
*/
// head 为被初始化的 循环队列(Circular queue) 头对象的地址；
// 初始化 循环队列 的头
#define CIRCLEQ_INIT(head) do { \
(head)->cqh_first = CIRCLEQ_END(head); \
(head)->cqh_last = CIRCLEQ_END(head); \
} while (0)
// 在 listelm 后面，插入 elm 对象，循环队列(Circular queue) 成员 为 field(即为 listelm/elm 的成员)
// head 为 循环队列(Circular queue) 的头的地址
#define CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do { \
(elm)->field.cqe_next = (listelm)->field.cqe_next; \
(elm)->field.cqe_prev = (listelm); \
if ((listelm)->field.cqe_next == CIRCLEQ_END(head)) \
(head)->cqh_last = (elm); \
else \
(listelm)->field.cqe_next->field.cqe_prev = (elm); \
(listelm)->field.cqe_next = (elm); \
} while (0)
// 在 listelm 前面，插入 elm 对象，循环队列(Circular queue) 成员 为 field(即为 listelm/elm 的成员)
// head 为 循环队列(Circular queue) 的头的地址
#define CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do { \
(elm)->field.cqe_next = (listelm); \
(elm)->field.cqe_prev = (listelm)->field.cqe_prev; \
if ((listelm)->field.cqe_prev == CIRCLEQ_END(head)) \
(head)->cqh_first = (elm); \
else \
(listelm)->field.cqe_prev->field.cqe_next = (elm); \
(listelm)->field.cqe_prev = (elm); \
} while (0)
// 从 循环队列(Circular queue) 头，插入 elm 对象，循环队列(Circular queue) 成员 为 field(即为 elm 的成员)
#define CIRCLEQ_INSERT_HEAD(head, elm, field) do { \
(elm)->field.cqe_next = (head)->cqh_first; \
(elm)->field.cqe_prev = CIRCLEQ_END(head); \
if ((head)->cqh_last == CIRCLEQ_END(head)) \
(head)->cqh_last = (elm); \
else \
(head)->cqh_first->field.cqe_prev = (elm); \
(head)->cqh_first = (elm); \
} while (0)
// 从 循环队列(Circular queue) 尾，插入 elm 对象，循环队列(Circular queue) 成员 为 field(即为 elm 的成员)
#define CIRCLEQ_INSERT_TAIL(head, elm, field) do { \
(elm)->field.cqe_next = CIRCLEQ_END(head); \
(elm)->field.cqe_prev = (head)->cqh_last; \
if ((head)->cqh_first == CIRCLEQ_END(head)) \
(head)->cqh_first = (elm); \
else \
(head)->cqh_last->field.cqe_next = (elm); \
(head)->cqh_last = (elm); \
} while (0)
// 从 循环队列(Circular queue) 中，删除 elm 对象，循环队列(Circular queue) 成员 为 field(即为 elm 的成员)
// elm 对象在 循环队列Circular queue) 中
#define CIRCLEQ_REMOVE(head, elm, field) do { \
if ((elm)->field.cqe_next == CIRCLEQ_END(head)) \
(head)->cqh_last = (elm)->field.cqe_prev; \
else \
(elm)->field.cqe_next->field.cqe_prev = \
(elm)->field.cqe_prev; \
if ((elm)->field.cqe_prev == CIRCLEQ_END(head)) \
(head)->cqh_first = (elm)->field.cqe_next; \
else \
(elm)->field.cqe_prev->field.cqe_next = \
(elm)->field.cqe_next; \
} while (0)
// 从 循环队列(Circular queue) 中，使用 elm2 替代 elm 对象，循环队列(Circular queue) 成员 为 field(即为 elm2/elm 的成员)
// elm 对象在 循环队列Circular queue) 中，
// elm2 对象 不在 循环队列Circular queue) 中
#define CIRCLEQ_REPLACE(head, elm, elm2, field) do { \
if (((elm2)->field.cqe_next = (elm)->field.cqe_next) == \
CIRCLEQ_END(head)) \
(head).cqh_last = (elm2); \
else \
(elm2)->field.cqe_next->field.cqe_prev = (elm2); \
if (((elm2)->field.cqe_prev = (elm)->field.cqe_prev) == \
CIRCLEQ_END(head)) \
(head).cqh_first = (elm2); \
else \
(elm2)->field.cqe_prev->field.cqe_next = (elm2); \
} while (0)
#endif /* !SYS_QUEUE_H__ */