ajout makefile

Corto Callerisa
1 parent f05507c0
Showing 6 changed files with 217 additions and 43 deletions Show diff stats
Makefile
correcteur
correcteur.o
dictionnaire.c
dictionnaire.h
dictionnaire.o
@@ -0,0 +1,33 @@
+#
+# Makefile - Project de Programmation Avancee IMA3 : Correcteur Orthographique
+
+# compilateur
+CC = clang
+
+# "drapeau" en paramètres
+# ajouter "-O0" si besoin d'utiliser valgrind
+# -ggdb3 pour les information de debugging
+CFLAGS = -ggdb3 -O0 -Wall -Werror
+
+# Nom de l'executable
+EXE = correcteur
+
+# Liste des headers
+HDRS = dictionnaire.h
+
+# Liste des sources
+SRCS = correcteur.c dictionnaire.c
+
+# Generation automatique des .o
+OBJS = $(SRCS:.c=.o)
+
+# Commande de compilation
+$(EXE): $(OBJS) $(HDRS) Makefile
+	$(CC) $(CFLAGS) -o $@ $(OBJS)
+
+# dependances
+$(OBJS): $(HDRS) Makefile
+
+# nettoyage
+clean:
+	rm -f core $(EXE) *.o
+/**
+ * dictionnaire.c
+ *
+ * Implémente l'importation et la libération d'un dictionnaire en mémoire
+ * depuis un fichier texte.
+ */
  
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
+/* ctype.h pour les fonctions isalpha, tolower, isdigit et isspace */
 #include <ctype.h>
 #include <string.h>
  
+#include "dictionnaire.h"
  
-Noeud *racine;
-
-long fileSize;
  
  
-unsigned int nbr_mots;
+/* Variables globales */
  
+// Declaration du Noeud racine
+Noeud *racine;
  
+// Déclaration de reserve_noeud : permet d'allouer la taile du dictionnaire en une fois, simplifie la gestion
+// mémoire.
 Noeud *reserve_noeuds;
  
+// Déclaration du compteur de nombre de mots dans le dictionnaire.
+// Est utilise par la fonction taille_dic().
+unsigned int nbr_mots;
+
+// Variable global permettant de construire une  reserve de noeuds.
+// Type "long" pour ne pas être limité.
+long taille_fic;
  
-bool appartient(const char *mot)
+/**
+ * Teste si un mot appartient au dictionnaire.
+ * Retourne True si le mot est dans le dictionaire ou False sinon
+ */
+bool appartient(const char *mot) // Const pour que mot soit en lecture seule, il n'y a pas besoin de le modifier
 {
-    
-    Noeud *trav = NULL;
+    // Déclaration du pointeur parcourant le trie et initialisation a NULL
+    Noeud *nd_parcours_tmp = NULL;
  
-    
-    trav = racine;
+    // Fais pointer nd_parcours_tmp sur la racine
+    // Pour chaque nouveau nd_parcours_tmp pointe sur la racine pour verifier le mot
+    nd_parcours_tmp = racine;
  
-    
+    // Variable pour iterer char par char dans un mot
     int i = 0;
  
-    
+    // Vérifie que le le mot entré correspond à un parcours de l'arbre se terminant par mot_fini = True
     while (mot[i] != '\0') {
+        // On convertit le mot en minuscule pour se préoccuper uniquement de l'orthographe
+        char c;
+        if (isalpha(mot[i])) {
+            c = tolower(mot[i]);
+        } else {
+            c = mot[i];
+        }
  
-        char c = tolower(mot[i]);
-
-        if (isalpha(c)) {
+        // Gestion de l'apostrophe
+        if (c == '\'') {
+            // On regarde s'il existe un mot comprenant l'apostrophe, sinon le mot n'appartient pas au dico
+            if (nd_parcours_tmp->enfants[NB_CARAC - 1] == NULL) {
+                return false;
+            }
+            // Sinon on continue le parcours en allant au noeud suivant
+            nd_parcours_tmp = nd_parcours_tmp->enfants[NB_CARAC - 1];
+        }
  
-            if (trav->enfants[c - 'a'] == NULL) {
+        // Gestion des lettres
+        else if (isalpha(c)) {
+            // Verifie que le parcours correspondant au lettres du mot existe jusqu'ici.
+            // Retourne False si ce n'est pas le cas.
+            if (nd_parcours_tmp->enfants[c - 'a'] == NULL) {
                 return false;
             }
-            trav = trav->enfants[c - 'a'];
+            // Sinon on passe à la lettre suivante dans le dico
+            nd_parcours_tmp = nd_parcours_tmp->enfants[c - 'a'];
         }
+        // On avance dans le mot à vérifier
         i++;
     }
-    return trav->mot_fini;
+
+    // Retourne True si le mot existe dans le dictionnaire
+    return nd_parcours_tmp->mot_fini;
 }
  
-bool charger_dict(const char *dictionary)
+/**
+ * Importe le dictionnaire en mémoire.
+ * Retourne True en cas de succes et False sinon.
+ */
+bool importer_dict(const char *nom_dic)
 {
+    // Ouvre le fichier du dictionnaire
+    // 'b' permet d'avoir un stream de byte et non l'interpretation des caractères d'indentation en fonction du système.
+    // Cela garantie que fseek determine correctement la taille du fichier.
+    FILE *dict = fopen(nom_dic, "rb");
  
-    FILE *dict = fopen(dictionary, "rb");
-
+    // Erreur sur le fichier?
     if (dict == false) {
-        printf("Could not open this dictionary (dictionary.c file)");
+        printf("Impossible d'ouvrir le fichier (dictionnaire.c)");
         return false;
     }
  
+    // Determination de la taille_dic du fichier (en bytes)
     fseek(dict, 0, SEEK_END);
-    fileSize = ftell(dict);
+    taille_fic = ftell(dict);
  
+    // Remise du pointeur de fichier au debut
     fseek(dict, 0, SEEK_SET);
  
-    reserve_noeuds = calloc((fileSize), sizeof(Noeud));
+    // Initalise reserve_noeuds avec suffisament de mémoire pour différents dictionnaires
+    reserve_noeuds = calloc(taille_fic, sizeof(Noeud));
  
-    Noeud *nextFreeNode = reserve_noeuds;
+    // Premier Noeud du dictionnaire
+    Noeud *prochain_noeud_vide = reserve_noeuds;
  
-    char *buffer = malloc(fileSize + 1);
-    fread(buffer, 1, fileSize, dict);
+    // On transfère le fichier depuis un stream dans un tableau
+    char *buffer = malloc(taille_fic); // +1 pour le caractere de terminaison
+    fread(buffer, 1, taille_fic, dict);
  
-    buffer[fileSize] = '\0';
+    // Marque la fin du fichier
+    buffer[taille_fic] = '\0';
  
-    racine = nextFreeNode + 1;
+    // Initialisation du Noeud racine du trie
+    racine = prochain_noeud_vide + 1;
  
-    Noeud *trav = NULL;
+    // Déclare et initialise le pointeur sur le Noeud courant
+    Noeud *nd_courant = NULL;
  
-    char *words = buffer;
+    // Nouveau string permettant de charger les mots dans le trie
+    char *mots_fichier = buffer;
  
+    // Initialise le compteur pour la fonction taille()
     nbr_mots = 0;
  
-    while (*words) {
-       
-        trav = racine;
+    // On boucle tant que le caractere n'est pas  '\0' ou 'NULL'
+    while (*mots_fichier) {
+        // Départ du Noeud racine pour chaque mot
+        nd_courant = racine;
+
+        // Insère les mot dans l'espace mémoire pré-allouée.
+        // Si le char est un saut de ligne le mot est terminé fin d'un mot
+        for (; *mots_fichier != '\n' && *mots_fichier; mots_fichier++) {
+            // Gestion des mots avec apostrophe
+            if (*mots_fichier == '\'') {
+                // Si le mot avec apostrophe n'existe pas, on l'ajoute
+                if (nd_courant->enfants[NB_CARAC - 1] == NULL) {
+                    nd_courant->enfants[NB_CARAC - 1] = prochain_noeud_vide++;
+                }
+                // Passage au noeud suivant
+                nd_courant = nd_courant->enfants[NB_CARAC - 1];
+            }
  
-        for (; *words != '\n' && *words; words++) {
-         
+            // Gestion des lettres
             else {
-                if (trav->enfants[*words - 'a'] == NULL) {
-                    trav->enfants[*words - 'a'] = nextFreeNode++;
+                // Si le mot n'existe pas, on l'ajoute en prenant le prochain noeud dans la réserve
+                if (nd_courant->enfants[*mots_fichier - 'a'] == NULL) {
+                    nd_courant->enfants[*mots_fichier - 'a'] = prochain_noeud_vide++;
                 }
-
-                trav = trav->enfants[*words - 'a'];
+                // Passage au noeud suivant
+                nd_courant = nd_courant->enfants[*mots_fichier - 'a'];
             }
         }
  
-        trav->mot_fini = true;
+        // On est arrivé sur '\n' donc le mot est fini
+        nd_courant->mot_fini = true;
+        // Un mot de plus dans le dico
         nbr_mots++;
  
-        if (*words == '\n') {
-            words++;
+        // On absorbe le saut de ligne
+        if (*mots_fichier == '\n') {
+            mots_fichier++;
         }
     }
  
+    // Fermeture proprement du fichier et libération de la mémoire
     fclose(dict);
     free(buffer);
  
+    // Chargement avec succès
     return true;
 }
  
-unsigned int taille()
+/**
+ * Retourne le nombre de mot dans un dictionnaire (0 si non chargé)
+ */
+unsigned int taille_dic()
 {
+    // Déjà calculée lors l'importation du dictionnaire
     return nbr_mots;
 }
  
+/**
+ * Libération du dictionnaire en mémoire.
+ * Retourne true en cas de succès et false sinon.
+ */
 bool decharger()
 {
+    // Avantage de l'appel unique à calloc :
+    // Un seul appel à free est nécéssaire !
     free(reserve_noeuds);
+    // Libération mémoire avec succès
     return true;
 }
@@ -0,0 +1,52 @@
+/**
+ * dict.h
+ *
+ * Declaration des fonctions de manipulation d'un dictionnaire
+ */
+
+#ifndef DICT_H
+#define DICT_H
+
+#include <stdbool.h>
+
+#define NB_CARAC 27 // TODO 27 si gestion de l'apostrophe
+
+/*
+ * La structure principale du programme est un trie ou chaque Noeud possède jusqu'a
+ * 26 enfants ainsi qu'un booleen indiquant si le noeud termine un mot valide.
+ */
+typedef struct Noeud {
+    bool mot_fini;
+    struct Noeud *enfants[NB_CARAC];
+} Noeud;
+
+// Longueur maximum d'un mot :
+// Ex peur des mots long = Hippopotomonstrosesquippedaliophobie, 36 Lettres
+#define LONG_MAX 36
+
+/*
+ * Retourne True si le mot est dans le dictionnaire, False sinon.
+ */
+bool appartient(const char *mot);
+
+/*
+ * Charge le dictionnaire, retourne True si le dictionnaire est charge, False sinon
+ */
+bool importer_dict(const char *nom_dic);
+
+/*
+ * Retourne le nombre de mots d'un dictionnaire.
+ */
+unsigned int taille_dic(void);
+
+/*
+ * Quitte le dictionnaire, retourne True si le dictionnaire est quitte, False sinon
+ */
+bool decharger(void);
+
+/*
+ * Affiche les mots mal orthographies dans le fichier
+ */
+void print_erreurs(FILE *fp, int *malorthographies, int *mots);
+
+#endif