Mercurial > hg
comparison mcabber/src/list.h @ 24:e88b15cbf2de
[/trunk] Changeset 40 by mikael
* Change structure -> src directory for mcabber source code...
author | mikael |
---|---|
date | Sun, 27 Mar 2005 20:16:02 +0000 |
parents | |
children | 0cd8025eebee |
comparison
equal
deleted
inserted
replaced
23:d7107507424b | 24:e88b15cbf2de |
---|---|
1 #ifndef _LINUX_LIST_H | |
2 #define _LINUX_LIST_H | |
3 | |
4 /* | |
5 * Simple doubly linked list implementation. | |
6 * | |
7 * Some of the internal functions ("__xxx") are useful when | |
8 * manipulating whole lists rather than single entries, as | |
9 * sometimes we already know the next/prev entries and we can | |
10 * generate better code by using them directly rather than | |
11 * using the generic single-entry routines. | |
12 */ | |
13 | |
14 struct list_head { | |
15 struct list_head *next, *prev; | |
16 }; | |
17 | |
18 #define LIST_HEAD_INIT(name) { &(name), &(name) } | |
19 | |
20 #define LIST_HEAD(name) \ | |
21 struct list_head name = LIST_HEAD_INIT(name) | |
22 | |
23 #define INIT_LIST_HEAD(ptr) do { \ | |
24 (ptr)->next = (ptr); (ptr)->prev = (ptr); \ | |
25 } while (0) | |
26 | |
27 /* | |
28 * Insert a new entry between two known consecutive entries. | |
29 * | |
30 * This is only for internal list manipulation where we know | |
31 * the prev/next entries already! | |
32 */ | |
33 static inline void | |
34 __list_add(struct list_head *new, | |
35 struct list_head *prev, struct list_head *next) | |
36 { | |
37 next->prev = new; | |
38 new->next = next; | |
39 new->prev = prev; | |
40 prev->next = new; | |
41 } | |
42 | |
43 /** | |
44 * list_add - add a new entry | |
45 * @new: new entry to be added | |
46 * @head: list head to add it after | |
47 * | |
48 * Insert a new entry after the specified head. | |
49 * This is good for implementing stacks. | |
50 */ | |
51 static inline void list_add(struct list_head *new, struct list_head *head) | |
52 { | |
53 __list_add(new, head, head->next); | |
54 } | |
55 | |
56 /** | |
57 * list_add_tail - add a new entry | |
58 * @new: new entry to be added | |
59 * @head: list head to add it before | |
60 * | |
61 * Insert a new entry before the specified head. | |
62 * This is useful for implementing queues. | |
63 */ | |
64 static inline void | |
65 list_add_tail(struct list_head *new, struct list_head *head) | |
66 { | |
67 __list_add(new, head->prev, head); | |
68 } | |
69 | |
70 /* | |
71 * Delete a list entry by making the prev/next entries | |
72 * point to each other. | |
73 * | |
74 * This is only for internal list manipulation where we know | |
75 * the prev/next entries already! | |
76 */ | |
77 static inline void | |
78 __list_del(struct list_head *prev, struct list_head *next) | |
79 { | |
80 next->prev = prev; | |
81 prev->next = next; | |
82 } | |
83 | |
84 /** | |
85 * list_del - deletes entry from list. | |
86 * @entry: the element to delete from the list. | |
87 * Note: list_empty on entry does not return true after this, the entry is in an undefined state. | |
88 */ | |
89 static inline void list_del(struct list_head *entry) | |
90 { | |
91 __list_del(entry->prev, entry->next); | |
92 entry->next = (void *) 0; | |
93 entry->prev = (void *) 0; | |
94 } | |
95 | |
96 /** | |
97 * list_del_init - deletes entry from list and reinitialize it. | |
98 * @entry: the element to delete from the list. | |
99 */ | |
100 static inline void list_del_init(struct list_head *entry) | |
101 { | |
102 __list_del(entry->prev, entry->next); | |
103 INIT_LIST_HEAD(entry); | |
104 } | |
105 | |
106 /** | |
107 * list_move - delete from one list and add as another's head | |
108 * @list: the entry to move | |
109 * @head: the head that will precede our entry | |
110 */ | |
111 static inline void | |
112 list_move(struct list_head *list, struct list_head *head) | |
113 { | |
114 __list_del(list->prev, list->next); | |
115 list_add(list, head); | |
116 } | |
117 | |
118 /** | |
119 * list_move_tail - delete from one list and add as another's tail | |
120 * @list: the entry to move | |
121 * @head: the head that will follow our entry | |
122 */ | |
123 static inline void | |
124 list_move_tail(struct list_head *list, struct list_head *head) | |
125 { | |
126 __list_del(list->prev, list->next); | |
127 list_add_tail(list, head); | |
128 } | |
129 | |
130 /** | |
131 * list_empty - tests whether a list is empty | |
132 * @head: the list to test. | |
133 */ | |
134 static inline int list_empty(struct list_head *head) | |
135 { | |
136 return head->next == head; | |
137 } | |
138 | |
139 static inline void | |
140 __list_splice(struct list_head *list, struct list_head *head) | |
141 { | |
142 struct list_head *first = list->next; | |
143 struct list_head *last = list->prev; | |
144 struct list_head *at = head->next; | |
145 | |
146 first->prev = head; | |
147 head->next = first; | |
148 | |
149 last->next = at; | |
150 at->prev = last; | |
151 } | |
152 | |
153 /** | |
154 * list_splice - join two lists | |
155 * @list: the new list to add. | |
156 * @head: the place to add it in the first list. | |
157 */ | |
158 static inline void | |
159 list_splice(struct list_head *list, struct list_head *head) | |
160 { | |
161 if (!list_empty(list)) | |
162 __list_splice(list, head); | |
163 } | |
164 | |
165 /** | |
166 * list_splice_init - join two lists and reinitialise the emptied list. | |
167 * @list: the new list to add. | |
168 * @head: the place to add it in the first list. | |
169 * | |
170 * The list at @list is reinitialised | |
171 */ | |
172 static inline void | |
173 list_splice_init(struct list_head *list, struct list_head *head) | |
174 { | |
175 if (!list_empty(list)) { | |
176 __list_splice(list, head); | |
177 INIT_LIST_HEAD(list); | |
178 } | |
179 } | |
180 | |
181 /** | |
182 * list_entry - get the struct for this entry | |
183 * @ptr: the &struct list_head pointer. | |
184 * @type: the type of the struct this is embedded in. | |
185 * @member: the name of the list_struct within the struct. | |
186 */ | |
187 #define list_entry(ptr, type, member) \ | |
188 ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member))) | |
189 | |
190 /** | |
191 * list_for_each_safe - iterate over a list safe against removal of list entry | |
192 * @pos: the &struct list_head to use as a loop counter. | |
193 * @n: another &struct list_head to use as temporary storage | |
194 * @head: the head for your list. | |
195 */ | |
196 #define list_for_each_safe(pos, n, head) \ | |
197 for (pos = (head)->next, n = pos->next; pos != (head); \ | |
198 pos = n, n = pos->next) | |
199 | |
200 /** | |
201 * list_for_each_entry_safe - iterate over list of given type safe against removal of list entry | |
202 * @pos: the type * to use as a loop counter. | |
203 * @n: another type * to use as temporary storage | |
204 * @head: the head for your list. | |
205 * @member: the name of the list_struct within the struct. | |
206 */ | |
207 #define list_for_each_entry_safe(pos, n, head, member) \ | |
208 for (pos = list_entry((head)->next, typeof(*pos), member), \ | |
209 n = list_entry(pos->member.next, typeof(*pos), member); \ | |
210 &pos->member != (head); \ | |
211 pos = n, n = list_entry(n->member.next, typeof(*n), member)) | |
212 | |
213 #endif |