Changeset b72efe8 in mainline for uspace/lib
- Timestamp:
- 2011-06-19T14:38:59Z (14 years ago)
- Branches:
- lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
- Children:
- 74464e8
- Parents:
- 1d1bb0f
- Location:
- uspace/lib
- Files:
-
- 24 edited
Legend:
- Unmodified
- Added
- Removed
-
uspace/lib/block/libblock.c
r1d1bb0f rb72efe8 60 60 static FIBRIL_MUTEX_INITIALIZE(dcl_lock); 61 61 /** Device connection list head. */ 62 static LIST_INITIALIZE(dcl _head);62 static LIST_INITIALIZE(dcl); 63 63 64 64 #define CACHE_BUCKETS_LOG2 10 … … 72 72 unsigned blocks_cached; /**< Number of cached blocks. */ 73 73 hash_table_t block_hash; 74 li nk_t free_head;74 list_t free_list; 75 75 enum cache_mode mode; 76 76 } cache_t; … … 97 97 static devcon_t *devcon_search(devmap_handle_t devmap_handle) 98 98 { 99 link_t *cur;100 101 99 fibril_mutex_lock(&dcl_lock); 102 100 103 for (cur = dcl_head.next; cur != &dcl_head; cur = cur->next) {101 list_foreach(dcl, cur) { 104 102 devcon_t *devcon = list_get_instance(cur, devcon_t, link); 105 103 if (devcon->devmap_handle == devmap_handle) { … … 116 114 size_t bsize, void *comm_area, size_t comm_size) 117 115 { 118 link_t *cur;119 116 devcon_t *devcon; 120 117 … … 138 135 139 136 fibril_mutex_lock(&dcl_lock); 140 for (cur = dcl_head.next; cur != &dcl_head; cur = cur->next) {137 list_foreach(dcl, cur) { 141 138 devcon_t *d = list_get_instance(cur, devcon_t, link); 142 139 if (d->devmap_handle == devmap_handle) { … … 146 143 } 147 144 } 148 list_append(&devcon->link, &dcl _head);145 list_append(&devcon->link, &dcl); 149 146 fibril_mutex_unlock(&dcl_lock); 150 147 return EOK; … … 294 291 295 292 fibril_mutex_initialize(&cache->lock); 296 list_initialize(&cache->free_ head);293 list_initialize(&cache->free_list); 297 294 cache->lblock_size = size; 298 295 cache->block_count = blocks; … … 335 332 * bother with the cache and block locks because we are single-threaded. 336 333 */ 337 while (!list_empty(&cache->free_ head)) {338 block_t *b = list_get_instance( cache->free_head.next,334 while (!list_empty(&cache->free_list)) { 335 block_t *b = list_get_instance(list_first(&cache->free_list), 339 336 block_t, free_link); 340 337 … … 367 364 if (cache->blocks_cached < CACHE_LO_WATERMARK) 368 365 return true; 369 if (!list_empty(&cache->free_ head))366 if (!list_empty(&cache->free_list)) 370 367 return false; 371 368 return true; … … 456 453 unsigned long temp_key; 457 454 recycle: 458 if (list_empty(&cache->free_ head)) {455 if (list_empty(&cache->free_list)) { 459 456 fibril_mutex_unlock(&cache->lock); 460 457 rc = ENOMEM; 461 458 goto out; 462 459 } 463 l = cache->free_head.next;460 l = list_first(&cache->free_list); 464 461 b = list_get_instance(l, block_t, free_link); 465 462 … … 476 473 */ 477 474 list_remove(&b->free_link); 478 list_append(&b->free_link, &cache->free_ head);475 list_append(&b->free_link, &cache->free_list); 479 476 fibril_mutex_unlock(&cache->lock); 480 477 fibril_mutex_lock(&devcon->comm_area_lock); … … 668 665 goto retry; 669 666 } 670 list_append(&block->free_link, &cache->free_ head);667 list_append(&block->free_link, &cache->free_list); 671 668 } 672 669 fibril_mutex_unlock(&block->lock); -
uspace/lib/c/generic/adt/hash_table.c
r1d1bb0f rb72efe8 61 61 assert(max_keys > 0); 62 62 63 h->entry = malloc(m * sizeof(li nk_t));63 h->entry = malloc(m * sizeof(list_t)); 64 64 if (!h->entry) 65 65 return false; 66 66 67 memset((void *) h->entry, 0, m * sizeof(li nk_t));67 memset((void *) h->entry, 0, m * sizeof(list_t)); 68 68 69 69 hash_count_t i; … … 123 123 assert(chain < h->entries); 124 124 125 link_t *cur; 126 for (cur = h->entry[chain].next; cur != &h->entry[chain]; 127 cur = cur->next) { 125 list_foreach(h->entry[chain], cur) { 128 126 if (h->op->compare(key, h->max_keys, cur)) { 129 127 /* … … 153 151 assert(keys <= h->max_keys); 154 152 155 link_t *cur;156 157 153 if (keys == h->max_keys) { 154 link_t *cur; 155 158 156 /* 159 157 * All keys are known, hash_table_find() can be used to find the … … 176 174 hash_index_t chain; 177 175 for (chain = 0; chain < h->entries; chain++) { 178 for (cur = h->entry[chain].next; cur != &h->entry[chain]; 176 link_t *cur; 177 178 for (cur = h->entry[chain].head.next; cur != &h->entry[chain].head; 179 179 cur = cur->next) { 180 180 if (h->op->compare(key, keys, cur)) { … … 203 203 { 204 204 hash_index_t bucket; 205 link_t *cur;206 205 207 206 for (bucket = 0; bucket < h->entries; bucket++) { 208 for (cur = h->entry[bucket].next; cur != &h->entry[bucket]; 209 cur = cur->next) { 207 list_foreach(h->entry[bucket], cur) { 210 208 f(cur, arg); 211 209 } -
uspace/lib/c/generic/adt/list.c
r1d1bb0f rb72efe8 30 30 * @{ 31 31 */ 32 /** @file 32 33 /** 34 * @file 35 * @brief Functions completing doubly linked circular list implementaion. 36 * 37 * This file contains some of the functions implementing doubly linked circular lists. 38 * However, this ADT is mostly implemented in @ref list.h. 33 39 */ 34 40 35 41 #include <adt/list.h> 36 42 #include <bool.h> 37 43 38 44 /** Check for membership 39 45 * 40 * Check whether link is contained in the list head.41 * The membership is defined as pointer equivalence.46 * Check whether link is contained in a list. 47 * Membership is defined as pointer equivalence. 42 48 * 43 * @param link 44 * @param headList to look in.49 * @param link Item to look for. 50 * @param list List to look in. 45 51 * 46 52 * @return true if link is contained in head, false otherwise. 47 53 * 48 54 */ 49 int list_member(const link_t *link, const li nk_t *head)55 int list_member(const link_t *link, const list_t *list) 50 56 { 51 int found = 0;52 link_t *hlp = head->next;57 bool found = false; 58 link_t *hlp = list->head.next; 53 59 54 while (hlp != head) {60 while (hlp != &list->head) { 55 61 if (hlp == link) { 56 found = 1;62 found = true; 57 63 break; 58 64 } … … 63 69 } 64 70 65 66 71 /** Concatenate two lists 67 72 * 68 * Concatenate lists head1 and head2, producing a single69 * list head1 containing items from both (in head1, head270 * order) and empty list head2.73 * Concatenate lists @a list1 and @a list2, producing a single 74 * list @a list1 containing items from both (in @a list1, @a list2 75 * order) and empty list @a list2. 71 76 * 72 * @param head1First list and concatenated output73 * @param head2Second list and empty output.77 * @param list1 First list and concatenated output 78 * @param list2 Second list and empty output. 74 79 * 75 80 */ 76 void list_concat(li nk_t *head1, link_t *head2)81 void list_concat(list_t *list1, list_t *list2) 77 82 { 78 if (list_empty( head2))83 if (list_empty(list2)) 79 84 return; 80 81 head2->next->prev = head1->prev;82 head2->prev->next = head1;83 head1->prev->next = head2->next;84 head1->prev = head2->prev;85 list_initialize( head2);85 86 list2->head.next->prev = list1->head.prev; 87 list2->head.prev->next = &list1->head; 88 list1->head.prev->next = list2->head.next; 89 list1->head.prev = list2->head.prev; 90 list_initialize(list2); 86 91 } 87 88 92 89 93 /** Count list items … … 91 95 * Return the number of items in the list. 92 96 * 93 * @param link List to count. 94 * 95 * @return Number of items in the list. 96 * 97 * @param list List to count. 98 * @return Number of items in the list. 97 99 */ 98 unsigned int list_count(const li nk_t *link)100 unsigned int list_count(const list_t *list) 99 101 { 100 102 unsigned int count = 0; 101 link_t *hlp = link->next;102 103 103 while (hlp !=link) {104 list_foreach(*list, link) { 104 105 count++; 105 hlp = hlp->next;106 106 } 107 107 -
uspace/lib/c/generic/adt/prodcons.c
r1d1bb0f rb72efe8 61 61 fibril_condvar_wait(&pc->cv, &pc->mtx); 62 62 63 link_t *head = pc->list.next;63 link_t *head = list_first(&pc->list); 64 64 list_remove(head); 65 65 -
uspace/lib/c/generic/async.c
r1d1bb0f rb72efe8 160 160 161 161 /** Messages that should be delivered to this fibril. */ 162 li nk_t msg_queue;162 list_t msg_queue; 163 163 164 164 /** Identification of the opening call. */ … … 361 361 wd->to_event.inlist = true; 362 362 363 link_t *tmp = timeout_list. next;364 while (tmp != &timeout_list ) {363 link_t *tmp = timeout_list.head.next; 364 while (tmp != &timeout_list.head) { 365 365 awaiter_t *cur 366 366 = list_get_instance(tmp, awaiter_t, to_event.link); … … 372 372 } 373 373 374 list_ append(&wd->to_event.link, tmp);374 list_insert_before(&wd->to_event.link, tmp); 375 375 } 376 376 … … 569 569 } 570 570 571 msg_t *msg = list_get_instance( conn->msg_queue.next, msg_t, link);571 msg_t *msg = list_get_instance(list_first(&conn->msg_queue), msg_t, link); 572 572 list_remove(&msg->link); 573 573 … … 675 675 while (!list_empty(&fibril_connection->msg_queue)) { 676 676 msg_t *msg = 677 list_get_instance( fibril_connection->msg_queue.next, msg_t,678 link);677 list_get_instance(list_first(&fibril_connection->msg_queue), 678 msg_t, link); 679 679 680 680 list_remove(&msg->link); … … 806 806 futex_down(&async_futex); 807 807 808 link_t *cur = timeout_list.next;809 while (cur != &timeout_list) {808 link_t *cur = list_first(&timeout_list); 809 while (cur != NULL) { 810 810 awaiter_t *waiter = 811 811 list_get_instance(cur, awaiter_t, to_event.link); … … 813 813 if (tv_gt(&waiter->to_event.expires, &tv)) 814 814 break; 815 816 cur = cur->next;817 815 818 816 list_remove(&waiter->to_event.link); … … 828 826 fibril_add_ready(waiter->fid); 829 827 } 828 829 cur = list_first(&timeout_list); 830 830 } 831 831 … … 854 854 suseconds_t timeout; 855 855 if (!list_empty(&timeout_list)) { 856 awaiter_t *waiter = list_get_instance( timeout_list.next,857 awaiter_t, to_event.link);856 awaiter_t *waiter = list_get_instance( 857 list_first(&timeout_list), awaiter_t, to_event.link); 858 858 859 859 struct timeval tv; … … 1731 1731 */ 1732 1732 exch = (async_exch_t *) 1733 list_get_instance(sess->exch_list.next, async_exch_t, sess_link); 1733 list_get_instance(list_first(&sess->exch_list), 1734 async_exch_t, sess_link); 1735 1734 1736 list_remove(&exch->sess_link); 1735 1737 list_remove(&exch->global_link); … … 1743 1745 exch = (async_exch_t *) malloc(sizeof(async_exch_t)); 1744 1746 if (exch != NULL) { 1745 li st_initialize(&exch->sess_link);1746 li st_initialize(&exch->global_link);1747 link_initialize(&exch->sess_link); 1748 link_initialize(&exch->global_link); 1747 1749 exch->sess = sess; 1748 1750 exch->phone = sess->phone; … … 1761 1763 exch = (async_exch_t *) malloc(sizeof(async_exch_t)); 1762 1764 if (exch != NULL) { 1763 li st_initialize(&exch->sess_link);1764 li st_initialize(&exch->global_link);1765 link_initialize(&exch->sess_link); 1766 link_initialize(&exch->global_link); 1765 1767 exch->sess = sess; 1766 1768 exch->phone = phone; … … 1774 1776 */ 1775 1777 exch = (async_exch_t *) 1776 list_get_instance(inactive_exch_list.next, async_exch_t, 1777 global_link); 1778 list_get_instance(list_first(&inactive_exch_list), 1779 async_exch_t, global_link); 1780 1778 1781 list_remove(&exch->sess_link); 1779 1782 list_remove(&exch->global_link); -
uspace/lib/c/generic/devman.c
r1d1bb0f rb72efe8 35 35 */ 36 36 37 #include <adt/list.h> 37 38 #include <str.h> 38 39 #include <ipc/services.h> … … 231 232 } 232 233 233 link_t *link = match_ids->ids.next;234 234 match_id_t *match_id = NULL; 235 235 236 while (link != &match_ids->ids) {236 list_foreach(match_ids->ids, link) { 237 237 match_id = list_get_instance(link, match_id_t, link); 238 238 … … 255 255 return retval; 256 256 } 257 258 link = link->next;259 257 } 260 258 -
uspace/lib/c/generic/fibril.c
r1d1bb0f rb72efe8 222 222 fibril_t *dstf; 223 223 if ((stype == FIBRIL_TO_MANAGER) || (stype == FIBRIL_FROM_DEAD)) { 224 dstf = list_get_instance(manager_list.next, fibril_t, link); 224 dstf = list_get_instance(list_first(&manager_list), fibril_t, 225 link); 225 226 if (serialization_count && stype == FIBRIL_TO_MANAGER) { 226 227 serialized_threads++; … … 233 234 } else { 234 235 if (!list_empty(&serialized_list)) { 235 dstf = list_get_instance( serialized_list.next, fibril_t,236 link);236 dstf = list_get_instance(list_first(&serialized_list), 237 fibril_t, link); 237 238 serialized_threads--; 238 239 } else { 239 dstf = list_get_instance( ready_list.next, fibril_t,240 link);240 dstf = list_get_instance(list_first(&ready_list), 241 fibril_t, link); 241 242 } 242 243 } … … 326 327 327 328 if (!list_empty(&manager_list)) 328 list_remove( manager_list.next);329 list_remove(list_first(&manager_list)); 329 330 330 331 futex_up(&fibril_futex); -
uspace/lib/c/generic/fibril_synch.c
r1d1bb0f rb72efe8 148 148 fibril_t *f; 149 149 150 assert(!list_empty(&fm->waiters));151 tmp = fm->waiters.next;150 tmp = list_first(&fm->waiters); 151 assert(tmp != NULL); 152 152 wdp = list_get_instance(tmp, awaiter_t, wu_event.link); 153 153 wdp->active = true; … … 279 279 280 280 while (!list_empty(&frw->waiters)) { 281 link_t *tmp = frw->waiters.next;281 link_t *tmp = list_first(&frw->waiters); 282 282 awaiter_t *wdp; 283 283 fibril_t *f; … … 422 422 futex_down(&async_futex); 423 423 while (!list_empty(&fcv->waiters)) { 424 tmp = fcv->waiters.next;424 tmp = list_first(&fcv->waiters); 425 425 wdp = list_get_instance(tmp, awaiter_t, wu_event.link); 426 426 list_remove(&wdp->wu_event.link); -
uspace/lib/c/generic/io/io.c
r1d1bb0f rb72efe8 127 127 void __stdio_done(void) 128 128 { 129 link_t *link = files.next; 130 131 while (link != &files) { 132 FILE *file = list_get_instance(link, FILE, link); 129 while (!list_empty(&files)) { 130 FILE *file = list_get_instance(list_first(&files), FILE, link); 133 131 fclose(file); 134 link = files.next;135 132 } 136 133 } -
uspace/lib/c/generic/ipc.c
r1d1bb0f rb72efe8 458 458 while (!list_empty(&queued_calls)) { 459 459 async_call_t *call = 460 list_get_instance( queued_calls.next, async_call_t, list);460 list_get_instance(list_first(&queued_calls), async_call_t, list); 461 461 ipc_callid_t callid = 462 462 ipc_call_async_internal(call->u.msg.phoneid, &call->u.msg.data); … … 511 511 512 512 link_t *item; 513 for (item = dispatched_calls. next; item != &dispatched_calls;513 for (item = dispatched_calls.head.next; item != &dispatched_calls.head; 514 514 item = item->next) { 515 515 async_call_t *call = -
uspace/lib/c/include/adt/hash_table.h
r1d1bb0f rb72efe8 75 75 /** Hash table structure. */ 76 76 typedef struct { 77 li nk_t *entry;77 list_t *entry; 78 78 hash_count_t entries; 79 79 hash_count_t max_keys; -
uspace/lib/c/include/adt/list.h
r1d1bb0f rb72efe8 1 1 /* 2 2 * Copyright (c) 2001-2004 Jakub Jermar 3 * Copyright (c) 2011 Jiri Svoboda 3 4 * All rights reserved. 4 5 * … … 36 37 #define LIBC_LIST_H_ 37 38 39 #include <assert.h> 38 40 #include <unistd.h> 39 41 40 /** Doubly linked list head and link type. */42 /** Doubly linked list link. */ 41 43 typedef struct link { 42 44 struct link *prev; /**< Pointer to the previous item in the list. */ … … 44 46 } link_t; 45 47 48 /** Doubly linked list. */ 49 typedef struct list { 50 link_t head; /**< List head. Does not have any data. */ 51 } list_t; 52 46 53 /** Declare and initialize statically allocated list. 47 54 * … … 50 57 */ 51 58 #define LIST_INITIALIZE(name) \ 52 link_t name = { \ 53 .prev = &name, \ 54 .next = &name \ 59 list_t name = { \ 60 .head = { \ 61 .prev = &(name).head, \ 62 .next = &(name).head \ 63 } \ 55 64 } 56 65 … … 59 68 60 69 #define list_foreach(list, iterator) \ 61 for (link_t *iterator = (list).next; \ 62 iterator != &(list); iterator = iterator->next) 70 for (link_t *iterator = (list).head.next; \ 71 iterator != &(list).head; iterator = iterator->next) 72 73 #define assert_link_not_used(link) \ 74 assert((link)->prev == NULL && (link)->next == NULL) 63 75 64 76 /** Initialize doubly-linked circular list link … … 79 91 * Initialize doubly-linked circular list. 80 92 * 81 * @param list Pointer to link_t structure representing the list. 82 * 83 */ 84 static inline void list_initialize(link_t *list) 85 { 86 list->prev = list; 87 list->next = list; 93 * @param list Pointer to list_t structure. 94 * 95 */ 96 static inline void list_initialize(list_t *list) 97 { 98 list->head.prev = &list->head; 99 list->head.next = &list->head; 100 } 101 102 /** Insert item before another item in doubly-linked circular list. 103 * 104 */ 105 static inline void list_insert_before(link_t *lnew, link_t *lold) 106 { 107 lnew->next = lold; 108 lnew->prev = lold->prev; 109 lold->prev->next = lnew; 110 lold->prev = lnew; 111 } 112 113 /** Insert item after another item in doubly-linked circular list. 114 * 115 */ 116 static inline void list_insert_after(link_t *lnew, link_t *lold) 117 { 118 lnew->prev = lold; 119 lnew->next = lold->next; 120 lold->next->prev = lnew; 121 lold->next = lnew; 88 122 } 89 123 … … 93 127 * 94 128 * @param link Pointer to link_t structure to be added. 95 * @param list Pointer to link_t structure representing the list. 96 * 97 */ 98 static inline void list_prepend(link_t *link, link_t *list) 99 { 100 link->next = list->next; 101 link->prev = list; 102 list->next->prev = link; 103 list->next = link; 129 * @param list Pointer to list_t structure. 130 * 131 */ 132 static inline void list_prepend(link_t *link, list_t *list) 133 { 134 list_insert_after(link, &list->head); 104 135 } 105 136 … … 109 140 * 110 141 * @param link Pointer to link_t structure to be added. 111 * @param list Pointer to link_t structure representing the list. 112 * 113 */ 114 static inline void list_append(link_t *link, link_t *list) 115 { 116 link->prev = list->prev; 117 link->next = list; 118 list->prev->next = link; 119 list->prev = link; 120 } 121 122 /** Insert item before another item in doubly-linked circular list. 123 * 124 */ 125 static inline void list_insert_before(link_t *link, link_t *list) 126 { 127 list_append(link, list); 128 } 129 130 /** Insert item after another item in doubly-linked circular list. 131 * 132 */ 133 static inline void list_insert_after(link_t *link, link_t *list) 134 { 135 list_prepend(list, link); 142 * @param list Pointer to list_t structure. 143 * 144 */ 145 static inline void list_append(link_t *link, list_t *list) 146 { 147 list_insert_before(link, &list->head); 136 148 } 137 149 … … 155 167 * Query emptiness of doubly-linked circular list. 156 168 * 157 * @param list Pointer to lin k_t structure representing the list.158 * 159 */ 160 static inline int list_empty(li nk_t *list)161 { 162 return (list-> next == list);163 } 164 165 /** Get head item of alist.166 * 167 * @param list Pointer to li nk_t structure representing the list.169 * @param list Pointer to lins_t structure. 170 * 171 */ 172 static inline int list_empty(list_t *list) 173 { 174 return (list->head.next == &list->head); 175 } 176 177 /** Get first item in list. 178 * 179 * @param list Pointer to list_t structure. 168 180 * 169 181 * @return Head item of the list. … … 171 183 * 172 184 */ 173 static inline link_t *list_head(link_t *list) 174 { 175 return ((list->next == list) ? NULL : list->next); 185 static inline link_t *list_first(list_t *list) 186 { 187 return ((list->head.next == &list->head) ? NULL : list->head.next); 188 } 189 190 /** Get last item in list. 191 * 192 * @param list Pointer to list_t structure. 193 * 194 * @return Head item of the list. 195 * @return NULL if the list is empty. 196 * 197 */ 198 static inline link_t *list_last(list_t *list) 199 { 200 return ((list->head.prev == &list->head) ? NULL : list->head.prev); 176 201 } 177 202 … … 230 255 } 231 256 232 /** Get n-th item ofa list.257 /** Get n-th item in a list. 233 258 * 234 259 * @param list Pointer to link_t structure representing the list. … … 239 264 * 240 265 */ 241 static inline link_t *list_nth(li nk_t *list, unsigned int n)266 static inline link_t *list_nth(list_t *list, unsigned int n) 242 267 { 243 268 unsigned int cnt = 0; … … 253 278 } 254 279 255 extern int list_member(const link_t *, const li nk_t *);256 extern void list_concat(li nk_t *, link_t *);257 extern unsigned int list_count(const li nk_t *);280 extern int list_member(const link_t *, const list_t *); 281 extern void list_concat(list_t *, list_t *); 282 extern unsigned int list_count(const list_t *); 258 283 259 284 #endif -
uspace/lib/c/include/adt/prodcons.h
r1d1bb0f rb72efe8 42 42 fibril_mutex_t mtx; 43 43 fibril_condvar_t cv; 44 li nk_t list;44 list_t list; 45 45 } prodcons_t; 46 46 -
uspace/lib/c/include/async.h
r1d1bb0f rb72efe8 99 99 typedef struct { 100 100 /** List of inactive exchanges */ 101 li nk_t exch_list;101 list_t exch_list; 102 102 103 103 /** Exchange management style */ -
uspace/lib/c/include/fibril_synch.h
r1d1bb0f rb72efe8 45 45 fibril_owner_info_t oi; /**< Keep this the first thing. */ 46 46 int counter; 47 li nk_t waiters;47 list_t waiters; 48 48 } fibril_mutex_t; 49 49 … … 55 55 .counter = 1, \ 56 56 .waiters = { \ 57 .prev = &name.waiters, \ 58 .next = &name.waiters, \ 57 .head = { \ 58 .prev = &(name).waiters.head, \ 59 .next = &(name).waiters.head, \ 60 } \ 59 61 } \ 60 62 } … … 67 69 unsigned writers; 68 70 unsigned readers; 69 li nk_t waiters;71 list_t waiters; 70 72 } fibril_rwlock_t; 71 73 … … 78 80 .writers = 0, \ 79 81 .waiters = { \ 80 .prev = &name.waiters, \ 81 .next = &name.waiters, \ 82 .head = { \ 83 .prev = &(name).waiters.head, \ 84 .next = &(name).waiters.head, \ 85 } \ 82 86 } \ 83 87 } … … 87 91 88 92 typedef struct { 89 li nk_t waiters;93 list_t waiters; 90 94 } fibril_condvar_t; 91 95 … … 93 97 { \ 94 98 .waiters = { \ 95 .next = &name.waiters, \ 96 .prev = &name.waiters, \ 99 .head = { \ 100 .next = &(name).waiters.head, \ 101 .prev = &(name).waiters.head, \ 102 } \ 97 103 } \ 98 104 } -
uspace/lib/c/include/ipc/devman.h
r1d1bb0f rb72efe8 72 72 */ 73 73 typedef struct match_id_list { 74 li nk_t ids;74 list_t ids; 75 75 } match_id_list_t; 76 76 … … 95 95 { 96 96 match_id_t *mid = NULL; 97 link_t *link = ids->ids. next;97 link_t *link = ids->ids.head.next; 98 98 99 while (link != &ids->ids ) {99 while (link != &ids->ids.head) { 100 100 mid = list_get_instance(link, match_id_t,link); 101 101 if (mid->score < id->score) { 102 102 break; 103 } 103 } 104 104 link = link->next; 105 105 } … … 118 118 match_id_t *id; 119 119 120 while (!list_empty(&ids->ids)) {121 link = ids->ids.next;122 list_remove(link); 120 while (!list_empty(&ids->ids)) { 121 link = list_first(&ids->ids); 122 list_remove(link); 123 123 id = list_get_instance(link, match_id_t, link); 124 delete_match_id(id); 125 } 124 delete_match_id(id); 125 } 126 126 } 127 127 -
uspace/lib/drv/generic/driver.c
r1d1bb0f rb72efe8 139 139 find_interrupt_context_by_id(interrupt_context_list_t *list, int id) 140 140 { 141 interrupt_context_t *ctx; 142 141 143 fibril_mutex_lock(&list->mutex); 142 144 143 link_t *link = list->contexts.next; 144 interrupt_context_t *ctx; 145 146 while (link != &list->contexts) { 145 list_foreach(list->contexts, link) { 147 146 ctx = list_get_instance(link, interrupt_context_t, link); 148 147 if (ctx->id == id) { … … 150 149 return ctx; 151 150 } 152 link = link->next;153 151 } 154 152 … … 160 158 find_interrupt_context(interrupt_context_list_t *list, ddf_dev_t *dev, int irq) 161 159 { 160 interrupt_context_t *ctx; 161 162 162 fibril_mutex_lock(&list->mutex); 163 163 164 link_t *link = list->contexts.next; 165 interrupt_context_t *ctx; 166 167 while (link != &list->contexts) { 164 list_foreach(list->contexts, link) { 168 165 ctx = list_get_instance(link, interrupt_context_t, link); 169 166 if (ctx->irq == irq && ctx->dev == dev) { … … 171 168 return ctx; 172 169 } 173 link = link->next;174 170 } 175 171 … … 231 227 } 232 228 233 static ddf_fun_t *driver_get_function(li nk_t *functions, devman_handle_t handle)229 static ddf_fun_t *driver_get_function(list_t *functions, devman_handle_t handle) 234 230 { 235 231 ddf_fun_t *fun = NULL; 236 232 237 233 fibril_mutex_lock(&functions_mutex); 238 link_t *link = functions->next; 239 240 while (link != functions) { 234 235 list_foreach(*functions, link) { 241 236 fun = list_get_instance(link, ddf_fun_t, link); 242 237 if (fun->handle == handle) { … … 244 239 return fun; 245 240 } 246 247 link = link->next;248 241 } 249 242 -
uspace/lib/drv/include/ddf/interrupt.h
r1d1bb0f rb72efe8 60 60 typedef struct interrupt_context_list { 61 61 int curr_id; 62 li nk_t contexts;62 list_t contexts; 63 63 fibril_mutex_t mutex; 64 64 } interrupt_context_list_t; -
uspace/lib/usbhid/include/usb/hid/hiddescriptor.h
r1d1bb0f rb72efe8 74 74 usb_hid_report_path_t *usage_path); 75 75 76 void usb_hid_descriptor_print_list(li nk_t *head);76 void usb_hid_descriptor_print_list(list_t *list); 77 77 78 78 void usb_hid_report_reset_local_items(usb_hid_report_item_t *report_item); 79 79 80 void usb_hid_free_report_list(li nk_t *head);80 void usb_hid_free_report_list(list_t *list); 81 81 82 82 usb_hid_report_item_t *usb_hid_report_item_clone( -
uspace/lib/usbhid/include/usb/hid/hidpath.h
r1d1bb0f rb72efe8 88 88 uint8_t flags; 89 89 90 /** Link ed list structure*/91 link_t link;90 /** Link to usb_hid_report_path_t.items list */ 91 link_t rpath_items_link; 92 92 } usb_hid_report_usage_path_t; 93 93 … … 98 98 * */ 99 99 typedef struct { 100 /** Length of usage path */ 101 int depth; 100 /** Length of usage path */ 101 int depth; 102 102 103 103 /** Report id. Zero is reserved and means that report id is not used. 104 104 * */ 105 105 uint8_t report_id; 106 107 /** Linked list structure. */108 link_t link; /* list */109 106 110 /** Head of the list of usage path items. */111 link_t head;107 /** Link to usb_hid_report_path_t.collection_paths list. */ 108 link_t cpath_link; 112 109 110 /** List of usage path items. */ 111 list_t items; /* of usb_hid_report_usage_path_t */ 113 112 } usb_hid_report_path_t; 114 113 -
uspace/lib/usbhid/include/usb/hid/hidtypes.h
r1d1bb0f rb72efe8 95 95 int report_count; 96 96 97 /** Head of linked list of description of reports. */98 li nk_t reports;99 100 /** Head of linked list of all used usage/collection paths. */101 li nk_t collection_paths;97 /** List of description of reports. */ 98 list_t reports; /* of usb_hid_report_description_t */ 99 100 /** List of all used usage/collection paths. */ 101 list_t collection_paths; 102 102 103 103 /** Length of list of usage paths. */ … … 129 129 size_t item_length; 130 130 131 /** Li nked list of report items in report */132 li nk_t report_items;133 134 /** Link ed list of descriptions. */135 link_t link;131 /** List of report items in report */ 132 list_t report_items; 133 134 /** Link to usb_hid_report_t.reports list. */ 135 link_t reports_link; 136 136 } usb_hid_report_description_t; 137 137 /*---------------------------------------------------------------------------*/ … … 198 198 int32_t value; 199 199 200 /** Li st to another report items*/201 link_t link;200 /** Link to usb_hid_report_description_t.report_items list */ 201 link_t ritems_link; 202 202 } usb_hid_report_field_t; 203 203 -
uspace/lib/usbhid/src/hiddescriptor.c
r1d1bb0f rb72efe8 88 88 * @retval NULL If some error occurs 89 89 */ 90 usb_hid_report_path_t *usb_hid_report_path_try_insert( 91 usb_hid_report_t *report, usb_hid_report_path_t *cmp_path) { 92 93 link_t *path_it = report->collection_paths. next;90 usb_hid_report_path_t *usb_hid_report_path_try_insert(usb_hid_report_t *report, 91 usb_hid_report_path_t *cmp_path) 92 { 93 link_t *path_it = report->collection_paths.head.next; 94 94 usb_hid_report_path_t *path = NULL; 95 95 … … 98 98 } 99 99 100 while(path_it != &report->collection_paths ) {100 while(path_it != &report->collection_paths.head) { 101 101 path = list_get_instance(path_it, usb_hid_report_path_t, 102 link);102 cpath_link); 103 103 104 104 if(usb_hid_report_compare_usage_path(path, cmp_path, 105 105 USB_HID_PATH_COMPARE_STRICT) == EOK){ 106 106 break; 107 } 107 } 108 108 path_it = path_it->next; 109 109 } 110 if(path_it == &report->collection_paths ) {110 if(path_it == &report->collection_paths.head) { 111 111 path = usb_hid_report_path_clone(cmp_path); 112 112 if(path == NULL) { 113 113 return NULL; 114 114 } 115 list_append(&path-> link, &report->collection_paths);115 list_append(&path->cpath_link, &report->collection_paths); 116 116 report->collection_paths_count++; 117 117 … … 120 120 else { 121 121 return list_get_instance(path_it, usb_hid_report_path_t, 122 link);122 cpath_link); 123 123 } 124 124 } … … 192 192 193 193 memset(field, 0, sizeof(usb_hid_report_field_t)); 194 li st_initialize(&field->link);194 link_initialize(&field->ritems_link); 195 195 196 196 /* fill the attributes */ … … 291 291 } 292 292 293 li st_initialize (&report_des->link);293 link_initialize (&report_des->reports_link); 294 294 list_initialize (&report_des->report_items); 295 295 296 list_append(&report_des-> link, &report->reports);296 list_append(&report_des->reports_link, &report->reports); 297 297 report->report_count++; 298 298 } 299 299 300 300 /* append this field to the end of founded report list */ 301 list_append (&field->link, &report_des->report_items);301 list_append(&field->ritems_link, &report_des->report_items); 302 302 303 303 /* update the sizes */ … … 333 333 } 334 334 335 link_t *report_it = report->reports.next;336 335 usb_hid_report_description_t *report_des = NULL; 337 336 338 while(report_it != &report->reports) {337 list_foreach(report->reports, report_it) { 339 338 report_des = list_get_instance(report_it, 340 usb_hid_report_description_t, link);339 usb_hid_report_description_t, reports_link); 341 340 342 341 // if report id not set, return the first of the type … … 345 344 return report_des; 346 345 } 347 348 report_it = report_it->next;349 346 } 350 347 … … 377 374 size_t offset_output=0; 378 375 size_t offset_feature=0; 379 380 link_t stack; 381 list_initialize(&stack); 376 377 link_t *item_link; 378 379 list_t stack; 380 list_initialize(&stack); 382 381 383 382 /* parser structure initialization*/ … … 391 390 } 392 391 memset(report_item, 0, sizeof(usb_hid_report_item_t)); 393 li st_initialize(&(report_item->link));392 link_initialize(&(report_item->link)); 394 393 395 394 /* usage path context initialization */ … … 493 492 case USB_HID_REPORT_TAG_POP: 494 493 // restore current state from stack 495 if(list_empty (&stack)) { 494 item_link = list_first(&stack); 495 if (item_link == NULL) { 496 496 return EINVAL; 497 497 } 498 498 free(report_item); 499 500 report_item = list_get_instance( stack.next,499 500 report_item = list_get_instance(item_link, 501 501 usb_hid_report_item_t, link); 502 502 503 503 usb_hid_report_usage_path_t *tmp_usage_path; 504 504 tmp_usage_path = list_get_instance( 505 report_item->usage_path-> link.prev,506 usb_hid_report_usage_path_t, link);507 505 report_item->usage_path->cpath_link.prev, 506 usb_hid_report_usage_path_t, rpath_items_link); 507 508 508 usb_hid_report_set_last_item(usage_path, 509 509 USB_HID_TAG_CLASS_GLOBAL, tmp_usage_path->usage_page); … … 513 513 514 514 usb_hid_report_path_free(report_item->usage_path); 515 list_remove ( stack.next);515 list_remove (item_link); 516 516 517 517 break; … … 609 609 610 610 /* store collection atributes */ 611 path_item = list_get_instance( usage_path->head.prev,612 usb_hid_report_usage_path_t, link);613 path_item->flags = *data; 611 path_item = list_get_instance(list_first(&usage_path->items), 612 usb_hid_report_usage_path_t, rpath_items_link); 613 path_item->flags = *data; 614 614 615 615 /* set last item */ … … 900 900 * @return void 901 901 */ 902 void usb_hid_descriptor_print_list(li nk_t *head)902 void usb_hid_descriptor_print_list(list_t *list) 903 903 { 904 904 usb_hid_report_field_t *report_item; 905 link_t *item; 906 907 908 if(head == NULL || list_empty(head)) { 905 906 if(list == NULL || list_empty(list)) { 909 907 usb_log_debug("\tempty\n"); 910 908 return; 911 909 } 912 913 for(item = head->next; item != head; item = item->next) { 914 915 report_item = list_get_instance(item, usb_hid_report_field_t, 916 link); 910 911 list_foreach(*list, item) { 912 report_item = list_get_instance(item, usb_hid_report_field_t, 913 ritems_link); 917 914 918 915 usb_log_debug("\t\tOFFSET: %X\n", report_item->offset); 919 916 usb_log_debug("\t\tSIZE: %zu\n", report_item->size); 920 usb_log_debug("\t\tLOGMIN: %d\n", 917 usb_log_debug("\t\tLOGMIN: %d\n", 921 918 report_item->logical_minimum); 922 usb_log_debug("\t\tLOGMAX: %d\n", 923 report_item->logical_maximum); 924 usb_log_debug("\t\tPHYMIN: %d\n", 925 report_item->physical_minimum); 926 usb_log_debug("\t\tPHYMAX: %d\n", 927 report_item->physical_maximum); 928 usb_log_debug("\t\ttUSAGEMIN: %X\n", 919 usb_log_debug("\t\tLOGMAX: %d\n", 920 report_item->logical_maximum); 921 usb_log_debug("\t\tPHYMIN: %d\n", 922 report_item->physical_minimum); 923 usb_log_debug("\t\tPHYMAX: %d\n", 924 report_item->physical_maximum); 925 usb_log_debug("\t\ttUSAGEMIN: %X\n", 929 926 report_item->usage_minimum); 930 927 usb_log_debug("\t\tUSAGEMAX: %X\n", 931 928 report_item->usage_maximum); 932 usb_log_debug("\t\tUSAGES COUNT: %zu\n", 929 usb_log_debug("\t\tUSAGES COUNT: %zu\n", 933 930 report_item->usages_count); 934 931 … … 936 933 usb_log_debug("\t\ttUSAGE: %X\n", report_item->usage); 937 934 usb_log_debug("\t\tUSAGE PAGE: %X\n", report_item->usage_page); 938 935 939 936 usb_hid_print_usage_path(report_item->collection_path); 940 937 941 usb_log_debug("\n"); 938 usb_log_debug("\n"); 942 939 943 940 } … … 958 955 } 959 956 960 link_t *report_it = report->reports.next;961 957 usb_hid_report_description_t *report_des; 962 958 963 while(report_it != &report->reports) {964 report_des = list_get_instance(report_it, 965 usb_hid_report_description_t, link);959 list_foreach(report->reports, report_it) { 960 report_des = list_get_instance(report_it, 961 usb_hid_report_description_t, reports_link); 966 962 usb_log_debug("Report ID: %d\n", report_des->report_id); 967 963 usb_log_debug("\tType: %d\n", report_des->type); 968 usb_log_debug("\tLength: %zu\n", report_des->bit_length); 964 usb_log_debug("\tLength: %zu\n", report_des->bit_length); 969 965 usb_log_debug("\tB Size: %zu\n", 970 usb_hid_report_byte_size(report, 971 report_des->report_id, 966 usb_hid_report_byte_size(report, 967 report_des->report_id, 972 968 report_des->type)); 973 usb_log_debug("\tItems: %zu\n", report_des->item_length); 969 usb_log_debug("\tItems: %zu\n", report_des->item_length); 974 970 975 971 usb_hid_descriptor_print_list(&report_des->report_items); 976 977 report_it = report_it->next;978 972 } 979 973 } … … 983 977 * Releases whole linked list of report items 984 978 * 985 * @param head Head of list of report descriptor items (usb_hid_report_item_t)979 * @param list List of report descriptor items (usb_hid_report_item_t) 986 980 * @return void 987 981 */ 988 void usb_hid_free_report_list(li nk_t *head)982 void usb_hid_free_report_list(list_t *list) 989 983 { 990 return; 991 992 usb_hid_report_item_t *report_item;984 return; /* XXX What's this? */ 985 986 /* usb_hid_report_item_t *report_item; 993 987 link_t *next; 994 988 995 if( head == NULL || list_empty(head)) {989 if(list == NULL || list_empty(list)) { 996 990 return; 997 991 } 998 992 999 next = head->next;1000 while (next !=head) {1001 1002 report_item = list_get_instance(next, usb_hid_report_item_t,link);993 next = list->head.next; 994 while (next != &list->head) { 995 report_item = list_get_instance(next, usb_hid_report_item_t, 996 rpath_items_link); 1003 997 1004 998 while(!list_empty(&report_item->usage_path->link)) { 1005 999 usb_hid_report_remove_last_item(report_item->usage_path); 1006 1000 } 1007 1001 … … 1013 1007 1014 1008 return; 1015 1009 */ 1016 1010 } 1017 1011 /*---------------------------------------------------------------------------*/ … … 1029 1023 1030 1024 // free collection paths 1025 link_t *path_link; 1031 1026 usb_hid_report_path_t *path; 1032 1027 while(!list_empty(&report->collection_paths)) { 1033 path = list_get_instance(report->collection_paths.next, 1034 usb_hid_report_path_t, link); 1035 1036 usb_hid_report_path_free(path); 1028 path_link = list_first(&report->collection_paths); 1029 path = list_get_instance(path_link, 1030 usb_hid_report_path_t, cpath_link); 1031 1032 list_remove(path_link); 1033 usb_hid_report_path_free(path); 1037 1034 } 1038 1035 … … 1041 1038 usb_hid_report_field_t *field; 1042 1039 while(!list_empty(&report->reports)) { 1043 report_des = list_get_instance( report->reports.next,1044 usb_hid_report_description_t, link);1045 1046 list_remove(&report_des-> link);1040 report_des = list_get_instance(list_first(&report->reports), 1041 usb_hid_report_description_t, reports_link); 1042 1043 list_remove(&report_des->reports_link); 1047 1044 1048 1045 while(!list_empty(&report_des->report_items)) { 1049 1046 field = list_get_instance( 1050 report_des->report_items.next,1051 usb_hid_report_field_t,link);1052 1053 list_remove(&field-> link);1047 list_first(&report_des->report_items), 1048 usb_hid_report_field_t, ritems_link); 1049 1050 list_remove(&field->ritems_link); 1054 1051 1055 1052 free(field); -
uspace/lib/usbhid/src/hidparser.c
r1d1bb0f rb72efe8 135 135 size_t size, uint8_t *report_id) 136 136 { 137 link_t *list_item;138 137 usb_hid_report_field_t *item; 139 138 … … 161 160 162 161 /* read data */ 163 list_item = report_des->report_items.next; 164 while(list_item != &(report_des->report_items)) { 165 162 list_foreach(report_des->report_items, list_item) { 166 163 item = list_get_instance(list_item, usb_hid_report_field_t, 167 link);164 ritems_link); 168 165 169 166 if(USB_HID_ITEM_FLAG_CONSTANT(item->item_flags) == 0) { … … 200 197 } 201 198 } 202 list_item = list_item->next;203 199 } 204 200 … … 310 306 } 311 307 312 link_t *report_it = report->reports.next;313 308 usb_hid_report_description_t *report_des = NULL; 314 while(report_it != &report->reports) { 315 report_des = list_get_instance(report_it, 316 usb_hid_report_description_t, link); 309 310 list_foreach(report->reports, report_it) { 311 report_des = list_get_instance(report_it, 312 usb_hid_report_description_t, reports_link); 317 313 318 if((report_des->report_id == report_id) && 314 if((report_des->report_id == report_id) && 319 315 (report_des->type == USB_HID_REPORT_TYPE_OUTPUT)){ 320 316 break; 321 317 } 322 323 report_it = report_it->next;324 318 } 325 319 … … 362 356 uint8_t report_id, uint8_t *buffer, size_t size) 363 357 { 364 link_t *item;365 358 int32_t value=0; 366 359 int offset; … … 384 377 } 385 378 386 usb_hid_report_field_t *report_item; 387 item = report_des->report_items.next; 388 while(item != &report_des->report_items) { 389 report_item = list_get_instance(item, usb_hid_report_field_t, link); 379 usb_hid_report_field_t *report_item; 380 381 list_foreach(report_des->report_items, item) { 382 report_item = list_get_instance(item, usb_hid_report_field_t, 383 ritems_link); 390 384 391 385 value = usb_hid_translate_data_reverse(report_item, … … 449 443 // reset value 450 444 report_item->value = 0; 451 452 item = item->next;453 445 } 454 446 … … 550 542 551 543 if(field == NULL){ 552 field_it = report_des->report_items. next;553 } 554 else { 555 field_it = field-> link.next;556 } 557 558 while(field_it != &report_des->report_items ) {544 field_it = report_des->report_items.head.next; 545 } 546 else { 547 field_it = field->ritems_link.next; 548 } 549 550 while(field_it != &report_des->report_items.head) { 559 551 field = list_get_instance(field_it, usb_hid_report_field_t, 560 link);552 ritems_link); 561 553 562 554 if(USB_HID_ITEM_FLAG_CONSTANT(field->item_flags) == 0) { … … 611 603 } 612 604 else { 613 report_it = report_des-> link.next;605 report_it = report_des->reports_link.next; 614 606 } 615 607 } 616 608 else { 617 report_it = report->reports. next;618 } 619 620 while(report_it != &report->reports ) {609 report_it = report->reports.head.next; 610 } 611 612 while(report_it != &report->reports.head) { 621 613 report_des = list_get_instance(report_it, 622 usb_hid_report_description_t, link);614 usb_hid_report_description_t, reports_link); 623 615 624 616 if(report_des->type == type){ -
uspace/lib/usbhid/src/hidpath.c
r1d1bb0f rb72efe8 81 81 return ENOMEM; 82 82 } 83 li st_initialize(&item->link);83 link_initialize(&item->rpath_items_link); 84 84 85 85 item->usage = usage; … … 87 87 item->flags = 0; 88 88 89 list_append (&item-> link, &usage_path->head);89 list_append (&item->rpath_items_link, &usage_path->items); 90 90 usage_path->depth++; 91 91 return EOK; … … 100 100 void usb_hid_report_remove_last_item(usb_hid_report_path_t *usage_path) 101 101 { 102 link_t *item_link; 102 103 usb_hid_report_usage_path_t *item; 103 104 104 if(!list_empty(&usage_path->head)){ 105 item = list_get_instance(usage_path->head.prev, 106 usb_hid_report_usage_path_t, link); 107 list_remove(usage_path->head.prev); 105 if(!list_empty(&usage_path->items)){ 106 item_link = list_last(&usage_path->items); 107 item = list_get_instance(item_link, 108 usb_hid_report_usage_path_t, rpath_items_link); 109 list_remove(item_link); 108 110 usage_path->depth--; 109 111 free(item); … … 122 124 usb_hid_report_usage_path_t *item; 123 125 124 if(!list_empty(&usage_path-> head)){125 item = list_get_instance( usage_path->head.prev,126 usb_hid_report_usage_path_t, link);126 if(!list_empty(&usage_path->items)){ 127 item = list_get_instance(list_last(&usage_path->items), 128 usb_hid_report_usage_path_t, rpath_items_link); 127 129 128 130 memset(item, 0, sizeof(usb_hid_report_usage_path_t)); … … 145 147 usb_hid_report_usage_path_t *item; 146 148 147 if(!list_empty(&usage_path-> head)){148 item = list_get_instance( usage_path->head.prev,149 usb_hid_report_usage_path_t,link);149 if(!list_empty(&usage_path->items)){ 150 item = list_get_instance(list_last(&usage_path->items), 151 usb_hid_report_usage_path_t, rpath_items_link); 150 152 151 153 switch(tag) { … … 173 175 usb_log_debug("\tLENGTH: %d\n", path->depth); 174 176 175 link_t *item = path->head.next;176 177 usb_hid_report_usage_path_t *path_item; 177 while(item != &path->head) { 178 179 path_item = list_get_instance(item, usb_hid_report_usage_path_t, 180 link);178 179 list_foreach(path->items, item) { 180 path_item = list_get_instance(item, usb_hid_report_usage_path_t, 181 rpath_items_link); 181 182 182 183 usb_log_debug("\tUSAGE_PAGE: %X\n", path_item->usage_page); 183 184 usb_log_debug("\tUSAGE: %X\n", path_item->usage); 184 usb_log_debug("\tFLAGS: %d\n", path_item->flags); 185 186 item = item->next; 185 usb_log_debug("\tFLAGS: %d\n", path_item->flags); 187 186 } 188 187 } … … 233 232 } 234 233 235 report_link = report_path->head.next; 236 path_link = path->head.next; 237 path_item = list_get_instance(path_link, 238 usb_hid_report_usage_path_t, link); 239 240 while(report_link != &report_path->head) { 241 report_item = list_get_instance(report_link, 242 usb_hid_report_usage_path_t, link); 234 path_link = list_first(&path->items); 235 path_item = list_get_instance(path_link, 236 usb_hid_report_usage_path_t, rpath_items_link); 237 238 list_foreach(report_path->items, report_link) { 239 report_item = list_get_instance(report_link, 240 usb_hid_report_usage_path_t, rpath_items_link); 243 241 244 if(USB_HID_SAME_USAGE_PAGE(report_item->usage_page, 242 if(USB_HID_SAME_USAGE_PAGE(report_item->usage_page, 245 243 path_item->usage_page)){ 246 244 … … 257 255 } 258 256 } 259 260 report_link = report_link->next;261 257 } 262 258 … … 273 269 case USB_HID_PATH_COMPARE_BEGIN: 274 270 275 report_link = report_path-> head.next;276 path_link = path-> head.next;271 report_link = report_path->items.head.next; 272 path_link = path->items.head.next; 277 273 278 while((report_link != &report_path-> head) &&279 (path_link != &path-> head)) {274 while((report_link != &report_path->items.head) && 275 (path_link != &path->items.head)) { 280 276 281 277 report_item = list_get_instance(report_link, 282 usb_hid_report_usage_path_t, link);278 usb_hid_report_usage_path_t, rpath_items_link); 283 279 284 280 path_item = list_get_instance(path_link, 285 usb_hid_report_usage_path_t, link);281 usb_hid_report_usage_path_t, rpath_items_link); 286 282 287 283 if(!USB_HID_SAME_USAGE_PAGE(report_item->usage_page, … … 297 293 } 298 294 299 295 } 300 296 301 297 if((((flags & USB_HID_PATH_COMPARE_BEGIN) != 0) && 302 (path_link == &path-> head)) ||303 ((report_link == &report_path-> head) &&304 (path_link == &path-> head))) {298 (path_link == &path->items.head)) || 299 ((report_link == &report_path->items.head) && 300 (path_link == &path->items.head))) { 305 301 306 302 return EOK; … … 314 310 case USB_HID_PATH_COMPARE_END: 315 311 316 report_link = report_path-> head.prev;317 path_link = path-> head.prev;318 319 if(list_empty(&path-> head)){312 report_link = report_path->items.head.prev; 313 path_link = path->items.head.prev; 314 315 if(list_empty(&path->items)){ 320 316 return EOK; 321 317 } 322 318 323 while((report_link != &report_path-> head) &&324 (path_link != &path-> head)) {319 while((report_link != &report_path->items.head) && 320 (path_link != &path->items.head)) { 325 321 326 report_item = list_get_instance(report_link, 327 usb_hid_report_usage_path_t, link);322 report_item = list_get_instance(report_link, 323 usb_hid_report_usage_path_t, rpath_items_link); 328 324 329 325 path_item = list_get_instance(path_link, 330 usb_hid_report_usage_path_t, link);326 usb_hid_report_usage_path_t, rpath_items_link); 331 327 332 328 if(!USB_HID_SAME_USAGE_PAGE(report_item->usage_page, … … 343 339 } 344 340 345 if(path_link == &path-> head) {341 if(path_link == &path->items.head) { 346 342 return EOK; 347 343 } … … 373 369 path->depth = 0; 374 370 path->report_id = 0; 375 li st_initialize(&path->link);376 list_initialize(&path-> head);371 link_initialize(&path->cpath_link); 372 list_initialize(&path->items); 377 373 return path; 378 374 } … … 388 384 void usb_hid_report_path_free(usb_hid_report_path_t *path) 389 385 { 390 while(!list_empty(&path-> head)){386 while(!list_empty(&path->items)){ 391 387 usb_hid_report_remove_last_item(path); 392 388 } 393 389 394 list_remove(&path->link);390 assert_link_not_used(&path->cpath_link); 395 391 free(path); 396 392 } … … 406 402 usb_hid_report_path_t *usage_path) 407 403 { 408 link_t *path_link;409 404 usb_hid_report_usage_path_t *path_item; 410 405 usb_hid_report_usage_path_t *new_path_item; … … 417 412 new_usage_path->report_id = usage_path->report_id; 418 413 419 if(list_empty(&usage_path-> head)){414 if(list_empty(&usage_path->items)){ 420 415 return new_usage_path; 421 416 } 422 417 423 path_link = usage_path->head.next; 424 while(path_link != &usage_path->head) { 425 path_item = list_get_instance(path_link, 426 usb_hid_report_usage_path_t, link); 418 list_foreach(usage_path->items, path_link) { 419 path_item = list_get_instance(path_link, 420 usb_hid_report_usage_path_t, rpath_items_link); 427 421 428 422 new_path_item = malloc(sizeof(usb_hid_report_usage_path_t)); … … 431 425 } 432 426 433 li st_initialize (&new_path_item->link);427 link_initialize(&new_path_item->rpath_items_link); 434 428 new_path_item->usage_page = path_item->usage_page; 435 429 new_path_item->usage = path_item->usage; 436 430 new_path_item->flags = path_item->flags; 437 431 438 list_append(&new_path_item->link, &new_usage_path->head); 432 list_append(&new_path_item->rpath_items_link, 433 &new_usage_path->items); 439 434 new_usage_path->depth++; 440 441 path_link = path_link->next;442 435 } 443 436
Note:
See TracChangeset
for help on using the changeset viewer.