X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=list.h;h=78c302fa322fe6bc2dae2926e95e58189c10c944;hp=f4064470b6beb69eca1a37ebd588b04a5aa7fdc4;hb=442a3320ff155d09b990c0ee2abace399cbcd6dd;hpb=be84b7551e3be696edf2685dca9aabcf5c355d73

diff --git a/list.h b/list.h
index f4064470..78c302fa 100644
--- a/list.h
+++ b/list.h
@@ -25,53 +25,44 @@ struct list_head {
 #define INITIALIZED_LIST_HEAD(name) struct list_head name = {&(name), &(name)}
 
 /** This must be called before using any other list functions. */
-#define INIT_LIST_HEAD(ptr) do { \
-	(ptr)->next = (ptr); (ptr)->prev = (ptr); \
-} while (0)
+static inline void init_list_head(struct list_head *head)
+{
+	head->next = head;
+	head->prev = head;
+}
 
 /**
  * Insert a new entry after the specified head.
  *
- * \param new The new entry to add.
+ * \param entry The new entry to add.
  * \param head The list head to add it after.
  *
  * This is good for implementing stacks.
  */
-static inline void para_list_add(struct list_head *new, struct list_head *head)
+static inline void para_list_add(struct list_head *entry, struct list_head *head)
 {
-	new->prev = head;
-	new->next = head->next;
-	head->next->prev = new;
-	head->next = new;
+	entry->prev = head;
+	entry->next = head->next;
+	head->next->prev = entry;
+	head->next = entry;
 }
 
 /**
  * Insert a new entry before the specified head.
  *
- * \param new The new entry to add.
+ * \param entry The new entry to add.
  * \param head list head to add it before.
  *
  * This is useful for implementing queues.
  */
-static inline void list_add_tail(struct list_head *new, struct list_head *head)
+static inline void list_add_tail(struct list_head *entry, struct list_head *head)
 {
-	new->prev = head->prev;
-	new->next = head;
-	head->prev->next = new;
-	head->prev = new;
+	entry->prev = head->prev;
+	entry->next = head;
+	head->prev->next = entry;
+	head->prev = entry;
 }
 
-/*
- * These non-NULL pointers result in page faults when dereferenced. This helps
- * to catch bugs resulting from using deleted list heads.
- */
-
-/** Used for poisoning the next pointer. */
-#define LIST_POISON1 ((void *)0x00100100)
-
-/** Used for poisoning the prev pointer. */
-#define LIST_POISON2 ((void *)0x00200200)
-
 /**
  * Delete an entry from a list.
  *
@@ -84,20 +75,24 @@ static inline void list_del(struct list_head *entry)
 {
 	entry->prev->next = entry->next;
 	entry->next->prev = entry->prev;
-	entry->next = LIST_POISON1;
-	entry->prev = LIST_POISON2;
+	/*
+	 * These non-NULL pointers result in page faults when dereferenced.
+	 * This helps to catch bugs resulting from using deleted list heads.
+	 */
+	entry->next = (void *)0x00100100;
+	entry->prev = (void *)0x00200200;
 }
 
 /**
  * Delete an entry from one list and add it as another list's head.
  *
- * \param list The entry to move.
+ * \param entry The entry to move.
  * \param head The head that will precede our entry.
  */
-static inline void list_move(struct list_head *list, struct list_head *head)
+static inline void list_move(struct list_head *entry, struct list_head *head)
 {
-        list_del(list);
-        para_list_add(list, head);
+        list_del(entry);
+        para_list_add(entry, head);
 }
 
 /**
@@ -110,6 +105,16 @@ static inline int list_empty(const struct list_head *head)
 	return head->next == head;
 }
 
+/**
+ * Test whether a list has just one entry.
+ *
+ * \param head The list to test.
+ */
+static inline int list_is_singular(const struct list_head *head)
+{
+	return !list_empty(head) && (head->next == head->prev);
+}
+
 /**
  * Get the struct in which this entry is embedded in.
  *
@@ -122,7 +127,7 @@ static inline int list_empty(const struct list_head *head)
 /**
  * Iterate over a list.
  *
- * \param pos A list head pointer which serves as the iterator.
+ * \param pos A struct pointer which serves as the iterator.
  * \param head The head of the list.
  * \param member The name of the list head member within the structure.
  */
@@ -134,8 +139,8 @@ static inline int list_empty(const struct list_head *head)
 /**
  * Iterate over list, safe against removal of list entry.
  *
- * \param pos The iterator.
- * \param n A list head pointer which is used as temporary storage.
+ * \param pos The iterator struct pointer.
+ * \param n A second struct pointer which is used as temporary storage.
  * \param head The head of the list.
  * \param member The name of the list head member within the structure.
  */
@@ -156,13 +161,3 @@ static inline int list_empty(const struct list_head *head)
  */
 #define list_first_entry(ptr, type, member) \
 	list_entry((ptr)->next, type, member)
-
-/**
- * Test whether a list has just one entry.
- *
- * \param head The list to test.
- */
-static inline int list_is_singular(const struct list_head *head)
-{
-	return !list_empty(head) && (head->next == head->prev);
-}