dllist.c

   1 /* vim: set et sts=4 sw=4 fdm=indent fdl=1 fdn=0 fo+=t tw=80:
   2  *
   3  * Taller de Programación (75.42).
   4  *
   5  * Ejercicio Número 2:
   6  * Programa calculadora.
   7  *
   8  * Copyleft 2003 - Leandro Lucarella <llucare@fi.uba.ar>
   9  * Puede copiar, modificar y distribuir este programa bajo los términos de
  10  * la licencia GPL (http://www.gnu.org/).
  11  *
  12  * Creado: sáb ago 30 20:34:45 ART 2003
  13  *
  14  * $Id$
  15  */
  16
  17 #include "dllist.h"
  18 /* Para usar NULL, malloc() y free(). */
  19 #include <stdlib.h>
  20
  21 bool DLList_init(DLList* list) {
  22     /* Aloco memoria para la lista. */
  23     /*list = (DLList*)malloc(sizeof(DLList));*/
  24     /* Si la obtuve, inicializo todo a NULL y devuelvo TRUE. */
  25     if (list) {
  26         list->first   = NULL;
  27         list->current = NULL;
  28         list->last    = NULL;
  29         return TRUE;
  30     /* Si no hay más memoria devuelvo FALSE. */
  31     } else {
  32         return FALSE;
  33     }
  34 }
  35
  36 bool DLList_empty(DLList* list) {
  37     return list->first == NULL;
  38 }
  39
  40 void* DLList_begin(DLList* list) {
  41     list->current = list->first;
  42     /* Si hay un nodo, devulevo sus datos, si no NULL. */
  43     return list->current ? list->current->data : NULL;
  44 }
  45
  46 void* DLList_end(DLList* list) {
  47     list->current = list->last;
  48     /* Si hay un nodo, devulevo sus datos, si no NULL. */
  49     return list->current ? list->current->data : NULL;
  50 }
  51
  52 bool DLList_have_more(DLList* list) {
  53     return list->current != NULL;
  54 }
  55
  56 void* DLList_current(DLList* list) {
  57     return list->current ? list->current->data : NULL;
  58 }
  59
  60 void* DLList_next(DLList* list) {
  61     DLNode* current = list->current;
  62     /* Si no está vacía ni ya fue terminada de recorrer. */
  63     if (current) {
  64         /* Apuntamos el actual al próximo. */
  65         list->current = current->next;
  66         /* Devolvemos los datos del próximo o NULL si no había otro. */
  67         return list->current ? list->current->data : NULL;
  68     /* Si está vacía o ya fue terminada de recorrer devolvemos NULL. */
  69     } else {
  70         return NULL;
  71     }
  72 }
  73
  74 void* DLList_prev(DLList* list) {
  75     DLNode* current = list->current;
  76     /* Si no está vacía ni ya fue terminada de recorrer. */
  77     if (current) {
  78         /* Apuntamos el actual al anterior. */
  79         list->current = current->prev;
  80         /* Devolvemos los datos del anterior o NULL si no había otro. */
  81         return list->current ? list->current->data : NULL;
  82     /* Si está vacía o ya fue terminada de recorrer devolvemos NULL. */
  83     } else {
  84         return NULL;
  85     }
  86 }
  87
  88 bool DLList_unshift(DLList* list, void* data) {
  89     DLNode* node = (DLNode*)malloc(sizeof(DLNode));
  90     /* Si obtenemos la memoria bien, actualizamos lo que sea necesario. */
  91     if (node) {
  92         /* Inicializamos el nuevo nodo. */
  93         node->prev = NULL;
  94         node->data = data;
  95         node->next = list->first;
  96         /* Apunto el nodo actual al nuevo nodo. */
  97         list->current = node;
  98         /* Si la lista está vacía hay que hacer apuntar todo al nuevo nodo. */
  99         if (list->first == NULL) {
 100             list->first = node;
 101             list->last  = node;
 102         /* Si no está vacía. */
 103         } else {
 104             /* Apunto el nodo anterior al primer nodo de la lista al nuevo. */
 105             list->first->prev = node;
 106             /* Apunto el primer nodo de la lista al nuevo. */
 107             list->first = node;
 108         }
 109     }
 110     return node ? TRUE : FALSE;
 111 }
 112
 113 bool DLList_push(DLList* list, void* data) {
 114     DLNode* node = (DLNode*)malloc(sizeof(DLNode));
 115     /* Si obtenemos la memoria bien, actualizamos lo que sea necesario. */
 116     if (node) {
 117         /* Inicializamos el nuevo nodo. */
 118         node->prev = list->last;
 119         node->data = data;
 120         node->next = NULL;
 121         /* Apunto el nodo actual al nuevo nodo. */
 122         list->current = node;
 123         /* Si la lista está vacía hay que hacer apuntar todo al nuevo nodo. */
 124         if (list->first == NULL) {
 125             list->first = node;
 126             list->last  = node;
 127         /* Si no está vacía. */
 128         } else {
 129             /* Apunto el próximo nodo del último nodo de la lista al nuevo. */
 130             list->last->next = node;
 131             /* Apunto el último nodo de la lista al nuevo. */
 132             list->last = node;
 133         }
 134     }
 135     return node ? TRUE : FALSE;
 136 }
 137
 138 void* DLList_shift(DLList* list) {
 139     /* Primer nodo */
 140     DLNode* node = list->first;
 141     /* Datos del primer nodo. */
 142     void* data = node->data;
 143     /* Pongo como primer nodo al siguiente. */
 144     list->first = node->next;
 145     /* Pongo al primero como nodo actual. */
 146     list->current = list->first;
 147     /* Si era el único pongo el último en NULL. */
 148     if (!list->first) {
 149         list->last = NULL;
 150     /* Si no, pongo el anterior en NULL. */
 151     } else {
 152         list->first->prev = NULL;
 153     }
 154     /* Libero memoria del nodo. */
 155     free(node);
 156     return data;
 157 }
 158
 159 void* DLList_pop(DLList* list) {
 160     /* Último nodo */
 161     DLNode* node = list->last;
 162     /* Datos del último nodo. */
 163     void* data = node->data;
 164     /* Pongo como último nodo al anterior. */
 165     list->last = node->prev;
 166     /* Pongo al último como nodo actual. */
 167     list->current = list->last;
 168     /* Si era el único pongo el primero en NULL. */
 169     if (!list->last) {
 170         list->first = NULL;
 171     /* Si no, pongo el siguiente en NULL. */
 172     } else {
 173         list->last->next = NULL;
 174     }
 175     /* Libero memoria del nodo. */
 176     free(node);
 177     return data;
 178 }
 179