cbtcommon/list.h

   1 /*
   2  * Copyright 2001, 2002, 2003 David Mansfield and Cobite, Inc.
   3  * See COPYING file for license information
   4  */
   5
   6 #ifndef _COMMON_LIST_H
   7 #define _COMMON_LIST_H
   8
   9 /*
  10  * Stolen from linux-2.1.131
  11  * All comments from the original source unless otherwise noted
  12  * Added: the CLEAR_LIST_NODE macro
  13  */
  14
  15 /*
  16  * Simple doubly linked list implementation.
  17  *
  18  * Some of the internal functions ("__xxx") are useful when
  19  * manipulating whole lists rather than single entries, as
  20  * sometimes we already know the next/prev entries and we can
  21  * generate better code by using them directly rather than
  22  * using the generic single-entry routines.
  23  */
  24
  25 #include "inline.h"
  26 #include <stddef.h>
  27
  28 struct list_head {
  29         struct list_head *next, *prev;
  30 };
  31
  32 #define LIST_HEAD(name) \
  33         struct list_head name = { &name, &name }
  34
  35 #define INIT_LIST_HEAD(ptr)  do { \
  36         (ptr)->next = (ptr); (ptr)->prev = (ptr); \
  37 } while (0)
  38
  39 #define CLEAR_LIST_NODE(ptr) do { \
  40         (ptr)->next = NULL;  (ptr)->prev = NULL; \
  41 } while (0)
  42
  43 /*
  44  * Insert a new entry between two known consecutive entries.
  45  *
  46  * This is only for internal list manipulation where we know
  47  * the prev/next entries already!
  48  */
  49 static INLINE void __list_add(struct list_head *li,
  50         struct list_head * prev,
  51         struct list_head * next)
  52 {
  53         next->prev = li;
  54         li->next = next;
  55         li->prev = prev;
  56         prev->next = li;
  57 }
  58
  59 /*
  60  * Insert a new entry after the specified head..
  61  */
  62 static INLINE void list_add(struct list_head *li, struct list_head *head)
  63 {
  64         __list_add(li, head, head->next);
  65 }
  66
  67 /*
  68  * Delete a list entry by making the prev/next entries
  69  * point to each other.
  70  *
  71  * This is only for internal list manipulation where we know
  72  * the prev/next entries already!
  73  */
  74 static INLINE void __list_del(struct list_head * prev,
  75                                   struct list_head * next)
  76 {
  77         next->prev = prev;
  78         prev->next = next;
  79 }
  80
  81 static INLINE void list_del(struct list_head *entry)
  82 {
  83         __list_del(entry->prev, entry->next);
  84 }
  85
  86 static INLINE int list_empty(struct list_head *head)
  87 {
  88         return head->next == head;
  89 }
  90
  91 /*
  92  * Splice in "list" into "head"
  93  */
  94 static INLINE void list_splice(struct list_head *list, struct list_head *head)
  95 {
  96         struct list_head *first = list->next;
  97
  98         if (first != list) {
  99                 struct list_head *last = list->prev;
 100                 struct list_head *at = head->next;
 101
 102                 first->prev = head;
 103                 head->next = first;
 104
 105                 last->next = at;
 106                 at->prev = last;
 107         }
 108 }
 109
 110 #define list_entry(ptr, type, member) \
 111    ((type *)((char *)(ptr)-offsetof(type, member)))
 112
 113 #endif /* _COMMON_LIST_H */