Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset b76ce3f in mainline


Ignore:
Timestamp:
2017-06-27T16:52:59Z (3 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
master
Children:
30eab78
Parents:
9e7615d
Message:

Reduce divergence between kernel and libc versions of adt/list.h

Files:
2 edited

Legend:

Unmodified
Added
Removed
  • kernel/generic/include/adt/list.h

    r9e7615d rb76ce3f  
    5353} list_t;
    5454
    55 
    5655extern bool list_member(const link_t *, const list_t *);
    5756extern void list_splice(list_t *, link_t *);
    5857extern unsigned long list_count(const list_t *);
    5958
    60 
    6159/** Declare and initialize statically allocated list.
    6260 *
     
    6563 */
    6664#define LIST_INITIALIZE(name) \
    67         list_t name = { \
     65        list_t name = LIST_INITIALIZER(name)
     66
     67/** Initializer for statically allocated list.
     68 *
     69 * @code
     70 * struct named_list {
     71 *     const char *name;
     72 *     list_t list;
     73 * } var = {
     74 *     .name = "default name",
     75 *     .list = LIST_INITIALIZER(name_list.list)
     76 * };
     77 * @endcode
     78 *
     79 * @param name Name of the new statically allocated list.
     80 *
     81 */
     82#define LIST_INITIALIZER(name) \
     83        { \
    6884                .head = { \
    6985                        .prev = &(name).head, \
     
    88104
    89105/** Unlike list_foreach(), allows removing items while traversing a list.
    90  * 
     106 *
    91107 * @code
    92108 * list_t mylist;
     
    118134            iterator = next_iter, next_iter = iterator->next)
    119135
    120        
    121136#define assert_link_not_used(link) \
    122137        assert(!link_used(link))
     138
     139/** Returns true if the link is definitely part of a list. False if not sure. */
     140static inline bool link_in_use(const link_t *link)
     141{
     142        return link->prev != NULL && link->next != NULL;
     143}
    123144
    124145/** Initialize doubly-linked circular list link
     
    247268 *
    248269 */
    249 static inline link_t *list_last(list_t *list)
    250 {
    251         return ((list->head.prev == &list->head) ? NULL : list->head.prev);
     270static inline link_t *list_last(const list_t *list)
     271{
     272        return (list->head.prev == &list->head) ? NULL : list->head.prev;
    252273}
    253274
     
    259280 * @return Next item or NULL if @a link is the last item.
    260281 */
    261 static inline link_t *list_next(link_t *link, const list_t *list)
     282static inline link_t *list_next(const link_t *link, const list_t *list)
    262283{
    263284        return (link->next == &list->head) ? NULL : link->next;
     
    271292 * @return Previous item or NULL if @a link is the first item.
    272293 */
    273 static inline link_t *list_prev(link_t *link, const list_t *list)
     294static inline link_t *list_prev(const link_t *link, const list_t *list)
    274295{
    275296        return (link->prev == &list->head) ? NULL : link->prev;
     
    354375 *
    355376 */
    356 static inline link_t *list_nth(list_t *list, unsigned long n)
     377static inline link_t *list_nth(const list_t *list, unsigned long n)
    357378{
    358379        unsigned long cnt = 0;
    359         link_t *link;
    360380       
    361         link = list_first(list);
     381        link_t *link = list_first(list);
    362382        while (link != NULL) {
    363383                if (cnt == n)
  • uspace/lib/c/include/adt/list.h

    r9e7615d rb76ce3f  
    4040#include <stdbool.h>
    4141#include <stddef.h>
     42#include <trace.h>
    4243
    4344/** Doubly linked list link. */
     
    5152        link_t head;  /**< List head. Does not have any data. */
    5253} list_t;
     54
     55extern bool list_member(const link_t *, const list_t *);
     56extern void list_concat(list_t *, list_t *);
     57extern unsigned long list_count(const list_t *);
    5358
    5459/** Declare and initialize statically allocated list.
     
    8893#define list_foreach(list, member, itype, iterator) \
    8994        for (itype *iterator = NULL; iterator == NULL; iterator = (itype *) 1) \
    90             for (link_t *_link = (list).head.next; \
    91             iterator = list_get_instance(_link, itype, member), \
    92             _link != &(list).head; _link = _link->next)
     95                for (link_t *_link = (list).head.next; \
     96                    iterator = list_get_instance(_link, itype, member), \
     97                    _link != &(list).head; _link = _link->next)
    9398
    9499#define list_foreach_rev(list, member, itype, iterator) \
    95100        for (itype *iterator = NULL; iterator == NULL; iterator = (itype *) 1) \
    96             for (link_t *_link = (list).head.prev; \
    97             iterator = list_get_instance(_link, itype, member), \
    98             _link != &(list).head; _link = _link->prev)
     101                for (link_t *_link = (list).head.prev; \
     102                    iterator = list_get_instance(_link, itype, member), \
     103                    _link != &(list).head; _link = _link->prev)
    99104
    100105/** Unlike list_foreach(), allows removing items while traversing a list.
     
    125130#define list_foreach_safe(list, iterator, next_iter) \
    126131        for (link_t *iterator = (list).head.next, \
    127                 *next_iter = iterator->next; \
    128                 iterator != &(list).head; \
    129                 iterator = next_iter, next_iter = iterator->next)
     132            *next_iter = iterator->next; \
     133            iterator != &(list).head; \
     134            iterator = next_iter, next_iter = iterator->next)
    130135
    131136#define assert_link_not_used(link) \
     
    145150 *
    146151 */
    147 static inline void link_initialize(link_t *link)
     152NO_TRACE static inline void link_initialize(link_t *link)
    148153{
    149154        link->prev = NULL;
     
    158163 *
    159164 */
    160 static inline void list_initialize(list_t *list)
     165NO_TRACE static inline void list_initialize(list_t *list)
    161166{
    162167        list->head.prev = &list->head;
     
    194199 *
    195200 */
    196 static inline void list_prepend(link_t *link, list_t *list)
     201NO_TRACE static inline void list_prepend(link_t *link, list_t *list)
    197202{
    198203        list_insert_after(link, &list->head);
     
    207212 *
    208213 */
    209 static inline void list_append(link_t *link, list_t *list)
     214NO_TRACE static inline void list_append(link_t *link, list_t *list)
    210215{
    211216        list_insert_before(link, &list->head);
     
    220225 *
    221226 */
    222 static inline void list_remove(link_t *link)
     227NO_TRACE static inline void list_remove(link_t *link)
    223228{
    224229        if ((link->prev != NULL) && (link->next != NULL)) {
     
    237242 *
    238243 */
    239 static inline bool list_empty(const list_t *list)
     244NO_TRACE static inline bool list_empty(const list_t *list)
    240245{
    241246        return (list->head.next == &list->head);
     
    274279 *
    275280 * @return Next item or NULL if @a link is the last item.
    276  *
    277281 */
    278282static inline link_t *list_next(const link_t *link, const list_t *list)
     
    287291 *
    288292 * @return Previous item or NULL if @a link is the first item.
    289  *
    290293 */
    291294static inline link_t *list_prev(const link_t *link, const list_t *list)
     
    307310 *
    308311 */
    309 static inline void headless_list_split_or_concat(link_t *part1, link_t *part2)
     312NO_TRACE static inline void headless_list_split_or_concat(link_t *part1, link_t *part2)
    310313{
    311314        part1->prev->next = part2;
     
    328331 *
    329332 */
    330 static inline void headless_list_split(link_t *part1, link_t *part2)
     333NO_TRACE static inline void headless_list_split(link_t *part1, link_t *part2)
    331334{
    332335        headless_list_split_or_concat(part1, part2);
     
    343346 *
    344347 */
    345 static inline void headless_list_concat(link_t *part1, link_t *part2)
     348NO_TRACE static inline void headless_list_concat(link_t *part1, link_t *part2)
    346349{
    347350        headless_list_split_or_concat(part1, part2);
     
    396399}
    397400
    398 extern bool list_member(const link_t *, const list_t *);
    399 extern void list_concat(list_t *, list_t *);
    400 extern unsigned long list_count(const list_t *);
    401401
    402402#endif
Note: See TracChangeset for help on using the changeset viewer.