Index: uspace/lib/c/generic/adt/hash_table.c =================================================================== --- uspace/lib/c/generic/adt/hash_table.c (revision a8bc7f8ffbe7619c0a815a40e4d05bd262b5c6a6) +++ uspace/lib/c/generic/adt/hash_table.c (revision 5203e2569a38ea677d1b3f202650bb36f9609583) @@ -61,9 +61,9 @@ assert(max_keys > 0); - h->entry = malloc(m * sizeof(link_t)); + h->entry = malloc(m * sizeof(list_t)); if (!h->entry) return false; - memset((void *) h->entry, 0, m * sizeof(link_t)); + memset((void *) h->entry, 0, m * sizeof(list_t)); hash_count_t i; @@ -123,7 +123,5 @@ assert(chain < h->entries); - link_t *cur; - for (cur = h->entry[chain].next; cur != &h->entry[chain]; - cur = cur->next) { + list_foreach(h->entry[chain], cur) { if (h->op->compare(key, h->max_keys, cur)) { /* @@ -153,7 +151,7 @@ assert(keys <= h->max_keys); - link_t *cur; - if (keys == h->max_keys) { + link_t *cur; + /* * All keys are known, hash_table_find() can be used to find the @@ -176,5 +174,7 @@ hash_index_t chain; for (chain = 0; chain < h->entries; chain++) { - for (cur = h->entry[chain].next; cur != &h->entry[chain]; + link_t *cur; + + for (cur = h->entry[chain].head.next; cur != &h->entry[chain].head; cur = cur->next) { if (h->op->compare(key, keys, cur)) { @@ -203,9 +203,7 @@ { hash_index_t bucket; - link_t *cur; for (bucket = 0; bucket < h->entries; bucket++) { - for (cur = h->entry[bucket].next; cur != &h->entry[bucket]; - cur = cur->next) { + list_foreach(h->entry[bucket], cur) { f(cur, arg); } Index: uspace/lib/c/generic/adt/list.c =================================================================== --- uspace/lib/c/generic/adt/list.c (revision a8bc7f8ffbe7619c0a815a40e4d05bd262b5c6a6) +++ uspace/lib/c/generic/adt/list.c (revision 5203e2569a38ea677d1b3f202650bb36f9609583) @@ -30,29 +30,35 @@ * @{ */ -/** @file + +/** + * @file + * @brief Functions completing doubly linked circular list implementaion. + * + * This file contains some of the functions implementing doubly linked circular lists. + * However, this ADT is mostly implemented in @ref list.h. */ #include - +#include /** Check for membership * - * Check whether link is contained in the list head. - * The membership is defined as pointer equivalence. + * Check whether link is contained in a list. + * Membership is defined as pointer equivalence. * - * @param link Item to look for. - * @param head List to look in. + * @param link Item to look for. + * @param list List to look in. * * @return true if link is contained in head, false otherwise. * */ -int list_member(const link_t *link, const link_t *head) +int list_member(const link_t *link, const list_t *list) { - int found = 0; - link_t *hlp = head->next; + bool found = false; + link_t *hlp = list->head.next; - while (hlp != head) { + while (hlp != &list->head) { if (hlp == link) { - found = 1; + found = true; break; } @@ -63,27 +69,25 @@ } - /** Concatenate two lists * - * Concatenate lists head1 and head2, producing a single - * list head1 containing items from both (in head1, head2 - * order) and empty list head2. + * Concatenate lists @a list1 and @a list2, producing a single + * list @a list1 containing items from both (in @a list1, @a list2 + * order) and empty list @a list2. * - * @param head1 First list and concatenated output - * @param head2 Second list and empty output. + * @param list1 First list and concatenated output + * @param list2 Second list and empty output. * */ -void list_concat(link_t *head1, link_t *head2) +void list_concat(list_t *list1, list_t *list2) { - if (list_empty(head2)) + if (list_empty(list2)) return; - - head2->next->prev = head1->prev; - head2->prev->next = head1; - head1->prev->next = head2->next; - head1->prev = head2->prev; - list_initialize(head2); + + list2->head.next->prev = list1->head.prev; + list2->head.prev->next = &list1->head; + list1->head.prev->next = list2->head.next; + list1->head.prev = list2->head.prev; + list_initialize(list2); } - /** Count list items @@ -91,17 +95,13 @@ * Return the number of items in the list. * - * @param link List to count. - * - * @return Number of items in the list. - * + * @param list List to count. + * @return Number of items in the list. */ -unsigned int list_count(const link_t *link) +unsigned int list_count(const list_t *list) { unsigned int count = 0; - link_t *hlp = link->next; - while (hlp != link) { + list_foreach(*list, link) { count++; - hlp = hlp->next; } Index: uspace/lib/c/generic/adt/prodcons.c =================================================================== --- uspace/lib/c/generic/adt/prodcons.c (revision a8bc7f8ffbe7619c0a815a40e4d05bd262b5c6a6) +++ uspace/lib/c/generic/adt/prodcons.c (revision 5203e2569a38ea677d1b3f202650bb36f9609583) @@ -61,5 +61,5 @@ fibril_condvar_wait(&pc->cv, &pc->mtx); - link_t *head = pc->list.next; + link_t *head = list_first(&pc->list); list_remove(head); Index: uspace/lib/c/generic/async.c =================================================================== --- uspace/lib/c/generic/async.c (revision a8bc7f8ffbe7619c0a815a40e4d05bd262b5c6a6) +++ uspace/lib/c/generic/async.c (revision 5203e2569a38ea677d1b3f202650bb36f9609583) @@ -160,5 +160,5 @@ /** Messages that should be delivered to this fibril. */ - link_t msg_queue; + list_t msg_queue; /** Identification of the opening call. */ @@ -361,6 +361,6 @@ wd->to_event.inlist = true; - link_t *tmp = timeout_list.next; - while (tmp != &timeout_list) { + link_t *tmp = timeout_list.head.next; + while (tmp != &timeout_list.head) { awaiter_t *cur = list_get_instance(tmp, awaiter_t, to_event.link); @@ -372,5 +372,5 @@ } - list_append(&wd->to_event.link, tmp); + list_insert_before(&wd->to_event.link, tmp); } @@ -569,5 +569,5 @@ } - msg_t *msg = list_get_instance(conn->msg_queue.next, msg_t, link); + msg_t *msg = list_get_instance(list_first(&conn->msg_queue), msg_t, link); list_remove(&msg->link); @@ -675,6 +675,6 @@ while (!list_empty(&fibril_connection->msg_queue)) { msg_t *msg = - list_get_instance(fibril_connection->msg_queue.next, msg_t, - link); + list_get_instance(list_first(&fibril_connection->msg_queue), + msg_t, link); list_remove(&msg->link); @@ -806,6 +806,6 @@ futex_down(&async_futex); - link_t *cur = timeout_list.next; - while (cur != &timeout_list) { + link_t *cur = list_first(&timeout_list); + while (cur != NULL) { awaiter_t *waiter = list_get_instance(cur, awaiter_t, to_event.link); @@ -813,6 +813,4 @@ if (tv_gt(&waiter->to_event.expires, &tv)) break; - - cur = cur->next; list_remove(&waiter->to_event.link); @@ -828,4 +826,6 @@ fibril_add_ready(waiter->fid); } + + cur = list_first(&timeout_list); } @@ -854,6 +854,6 @@ suseconds_t timeout; if (!list_empty(&timeout_list)) { - awaiter_t *waiter = list_get_instance(timeout_list.next, - awaiter_t, to_event.link); + awaiter_t *waiter = list_get_instance( + list_first(&timeout_list), awaiter_t, to_event.link); struct timeval tv; @@ -1731,5 +1731,7 @@ */ exch = (async_exch_t *) - list_get_instance(sess->exch_list.next, async_exch_t, sess_link); + list_get_instance(list_first(&sess->exch_list), + async_exch_t, sess_link); + list_remove(&exch->sess_link); list_remove(&exch->global_link); @@ -1743,6 +1745,6 @@ exch = (async_exch_t *) malloc(sizeof(async_exch_t)); if (exch != NULL) { - list_initialize(&exch->sess_link); - list_initialize(&exch->global_link); + link_initialize(&exch->sess_link); + link_initialize(&exch->global_link); exch->sess = sess; exch->phone = sess->phone; @@ -1761,6 +1763,6 @@ exch = (async_exch_t *) malloc(sizeof(async_exch_t)); if (exch != NULL) { - list_initialize(&exch->sess_link); - list_initialize(&exch->global_link); + link_initialize(&exch->sess_link); + link_initialize(&exch->global_link); exch->sess = sess; exch->phone = phone; @@ -1774,6 +1776,7 @@ */ exch = (async_exch_t *) - list_get_instance(inactive_exch_list.next, async_exch_t, - global_link); + list_get_instance(list_first(&inactive_exch_list), + async_exch_t, global_link); + list_remove(&exch->sess_link); list_remove(&exch->global_link); Index: uspace/lib/c/generic/devman.c =================================================================== --- uspace/lib/c/generic/devman.c (revision a8bc7f8ffbe7619c0a815a40e4d05bd262b5c6a6) +++ uspace/lib/c/generic/devman.c (revision 5203e2569a38ea677d1b3f202650bb36f9609583) @@ -35,4 +35,5 @@ */ +#include #include #include @@ -231,8 +232,7 @@ } - link_t *link = match_ids->ids.next; match_id_t *match_id = NULL; - while (link != &match_ids->ids) { + list_foreach(match_ids->ids, link) { match_id = list_get_instance(link, match_id_t, link); @@ -255,6 +255,4 @@ return retval; } - - link = link->next; } Index: uspace/lib/c/generic/fibril.c =================================================================== --- uspace/lib/c/generic/fibril.c (revision a8bc7f8ffbe7619c0a815a40e4d05bd262b5c6a6) +++ uspace/lib/c/generic/fibril.c (revision 5203e2569a38ea677d1b3f202650bb36f9609583) @@ -222,5 +222,6 @@ fibril_t *dstf; if ((stype == FIBRIL_TO_MANAGER) || (stype == FIBRIL_FROM_DEAD)) { - dstf = list_get_instance(manager_list.next, fibril_t, link); + dstf = list_get_instance(list_first(&manager_list), fibril_t, + link); if (serialization_count && stype == FIBRIL_TO_MANAGER) { serialized_threads++; @@ -233,10 +234,10 @@ } else { if (!list_empty(&serialized_list)) { - dstf = list_get_instance(serialized_list.next, fibril_t, - link); + dstf = list_get_instance(list_first(&serialized_list), + fibril_t, link); serialized_threads--; } else { - dstf = list_get_instance(ready_list.next, fibril_t, - link); + dstf = list_get_instance(list_first(&ready_list), + fibril_t, link); } } @@ -326,5 +327,5 @@ if (!list_empty(&manager_list)) - list_remove(manager_list.next); + list_remove(list_first(&manager_list)); futex_up(&fibril_futex); Index: uspace/lib/c/generic/fibril_synch.c =================================================================== --- uspace/lib/c/generic/fibril_synch.c (revision a8bc7f8ffbe7619c0a815a40e4d05bd262b5c6a6) +++ uspace/lib/c/generic/fibril_synch.c (revision 5203e2569a38ea677d1b3f202650bb36f9609583) @@ -148,6 +148,6 @@ fibril_t *f; - assert(!list_empty(&fm->waiters)); - tmp = fm->waiters.next; + tmp = list_first(&fm->waiters); + assert(tmp != NULL); wdp = list_get_instance(tmp, awaiter_t, wu_event.link); wdp->active = true; @@ -279,5 +279,5 @@ while (!list_empty(&frw->waiters)) { - link_t *tmp = frw->waiters.next; + link_t *tmp = list_first(&frw->waiters); awaiter_t *wdp; fibril_t *f; @@ -422,5 +422,5 @@ futex_down(&async_futex); while (!list_empty(&fcv->waiters)) { - tmp = fcv->waiters.next; + tmp = list_first(&fcv->waiters); wdp = list_get_instance(tmp, awaiter_t, wu_event.link); list_remove(&wdp->wu_event.link); Index: uspace/lib/c/generic/io/io.c =================================================================== --- uspace/lib/c/generic/io/io.c (revision a8bc7f8ffbe7619c0a815a40e4d05bd262b5c6a6) +++ uspace/lib/c/generic/io/io.c (revision 5203e2569a38ea677d1b3f202650bb36f9609583) @@ -127,10 +127,7 @@ void __stdio_done(void) { - link_t *link = files.next; - - while (link != &files) { - FILE *file = list_get_instance(link, FILE, link); + while (!list_empty(&files)) { + FILE *file = list_get_instance(list_first(&files), FILE, link); fclose(file); - link = files.next; } } Index: uspace/lib/c/generic/ipc.c =================================================================== --- uspace/lib/c/generic/ipc.c (revision a8bc7f8ffbe7619c0a815a40e4d05bd262b5c6a6) +++ uspace/lib/c/generic/ipc.c (revision 5203e2569a38ea677d1b3f202650bb36f9609583) @@ -458,5 +458,5 @@ while (!list_empty(&queued_calls)) { async_call_t *call = - list_get_instance(queued_calls.next, async_call_t, list); + list_get_instance(list_first(&queued_calls), async_call_t, list); ipc_callid_t callid = ipc_call_async_internal(call->u.msg.phoneid, &call->u.msg.data); @@ -511,5 +511,5 @@ link_t *item; - for (item = dispatched_calls.next; item != &dispatched_calls; + for (item = dispatched_calls.head.next; item != &dispatched_calls.head; item = item->next) { async_call_t *call =