Se hace una prueba del parser_equation() y se corrigen varios bugs.

[z.facultad/75.42/calculadora.git] / dllist.c

diff --git a/dllist.c b/dllist.c
index 20f45c6896342d615fbe4fb2ca1ad90f7497b439..8b427dcb2724653c5c8d1792ca43f2f77c7b234a 100644 (file)
--- a/dllist.c
+++ b/dllist.c
@@ -18,19 +18,29 @@
 /* Para usar NULL, malloc() y free(). */
 #include <stdlib.h>
 
 /* Para usar NULL, malloc() y free(). */
 #include <stdlib.h>
 

-bool DLList_init(DLList* list) {
+DLList* DLList_new(void) {

     /* Aloco memoria para la lista. */
     /* Aloco memoria para la lista. */

-    /*list = (DLList*)malloc(sizeof(DLList));*/
-    /* Si la obtuve, inicializo todo a NULL y devuelvo TRUE. */
+    DLList* list = (DLList*)malloc(sizeof(DLList));
+    /* Si la obtuve, inicializo todo a NULL. */

     if (list) {
         list->first   = NULL;
         list->current = NULL;
         list->last    = NULL;
     if (list) {
         list->first   = NULL;
         list->current = NULL;
         list->last    = NULL;

-        return TRUE;
-    /* Si no hay más memoria devuelvo FALSE. */
-    } else {
-        return FALSE;

     }
     }

+    /* Devuelvo el nuevo puntero. */
+    return list;
+}
+
+void DLList_delete(DLList* list) {
+    /* Si el puntero a la lista no es NULL. */
+    if (list) {
+        /* Elimino los nodos. */
+        while (!DLList_empty(list)) {
+            DLList_pop(list);
+        }
+    }
+    /* Libero memoria de la lista. */
+    free(list);

 }
 
 bool DLList_empty(DLList* list) {
 }
 
 bool DLList_empty(DLList* list) {


@@ -177,3 +187,31 @@ void* DLList_pop(DLList* list) {
     return data;
 }
 
     return data;
 }
 

+void* DLList_remove_current(DLList* list) {
+    /* Nodo actual */
+    DLNode* current = list->current;
+    /* Datos del nodo actual. */
+    void* data = current->data;
+    /* Si tiene siguiente. */
+    if (current->next) {
+        /* Se pone como anterior del siguiente al anterior del actual. */
+        current->next->prev = current->prev;
+    /* Si no tiene siguiente, se pone como último al anterior del actual. */
+    } else {
+        list->last = current->prev;
+    }
+    /* Si tiene anterior. */
+    if (current->prev) {
+        /* Se pone como siguiente del anterior al siguiente del actual. */
+        current->prev->next = current->next;
+    /* Si no tiene anterior, se pone como primero al siguiente del actual. */
+    } else {
+        list->first = current->next;
+    }
+    /* Pongo como elemento actual al próximo elemento. */
+    list->current = current->next;
+    /* Libero memoria del nodo. */
+    free(current);
+    return data;
+}
+