harmonize variable names

arbre.c

@@ -33,20 +33,20 @@ int listeVersArbre(Liste *liste) {
     return nombreLettresDansFichier;
 }
 
-void assignationCode(Arbre arbre, int codeActuel, int longueur, Entete *lettresListe, int *i, int *longueurTotale) {
+void assignationCode(Arbre arbre, int codeActuel, int longueur, Entete *enteteListe, int *i, int *longueurTotale) {
     if (arbre->lettre != '\0') { // si c'est une lettre qu'on regarde
-        lettresListe[*i].lettre = arbre->lettre; // ajout de la lettre
+        enteteListe[*i].lettre = arbre->lettre; // ajout de la lettre
-        lettresListe[*i].code = codeActuel; // assignation de son code
+        enteteListe[*i].code = codeActuel; // assignation de son code
-        lettresListe[*i].longueur = longueur; // longueur du code (ex: 1001 est de taille 4)
+        enteteListe[*i].longueur = longueur; // longueur du code (ex: 1001 est de taille 4)
 
         *i += 1; // on incrémente de 1
         *longueurTotale += longueur * arbre->frequence; // incrémente la taille du code à la taille totale finale
     } else { // si c'est une "mini-racine"
         longueur++;
         codeActuel <<= 1; // décalage de bit vers la gauche
-        assignationCode(arbre->gauche, codeActuel, longueur, lettresListe, i, longueurTotale); // appel récursif arbre de gauche
+        assignationCode(arbre->gauche, codeActuel, longueur, enteteListe, i, longueurTotale); // appel récursif arbre de gauche
         codeActuel |= 1; // copie de bit si nécessaire (porte ou)
-        assignationCode(arbre->droite, codeActuel, longueur, lettresListe, i, longueurTotale); // appel récursif arbre de droite
+        assignationCode(arbre->droite, codeActuel, longueur, enteteListe, i, longueurTotale); // appel récursif arbre de droite
     }
 }
 
@@ -61,16 +61,16 @@ void freeArbre(Arbre arbre) {
 }
 
 Entete *arbreVersListe(Arbre arbre, int taille, int *tailleTotale) {
-    Entete *lettres;
+    Entete *enteteListe;
-    if ((lettres = (Entete*)malloc(taille * sizeof(Entete))) == NULL) { // on alloue la liste qui va contenir nos caractères
+    if ((enteteListe = (Entete*)malloc(taille * sizeof(Entete))) == NULL) { // on alloue la liste qui va contenir nos caractères
         printf("Impossible d'allouer de la mémoire supplémentaire (arbreVersListe).\n"); // gestion de l'erreur
         exit(1);
     }
     int i = 0; // initialisation de `i` au début car `assignationCode` est récursif
-    assignationCode(arbre, '\0', 0, lettres, &i, tailleTotale); // on commence avec une racine nulle et une taille de 0
+    assignationCode(arbre, '\0', 0, enteteListe, &i, tailleTotale); // on commence avec une racine nulle et une taille de 0
     freeArbre(arbre);
 
-    return lettres;
+    return enteteListe;
 }
 
 Entete *fichierVersListe(FILE *fichier, int *nombreLettresDansFichier, int *tailleTotale) {
@@ -89,16 +89,15 @@ Entete *fichierVersListe(FILE *fichier, int *nombreLettresDansFichier, int *tail
 }
 
 void compression(FILE *entree, FILE *sortie) {
-    /* fclose temporaire pour supprimer les warnings */
     int nombreLettresDansFichier; // initialisé par `listeVersArbre`
     int tailleTotale = 0; // taille totale en en bit du fichier en sortie
-    Entete *entete = fichierVersListe(entree, &nombreLettresDansFichier, &tailleTotale);
+    Entete *enteteListe = fichierVersListe(entree, &nombreLettresDansFichier, &tailleTotale);
 
     // On écrit l'entête du fichier avec la table complète des correspondances
-    enteteVersFichier(entete, nombreLettresDansFichier, tailleTotale, sortie);
+    enteteVersFichier(enteteListe, nombreLettresDansFichier, tailleTotale, sortie);
 
     // On écrit les données huffman-isée dans le fichier
-    huffmanVersFichier(entree, sortie, entete, nombreLettresDansFichier);
+    huffmanVersFichier(entree, sortie, enteteListe, nombreLettresDansFichier);
 }
 
 void decompression(FILE *entree, FILE *sortie) {

arbre.h

@@ -37,7 +37,7 @@ void decompression(FILE *entree, FILE *sortie);
     J'essaie de favoriser l'utilisation de pointeur pour éviter de recopier plus fois la même chose en mémoire.
     Parcours prefixé de l'arbre.
 */
-void assignationCode(Arbre arbre, int codeActuel, int longueur, Entete *lettresListe, int *i, int *longueurTotale);
+void assignationCode(Arbre arbre, int codeActuel, int longueur, Entete *enteteListe, int *i, int *longueurTotale);
 
 // Convertis un arbre (struct Arbre/Liste) en liste (struct Entete).
 Entete *arbreVersListe(Arbre arbre, int taille, int *tailleTotale);
@@ -46,9 +46,9 @@ Entete *arbreVersListe(Arbre arbre, int taille, int *tailleTotale);
 Entete *fichierVersListe(FILE *fichier, int *nombreLettresDansFichier, int *tailleTotale);
 
 // Écrit l'entête avec la table de Huffman dans le fichier.
-void enteteVersFichier(Entete *lettres, int nombreLettresDansFichier, int longueurTotale, FILE *fichier);
+void enteteVersFichier(Entete *enteteListe, int nombreLettresDansFichier, int longueurTotale, FILE *fichier);
 
 // Écrit les données une fois traduite après l'algorithme de Huffman dans le fichier de sortie.
-void huffmanVersFichier(FILE *entree, FILE *sortie, Entete *listeLettres, int nombreLettresDansFichier);
+void huffmanVersFichier(FILE *entree, FILE *sortie, Entete *enteteListe, int nombreLettresDansFichier);
 
 #endif