Lines Matching refs:lp
36 #define ELEM_TO_NODE(lp, e) \
37 ((uu_list_node_impl_t *)((uintptr_t)(e) + (lp)->ul_offset))
39 #define NODE_TO_ELEM(lp, n) \
40 ((void *)((uintptr_t)(n) - (lp)->ul_offset))
183 uu_list_t *lp, *next, *prev;
199 lp = uu_zalloc(sizeof (*lp));
200 if (lp == NULL) {
205 lp->ul_pool = pp;
206 lp->ul_parent_enc = UU_PTR_ENCODE(parent);
207 lp->ul_offset = pp->ulp_nodeoffset;
208 lp->ul_debug = pp->ulp_debug || (flags & UU_LIST_DEBUG);
209 lp->ul_sorted = (flags & UU_LIST_SORTED);
210 lp->ul_numnodes = 0;
211 lp->ul_index = (pp->ulp_last_index = INDEX_NEXT(pp->ulp_last_index));
213 lp->ul_null_node.uln_next = &lp->ul_null_node;
214 lp->ul_null_node.uln_prev = &lp->ul_null_node;
216 lp->ul_null_walk.ulw_next = &lp->ul_null_walk;
217 lp->ul_null_walk.ulw_prev = &lp->ul_null_walk;
222 lp->ul_next_enc = UU_PTR_ENCODE(next);
223 lp->ul_prev_enc = UU_PTR_ENCODE(prev);
224 next->ul_prev_enc = UU_PTR_ENCODE(lp);
225 prev->ul_next_enc = UU_PTR_ENCODE(lp);
228 return (lp);
232 uu_list_destroy(uu_list_t *lp)
234 uu_list_pool_t *pp = lp->ul_pool;
236 if (lp->ul_debug) {
237 if (lp->ul_null_node.uln_next != &lp->ul_null_node ||
238 lp->ul_null_node.uln_prev != &lp->ul_null_node) {
240 (void *)lp);
242 if (lp->ul_numnodes != 0) {
244 "but list is empty\n", (void *)lp);
246 if (lp->ul_null_walk.ulw_next != &lp->ul_null_walk ||
247 lp->ul_null_walk.ulw_prev != &lp->ul_null_walk) {
249 (void *)lp);
254 UU_LIST_PTR(lp->ul_next_enc)->ul_prev_enc = lp->ul_prev_enc;
255 UU_LIST_PTR(lp->ul_prev_enc)->ul_next_enc = lp->ul_next_enc;
257 lp->ul_prev_enc = UU_PTR_ENCODE(NULL);
258 lp->ul_next_enc = UU_PTR_ENCODE(NULL);
259 lp->ul_pool = NULL;
260 uu_free(lp);
264 list_insert(uu_list_t *lp, uu_list_node_impl_t *np, uu_list_node_impl_t *prev,
267 if (lp->ul_debug) {
270 "neighbors\n", (void *)lp, (void *)next,
273 if (np->uln_next != POOL_TO_MARKER(lp->ul_pool) ||
277 (void *)lp, NODE_TO_ELEM(lp, np), (void *)np);
282 lp->ul_index = INDEX_NEXT(lp->ul_index);
289 lp->ul_numnodes++;
293 uu_list_insert(uu_list_t *lp, void *elem, uu_list_index_t idx)
299 np = &lp->ul_null_node;
301 if (lp->ul_debug) {
302 if (!INDEX_VALID(lp, idx))
304 (void *)lp, elem, (void *)idx,
309 "index\n", (void *)lp, elem, (void *)idx);
312 list_insert(lp, ELEM_TO_NODE(lp, elem), np->uln_prev, np);
316 uu_list_find(uu_list_t *lp, void *elem, void *private, uu_list_index_t *out)
318 int sorted = lp->ul_sorted;
319 uu_compare_fn_t *func = lp->ul_pool->ulp_cmp;
330 for (np = lp->ul_null_node.uln_next; np != &lp->ul_null_node;
332 void *ep = NODE_TO_ELEM(lp, np);
336 *out = NODE_TO_INDEX(lp, np);
341 *out = NODE_TO_INDEX(lp, np);
346 *out = NODE_TO_INDEX(lp, 0);
351 uu_list_nearest_next(uu_list_t *lp, uu_list_index_t idx)
356 np = &lp->ul_null_node;
358 if (lp->ul_debug) {
359 if (!INDEX_VALID(lp, idx))
361 (void *)lp, (void *)idx,
366 "index\n", (void *)lp, (void *)idx);
369 if (np == &lp->ul_null_node)
372 return (NODE_TO_ELEM(lp, np));
376 uu_list_nearest_prev(uu_list_t *lp, uu_list_index_t idx)
381 np = &lp->ul_null_node;
383 if (lp->ul_debug) {
384 if (!INDEX_VALID(lp, idx))
386 (void *)lp, (void *)idx, INDEX_CHECK(idx)?
390 "index\n", (void *)lp, (void *)idx);
393 if ((np = np->uln_prev) == &lp->ul_null_node)
396 return (NODE_TO_ELEM(lp, np));
400 list_walk_init(uu_list_walk_t *wp, uu_list_t *lp, uint32_t flags)
408 wp->ulw_list = lp;
412 wp->ulw_next_result = lp->ul_null_node.uln_next;
414 wp->ulw_next_result = lp->ul_null_node.uln_prev;
416 if (lp->ul_debug || robust) {
422 wp->ulw_next = next = &lp->ul_null_walk;
430 list_walk_advance(uu_list_walk_t *wp, uu_list_t *lp)
435 if (np == &lp->ul_null_node)
459 uu_list_walk_start(uu_list_t *lp, uint32_t flags)
474 list_walk_init(wp, lp, flags);
481 uu_list_t *lp = wp->ulw_list;
482 uu_list_node_impl_t *np = list_walk_advance(wp, lp);
487 return (NODE_TO_ELEM(lp, np));
498 uu_list_walk(uu_list_t *lp, uu_walk_fn_t *func, void *private, uint32_t flags)
512 if (lp->ul_debug || robust) {
516 list_walk_init(&my_walk, lp, flags);
523 for (np = lp->ul_null_node.uln_next;
524 status == UU_WALK_NEXT && np != &lp->ul_null_node;
526 status = (*func)(NODE_TO_ELEM(lp, np), private);
529 for (np = lp->ul_null_node.uln_prev;
530 status == UU_WALK_NEXT && np != &lp->ul_null_node;
532 status = (*func)(NODE_TO_ELEM(lp, np), private);
543 uu_list_remove(uu_list_t *lp, void *elem)
545 uu_list_node_impl_t *np = ELEM_TO_NODE(lp, elem);
548 if (lp->ul_debug) {
551 (void *)lp, elem);
555 lp->ul_index = INDEX_NEXT(lp->ul_index);
562 for (wp = lp->ul_null_walk.ulw_next; wp != &lp->ul_null_walk;
566 (void) list_walk_advance(wp, lp);
569 "walker\n", (void *)lp, elem);
576 lp->ul_numnodes--;
578 np->uln_next = POOL_TO_MARKER(lp->ul_pool);
583 uu_list_teardown(uu_list_t *lp, void **cookie)
590 if (lp->ul_debug && *cookie != NULL)
592 (void *)lp, (void *)cookie);
594 ep = uu_list_first(lp);
596 uu_list_remove(lp, ep);
601 uu_list_insert_before(uu_list_t *lp, void *target, void *elem)
603 uu_list_node_impl_t *np = ELEM_TO_NODE(lp, target);
606 np = &lp->ul_null_node;
608 if (lp->ul_debug) {
612 (void *)lp, target, elem, target);
614 if (lp->ul_sorted) {
615 if (lp->ul_debug)
617 "UU_LIST_SORTED\n", (void *)lp);
622 list_insert(lp, ELEM_TO_NODE(lp, elem), np->uln_prev, np);
627 uu_list_insert_after(uu_list_t *lp, void *target, void *elem)
629 uu_list_node_impl_t *np = ELEM_TO_NODE(lp, target);
632 np = &lp->ul_null_node;
634 if (lp->ul_debug) {
638 (void *)lp, target, elem, target);
640 if (lp->ul_sorted) {
641 if (lp->ul_debug)
643 "UU_LIST_SORTED\n", (void *)lp);
648 list_insert(lp, ELEM_TO_NODE(lp, elem), np, np->uln_next);
653 uu_list_numnodes(uu_list_t *lp)
655 return (lp->ul_numnodes);
659 uu_list_first(uu_list_t *lp)
661 uu_list_node_impl_t *n = lp->ul_null_node.uln_next;
662 if (n == &lp->ul_null_node)
664 return (NODE_TO_ELEM(lp, n));
668 uu_list_last(uu_list_t *lp)
670 uu_list_node_impl_t *n = lp->ul_null_node.uln_prev;
671 if (n == &lp->ul_null_node)
673 return (NODE_TO_ELEM(lp, n));
677 uu_list_next(uu_list_t *lp, void *elem)
679 uu_list_node_impl_t *n = ELEM_TO_NODE(lp, elem);
682 if (n == &lp->ul_null_node)
684 return (NODE_TO_ELEM(lp, n));
688 uu_list_prev(uu_list_t *lp, void *elem)
690 uu_list_node_impl_t *n = ELEM_TO_NODE(lp, elem);
693 if (n == &lp->ul_null_node)
695 return (NODE_TO_ELEM(lp, n));