list.h

Go to the documentation of this file.

#ifndef __LIST
#define __LIST


#define ALLOCATE(type)  ( (type *) malloc(sizeof(type)) )

#define DEF_ALLOC(type, name)   \
        type *name;     \
        ( name = (type *) malloc(sizeof(type)) );


#define LIST_DATA(type)         struct { struct type *next,*previous; }

// Macros de uso interno
#define LIST_NEXT(list,node)            ((node->list).next)
#define LIST_PREVIOUS(list,node)        ((node->list).previous)

#define HEADER_NEXT(header)             ((header).next)
#define HEADER_PREVIOUS(header)         ((header).previous)


#define LIST_NEW(type)          \
        struct {                                \
                type *next;                     \
                type *previous;         \
        }

#define LIST_INITIALIZER        {NULL,NULL}

#define LIST_INIT(header)                       \
        HEADER_NEXT(header)=NULL;               \
        HEADER_PREVIOUS(header)=NULL;


#define LIST_FIRST(header)              \
        HEADER_NEXT(header)

#define LIST_TAIL(header)               \
        HEADER_PREVIOUS(header)



#define LIST_EMPTY(header)              \
        ((HEADER_NEXT(header) && HEADER_PREVIOUS(header)) ? 0 : 1)


#define LIST_ADD(header,list,node)                                                      \
        LIST_NEXT(list,node)=HEADER_NEXT(header);                                       \
        if ( HEADER_NEXT(header) != NULL)                                               \
                LIST_PREVIOUS( list, LIST_NEXT(list,node) )= node;              \
        else                                                                    \
                HEADER_PREVIOUS(header)=node;                                   \
        LIST_PREVIOUS(list,node)=NULL;                                          \
        HEADER_NEXT(header)=node;



#define LIST_ADD_TAIL(header,list,node)                         \
        if ( HEADER_PREVIOUS(header) != NULL )                  \
                LIST_NEXT( list, HEADER_PREVIOUS(header) ) = node;      \
        else                                                    \
                HEADER_NEXT(header) = node;                     \
        LIST_NEXT(list,node) = NULL;                                    \
        LIST_PREVIOUS(list,node) = HEADER_PREVIOUS(header);             \
        HEADER_PREVIOUS(header) = node;


#define LIST_DEL(header,list,node)                                              \
        if ( LIST_PREVIOUS(list,node) != NULL )                                 \
                LIST_NEXT( list, LIST_PREVIOUS(list,node) ) = LIST_NEXT(list,node);     \
        else                                                            \
                HEADER_NEXT(header) = LIST_NEXT(list,node);                     \
        if ( LIST_NEXT(list,node) != NULL )                                     \
                LIST_PREVIOUS( list, LIST_NEXT(list,node) ) = LIST_PREVIOUS(list,node); \
        else                                                            \
                HEADER_PREVIOUS(header) = LIST_PREVIOUS(list,node);
        

#define LIST_FOREACH(var,header,list)                                                   \
        for(var=HEADER_NEXT(header); var!=NULL; var=LIST_NEXT(list,var))



/* \brief Simil LIST_FOREACH, pero se pueden remover los nodos que se recorren
 * su utilizacion es un poco compleja (deben agregarse dos líneas de código para su correcto uso)
 *
 *   _LIST_FOREACH(child, actual->childs, brothers) {
 *      aux = LIST_NEXT(brothers, child);                                                       // Agregado 1
 *      if (child->estado == TASK_ZOMBIE)
 *              pid = sys_waitpid(child->pid,&value,WNOHANG);
 *      child = aux;                                                                                            // Agregado 2
 *       }
 * \todo Implementarlo más limpiamente
 */
#define _LIST_FOREACH(var,header,list)                                                  \
        for(var=HEADER_NEXT(header); var!=NULL; )

/* \brief Permite insertar un nodo antes de otro nodo determinado
 * es importante que nodebefore sea un nodo válido, esto implica que
 * no se permite que nodebefore sea NULL por ejemplo.
 */
#define LIST_INSERT_BEFORE(header,list,nodebefore,node)                         \
        LIST_PREVIOUS(list,node)=LIST_PREVIOUS(list,nodebefore);                \
        LIST_NEXT(list,node)=nodebefore;                                                                                                                \
        if ( HEADER_NEXT(header)==nodebefore )                                                                                  \
                HEADER_NEXT(header)=node;                                                                                                                                       \
        else                                                                                                                                                                                                                            \
                LIST_NEXT(list,LIST_PREVIOUS(list,nodebefore))=node;                    \
        LIST_PREVIOUS(list,nodebefore)=node;

        


#define LIST_FOREACH_REVERSE(var,header,list)                                           \
        for(var=HEADER_PREVIOUS(header); var!=NULL; var=LIST_PREVIOUS(list,var))


/* Permite buscar un nodo de la lista por un valor de
 * un atributo particular.
 * Recibe como argumentos la lista, la variable donde
 * devuelve un puntero al nodo encontrado o NULL en caso
 * de busqueda sin resultados, el siguiente argumento es
 * el nombre de la variable a buscar (definida en la 
 * estructura y por ultimo el valor buscado.
 * ej:
 *              task_struct_t *nodobuscado;
 *              LIST_FIND(runqueue,nodobuscado,priority,3)
 */
#define LIST_FIND(header,list,var,name,value)                                                   \
        for(var=HEADER_NEXT(header); var!=NULL && var->name!=value; var=LIST_NEXT(list,var))


#define LIST_ATTACH(dest, src, type)                                    \
{       type *aux;                                                                                      \
        _LIST_FOREACH(ptr, src) {                       \
                aux = LIST_NEXT(src,ptr);                                                       \
                LIST_ADD_TAIL(dest,dest, ptr);  \
                ptr = aux;                                                                              \
        }                                                                                                       \
}

#define LIST_CLEAN(header)                                                                      \
        LIST_INIT(header);

#define LIST_REPLACE(list, original, replace)                                           \
        LIST_NEXT(list, replace) = LIST_NEXT(list, original);                   \
        LIST_PREVIOUS(list, replace) = LIST_PREVIOUS(list, original);   \
        if (LIST_NEXT(list, replace))                                                                   \
                LIST_PREVIOUS(list,LIST_NEXT(list, replace)) = replace;         \
        if (LIST_PREVIOUS(list, replace))                                                               \
                LIST_NEXT(list,LIST_PREVIOUS(list, replace)) = replace;

#endif

---