From babbbfbecae6c5be3e46229153fa475b5d798231 Mon Sep 17 00:00:00 2001 From: Corto Callerisa Date: Fri, 3 May 2019 01:11:19 +0200 Subject: [PATCH] ajout makefile --- Makefile | 33 +++++++++++++++++++++++++++++++++ correcteur | Bin 0 -> 23304 bytes correcteur.o | Bin 0 -> 10232 bytes dictionnaire.c | 175 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++------------------------------------------- dictionnaire.h | 52 ++++++++++++++++++++++++++++++++++++++++++++++++++++ dictionnaire.o | Bin 0 -> 9800 bytes 6 files changed, 217 insertions(+), 43 deletions(-) create mode 100644 Makefile create mode 100755 correcteur create mode 100644 correcteur.o create mode 100644 dictionnaire.h create mode 100644 dictionnaire.o diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..36b8678 --- /dev/null +++ b/Makefile @@ -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 diff --git a/correcteur b/correcteur new file mode 100755 index 0000000..6845021 Binary files /dev/null and b/correcteur differ diff --git a/correcteur.o b/correcteur.o new file mode 100644 index 0000000..1808d58 Binary files /dev/null and b/correcteur.o differ diff --git a/dictionnaire.c b/dictionnaire.c index 80ea42a..e502e98 100644 --- a/dictionnaire.c +++ b/dictionnaire.c @@ -1,118 +1,207 @@ +/** + * dictionnaire.c + * + * Implémente l'importation et la libération d'un dictionnaire en mémoire + * depuis un fichier texte. + */ #include #include #include +/* ctype.h pour les fonctions isalpha, tolower, isdigit et isspace */ #include #include +#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; } diff --git a/dictionnaire.h b/dictionnaire.h new file mode 100644 index 0000000..d0c7f3f --- /dev/null +++ b/dictionnaire.h @@ -0,0 +1,52 @@ +/** + * dict.h + * + * Declaration des fonctions de manipulation d'un dictionnaire + */ + +#ifndef DICT_H +#define DICT_H + +#include + +#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 diff --git a/dictionnaire.o b/dictionnaire.o new file mode 100644 index 0000000..d4b34ee Binary files /dev/null and b/dictionnaire.o differ -- libgit2 0.21.2