Changeset 55b77d9 in mainline for kernel/generic/src/adt

Timestamp:

2011-06-17T20:39:16Z (14 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

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

Children:

8f164724

Parents:

98caf49

Message:

Separate list_t typedef from link_t (kernel part).

• list_t represents lists
• Use list_first(), list_last(), list_empty() where appropriate
• Use list_foreach() where possible
• Replace improper uses of list_prepend() with list_insert_after()
• Replace improper uses of list_append() with list_insert_before()

Location:

kernel/generic/src/adt

Files:

• btree.c (modified) (8 diffs)
• hash_table.c (modified) (6 diffs)
• list.c (modified) (2 diffs)

kernel/generic/src/adt/btree.c

@@ -108 +108 @@
 void btree_create(btree_t *t)
 {
-        list_initialize(&t->leaf_head);
+        list_initialize(&t->leaf_list);
         t->root = (btree_node_t *) slab_alloc(btree_node_slab, 0);
         node_initialize(t->root);
-        list_append(&t->root->leaf_link, &t->leaf_head);
+        list_append(&t->root->leaf_link, &t->leaf_list);
 }
 
@@ -588 +588 @@
                 
                 if (LEAF_NODE(node)) {
-                        list_prepend(&rnode->leaf_link, &node->leaf_link);
+                        list_insert_after(&rnode->leaf_link, &node->leaf_link);
                 }
                 
@@ -953 +953 @@
         ASSERT(LEAF_NODE(node));
         
-        if (node->leaf_link.prev != &t->leaf_head)
+        if (node->leaf_link.prev != &t->leaf_list.head)
                 return list_get_instance(node->leaf_link.prev, btree_node_t, leaf_link);
         else
@@ -972 +972 @@
         ASSERT(LEAF_NODE(node));
         
-        if (node->leaf_link.next != &t->leaf_head)
+        if (node->leaf_link.next != &t->leaf_list.head)
                 return list_get_instance(node->leaf_link.next, btree_node_t, leaf_link);
         else
@@ -987 +987 @@
         size_t i;
         int depth = t->root->depth;
-        link_t head, *cur;
+        list_t list;
         
         printf("Printing B-tree:\n");
-        list_initialize(&head);
-        list_append(&t->root->bfs_link, &head);
+        list_initialize(&list);
+        list_append(&t->root->bfs_link, &list);
         
         /*
@@ -997 +997 @@
          * Levels are distinguished from one another by node->depth.
          */
-        while (!list_empty(&head)) {
+        while (!list_empty(&list)) {
                 link_t *hlp;
                 btree_node_t *node;
                 
-                hlp = head.next;
-                ASSERT(hlp != &head);
+                hlp = list_first(&list);
+                ASSERT(hlp != NULL);
                 node = list_get_instance(hlp, btree_node_t, bfs_link);
                 list_remove(hlp);
@@ -1018 +1018 @@
                         printf("%" PRIu64 "%s", node->key[i], i < node->keys - 1 ? "," : "");
                         if (node->depth && node->subtree[i]) {
-                                list_append(&node->subtree[i]->bfs_link, &head);
+                                list_append(&node->subtree[i]->bfs_link, &list);
                         }
                 }
                 
                 if (node->depth && node->subtree[i])
-                        list_append(&node->subtree[i]->bfs_link, &head);
+                        list_append(&node->subtree[i]->bfs_link, &list);
                 
                 printf(")");
@@ -1031 +1031 @@
         
         printf("Printing list of leaves:\n");
-        for (cur = t->leaf_head.next; cur != &t->leaf_head; cur = cur->next) {
+        list_foreach(t->leaf_list, cur) {
                 btree_node_t *node;
                 

kernel/generic/src/adt/hash_table.c

@@ -62 +62 @@
         ASSERT(max_keys > 0);
         
-        h->entry = (link_t *) malloc(m * sizeof(link_t), 0);
+        h->entry = (list_t *) malloc(m * sizeof(list_t), 0);
         if (!h->entry)
                 panic("Cannot allocate memory for hash table.");
         
-        memsetb(h->entry, m * sizeof(link_t), 0);
+        memsetb(h->entry, m * sizeof(list_t), 0);
         
         for (i = 0; i < m; i++)
@@ -107 +107 @@
 link_t *hash_table_find(hash_table_t *h, sysarg_t key[])
 {
-        link_t *cur;
         size_t chain;
         
@@ -118 +117 @@
         ASSERT(chain < h->entries);
         
-        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)) {
                         /*
@@ -141 +140 @@
 {
         size_t chain;
-        link_t *cur;
         
         ASSERT(h);
@@ -150 +148 @@
         
         if (keys == h->max_keys) {
+                link_t *cur;
         
                 /*
@@ -169 +168 @@
          */
         for (chain = 0; chain < h->entries; chain++) {
-                for (cur = h->entry[chain].next; cur != &h->entry[chain]; cur = cur->next) {
+                list_foreach(h->entry[chain], cur) {
                         if (h->op->compare(key, keys, cur)) {
                                 link_t *hlp;

kernel/generic/src/adt/list.c

@@ -43 +43 @@
 /** 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)
 {
         bool found = false;
-        link_t *hlp = head->next;
+        link_t *hlp = list->head.next;
         
-        while (hlp != head) {
+        while (hlp != &list->head) {
                 if (hlp == link) {
                         found = true;
@@ -68 +68 @@
 }
 
-
 /** 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);
 }