Changeset b72efe8 in mainline for uspace/lib/c/generic/adt

Timestamp:

2011-06-19T14:38:59Z (14 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

74464e8

Parents:

1d1bb0f

Message:

Separate list_t typedef from link_t (user-space part).

• list_t represents lists
• Use list_first(), list_last(), list_empty() where appropriate
• Use list_foreach() where possible
• assert_link_not_used()
• usb_hid_report_path_free() shall not unlink the path, caller must do it

Location:

uspace/lib/c/generic/adt

Files:

• hash_table.c (modified) (5 diffs)
• list.c (modified) (3 diffs)
• prodcons.c (modified) (1 diff)

uspace/lib/c/generic/adt/hash_table.c

@@ -61 +61 @@
         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 +123 @@
         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 +151 @@
         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 +174 @@
         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 +203 @@
 {
         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);
                 }

uspace/lib/c/generic/adt/list.c

@@ -30 +30 @@
  * @{
  */
-/** @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 <adt/list.h>
-
+#include <bool.h>
 
 /** 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 +69 @@
 }
 
-
 /** 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 +95 @@
  * 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;
         }
         

uspace/lib/c/generic/adt/prodcons.c

@@ -61 +61 @@
                 fibril_condvar_wait(&pc->cv, &pc->mtx);
         
-        link_t *head = pc->list.next;
+        link_t *head = list_first(&pc->list);
         list_remove(head);