Main Page | Modules | Class List | File List | Class Members | File Members | Related Pages | Search for 

list.h File Reference

Go to the source code of this file.

Defines

Define Documentation

#define _LIST_FOREACH (  var,
header,
list   )     for(var=HEADER_NEXT(header); var!=NULL; )
 

Definition at line 175 of file list.h.

Referenced by sys_exit_notify().

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

Aloca un nodo de la lista.

a incluir en las estructuras de datos a colocar en listas ej: typedef struct task_struct_t { word pid; int priority; .... LIST_DATA(task_struct_t) runqueue; LIST_DATA(task_struct_t) zombiequeue; .... } task_struct_t;

Definition at line 22 of file list.h.

#define DEF_ALLOC (  type,
name   ) 
 

Value:

type *name;     \
        ( name = (type *) malloc(sizeof(type)) );
Define un puntero y aloca un nodo de la lista.

Definition at line 25 of file list.h.

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

Definition at line 58 of file list.h.

Referenced by actualizar_timers().

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

Definition at line 59 of file list.h.

#define LIST_ADD (  header,
list,
node   ) 
 

Value:

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;
Agrega un nodo al principio de la lista (entre el HEAD y el primero nodo que existe). Se supone que el puntero al nodo que recibe como argumento apunta a una estructura prealocada. ej: LIST_ADD(runqueue,nodo1);

Definition at line 108 of file list.h.

Referenced by cache_read(), sys_exec(), and sys_execve().

#define LIST_ADD_TAIL (  header,
list,
node   ) 
 

Value:

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;
Idem a LIST_ADD pero el nuevo nodo es insertado al final de la lista. ej: LIST_ADD_TAIL(runqueue,nodo2);

Definition at line 124 of file list.h.

Referenced by cache_read(), insert_timer(), sendrequest(), sys_exec(), sys_execve(), sys_exit_notify(), and sys_fork().

#define LIST_ATTACH (  dest,
src,
type   ) 
 

Value:

{       type *aux;                                                                                      \
        _LIST_FOREACH(ptr, src) {                       \
                aux = LIST_NEXT(src,ptr);                                                       \
                LIST_ADD_TAIL(dest,dest, ptr);  \
                ptr = aux;                                                                              \
        }                                                                                                       \
}
Pasa los nodos de una lista a otra.

Parameters:
dest header de la lista destino
src header de la lista origen
type tipo de dato que describe al nodo
Note:
La lista origen queda totalmente deshecha

Definition at line 227 of file list.h.

#define LIST_CLEAN (  header   )     LIST_INIT(header);
 

Vacia una lista, realiza esto reinicializando el header, no realiza ningun cambio en los puntero de los nodos enlazados.

Definition at line 239 of file list.h.

Referenced by cache_read().

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

Macro para permitir la inclusión de una estructura en una lista doblemente enlazada.

Al colocarlo en una estructura permite la inclusión del nodo como parte de una lista doblemente enlazada, veamos un ejemplo:

                typedef struct {
                        pid_t pid;
                        pid_t ppid;

                        ...

                        LIST_DATA(task_struct_t) runqueue;
                        LIST_DATA(task_struct_t) io_pending;
                
                } task_struct_t;

el fragmento anterior muestra como las instancias de task_struct_t pueden formar parte de dos listas.

Definition at line 52 of file list.h.

#define LIST_DEL (  header,
list,
node   ) 
 

Value:

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);
Elimina un nodo de la lista. ej: LIST_DEL(runqueue_hdr,runqueue,nodo55);

Definition at line 138 of file list.h.

Referenced by actualizar_timers(), cache_read(), endrequest(), getfreeblock(), remove_timer(), sys_exec(), sys_execve(), sys_exit_notify(), and sys_waitpid().

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

Verifica si una lista está vacía.

Parameters:
header header de la lista
Returns:
1 en caso de que esté vacía y 0 en caso contrario

Definition at line 97 of file list.h.

#define LIST_FIND (  header,
list,
var,
name,
value   )     for(var=HEADER_NEXT(header); var!=NULL && var->name!=value; var=LIST_NEXT(list,var))
 

Definition at line 217 of file list.h.

#define LIST_FIRST (  header   )     HEADER_NEXT(header)
 

Devuelve el primero nodo de la lista.

Note:
ej.: first_node = LIST_FIRST(free_list);

Definition at line 83 of file list.h.

Referenced by endrequest(), getfreeblock(), and getrequest().

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

Permite recorrer la lista de principio a fin. Utiliza como argumentos un puntero del tipo de los nodos y la lista. ej: task_struct_t *nodotmp; LIST_FOREACH(nodotmp,runqueue_hdr,runqueue) { if ( nodotmp->priority > ... ) .. ... }

Definition at line 159 of file list.h.

Referenced by cache_read(), insert_timer(), remove_timer(), show_cached_list(), sys_waitpid(), and timer_dump().

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

Idem LIST_FOREACH pero desde el fin al ppio de la lista ej: task_struct_t *nodotmp; LIST_FOREACH_REVERSE(nodotmp,runqueue_hdr,runqueue) { if ( nodotmp->priority > ... ) .. ... }

Definition at line 202 of file list.h.

#define LIST_INIT (  header   ) 
 

Value:

HEADER_NEXT(header)=NULL;               \
        HEADER_PREVIOUS(header)=NULL;

Definition at line 75 of file list.h.

Referenced by sys_exec(), sys_execve(), and sys_fork().

#define LIST_INITIALIZER   {NULL,NULL}
 

Definition at line 73 of file list.h.

Referenced by LIST_NEW().

#define LIST_INSERT_BEFORE (  header,
list,
nodebefore,
node   ) 
 

Value:

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;

Definition at line 182 of file list.h.

Referenced by insert_timer().

#define LIST_NEW (  type   ) 
 

Value:

struct {                                \
                type *next;                     \
                type *previous;         \
        }
Creacion de la lista Define la estructura que funciona como nodo HEAD ej: LIST_NEW(task_struct_t) runqueue;

Definition at line 67 of file list.h.

#define LIST_NEXT (  list,
node   )     ((node->list).next)
 

Definition at line 55 of file list.h.

Referenced by actualizar_timers(), and sys_exit_notify().

#define LIST_PREVIOUS (  list,
node   )     ((node->list).previous)
 

Definition at line 56 of file list.h.

#define LIST_REPLACE (  list,
original,
replace   ) 
 

Value:

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;

Definition at line 242 of file list.h.

#define LIST_TAIL (  header   )     HEADER_PREVIOUS(header)
 

Devuelve el último nodo de la lista.

Definition at line 88 of file list.h.

Generated on Sun May 30 18:38:36 2004 for Routix OS by doxygen 1.3.6