58 lnew->list_next = (node); \
59 lnew->list_prev = (node)->list_prev; \
60 (node)->list_prev->list_next = lnew; \
61 (node)->list_prev = lnew; \
62 }
63
64 #define list_remove_node(node) \
65 (node)->list_prev->list_next = (node)->list_next; \
66 (node)->list_next->list_prev = (node)->list_prev; \
67 (node)->list_next = (node)->list_prev = NULL
68
69 void
70 list_create(list_t *list, size_t size, size_t offset)
71 {
72 ASSERT(list);
73 ASSERT(size > 0);
74 ASSERT(size >= offset + sizeof (list_node_t));
75
76 list->list_size = size;
77 list->list_offset = offset;
78 list->list_head.list_next = list->list_head.list_prev =
79 &list->list_head;
80 }
81
82 void
83 list_destroy(list_t *list)
84 {
85 list_node_t *node = &list->list_head;
86
87 ASSERT(list);
88 ASSERT(list->list_head.list_next == node);
89 ASSERT(list->list_head.list_prev == node);
90
91 node->list_next = node->list_prev = NULL;
92 }
93
94 void
95 list_insert_after(list_t *list, void *object, void *nobject)
96 {
97 if (object == NULL) {
98 list_insert_head(list, nobject);
99 } else {
100 list_node_t *lold = list_d2l(list, object);
101 list_insert_after_node(list, lold, nobject);
102 }
103 }
104
105 void
106 list_insert_before(list_t *list, void *object, void *nobject)
107 {
108 if (object == NULL) {
109 list_insert_tail(list, nobject);
110 } else {
111 list_node_t *lold = list_d2l(list, object);
112 list_insert_before_node(list, lold, nobject);
113 }
114 }
115
116 void
117 list_insert_head(list_t *list, void *object)
118 {
119 list_node_t *lold = &list->list_head;
120 list_insert_after_node(list, lold, object);
121 }
122
123 void
124 list_insert_tail(list_t *list, void *object)
125 {
126 list_node_t *lold = &list->list_head;
127 list_insert_before_node(list, lold, object);
128 }
129
130 void
131 list_remove(list_t *list, void *object)
132 {
133 list_node_t *lold = list_d2l(list, object);
134 ASSERT(!list_empty(list));
135 ASSERT(lold->list_next != NULL);
136 list_remove_node(lold);
137 }
138
139 void *
140 list_remove_head(list_t *list)
141 {
142 list_node_t *head = list->list_head.list_next;
143 if (head == &list->list_head)
144 return (NULL);
145 list_remove_node(head);
146 return (list_object(list, head));
147 }
148
149 void *
150 list_remove_tail(list_t *list)
151 {
152 list_node_t *tail = list->list_head.list_prev;
153 if (tail == &list->list_head)
154 return (NULL);
155 list_remove_node(tail);
156 return (list_object(list, tail));
157 }
158
159 void *
160 list_head(list_t *list)
161 {
162 if (list_empty(list))
163 return (NULL);
164 return (list_object(list, list->list_head.list_next));
165 }
166
167 void *
168 list_tail(list_t *list)
169 {
170 if (list_empty(list))
171 return (NULL);
172 return (list_object(list, list->list_head.list_prev));
173 }
174
192 return (list_object(list, node->list_prev));
193
194 return (NULL);
195 }
196
197 /*
198 * Insert src list after dst list. Empty src list thereafter.
199 */
200 void
201 list_move_tail(list_t *dst, list_t *src)
202 {
203 list_node_t *dstnode = &dst->list_head;
204 list_node_t *srcnode = &src->list_head;
205
206 ASSERT(dst->list_size == src->list_size);
207 ASSERT(dst->list_offset == src->list_offset);
208
209 if (list_empty(src))
210 return;
211
212 dstnode->list_prev->list_next = srcnode->list_next;
213 srcnode->list_next->list_prev = dstnode->list_prev;
214 dstnode->list_prev = srcnode->list_prev;
215 srcnode->list_prev->list_next = dstnode;
216
217 /* empty src list */
218 srcnode->list_next = srcnode->list_prev = srcnode;
219 }
220
221 void
222 list_link_replace(list_node_t *lold, list_node_t *lnew)
223 {
224 ASSERT(list_link_active(lold));
225 ASSERT(!list_link_active(lnew));
226
227 lnew->list_next = lold->list_next;
228 lnew->list_prev = lold->list_prev;
229 lold->list_prev->list_next = lnew;
230 lold->list_next->list_prev = lnew;
231 lold->list_next = lold->list_prev = NULL;
232 }
233
234 void
235 list_link_init(list_node_t *link)
236 {
237 link->list_next = NULL;
238 link->list_prev = NULL;
239 }
240
241 int
242 list_link_active(list_node_t *link)
243 {
244 return (link->list_next != NULL);
245 }
246
247 int
248 list_is_empty(list_t *list)
249 {
250 return (list_empty(list));
251 }
|
58 lnew->list_next = (node); \
59 lnew->list_prev = (node)->list_prev; \
60 (node)->list_prev->list_next = lnew; \
61 (node)->list_prev = lnew; \
62 }
63
64 #define list_remove_node(node) \
65 (node)->list_prev->list_next = (node)->list_next; \
66 (node)->list_next->list_prev = (node)->list_prev; \
67 (node)->list_next = (node)->list_prev = NULL
68
69 void
70 list_create(list_t *list, size_t size, size_t offset)
71 {
72 ASSERT(list);
73 ASSERT(size > 0);
74 ASSERT(size >= offset + sizeof (list_node_t));
75
76 list->list_size = size;
77 list->list_offset = offset;
78 list->list_numnodes = 0;
79 list->list_head.list_next = list->list_head.list_prev =
80 &list->list_head;
81 }
82
83 void
84 list_destroy(list_t *list)
85 {
86 list_node_t *node = &list->list_head;
87
88 ASSERT(list);
89 ASSERT(list->list_head.list_next == node);
90 ASSERT(list->list_head.list_prev == node);
91
92 list->list_numnodes = 0;
93 node->list_next = node->list_prev = NULL;
94 }
95
96 void
97 list_insert_after(list_t *list, void *object, void *nobject)
98 {
99 if (object == NULL) {
100 list_insert_head(list, nobject);
101 } else {
102 list_node_t *lold = list_d2l(list, object);
103 list_insert_after_node(list, lold, nobject);
104 }
105 }
106
107 void
108 list_insert_before(list_t *list, void *object, void *nobject)
109 {
110 if (object == NULL) {
111 list_insert_tail(list, nobject);
112 } else {
113 list_node_t *lold = list_d2l(list, object);
114 list_insert_before_node(list, lold, nobject);
115 }
116 }
117
118 void
119 list_insert_head(list_t *list, void *object)
120 {
121 list_node_t *lold = &list->list_head;
122 list->list_numnodes++;
123 list_insert_after_node(list, lold, object);
124 }
125
126 void
127 list_insert_tail(list_t *list, void *object)
128 {
129 list_node_t *lold = &list->list_head;
130 list->list_numnodes++;
131 list_insert_before_node(list, lold, object);
132 }
133
134 void
135 list_remove(list_t *list, void *object)
136 {
137 list_node_t *lold = list_d2l(list, object);
138 ASSERT(!list_empty(list));
139 ASSERT(lold->list_next != NULL);
140 list->list_numnodes--;
141 list_remove_node(lold);
142 }
143
144 void *
145 list_remove_head(list_t *list)
146 {
147 list_node_t *head = list->list_head.list_next;
148 if (head == &list->list_head)
149 return (NULL);
150 list->list_numnodes--;
151 list_remove_node(head);
152 return (list_object(list, head));
153 }
154
155 void *
156 list_remove_tail(list_t *list)
157 {
158 list_node_t *tail = list->list_head.list_prev;
159 if (tail == &list->list_head)
160 return (NULL);
161 list->list_numnodes--;
162 list_remove_node(tail);
163 return (list_object(list, tail));
164 }
165
166 void *
167 list_head(list_t *list)
168 {
169 if (list_empty(list))
170 return (NULL);
171 return (list_object(list, list->list_head.list_next));
172 }
173
174 void *
175 list_tail(list_t *list)
176 {
177 if (list_empty(list))
178 return (NULL);
179 return (list_object(list, list->list_head.list_prev));
180 }
181
199 return (list_object(list, node->list_prev));
200
201 return (NULL);
202 }
203
204 /*
205 * Insert src list after dst list. Empty src list thereafter.
206 */
207 void
208 list_move_tail(list_t *dst, list_t *src)
209 {
210 list_node_t *dstnode = &dst->list_head;
211 list_node_t *srcnode = &src->list_head;
212
213 ASSERT(dst->list_size == src->list_size);
214 ASSERT(dst->list_offset == src->list_offset);
215
216 if (list_empty(src))
217 return;
218
219 dst->list_numnodes += src->list_numnodes;
220 dstnode->list_prev->list_next = srcnode->list_next;
221 srcnode->list_next->list_prev = dstnode->list_prev;
222 dstnode->list_prev = srcnode->list_prev;
223 srcnode->list_prev->list_next = dstnode;
224
225 /* empty src list */
226 src->list_numnodes = 0;
227 srcnode->list_next = srcnode->list_prev = srcnode;
228 }
229
230 void
231 list_link_replace(list_node_t *lold, list_node_t *lnew)
232 {
233 ASSERT(list_link_active(lold));
234 ASSERT(!list_link_active(lnew));
235
236 lnew->list_next = lold->list_next;
237 lnew->list_prev = lold->list_prev;
238 lold->list_prev->list_next = lnew;
239 lold->list_next->list_prev = lnew;
240 lold->list_next = lold->list_prev = NULL;
241 }
242
243 void
244 list_link_init(list_node_t *link)
245 {
246 link->list_next = NULL;
247 link->list_prev = NULL;
248 }
249
250 int
251 list_link_active(list_node_t *link)
252 {
253 return (link->list_next != NULL);
254 }
255
256 int
257 list_is_empty(list_t *list)
258 {
259 return (list_empty(list));
260 }
261
262 ulong_t
263 list_numnodes(list_t *list)
264 {
265 /*
266 size_t sz = 0;
267 list_node_t *node;
268
269 node = &list->list_head;
270 while (node->list_next != &list->list_head) {
271 sz++;
272 node = node->list_next;
273 }
274 return (sz);
275 */
276 return (list->list_numnodes);
277 }
|