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 #include <stdlib.h>
  19
  20 bool DLList_init(DLList* list) {
  21     /* Aloco memoria para la lista. */
  22     /*list = (DLList*)malloc(sizeof(DLList));*/
  23     /* Si la obtuve, inicializo todo a NULL y devuelvo TRUE. */
  24     if (list) {
  25         list->first      = NULL;
  26         list->current    = NULL;
  27         list->last       = NULL;
  28         return TRUE;
  29     /* Si no hay más memoria devuelvo FALSE. */
  30     } else {
  31         return FALSE;
  32     }
  33 }
  34
  35 bool DLList_empty(DLList* list) {
  36     return list->first == NULL;
  37 }
  38
  39 void* DLList_begin(DLList* list) {
  40     list->current = list->first;
  41     /* Si hay un nodo, devulevo sus datos, si no NULL. */
  42     return list->current ? list->current->data : NULL;
  43 }
  44
  45 void* DLList_end(DLList* list) {
  46     list->current = list->last;
  47     /* Si hay un nodo, devulevo sus datos, si no NULL. */
  48     return list->current ? list->current->data : NULL;
  49 }
  50
  51 bool DLList_have_more(DLList* list) {
  52     return list->current != NULL;
  53 }
  54
  55 void* DLList_current(DLList* list) {
  56     return list->current ? list->current->data : NULL;
  57 }
  58
  59 void* DLList_next(DLList* list) {
  60     DLNode* current = list->current;
  61     /* Si no está vacía ni ya fue terminada de recorrer. */
  62     if (current) {
  63         /* Apuntamos el actual al próximo. */
  64         list->current = current->next;
  65         /* Devolvemos los datos del próximo o NULL si no había otro. */
  66         return list->current ? list->current->data : NULL;
  67     /* Si está vacía o ya fue terminada de recorrer devolvemos NULL. */
  68     } else {
  69         return NULL;
  70     }
  71 }
  72
  73 void* DLList_prev(DLList* list) {
  74     DLNode* current = list->current;
  75     /* Si no está vacía ni ya fue terminada de recorrer. */
  76     if (current) {
  77         /* Apuntamos el actual al anterior. */
  78         list->current = current->prev;
  79         /* Devolvemos los datos del anterior o NULL si no había otro. */
  80         return list->current ? list->current->data : NULL;
  81     /* Si está vacía o ya fue terminada de recorrer devolvemos NULL. */
  82     } else {
  83         return NULL;
  84     }
  85 }
  86
  87 bool DLList_unshift(DLList* list, void* data) {
  88     DLNode* node = (DLNode*)malloc(sizeof(DLNode));
  89     /* Si obtenemos la memoria bien, actualizamos lo que sea necesario. */
  90     if (node) {
  91         /* Inicializamos el nuevo nodo. */
  92         node->prev = NULL;
  93         node->data = data;
  94         node->next = list->first;
  95         /* Apunto el nodo actual al nuevo nodo. */
  96         list->current = node;
  97         /* Si la lista está vacía hay que hacer apuntar todo al nuevo nodo. */
  98         if (list->first == NULL) {
  99             list->first   = node;
 100             list->last    = node;
 101         /* Si no está vacía. */
 102         } else {
 103             /* Apunto el nodo anterior al primer nodo de la lista al nuevo. */
 104             list->first->prev = node;
 105             /* Apunto el primer nodo de la lista al nuevo. */
 106             list->first = node;
 107         }
 108     }
 109     return node ? TRUE : FALSE;
 110 }
 111
 112 bool DLList_push(DLList* list, void* data) {
 113     DLNode* node = (DLNode*)malloc(sizeof(DLNode));
 114     /* Si obtenemos la memoria bien, actualizamos lo que sea necesario. */
 115     if (node) {
 116         /* Inicializamos el nuevo nodo. */
 117         node->prev = list->last;
 118         node->data = data;
 119         node->next = NULL;
 120         /* Apunto el nodo actual al nuevo nodo. */
 121         list->current = node;
 122         /* Si la lista está vacía hay que hacer apuntar todo al nuevo nodo. */
 123         if (list->first == NULL) {
 124             list->first   = node;
 125             list->last    = node;
 126         /* Si no está vacía. */
 127         } else {
 128             /* Apunto el próximo nodo del último nodo de la lista al nuevo. */
 129             list->last->next = node;
 130             /* Apunto el último nodo de la lista al nuevo. */
 131             list->last = node;
 132         }
 133     }
 134     return node ? TRUE : FALSE;
 135 }
 136
 137 void* DLList_shift(DLList* list) {
 138     /* Primer nodo */
 139     DLNode* node = list->first;
 140     /* Datos del primer nodo. */
 141     void* data = node->data;
 142     /* Pongo como primer nodo al siguiente. */
 143     list->first = node->next;
 144     /* Pongo al primero como nodo actual. */
 145     list->current = list->first;
 146     /* Si era el único pongo el último en NULL. */
 147     if (!list->first) {
 148         list->last = NULL;
 149     /* Si no, pongo el anterior en NULL. */
 150     } else {
 151         list->first->prev = NULL;
 152     }
 153     /* Libero memoria del nodo. */
 154     free(node);
 155     return data;
 156 }
 157
 158 void* DLList_pop(DLList* list) {
 159     /* Último nodo */
 160     DLNode* node = list->last;
 161     /* Datos del último nodo. */
 162     void* data = node->data;
 163     /* Pongo como último nodo al anterior. */
 164     list->last = node->prev;
 165     /* Pongo al último como nodo actual. */
 166     list->current = list->last;
 167     /* Si era el único pongo el primero en NULL. */
 168     if (!list->last) {
 169         list->first = NULL;
 170     /* Si no, pongo el siguiente en NULL. */
 171     } else {
 172         list->last->next = NULL;
 173     }
 174     /* Libero memoria del nodo. */
 175     free(node);
 176     return data;
 177 }
 178