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

#define nil NULL // pour faire plus lisp

typedef char * str ;
typedef struct node { str car ; struct node * cdr ; } node, * list ;

void putlist(list L);
list cons(str car, list L);
void usage(str message);
int length(list L);
int decons(list L, str *tablChaine);
void affChaine(str * tablChaine);

// Ce programme crée d'abord une liste L à partir du tableau code (fonction cons),
// ensuite affiche la liste L (dans l'ordre inverse) grace à putList,
// puis transcrit la liste L dans un nouveau tableau tablChaine (fonction decons),
// et finalement affiche le  nouveau tableau tablChaine (fonction affChaine).
// Le programme est écrit pour s'adapter à la taille du tableau code (affecté au début du programme),
// même la taile de tablChaine pour laquelle de la mémoire est alloué dynamiquement
// en fonction de la taille de la liste + 1 pour le nil final (30 pour les plus longs mots en français, voir wikipedia).
// A ma grande surprise, si j'alloue 0 en mémoire à la place de lon * sizeof(char *) et 30 * sizeof(char)
// le programme tourne toujours !!!

int main(){
    int k=0;
    list L = nil ;
    printf("%ld\n", sizeof(node));
    char * code[]={"papa", "alpha", "zulu", "hotel", "charlie", "bay", nil};
    while (code[k]) L = cons(code[k++], L) ;
    putlist(L) ;
    int lon= length(L)+1;
    str *tablChaine= malloc(0);    //lon* sizeof(char *)
    for(int i=0; i<lon; i++) tablChaine[i] = malloc(0); // 30 * sizeof(char)
    decons(L,tablChaine);
    printf("\n");
    affChaine(tablChaine);
    return 0 ;
}

list cons(str car, list L){
    list new = malloc(sizeof(node)) ;
    if (! new) usage("cons : manque de RAM") ; // enfin, un peu de sérieux !
    new -> car = car ;
    new -> cdr = L ;
    return new ;
}

void putlist(list L){
    if (! L) return ; // nil : fin de liste
    putlist(L -> cdr) ;
    printf("%s ", L -> car) ;
}

// une version recursive de length
int length(list L){
    if (! L) return 0;
    else return (1+length(L -> cdr));
}

// decons() remplit le tableau tablChaine à partir de la liste L en ordre inverse
// la fin du tableau est marquée par nil, j'utilise une liste auxiliaire new
// comme dans la fonction cons
// Pareil ici si je fais malloc(0) le programme tourne toujours ???!!!
int decons(list L, str *tablChaine){
    list new =malloc(sizeof(node)) ;
    if (! new) usage("cons : manque de RAM") ; // enfin, un peu de sérieux !
    new=L;
    int lon = length(L);
    for (int i=lon-1; i>=0; i--) {
        tablChaine[i] =new->car;
        new=new->cdr;
    }
    tablChaine[lon] =nil;
    return 0;
}

// Affiche un tableau de chaines qui se termine par nil
void affChaine(str * tablChaine){
    int i=0;
    while(tablChaine[i]) printf(" %s ",  tablChaine[i++]);
}

void usage(str message) { fprintf(stderr, "%s\n", message) ; exit(1) ; }