list.h

浏览该文件的文档.

 
#ifndef LIST_H
#define LIST_H
 
 
#ifndef NULL
#define NULL 0
#endif
 
/*
 * These are non-NULL pointers that will result in page faults
 * under normal circumstances, used to verify that nobody uses
 * non-initialized list entries.
 */
#define LIST_POISON1  ((void *) 0x00100100)
#define LIST_POISON2  ((void *) 0x00200200)
 
/*
 * Simple doubly linked list implementation.
 *
 * Some of the internal functions ("__xxx") are useful when
 * manipulating whole lists rather than single entries, as
 * sometimes we already know the next/prev entries and we can
 * generate better code by using them directly rather than
 * using the generic single-entry routines.
 */
 
struct list_head {
    struct list_head *next, *prev;
};
 
#define LIST_HEAD_INIT(name) { &(name), &(name) }
 
#define LIST_HEAD(name) \
    struct list_head name = LIST_HEAD_INIT(name)
 
#define INIT_LIST_HEAD(ptr) do { \
    (ptr)->next = (ptr); (ptr)->prev = (ptr); \
} while (0)
 
/*
 * Insert a l_new entry between two known consecutive entries. 
 *
 * This is only for internal list manipulation where we know
 * the prev/next entries already!
 */
void __list_add(struct list_head * l_new,
    struct list_head * prev,
    struct list_head * next);
 
void list_add(struct list_head *l_new, struct list_head *head);
 
void list_add_tail(struct list_head *l_new, struct list_head *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!
 */
void __list_del(struct list_head * prev,
                  struct list_head * next);
 
void list_del(struct list_head *entry);
 
void list_del_init(struct list_head *entry);
 
int list_empty(struct list_head *head);
 
void list_splice(struct list_head *list, struct list_head *head);
 
#define list_entry(ptr, type, member) \
    ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))
 
#define list_first_entry(ptr, type, member) \
    list_entry((ptr)->next, type, member)
 
#define list_last_entry(ptr, type, member) \
    list_entry((ptr)->prev, type, member)
 
#define list_first_entry_or_null(ptr, type, member) \
    (!list_empty(ptr) ? list_first_entry(ptr, type, member) : NULL)
 
#define list_for_each(pos, head) \
    for (pos = (head)->next; pos != (head); pos = pos->next)
            
#define list_for_each_safe(pos, n, head) \
    for (pos = (head)->next, n = pos->next; pos != (head); \
        pos = n, n = pos->next)
 
#define list_for_each_prev(pos, head) \
    for (pos = (head)->prev; pos != (head); pos = pos->prev)
         
/*
 * Double linked lists with a single pointer list head.
 * Mostly useful for hash tables where the two pointer list head is
 * too wasteful.
 * You lose the ability to access the tail in O(1).
 */
 
struct hlist_node {
    struct hlist_node *next, **pprev;
};
 
struct hlist_head {
    struct hlist_node *first;
};
 
#define INIT_HLIST_HEAD(ptr) ((ptr)->first = NULL)
#define INIT_HLIST_NODE(h) \
{ \
    h->next = NULL; \
    h->pprev = NULL; \
}
 
#define hlist_unhashed(h) (!h->pprev)
 
#define hlist_empty(h) (!h->first)
 
void hlist_del(struct hlist_node *n);
void hlist_del_init(struct hlist_node *n);
void hlist_add_head(struct hlist_node *n, struct hlist_head *h);
 
/* next must be != NULL */
void hlist_add_before(struct hlist_node *n, struct hlist_node *next);
void hlist_add_behind(struct hlist_node *n, struct hlist_node *prev);
/* after that we'll appear to be on some hlist and hlist_del will work */
void hlist_add_fake(struct hlist_node *n);
int hlist_fake(struct hlist_node *h);
 
/*
 * Move a list from one list head to another. Fixup the pprev
 * reference of the first entry if it exists.
 */
void hlist_move_list(struct hlist_head *old, struct hlist_head *l_new);
 
#define hlist_entry(ptr, type, member) \
    ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))
 
#define hlist_for_each(pos, head) \
    for (pos = (head)->first; pos ; pos = pos->next)
 
#define hlist_for_each_safe(pos, n, head) \
    for (pos = (head)->first; pos && ({ n = pos->next; 1; }); pos = n)
 
 
#endif // _WHEELC_LIST_H_