pslist.h

Go to the documentation of this file.

#ifndef PSLIST_H
#define PSLIST_H
 
#include "elutils/c_decls.h"
__BEGIN_DECLS /* till __END_DECLS */
 
#undef offsetof
#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
 
#undef container_of
#define container_of(ptr, type, member) ({ const typeof( ((type *)0)->member ) *__mptr = (ptr); (type *)( (char *)__mptr - offsetof(type,member) );})
 
struct psl_hd
{
    struct psl_hd *next, *prev;
};
typedef struct psl_hd psl_hd_t;
 
#define PSL_HD_INIT(name) { &(name), &(name) }
#define PSL_HD(name) struct psl_hd name = PSL_HD_INIT(name)
 
static inline void psl_init(psl_hd_t *list)
{
    list->next = list;
    list->prev = list;
}
 
#define psl_entry(ptr, type, member) container_of(ptr, type, member)
 
#define psl_for_each_entry(pos, head, member)               \
    for (pos = psl_entry((head)->next, typeof(*pos), member);       \
    &pos->member != (head);                     \
    pos = psl_entry(pos->member.next, typeof(*pos), member))
 
#define psl_for_each_entry_safe(pos, n, head, member)       \
    for (pos = psl_entry((head)->next, typeof(*pos), member),   \
    n = psl_entry(pos->member.next, typeof(*pos), member);  \
        &pos->member != (head);                 \
        pos = n, n = psl_entry(n->member.next, typeof(*n), member))
 
// @formatter:off
#define psl_count(TYPE, head, member, pcount)               \
{   *pcount = 0; TYPE *pos;                     \
    for (pos = psl_entry((head)->next, typeof(*pos), member);       \
         &pos->member != (head);                    \
     pos = psl_entry(pos->member.next, typeof(*pos), member)) { \
    *pcount++;                          \
    }                                   \
}
// @formatter:on
 
static inline int psl_empty(const struct psl_hd *head)
{
    return head->next == head;
}
 
/*
 * Insert a new entry between two known consecutive entries.
 *
 * This is only for internal list manipulation where we know
 * the prev/next entries already!
 */
static inline void __psl_add(struct psl_hd *_new, struct psl_hd *prev, struct psl_hd *next)
{
    next->prev = _new;
    _new->next = next;
    _new->prev = prev;
    prev->next = _new;
}
 
static inline void psl_add(struct psl_hd *_new, struct psl_hd *head)
{
    __psl_add(_new, head, head->next);
}
 
static inline void psl_add_tail(struct psl_hd *_new, struct psl_hd *head)
{
    __psl_add(_new, head->prev, head);
}
 
/*
 * Delete a list entry by making the prev/next entries
 * point to each other.
 *
 * This is only for internal list manipulation where we know
 * the prev/next entries already!
 */
static inline void __psl_del(struct psl_hd *prev, struct psl_hd *next)
{
    next->prev = prev;
    prev->next = next;
}
 
#define LIST_POISON1  ((void *) 0x00100100)
#define LIST_POISON2  ((void *) 0x00200200)
static inline void psl_del(struct psl_hd *entry)
{
    __psl_del(entry->prev, entry->next);
    entry->next = (struct psl_hd*) LIST_POISON1;
    entry->prev = (struct psl_hd*) LIST_POISON2;
}
 
static inline int psl_is_head(const struct psl_hd *list, const struct psl_hd *head)
{
    return list == head;
}
 
static inline struct psl_hd* psl_first(const struct psl_hd *head)   
{
    return head->next;
}
#define PSL_FIRST_ENTRY(ptr, type, member) psl_entry(ptr->next, type, member)
 
#define PSL_SHOW_STRING(PSL_HD, TYPE, PSL_LINK, STRING_NAME)    \
{ int i = 0; TYPE *pos;                     \
    psl_for_each_entry(pos, PSL_HD, PSL_LINK) {         \
    char *str = pos->STRING_NAME;               \
    MB_DBG("%i: '%s'\n", i, str);               \
    i++;                            \
    }                               \
}    //PSL_SHOW_STRING(PSL_HD, TYPE, PSL_LINK, STRING_NAME) =====
 
static inline void psl_move_head2head(psl_hd_t *new_hd, psl_hd_t *old_hd) \
{
    new_hd->next = old_hd->next;
    new_hd->prev = old_hd->prev;
    new_hd->next->prev = new_hd;
    new_hd->prev->next = new_hd;
    psl_init(old_hd);
}
 
__END_DECLS
#endif /* PSLIST_H */