Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/usbhid/src/hidpath.c

    rb72efe8 rdcb7d7cd  
    8181                return ENOMEM;
    8282        }
    83         link_initialize(&item->rpath_items_link);
     83        list_initialize(&item->link);
    8484
    8585        item->usage = usage;
    … …  
    8787        item->flags = 0;
    8888       
    89         list_append (&item->rpath_items_link, &usage_path->items);
     89        list_append (&item->link, &usage_path->head);
    9090        usage_path->depth++;
    9191        return EOK;
    … …  
    100100void usb_hid_report_remove_last_item(usb_hid_report_path_t *usage_path)
    101101{
    102         link_t *item_link;
    103102        usb_hid_report_usage_path_t *item;
    104103       
    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);
     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);
    110108                usage_path->depth--;
    111109                free(item);
    … …  
    124122        usb_hid_report_usage_path_t *item;
    125123       
    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);
     124        if(!list_empty(&usage_path->head)){     
     125                item = list_get_instance(usage_path->head.prev,
     126                        usb_hid_report_usage_path_t, link);
    129127
    130128                memset(item, 0, sizeof(usb_hid_report_usage_path_t));
    … …  
    147145        usb_hid_report_usage_path_t *item;
    148146       
    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);
     147        if(!list_empty(&usage_path->head)){     
     148                item = list_get_instance(usage_path->head.prev,
     149                                         usb_hid_report_usage_path_t, link);
    152150
    153151                switch(tag) {
    … …  
    175173        usb_log_debug("\tLENGTH: %d\n", path->depth);
    176174
     175        link_t *item = path->head.next;
    177176        usb_hid_report_usage_path_t *path_item;
    178 
    179         list_foreach(path->items, item) {
    180                 path_item = list_get_instance(item, usb_hid_report_usage_path_t,
    181                         rpath_items_link);
     177        while(item != &path->head) {
     178
     179                path_item = list_get_instance(item, usb_hid_report_usage_path_t, 
     180                        link);
    182181
    183182                usb_log_debug("\tUSAGE_PAGE: %X\n", path_item->usage_page);
    184183                usb_log_debug("\tUSAGE: %X\n", path_item->usage);
    185                 usb_log_debug("\tFLAGS: %d\n", path_item->flags);
     184                usb_log_debug("\tFLAGS: %d\n", path_item->flags);               
     185               
     186        item = item->next;
    186187        }
    187188}
    … …  
    232233                }
    233234
    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);
     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);
    241243                               
    242                         if(USB_HID_SAME_USAGE_PAGE(report_item->usage_page,
     244                        if(USB_HID_SAME_USAGE_PAGE(report_item->usage_page, 
    243245                                path_item->usage_page)){
    244246                                       
    … …  
    255257                                }
    256258                        }
     259
     260                        report_link = report_link->next;
    257261                }
    258262
    … …  
    269273        case USB_HID_PATH_COMPARE_BEGIN:
    270274       
    271                 report_link = report_path->items.head.next;
    272                 path_link = path->items.head.next;
     275                report_link = report_path->head.next;
     276                path_link = path->head.next;
    273277                       
    274                 while((report_link != &report_path->items.head) &&
    275                       (path_link != &path->items.head)) {
     278                while((report_link != &report_path->head) &&
     279                      (path_link != &path->head)) {
    276280                                         
    277281                        report_item = list_get_instance(report_link,
    278                                 usb_hid_report_usage_path_t, rpath_items_link);
     282                                usb_hid_report_usage_path_t, link);
    279283                                         
    280284                        path_item = list_get_instance(path_link,
    281                                 usb_hid_report_usage_path_t, rpath_items_link);
     285                                usb_hid_report_usage_path_t, link);
    282286
    283287                        if(!USB_HID_SAME_USAGE_PAGE(report_item->usage_page,
    … …  
    293297                        }
    294298                       
    295                 }
     299                                }
    296300
    297301                if((((flags & USB_HID_PATH_COMPARE_BEGIN) != 0) &&
    298                         (path_link == &path->items.head)) ||
    299                    ((report_link == &report_path->items.head) &&
    300                         (path_link == &path->items.head))) {
     302                        (path_link == &path->head)) ||
     303                   ((report_link == &report_path->head) &&
     304                        (path_link == &path->head))) {
    301305                               
    302306                        return EOK;
    … …  
    310314        case USB_HID_PATH_COMPARE_END:
    311315
    312                 report_link = report_path->items.head.prev;
    313                 path_link = path->items.head.prev;
    314 
    315                 if(list_empty(&path->items)){
     316                report_link = report_path->head.prev;
     317                path_link = path->head.prev;
     318
     319                if(list_empty(&path->head)){
    316320                        return EOK;
    317321                }
    318322                       
    319                 while((report_link != &report_path->items.head) &&
    320                       (path_link != &path->items.head)) {
     323                while((report_link != &report_path->head) &&
     324                      (path_link != &path->head)) {
    321325                                                 
    322                         report_item = list_get_instance(report_link,
    323                                 usb_hid_report_usage_path_t, rpath_items_link);
     326                        report_item = list_get_instance(report_link, 
     327                                usb_hid_report_usage_path_t, link);
    324328
    325329                        path_item = list_get_instance(path_link,
    326                                 usb_hid_report_usage_path_t, rpath_items_link);
     330                                usb_hid_report_usage_path_t, link);             
    327331                                                 
    328332                        if(!USB_HID_SAME_USAGE_PAGE(report_item->usage_page,
    … …  
    339343                }
    340344
    341                 if(path_link == &path->items.head) {
     345                if(path_link == &path->head) {
    342346                        return EOK;
    343347                }
    … …  
    369373                path->depth = 0;
    370374                path->report_id = 0;
    371                 link_initialize(&path->cpath_link);
    372                 list_initialize(&path->items);
     375                list_initialize(&path->link);
     376                list_initialize(&path->head);
    373377                return path;
    374378        }
    … …  
    384388void usb_hid_report_path_free(usb_hid_report_path_t *path)
    385389{
    386         while(!list_empty(&path->items)){
     390        while(!list_empty(&path->head)){
    387391                usb_hid_report_remove_last_item(path);
    388392        }
    389393
    390         assert_link_not_used(&path->cpath_link);
     394        list_remove(&path->link);
    391395        free(path);
    392396}
    … …  
    402406        usb_hid_report_path_t *usage_path)
    403407{
     408        link_t *path_link;
    404409        usb_hid_report_usage_path_t *path_item;
    405410        usb_hid_report_usage_path_t *new_path_item;
    … …  
    412417        new_usage_path->report_id = usage_path->report_id;
    413418       
    414         if(list_empty(&usage_path->items)){
     419        if(list_empty(&usage_path->head)){
    415420                return new_usage_path;
    416421        }
    417422
    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);
     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);
    421427
    422428                new_path_item = malloc(sizeof(usb_hid_report_usage_path_t));
    … …  
    425431                }
    426432               
    427                 link_initialize(&new_path_item->rpath_items_link);
     433                list_initialize (&new_path_item->link);         
    428434                new_path_item->usage_page = path_item->usage_page;
    429435                new_path_item->usage = path_item->usage;               
    430436                new_path_item->flags = path_item->flags;               
    431437               
    432                 list_append(&new_path_item->rpath_items_link,
    433                     &new_usage_path->items);
     438                list_append(&new_path_item->link, &new_usage_path->head);
    434439                new_usage_path->depth++;
     440
     441                path_link = path_link->next;
    435442        }
    436443
Note: See TracChangeset for help on using the changeset viewer.