Changeset 00b7fc8 in mainline

Timestamp:

2019-02-01T22:32:38Z (5 years ago)

Author:

Jiří Zárevúcky <zarevucky.jiri@…>

Parents:

f959a20f

git-author:

Jiří Zárevúcky <zarevucky.jiri@…> (2019-02-01 21:46:05)

git-committer:

Jiří Zárevúcky <zarevucky.jiri@…> (2019-02-01 22:32:38)

Message:

wip

Location:

uspace

Files:

• app/taskdump/fibrildump.c (modified) (1 diff)
• lib/c/generic/adt/list.c (modified) (2 diffs)
• lib/c/include/adt/list.h (modified) (20 diffs)

uspace/app/taskdump/fibrildump.c

@@ -107 +107 @@
                         return EIO;
 
-                addr = (uintptr_t) link.next;
+                addr = (uintptr_t) link.__adt_link_next;
                 if (addr == fibril_list_addr)
                         break;

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

@@ -55 +55 @@
 bool list_member(const link_t *link, const list_t *list)
 {
-        bool found = false;
-        link_t *hlp = list->head.next;
+        if (list_empty(list))
+                return false;
 
-        while (hlp != &list->head) {
-                if (hlp == link) {
-                        found = true;
-                        break;
-                }
-                hlp = hlp->next;
+        link_t *hlp = list->__adt_list_head.__adt_link_next;
+
+        while (hlp != &list->__adt_list_head) {
+                if (hlp == link)
+                        return true;
+                hlp = hlp->__adt_link_next;
         }
 
-        return found;
+        return false;
 }
 
@@ -83 +83 @@
 
         /* Attach list to destination. */
-        list->head.next->prev = pos;
-        list->head.prev->next = pos->next;
+        list->__adt_list_head.__adt_link_next->__adt_link_prev = pos;
+        list->__adt_list_head.__adt_link_prev->__adt_link_next = pos->__adt_link_next;
 
         /* Link destination list to the added list. */
-        pos->next->prev = list->head.prev;
-        pos->next = list->head.next;
+        pos->__adt_link_next->__adt_link_prev = list->__adt_list_head.__adt_link_prev;
+        pos->__adt_link_next = list->__adt_list_head.__adt_link_next;
 
         list_initialize(list);

uspace/lib/c/include/adt/list.h

@@ -44 +44 @@
 
 /** Doubly linked list link. */
-typedef struct link {
-        struct link *prev;  /**< Pointer to the previous item in the list. */
-        struct link *next;  /**< Pointer to the next item in the list. */
+typedef struct __adt_link {
+        struct __adt_link *__adt_link_prev;  /**< Pointer to the previous item in the list. */
+        struct __adt_link *__adt_link_next;  /**< Pointer to the next item in the list. */
 } link_t;
 
 /** Doubly linked list. */
-typedef struct list {
-        link_t head;  /**< List head. Does not have any data. */
+typedef struct {
+        link_t __adt_list_head;  /**< List head. Does not have any data. */
 } list_t;
 
@@ -83 +83 @@
 #define LIST_INITIALIZER(name) \
         { \
-                .head = { \
-                        .prev = &(name).head, \
-                        .next = &(name).head \
+                .__adt_list_head = { \
+                        .__adt_link_prev = &(name).__adt_list_head, \
+                        .__adt_link_next = &(name).__adt_list_head \
                 } \
         }
@@ -92 +92 @@
         ((type *) (((void *)(link)) - list_link_to_void(&(((type *) NULL)->member))))
 
+#define list_foreach_internal(list, member, itype, iterator, next, link) \
+        for (itype *iterator = NULL; iterator == NULL; iterator = (itype *) 1) \
+                for (link_t *link = (list).__adt_list_head.next; \
+                    iterator = list_get_instance(link, itype, member), \
+                    link != &(list).__adt_list_head; link = link->next)
+
+#define __ADT_LIST_CONCAT(a, b) __ADT_LIST_CONCAT1(a, b)
+#define __ADT_LIST_CONCAT1(a, b) a##b
+
 #define list_foreach(list, member, itype, iterator) \
-        for (itype *iterator = NULL; iterator == NULL; iterator = (itype *) 1) \
-                for (link_t *_link = (list).head.next; \
-                    iterator = list_get_instance(_link, itype, member), \
-                    _link != &(list).head; _link = _link->next)
+        list_foreach_internal(list, member, itype, iterator, __adt_link_next, __ADT_LIST_CONCAT(__tmp_link_, __COUNTER__))
 
 #define list_foreach_rev(list, member, itype, iterator) \
-        for (itype *iterator = NULL; iterator == NULL; iterator = (itype *) 1) \
-                for (link_t *_link = (list).head.prev; \
-                    iterator = list_get_instance(_link, itype, member), \
-                    _link != &(list).head; _link = _link->prev)
+        list_foreach_internal(list, member, itype, iterator, __adt_link_prev, __ADT_LIST_CONCAT(__tmp_link_, __COUNTER__))
 
 /** Unlike list_foreach(), allows removing items while traversing a list.
@@ -130 +133 @@
  */
 #define list_foreach_safe(list, iterator, next_iter) \
-        for (link_t *iterator = (list).head.next, \
-            *next_iter = iterator->next; \
-            iterator != &(list).head; \
-            iterator = next_iter, next_iter = iterator->next)
+        for (link_t *iterator = (list).__adt_list_head.__adt_link_next, \
+            *next_iter = iterator->__adt_link_next; \
+            iterator != &(list).__adt_list_head; \
+            iterator = next_iter, next_iter = iterator->__adt_link_next)
 
 #define assert_link_not_used(link) \
@@ -141 +144 @@
 static inline bool link_in_use(const link_t *link)
 {
-        return link->prev != NULL && link->next != NULL;
+        return link->__adt_link_prev != NULL && link->__adt_link_next != NULL;
 }
 
@@ -153 +156 @@
 NO_TRACE static inline void link_initialize(link_t *link)
 {
-        link->prev = NULL;
-        link->next = NULL;
+        assert(link);
+        link->__adt_link_prev = NULL;
+        link->__adt_link_next = NULL;
 }
 
@@ -166 +170 @@
 NO_TRACE static inline void list_initialize(list_t *list)
 {
-        list->head.prev = &list->head;
-        list->head.next = &list->head;
+        assert(list);
+        list->__adt_list_head.__adt_link_prev = &list->__adt_list_head;
+        list->__adt_list_head.__adt_link_next = &list->__adt_list_head;
 }
 
@@ -175 +180 @@
 static inline void list_insert_before(link_t *lnew, link_t *lold)
 {
-        lnew->next = lold;
-        lnew->prev = lold->prev;
-        lold->prev->next = lnew;
-        lold->prev = lnew;
+        assert(lnew);
+        assert(lold);
+        lnew->__adt_link_next = lold;
+        lnew->__adt_link_prev = lold->__adt_link_prev;
+        lold->__adt_link_prev->__adt_link_next = lnew;
+        lold->__adt_link_prev = lnew;
 }
 
@@ -186 +193 @@
 static inline void list_insert_after(link_t *lnew, link_t *lold)
 {
-        lnew->prev = lold;
-        lnew->next = lold->next;
-        lold->next->prev = lnew;
-        lold->next = lnew;
+        assert(lnew);
+        assert(lold);
+        lnew->__adt_link_prev = lold;
+        lnew->__adt_link_next = lold->__adt_link_next;
+        lold->__adt_link_next->__adt_link_prev = lnew;
+        lold->__adt_link_next = lnew;
 }
 
@@ -202 +211 @@
 NO_TRACE static inline void list_prepend(link_t *link, list_t *list)
 {
-        list_insert_after(link, &list->head);
+        list_insert_after(link, &list->__adt_list_head);
 }
 
@@ -215 +224 @@
 NO_TRACE static inline void list_append(link_t *link, list_t *list)
 {
-        list_insert_before(link, &list->head);
+        list_insert_before(link, &list->__adt_list_head);
 }
 
@@ -228 +237 @@
 NO_TRACE static inline void list_remove(link_t *link)
 {
-        if ((link->prev != NULL) && (link->next != NULL)) {
-                link->next->prev = link->prev;
-                link->prev->next = link->next;
+        if ((link->__adt_link_prev != NULL) && (link->__adt_link_next != NULL)) {
+                link->__adt_link_next->__adt_link_prev = link->__adt_link_prev;
+                link->__adt_link_prev->__adt_link_next = link->__adt_link_next;
         }
 
@@ -245 +254 @@
 NO_TRACE static inline bool list_empty(const list_t *list)
 {
-        return (list->head.next == &list->head);
+        return (list->__adt_list_head.__adt_link_next == &list->__adt_list_head);
 }
 
@@ -258 +267 @@
 static inline link_t *list_first(const list_t *list)
 {
-        return ((list->head.next == &list->head) ? NULL : list->head.next);
+        return ((list->__adt_list_head.__adt_link_next == &list->__adt_list_head) ? NULL : list->__adt_list_head.__adt_link_next);
 }
 
@@ -271 +280 @@
 static inline link_t *list_last(const list_t *list)
 {
-        return (list->head.prev == &list->head) ? NULL : list->head.prev;
+        return (list->__adt_list_head.__adt_link_prev == &list->__adt_list_head) ? NULL : list->__adt_list_head.__adt_link_prev;
 }
 
@@ -283 +292 @@
 static inline link_t *list_next(const link_t *link, const list_t *list)
 {
-        return (link->next == &list->head) ? NULL : link->next;
+        return (link->__adt_link_next == &list->__adt_list_head) ? NULL : link->__adt_link_next;
 }
 
@@ -295 +304 @@
 static inline link_t *list_prev(const link_t *link, const list_t *list)
 {
-        return (link->prev == &list->head) ? NULL : link->prev;
+        return (link->__adt_link_prev == &list->__adt_list_head) ? NULL : link->__adt_link_prev;
 }
 
@@ -313 +322 @@
 NO_TRACE static inline void headless_list_split_or_concat(link_t *part1, link_t *part2)
 {
-        part1->prev->next = part2;
-        part2->prev->next = part1;
-
-        link_t *hlp = part1->prev;
-
-        part1->prev = part2->prev;
-        part2->prev = hlp;
+        part1->__adt_link_prev->__adt_link_next = part2;
+        part2->__adt_link_prev->__adt_link_next = part1;
+
+        link_t *hlp = part1->__adt_link_prev;
+
+        part1->__adt_link_prev = part2->__adt_link_prev;
+        part2->__adt_link_prev = hlp;
 }
 
@@ -364 +373 @@
 NO_TRACE static inline void list_concat(list_t *list1, list_t *list2)
 {
-        list_splice(list2, list1->head.prev);
+        list_splice(list2, list1->__adt_list_head.__adt_link_prev);
 }
 
@@ -408 +417 @@
 static inline bool link_used(link_t *link)
 {
-        if (link->prev == NULL && link->next == NULL)
+        if (link->__adt_link_prev == NULL && link->__adt_link_next == NULL)
                 return false;
 
-        assert(link->prev != NULL && link->next != NULL);
+        assert(link->__adt_link_prev != NULL && link->__adt_link_next != NULL);
         return true;
 }