list.c

#include "list.h"
#include <stdlib.h>
#include <stdio.h>

int get_val(node_t* nodo){
    if(nodo == NULL)
        exit(-20);
    return nodo->val;
}
int init_list(list_t *L){
    if(L == NULL)
        return -1;

    L->head = L->tail = NULL;
    return 0;
}

int empty(list_t* L){
    if(L == NULL)
        return -1;

    return (L->head == NULL);
}

node_t* head(list_t* L){
    if(L == NULL)
        return NULL;

    return L->head;
}

node_t* tail(list_t* L){
    if(L == NULL)
        return NULL;

    return L->tail;
}

node_t* next(node_t* nodo){
    if(nodo == NULL)
        return NULL;

    return nodo->next;
}

node_t* prev(list_t* L, node_t* nodo){
    if(L == NULL){
        // termino prima che tu possa generare SEGFAULT
        exit(-1); //return NULL;  // settare errno in maniera opportuna, avrebbe senso terminare -> codice compromesso
    }

    if(nodo == NULL)
        return L->tail;

    node_t *p = L->head;
    node_t *prev = NULL;

    while( (p != nodo) && (p != NULL) ){
        prev = p;
        p = p->next;
    }

    return p==NULL? p : prev; // l'unico caso in cui p == NULL è quando non c'è
                              // il nodo(nodo == NULL gestito a parte)
                              // anche quando la lista è vuota
}


node_t* insert(list_t* L, node_t* nodo, int val){
    if(L == NULL)
        exit(-1);

    node_t *new_nodo = malloc(sizeof(*new_nodo));
    if(new_nodo == NULL)
        return NULL;

    new_nodo->val = val;
    new_nodo->next = NULL;
    if(head(L) == NULL){
        L->head = L->tail = new_nodo;
    }

    else if(nodo == NULL){ // sta inserendo in testa
        new_nodo->next = L->head;
        L->head = new_nodo;
    }
    else{
        new_nodo->next = nodo->next;
        nodo->next = new_nodo;
    }

    if(tail(L) == nodo){
        L->tail = new_nodo;
    }


    return new_nodo;
}


node_t *delete(list_t *L, node_t* nodo){
    if(L == NULL)
        exit(-1);

    if(empty(L))
        return NULL;

    if(nodo == NULL)
        return NULL; // dovresti settare errno

    // la lista è valida e pure il nodo

    node_t* prec = prev(L, nodo); // mi ricavo il precedente
    if(nodo == head(L)){
        L->head = L->head->next;
    }

    else{
        if(prec == NULL) // avendo escluso gli altri, l'unico caso è che il nodo non c'è
            return NULL;

        prec->next = nodo->next;
    }

    if(nodo == tail(L))
        L->tail = prec;


    free(nodo);

    return prec; // NULL solo se nodo == head
}

void print_list(list_t* L){
    if(L == NULL){
        printf("Lista nulla!\n");
        return;
    }

    if(empty(L)){
        printf("Lista vuota!\n");
        return;
    }

    node_t *p = L->head;
    while(p != NULL){
        printf("|%d|->", p->val);
        p = p->next;
    }
    puts("NULL");

    return;
}