include/slist.h

Go to the documentation of this file.

#ifndef SLIST_H_INCLUDED
#define SLIST_H_INCLUDED

#include <assert.h>
#include <types.h>

struct slist_node {
        struct slist_node       *next;  
};

struct slist {
        struct slist_node       first;
        struct slist_node       *last;
};

static inline void slist_init(struct slist *list)
{
        list->first.next = &list->first;
        list->last = &list->first;
}

static inline bool slist_is_empty(struct slist *list)
{
        return list->first.next == &list->first;
}

static inline bool slist_node_is_last(struct slist *list,
                struct slist_node *node)
{
        return node == list->last;
}

static inline bool slist_node_is_valid(struct slist *list,
                struct slist_node *node)
{
        return node != &list->first;
}

#define slist_entry(node, type, member)                         \
        container_of(node, type, member)

static inline void slist_insert_head(struct slist *list,
                struct slist_node *node)
{
        node->next = list->first.next;
        if (list->last == &list->first)
                list->last = node;
        list->first.next = node;
}

static inline void slist_insert_tail(struct slist *list,
                struct slist_node *node)
{
        node->next = &list->first;
        list->last->next = node;
        list->last = node;
}

static inline void slist_borrow_to_tail(struct slist *to, struct slist *from)
{
        assert(!slist_is_empty(from));

        from->last->next = &to->first;
        to->last->next = from->first.next;
        to->last = from->last;
}

static inline void slist_give_back_head(struct slist *to, struct slist *from)
{
        from->first.next = to->last->next;
        if (from->first.next == &from->first)
                from->last = &from->first;
        to->last->next = &to->first;
}

static inline void slist_move_to_tail(struct slist *to, struct slist *from)
{
        slist_borrow_to_tail(to, from);
        slist_init(from);
}

static inline struct slist_node *slist_peek_head_node(struct slist *list)
{
        assert(list);
        return list->first.next;
}

#define slist_peek_head(list, type, member)                     \
        slist_entry(slist_peek_head_node(list), type, member)

static inline struct slist_node *slist_peek_tail_node(struct slist *list)
{
        assert(list);
        return list->last;
}

#define slist_peek_tail(list, type, member)                     \
        slist_entry(slist_peek_tail_node(list), type, member)

static inline struct slist_node *slist_peek_next_node(struct slist_node *node)
{
        assert(node);
        return node->next;
}

#define slist_peek_next(node, type, member)                     \
        slist_entry(slist_peek_next_node(node), type, member)

static inline struct slist_node *slist_pop_head_node(struct slist *list)
{
        struct slist_node *node;

        assert(list);
        assert(list->first.next != &list->first);

        node = list->first.next;
        list->first.next = node->next;
        if (list->last == node)
                list->last = &list->first;

        return node;
}

#define slist_pop_head(list, type, member)                              \
        container_of(slist_pop_head_node(list), type, member)

#define slist_for_each_node(list, node)                                 \
        for (node = (list)->first.next; node != &(list)->first;         \
                        node = node->next)

#define slist_for_each_node_safe(list, node, tmp)                       \
        for (node = (list)->first.next, tmp = node->next;               \
                        node != &(list)->first;                         \
                        node = tmp, tmp = node->next)

#define slist_for_each(list, item, member)                              \
        for (item = slist_peek_head(list, typeof(*item), member);       \
                        &item->node != &(list)->first;                  \
                        item = slist_peek_next(&item->member,           \
                                typeof(*item), member))

#define slist_for_each_safe(list, item, tmp, member)                    \
        for (item = slist_peek_head(list, typeof(*item), member),       \
                        tmp = slist_peek_next(&item->member,            \
                                        typeof(*item), member);         \
                        &item->node != &(list)->first;                  \
                        item = tmp,                                     \
                        tmp = slist_peek_next(&item->member,            \
                                        typeof(*item), member))         \

#endif /* SLIST_H_INCLUDED */

---