sdardenn · sdardenn · sdardenn · sdardenn · sdardenn · sdardenn
Showing 8 changed files Show diff stats
Makefile
correcteur
correcteur.c
correcteur.o
dictionnaire.c
dictionnaire.h
dictionnaire.o
remarques.txt
@@ -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
 \ No newline at end of file
@@ -0,0 +1,155 @@
+/**
+ * correcteur.c
+ *
+ *
+ */
+
+#include <ctype.h>
+
+#include <stdio.h>
+#include <stdbool.h>
+// Permet d'utiliser EXIT_FAILURE et non exit(1)
+// EXIT_FAILURE est plus portable
+#include <stdlib.h>
+
+#include "dictionnaire.h"
+
+// Choix du dictionnaire par default
+#define DICTIONNAIRE_DEF "words"
+
+int main(int argc, char* argv[])
+{
+    // Verification du nombre d'arguments
+    if (argc != 2 && argc != 3)
+    {
+        printf("Utilisation: correcteur [fichier_dictionnaire] texte\n");
+        return EXIT_FAILURE;
+    }
+
+    // Determine le dictionnaire à utiliser
+    char* nom_dict = (argc == 3) ? argv[1] : DICTIONNAIRE_DEF;
+
+    // Charge le dictionnaire
+    bool est_charge = importer_dict(nom_dict);
+
+
+    // Verification de l'importation du dictionnaire
+    if (!est_charge)
+    {
+        printf("Erreur lors de l'importation du dictionnaire %s.\n", nom_dict);
+        return EXIT_FAILURE;
+    }
+
+
+    // Ouverture du texte
+    char* text = (argc == 3) ? argv[2] : argv[1];
+    FILE* fp = fopen(text, "r");
+    // Vérifie si l'ouverture est possible
+    if (fp == NULL)
+    {
+        printf("Erreur lors de l'ouverture du fichier %s.\n", text);
+        decharger();
+        return 1;
+    }
+
+    printf("\nMots malorthographiés\n\n");
+    int nb_malorthographie;
+    int nb_mots;
+    print_erreurs(fp, &nb_malorthographie, &nb_mots);
+
+    // Vérifie que la lecture s'est terminée sans erreurs
+    if (ferror(fp))
+    {
+        fclose(fp);
+        printf("Erreur lors de la lecture du fichier %s.\n", text);
+        decharger();
+        return 1;
+    }
+
+    // Fermeture du fichier
+    fclose(fp);
+
+
+
+    if (!decharger())
+    {
+        printf("Erreur lors de la liberation memoire%s.\n", nom_dict);
+        return 1;
+    }
+
+    // On affiche les informations sur les mots
+    printf("\nMots malorthographiés:     %d\n", nb_malorthographie);
+    printf("Mots dans le dictionnaire:  %d\n", taille_dic());
+    printf("Mots dans le texte:        %d\n", nb_mots);
+
+    return 0;
+}
+
+void print_erreurs(FILE *fp, int *malorthographies, int *mots)
+{
+    (*malorthographies) = 0;
+    (*mots) = 0;// initialisation des variables
+    int index = 0;
+    char mot[LONG_MAX+1];
+
+    // Verification de l'orthographe
+    int nb_mots_ligne = 0;
+    for (int c = fgetc(fp); c != EOF; c = fgetc(fp))
+    {
+        // On ne traite que les caracteres et les apostrophes
+        if (isalpha(c) || (c == '\'' && index > 0))
+        {
+            // Ajout du caractere dans le mot temporaire en construction
+            mot[index] = c;
+            index++;
+
+            // On annule la verification du mot s'il depasse la limite
+            if (index > LONG_MAX)
+            {
+                // On passe le reste du mot
+                while ((c = fgetc(fp)) != EOF && isalpha(c));
+
+                // Reinitialisation du mot temporaire
+                index = 0;
+            }
+        }
+
+        // On ignore les mots avec des chiffres
+        else if (isdigit(c))
+        {
+            // On passe le reste du mot
+            while ((c = fgetc(fp)) != EOF && isalnum(c));
+
+            // Reinitialisation du mot temporaire
+            index = 0;
+        }
+
+        // On prend un mot en entier
+        else if (index > 0)
+        {
+            // fin d'un mot
+            mot[index] = '\0';
+
+            // On incremente le compteur
+            (*mots)++;
+
+            // Vérifie si le mot est bien orthographie
+            bool malorthographie = !appartient(mot);
+
+
+            // On affiche les mots mal orthographies
+            if (malorthographie)
+            {
+                printf("%s\n", mot);
+                if (nb_mots_ligne == 2) {
+                    printf("\n");
+                    nb_mots_ligne = 0;
+                }
+                (*malorthographies)++;
+            }
+
+            // On passe au mot suivant
+            index = 0;
+        }
+    }
+}
 \ No newline at end of file
+/**
+ * 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
@@ -0,0 +1,2 @@
+verifier le correcteur avec le texte d'exemple
+Verifier l'orthographe
 \ No newline at end of file