home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / lxapi32.zip / Include / Linux / list.h < prev    next >
C/C++ Source or Header  |  2002-04-26  |  3KB  |  115 lines
  1. /* $Id: list.h,v 1.2 2002/04/26 23:09:09 smilcke Exp $ */
  2.  
  3. #ifndef _LINUX_LIST_H
  4. #define _LINUX_LIST_H
  5.  
  6. #ifdef __KERNEL__
  7.  
  8. /*
  9.  * Simple doubly linked list implementation.
  10.  *
  11.  * Some of the internal functions ("__xxx") are useful when
  12.  * manipulating whole lists rather than single entries, as
  13.  * sometimes we already know the next/prev entries and we can
  14.  * generate better code by using them directly rather than
  15.  * using the generic single-entry routines.
  16.  */
  17.  
  18. struct list_head {
  19.     struct list_head *next, *prev;
  20. };
  21.  
  22. #define LIST_HEAD_INIT(name) { &(name), &(name) }
  23.  
  24. #define LIST_HEAD(name) \
  25.     struct list_head name = LIST_HEAD_INIT(name)
  26.  
  27. #define INIT_LIST_HEAD(ptr) do { \
  28.     (ptr)->next = (ptr); (ptr)->prev = (ptr); \
  29. } while (0)
  30.  
  31. /*
  32.  * Insert a new entry between two known consecutive entries. 
  33.  *
  34.  * This is only for internal list manipulation where we know
  35.  * the prev/next entries already!
  36.  */
  37. static __inline__ void __list_add(struct list_head * newlh,
  38.     struct list_head * prev,
  39.     struct list_head * next)
  40. {
  41.     next->prev = newlh;
  42.     newlh->next = next;
  43.     newlh->prev = prev;
  44.     prev->next = newlh;
  45. }
  46.  
  47. /*
  48.  * Insert a new entry after the specified head..
  49.  */
  50. static __inline__ void list_add(struct list_head *newlh, struct list_head *head)
  51. {
  52.     __list_add(newlh, head, head->next);
  53. }
  54.  
  55. /*
  56.  * Insert a new entry before the specified head..
  57.  */
  58. static __inline__ void list_add_tail(struct list_head *newlh, struct list_head *head)
  59. {
  60.     __list_add(newlh, head->prev, head);
  61. }
  62.  
  63. /*
  64.  * Delete a list entry by making the prev/next entries
  65.  * point to each other.
  66.  *
  67.  * This is only for internal list manipulation where we know
  68.  * the prev/next entries already!
  69.  */
  70. static __inline__ void __list_del(struct list_head * prev,
  71.                   struct list_head * next)
  72. {
  73.     next->prev = prev;
  74.     prev->next = next;
  75. }
  76.  
  77. static __inline__ void list_del(struct list_head *entry)
  78. {
  79.     __list_del(entry->prev, entry->next);
  80. }
  81.  
  82. static __inline__ int list_empty(struct list_head *head)
  83. {
  84.     return head->next == head;
  85. }
  86.  
  87. /*
  88.  * Splice in "list" into "head"
  89.  */
  90. static __inline__ void list_splice(struct list_head *list, struct list_head *head)
  91. {
  92.     struct list_head *first = list->next;
  93.  
  94.     if (first != list) {
  95.         struct list_head *last = list->prev;
  96.         struct list_head *at = head->next;
  97.  
  98.         first->prev = head;
  99.         head->next = first;
  100.  
  101.         last->next = at;
  102.         at->prev = last;
  103.     }
  104. }
  105.  
  106. #define list_entry(ptr, type, member) \
  107.     ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member)))
  108.  
  109. #define list_for_each(entry, listhead) \
  110.         for(entry=(listhead)->next;entry != listhead;entry=entry->next) 
  111.  
  112. #endif /* __KERNEL__ */
  113.  
  114. #endif
  115.