RT-Thread - rtservice.h分析

　　本笔记作为自己的学习记录，纯属个人理解。

　　rtservice.h是 RT_Thread中关于双向链表和单相链表的相关定义。

　　双向链表主要实现了节点插入、删除、是否为空、计算链表长度的功能。这里主要分析一下是否为空、计算链表长度的功能。

　　是否为空：

rt_inline int rt_list_isempty(const rt_list_t *l)
{
    return l->next == l;
}

　　计算链表长度：

rt_inline unsigned int rt_list_len(const rt_list_t *l)
{
    unsigned int len = 0;
    const rt_list_t *p = l;
    while (p->next != l)
    {
        p = p->next;
        len ++;
    }

    return len;
}

　　这里输入的变量 const rt_list_t *l 其实是一个链表节点，这个节点作为链表头节点在使用时候创建，并初始化为指向本身，这个节点是一直存在的，也即链表至少有一个头节点存在。理解了这一点上边两个函数就好理解了。

　　下面在看一个重要的宏 rt_list_entry，这个宏本质是 rt_container_of，获取list的拥有者的入口地址。

#define rt_list_entry(node, type, member) \
    rt_container_of(node, type, member)

#define rt_container_of(ptr, type, member) \
    ((type *)((char *)(ptr) - (unsigned long)(&((type *)0)->member)))

　　例如如下一个结构体

struct obj {
    uint8_t m1;
    uint8_t m2;
    uint8_t m3;
    uint8_t m4;
    rt_list_t list;
    ...
};

　　(char *)(ptr)：ptr 是一个指向list的指针，转换为一个char 类型的指针；

　　(type *)0：等价于将0转换为一个指向 obj 类型变量的指针，且变量存储地址为0；

　　(type *)0)->member：获取 obj 类型的member元素，即 list 元素；

　　&((type *)0)->member：获取 obj 类型的 list 元素的地址，由于首地址为0，所以这个地址也是 list 元素相对于结构体变量的存储地址的偏移地址

　　(char *)(ptr) - (unsigned long)(&((type *)0)->member))：指向list的指针 减去 偏移地址，就指向了 list 元素所在结构体的存储地址，也即得到了结构体变量指针

　　其内存地址空间如下：

 

 　　

　　单相链表的内容相对好理解一些，就不再赘述了。下面是rtservice.h的部分代码，仅供参考

#define rt_container_of(ptr, type, member) \
    ((type *)((char *)(ptr) - (unsigned long)(&((type *)0)->member)))
    
#define RT_LIST_OBJECT_INIT(object) { &(object), &(object) }

rt_inline void rt_list_init(rt_list_t *l)
{
    l->next = l->prev = l;
}

rt_inline void rt_list_insert_after(rt_list_t *l, rt_list_t *n)
{
    l->next->prev = n;
    n->next = l->next;

    l->next = n;
    n->prev = l;
}

rt_inline void rt_list_insert_before(rt_list_t *l, rt_list_t *n)
{
    l->prev->next = n;
    n->prev = l->prev;

    l->prev = n;
    n->next = l;
}

rt_inline void rt_list_remove(rt_list_t *n)
{
    n->next->prev = n->prev;
    n->prev->next = n->next;

    n->next = n->prev = n;
}

rt_inline int rt_list_isempty(const rt_list_t *l)
{
    return l->next == l;
}

rt_inline unsigned int rt_list_len(const rt_list_t *l)
{
    unsigned int len = 0;
    const rt_list_t *p = l;
    while (p->next != l)
    {
        p = p->next;
        len ++;
    }

    return len;
}

#define rt_list_entry(node, type, member) \
    rt_container_of(node, type, member)

#define rt_list_for_each(pos, head) \
    for (pos = (head)->next; pos != (head); pos = pos->next)

rt_inline void rt_slist_init(rt_slist_t *l)
{
    l->next = RT_NULL;
}

rt_inline void rt_slist_append(rt_slist_t *l, rt_slist_t *n)
{
    struct rt_slist_node *node;

    node = l;
    while (node->next) node = node->next;

    /* append the node to the tail */
    node->next = n;
    n->next = RT_NULL;
}

rt_inline void rt_slist_insert(rt_slist_t *l, rt_slist_t *n)
{
    n->next = l->next;
    l->next = n;
}

rt_inline unsigned int rt_slist_len(const rt_slist_t *l)
{
    unsigned int len = 0;
    const rt_slist_t *list = l->next;
    while (list != RT_NULL)
    {
        list = list->next;
        len ++;
    }

    return len;
}

rt_inline rt_slist_t *rt_slist_remove(rt_slist_t *l, rt_slist_t *n)
{
    /* remove slist head */
    struct rt_slist_node *node = l;
    while (node->next && node->next != n) node = node->next;

    /* remove node */
    if (node->next != (rt_slist_t *)0) node->next = node->next->next;

    return l;
}

rt_inline rt_slist_t *rt_slist_first(rt_slist_t *l)
{
    return l->next;
}

rt_inline rt_slist_t *rt_slist_tail(rt_slist_t *l)
{
    while (l->next) l = l->next;

    return l;
}

rt_inline rt_slist_t *rt_slist_next(rt_slist_t *n)
{
    return n->next;
}

rt_inline int rt_slist_isempty(rt_slist_t *l)
{
    return l->next == RT_NULL;
}

#define rt_slist_entry(node, type, member) \
    rt_container_of(node, type, member)