queue.h(List)

LIST图例：

/*
 * List definitions.
 */
#define LIST_HEAD(name, type)                        \    //链表头定义
struct name {                                \
    struct type *lh_first;    /* first element */            \
}

展开SLIST_HEAD (event_list, event) 
struct event_list { 
struct event *slh_first; /* first element */ \
}
这样就定义了event_list结构，该结构具有一个访问event结构的指针slh_first

#define LIST_HEAD_INITIALIZER(head)                    \  //链表头初始化
    { NULL }

展开SLIST_HEAD_INITIALIZER（&pEventbase->eventqueue)  { NULL }
eventqueue是event_list结构对象，该宏是把eventqueue中的slh_first赋值为NULL

#define LIST_ENTRY(type)                        \    //链表结点定义
struct {                                \
    struct type *le_next;    /* next element */            \
    struct type **le_prev;    /* address of previous next element */    \
}

展开LIST_ENTRY(event)
struct{
    struct event *le_next;    
    struct event **le_prev;    
}

ENTRY结构被用在event结构中
struct event{
    TAILQ_ENTRY(event) ev_next;   //这里可以把TAILQ_ENTRY理解成LIST_ENTRY
    ...
}展开为
struct event{
    struct{
        struct event *le_next;    //指向下一个event结构的节点，实际上存放的是下一个event节点的地址
        struct event **le_prev;    //指向上一个event结构的节点,，实际上存放的是上一个event结构中event_next结构中le_next指针的地址
    } ev_next;
    ...
}

/*
 * List access methods
 */
#define    LIST_FIRST(head)        ((head)->lh_first)     //返回指向第一个节点的指针

展开LIST_FIRST(&pEventBase->eventqueue)    ((&pEventBase->eventqueue)->lh_first)

#define    LIST_END(head)            NULL    //链表尾部

展开LIST_END(&pEventBase->eventqueue)  NULL

#define    LIST_EMPTY(head)        (LIST_FIRST(head) == LIST_END(head))    //判断链表是否为空

展开LIST_EMPTY(&pEventBase->eventqueue)    (  ((&pEventBase->eventqueue)->lh_first)  == NULL )

#define    LIST_NEXT(elm, field)        ((elm)->field.le_next)    //获取elm指针所指的元素的下个元素的指针

展开LIST_NEXT(pEvent,event_next)   ( (pEvent)->event_next.le_next)

#define LIST_FOREACH(var, head, field)                    \    //遍历链表
    for((var) = LIST_FIRST(head);                    \
     (var)!= LIST_END(head);                    \
     (var) = LIST_NEXT(var, field))

展开LIST_FOREACH(pTmp, &pEventBase->eventqueue, event_next)
    for((pTmp) = LIST_FIRST(&pEventBase->eventqueue);
        (pTmp) != LIST_END(&pEventBase->eventqueue);
        (pTmp) =LIST_NEXT(pTmp,event_next) )继续展开
   for((pTmp) =  ((&pEventBase->eventqueue)->lh_first) ;
        (pTmp) !=NULL;
        (pTmp) = ( (pEvent)->event_next.le_next) )

/*
 * List functions.
 */
#define    LIST_INIT(head) do {                        \    //链表初始化
    LIST_FIRST(head) = LIST_END(head);                \
} while (0)

展开LIST_INIT(&pEventBase->eventqueue)
do{
      ((&pEventBase->eventqueue)->lh_first)  = NULL;
}while(0)

#define LIST_INSERT_AFTER(listelm, elm, field) do {            \     //在listelm所指元素后插入elm所指元素
    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)

初始状态：


执行LIST_INSERT_AFTER后：


图中的1，2，3，4分别对应
1.  (elm)->field.le_next = (listelm)->field.le_next                      //让elm的next指针指向listelm的next指针所指元素（也就是listelm的下一个节点）
2. (listelm)->field.le_next->field.le_prev = &(elm)->field.le_next;     //让listelm的下一个节点的prev指针指向elm的next指针
3. (listelm)->field.le_next = (elm);                                    //让listelm的next指针指向elm所指对象     
4.  (elm)->field.le_prev = &(listelm)->field.le_next;                   //  让elm的prev指针指向listelm的next指针

#define    LIST_INSERT_BEFORE(listelm, elm, field) do {            \    //在listelm所指元素前插入elm所指元素
    (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)

初始状态：


执行LIST_INSERT_BEFORE(listelm, elm, field) 


图中的1，2，3，4分别对应
1.  (elm)->field.le_prev = (listelm)->field.le_prev;                    //让elm的prev指针指向listelm的prev指针所指对象       
2.  (elm)->field.le_next = (listelm);                                   //让elm的next指针指向listelm指针所指对象
3.   *(listelm)->field.le_prev = (elm);                                 //让listelm的上一个节点的next指针指向elm所指对象   *(listelm)->field.le_prev结构获取listelm上一个节点的next指针     
4.   (listelm)->field.le_prev = &(elm)->field.le_next;                  //让listelm指针的prev指针指向elm的next指针

#define LIST_INSERT_HEAD(head, elm, field) do {                \     //在head所指元素后插入elm所指元素,也就是在第一个元素前插入elm
    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)

初始状态：

执行 LIST_INSERT_HEAD(head, elm, field) 后




图中的1，2，3，4分别对应
1. (elm)->field.le_next = (head)->lh_first                            //让elm的next指针指向head的lh_first所指元素，也就是第一个元素
2.  (head)->lh_first->field.le_prev = &(elm)->field.le_next;       //让第一个元素的prev指针指向elm的next指针
3.  (head)->lh_first = (elm);                                     //让head的lh_first指针指向elm所指元素
4.   (elm)->field.le_prev = &(head)->lh_first;                    // 让elm的prev指向head的lh_first指针   

#define LIST_REMOVE(elm, field) do {                    \    //移除elm所指元素
    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)

初始状态：

执行 LIST_REMOVE(elm, field)后




图中的1，2分别对应
1. (elm)->field.le_next->field.le_prev = (elm)->field.le_prev;    //让elm下一个元素的prev指针指向elm的prev指针所指元素（让elm的下一个元素的prev指针指向elm的上一个元素的next指针）
2.  *(elm)->field.le_prev = (elm)->field.le_next;                 //让elm的上一个元素的next指针指向elm的next指针所指元素


执行LIST_REMOVE(elm, field)后，elm的next指针与prev指针依然指向链表的节点,只不过链表中的节点不会再指向elm了

#define LIST_REPLACE(elm, elm2, field) do {                \     //用elm2所指元素替换elm所指元素
    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)

初始状态：

执行LIST_REPLACE(elm, elm2, field)后





图中的1，2，3，4分别对应
1. (elm2)->field.le_next = (elm)->field.le_next                                //让elm2的next指针指向elm的next指针所指元素（即elm的下一个元素）
2.  (elm2)->field.le_next->field.le_prev = &(elm2)->field.le_next;             //让elm2的下一个元素的prev指针指向elm2的next指针
3.  (elm2)->field.le_prev = (elm)->field.le_prev;                              //让elm2的prev指针指向elm的prev指针所指元素（即elm的上一个元素的next指针）
4.   *(elm2)->field.le_prev = (elm2);                                          //让elm2的上一个节点的next指针指向elm2所指元素（ *(elm2)->field.le_prev  表示elm2的上一个元素的next指针）

执行LIST_REPLACE(elm, elm2, field)后，elm的next指针与prev指针依然指向链表中的节点，不过链表中的节点不再指向elm