Correction des indentations (tabulations -> espaces)

include/huftree.h

@@ -8,20 +8,20 @@
  */
 typedef struct HufVertex HufVertex;
 struct HufVertex {
-	// Indique la fréquence d'apparition de la lettre du sommet
-	// dans le corpus original, ou bien la somme des fréquences
-	// de ses enfants (si ce n'est pas une feuille)
-	double frequency;
+    // Indique la fréquence d'apparition de la lettre du sommet
+    // dans le corpus original, ou bien la somme des fréquences
+    // de ses enfants (si ce n'est pas une feuille)
+    double frequency;
 
-	// Caractère du corpus original associé à ce sommet. Uniquement
-	// valable pour les feuilles. Pour les autres sommets, la valeur
-	// de (character) n'est pas garantie
-	char character;
+    // Caractère du corpus original associé à ce sommet. Uniquement
+    // valable pour les feuilles. Pour les autres sommets, la valeur
+    // de (character) n'est pas garantie
+    char character;
 
-	// Pointeurs vers les deux enfants de ce sommet. Ils valent tous
-	// deux NULL si le sommet est une feuille. À noter qu'un sommet
-	// a toujours 0 ou 2 enfants car un arbre de Huffman est binaire
-	HufVertex *child_l, *child_r;
+    // Pointeurs vers les deux enfants de ce sommet. Ils valent tous
+    // deux NULL si le sommet est une feuille. À noter qu'un sommet
+    // a toujours 0 ou 2 enfants car un arbre de Huffman est binaire
+    HufVertex *child_l, *child_r;
 };
 
 /**
@@ -29,11 +29,11 @@ struct HufVertex {
  */
 typedef struct HufTree HufTree;
 struct HufTree {
-	// Pointeur sur la racine de l'arbre
-	HufVertex *root;
+    // Pointeur sur la racine de l'arbre
+    HufVertex *root;
 
-	// Quantité de sommets dans l'arbre
-	size_t size;
+    // Quantité de sommets dans l'arbre
+    size_t size;
 };
 
 /**

src/compress.c

@@ -15,42 +15,42 @@
 static double* _createFrequencies(const char*);
 
 double* _createFrequencies(const char *filepath) {
-	double *frequencies = malloc(NUM_CHARS * sizeof(*frequencies));
-	int totalChars = 0;
+    double *frequencies = malloc(NUM_CHARS * sizeof(*frequencies));
+    int totalChars = 0;
 
-	for (size_t i = 0; i < NUM_CHARS; i++) {
-		frequencies[i] = 0;
-	}
+    for (size_t i = 0; i < NUM_CHARS; i++) {
+        frequencies[i] = 0;
+    }
 
-	// Ouverture du fichier en lecture seule, et comptage
-	// des occurences de chaque caractère ASCII ainsi que
-	// du nombre total de caractères
-	FILE *file = fopen(filepath, "r");
+    // Ouverture du fichier en lecture seule, et comptage
+    // des occurences de chaque caractère ASCII ainsi que
+    // du nombre total de caractères
+    FILE *file = fopen(filepath, "r");
 
     if (file == NULL) {
         fprintf(
             stderr, "Impossible d'ouvrir '%s' : %s\n",
             filepath, strerror(errno)
         );
-        
+
         exit(1);
     }
 
-	char current;
+    char current;
 
-	while ((current = fgetc(file)) != EOF) {
-		frequencies[(size_t) current]++;
-		totalChars++;
-	}
+    while ((current = fgetc(file)) != EOF) {
+        frequencies[(size_t) current]++;
+        totalChars++;
+    }
 
-	fclose(file);
+    fclose(file);
 
-	// Conversion des effectifs des caractères en fréquences
-	for (size_t i = 0; i < NUM_CHARS; i++) {
-		frequencies[i] /= totalChars;
-	}
+    // Conversion des effectifs des caractères en fréquences
+    for (size_t i = 0; i < NUM_CHARS; i++) {
+        frequencies[i] /= totalChars;
+    }
 
-	return frequencies;
+    return frequencies;
 }
 
 void compress(const char *filepath) {
@@ -62,17 +62,17 @@ void compress(const char *filepath) {
     }
 
     printVerbose("\nConstruction de l'arbre de Huffman\n");
-	HufTree tree = createTree(frequencies);
+    HufTree tree = createTree(frequencies);
 
     free(frequencies);
     frequencies = NULL;
 
-	if (isVerbose()) {
-		printTree(tree);
-	}
+    if (isVerbose()) {
+        printTree(tree);
+    }
 
     printVerbose("\nÉtiquetage des feuilles de l'arbre\n");
-	char** labels = createTreeLabels(tree);
+    char** labels = createTreeLabels(tree);
 
     freeTree(tree);
 
@@ -80,5 +80,5 @@ void compress(const char *filepath) {
         printLabelsTable(labels, NUM_CHARS);
     }
 
-	freeTreeLabels(labels);
+    freeTreeLabels(labels);
 }

src/display.c

@@ -26,15 +26,15 @@ void printTree(HufTree tree) {
     // Allocation d'un tampon suffisamment grand pour contenir
     // les indentations des sommets les plus profonds de l'arbre
     wchar_t *buffer = malloc(_maxDepth(*tree.root) * 4 * sizeof(*buffer));
-	_printVertex(*tree.root, buffer, 0);
+    _printVertex(*tree.root, buffer, 0);
     free(buffer);
 }
 
 void _printVertex(HufVertex vert, wchar_t *buffer, int length) {
-	if (vert.child_l != NULL && vert.child_r != NULL) {
+    if (vert.child_l != NULL && vert.child_r != NULL) {
         // Affichage d'un sommet avec enfants, on montre
         // la probabilité somme des enfants
-		printf("■\n");
+        printf("■\n");
 
         // Affichage du fils gauche. Augmentation du préfixe
         // pour l'affichage des enfants du fils gauche
@@ -55,11 +55,11 @@ void _printVertex(HufVertex vert, wchar_t *buffer, int length) {
 
         buffer[length] = ' ';
         _printVertex(*vert.child_r, buffer, length + 4);
-	} else {
+    } else {
         // Affichage d'une feuille de l'arbre, correspondant
         // à un caractère du corpus
-		printf("%c\n", _safeChar(vert.character));
-	}
+        printf("%c\n", _safeChar(vert.character));
+    }
 }
 
 int _maxDepth(HufVertex vert) {

src/huftree.c

@@ -4,30 +4,30 @@
 #include <string.h>
 
 /**
-* Trouver les deux sommets de valeur la plus faible parmi
-* tous les sommets pointés par le tableau. Place l'indice
-* du minimum dans `min` et de l'avant-dernier dans `sec`.
-*/
+ * Trouver les deux sommets de valeur la plus faible parmi
+ * tous les sommets pointés par le tableau. Place l'indice
+ * du minimum dans `min` et de l'avant-dernier dans `sec`.
+ */
 static void _findMinimalVertices(HufVertex**, size_t, size_t* min, size_t* sec);
 
 /**
-* Libérer récursivement la mémoire occupée par le sommet
-* donné ainsi que celle de tous ses enfants (s'il en a).
-*/
+ * Libérer récursivement la mémoire occupée par le sommet
+ * donné ainsi que celle de tous ses enfants (s'il en a).
+ */
 static void _freeTreeVertex(HufVertex*);
 
 /**
-* Créer une nouvelle chaîne contenant la chaîne donnée
-* suffixée du caractère donné
-*/
+ * Créer une nouvelle chaîne contenant la chaîne donnée
+ * suffixée du caractère donné
+ */
 static char* _appendToString(char*, size_t, char);
 
 /**
-* Remplit le tableau d'étiquettes données avec les étiquettes
-* des feuilles trouvées dans la sous-partie de l'arbre dont
-* le sommet donné est la racine. Toutes les étiquettes ajoutées
-* au tableau seront préfixées de la chaîne passée en paramètre
-*/
+ * Remplit le tableau d'étiquettes données avec les étiquettes
+ * des feuilles trouvées dans la sous-partie de l'arbre dont
+ * le sommet donné est la racine. Toutes les étiquettes ajoutées
+ * au tableau seront préfixées de la chaîne passée en paramètre
+ */
 static void _labelVertex(HufVertex, char**, char*, size_t);
 
 HufTree createTree(double* frequencies) {

src/main.c

@@ -36,22 +36,22 @@ static error_t parse_opt(int key, char *arg, struct argp_state *state) {
 
     switch (key) {
         case 'V':
-            args->verbose = TRUE;
-            break;
+        args->verbose = TRUE;
+        break;
 
         case ARGP_KEY_ARG:
-            // Consommation de tous les fichiers en argument
-            // et arrêt du parsage
-            args->files = &state->argv[state->next - 1];
-            state->next = state->argc;
-            break;
+        // Consommation de tous les fichiers en argument
+        // et arrêt du parsage
+        args->files = &state->argv[state->next - 1];
+        state->next = state->argc;
+        break;
 
         case ARGP_KEY_NO_ARGS:
-            argp_usage(state);
-            break;
+        argp_usage(state);
+        break;
 
         default:
-            return ARGP_ERR_UNKNOWN;
+        return ARGP_ERR_UNKNOWN;
     }
 
     return 0;