Traducteur mot à mot CORRECTION Ce document, ainsi que le programme C et un exemple de programme trad-fr-us, peut être trouvé en ligne à l'addresse suivante : http ://www.lifl.fr/hauspie/hauspie/teaching. Exercice 1 : Traducteur mot à mot (15 points) Vous apporterez un soin particulier à la libération de la mémoire allouée ainsi qu'à la gestion des erreurs éventuelles des fonctions systèmes Le but de cet exercice est d'écrire un traducteur de texte naïf. La traduction d'un texte d'une langue à une autre sera faite mot à mot. Pour cela, nous disposons de plusieurs programmes permettant de traduire un mot dans une langue donnée. Par exemple, nous pouvons avoir à disposition les programmes suivants : Programme Langue d'origine Langue de destination trad-us-fr Anglais US Français trad-fr-us Français Anglais US trad-de-fr Allemand Français trad-fr-de Français Allemand Ces programmes lisent un mot sur leur entrée standard et sortent la traduction sur leur sortie standard. Voici deux exemples d'utilisation d'un de ces programmes : hauspie@barbar:~/$./trad-us-fr chair ^D chaise hauspie@barbar:~/$ echo "Ordinateur"./trad-FR-US computer hauspie@barbar:~/$ Q 1. Écrire une fonction : char *traduire_mot(const char *mot, const char *langue_source, const char *langue_destination); qui prend un mot, une langue source et une langue destination en paramètre et qui retourne la traduction du mot (vous ferez attention à la validité du pointeur que retourne la fonction). La chaîne de caractère représentant une langue sera telle que décrite dans le tableau précédent (par exemple "US" pour la langue anglaise, "FR" pour la langue française). Cette fonction est chargée de créer deux tubes : un tube pour envoyer le mot à traduire; un autre tube pour récupérer le résultat de la traduction. Une fois les deux tubes créés, le processus père doit créer un processus ls qui eectuera les redirections nécessaires et exécutera la commande permettant d'eectuer la traduction dans la langue désirée. Le processus père lira alors le résultat de la traduction dans le tube et attendra la mort de son ls. Le mot traduit sera ensuite retourné par la fonction. Le schéma ci-dessous illustre la communication père-ls : Q 2. Écrire une fonction : int traduire_fichier(int source, int destination, const char *langue_source, const char *langue_destination); qui traduit le texte lu sur le descripteur source et envoyer la traduction sur le descripteur destination. La traduction sera faite mot à mot. La fonction retournera le nombre de mot traduits si tout s'est bien passé ou -1 s'il y a eu une erreur. On rapelle que la fonction isspace permet de tester si un caractère est un caractère de séparation (espace, tabulation...). Q 3. Écrire maintenant le main de votre programme qui devra supporter les options suivantes et appeler les fonctions précédentes pour eectuer le traitement :
-i chier_source Donne le nom du chier à traduire. Si cette option n'est pas présente sur la ligne de commande, votre programme devra traduire le texte qu'il lira sur son entrée standard. -o chier_destination Donne le nom du chier destination. Si cette option n'est pas présente sur la ligne de commande, votre programme devra produire la traduction sur la sortie standard. -il langue_source Précise la langue source. Si cette option n'est pas présente sur la ligne de commande, votre programme doit utiliser la langue "US". -ol langue_destination Précise la langue destination. Si cette option n'est pas présente sur la ligne de commande, votre programme doit utiliser la langue "FR". Une fois la traduction eectuée, votre programme doit acher un message indiquant à l'utilisateur le nombre de mots traduits. 1 #include <stdio.h> 2 #include <unistd.h> 3 #include <string.h> 4 #include <stdlib.h> 5 #include <ctype.h> 6 #include <sys/types.h> 7 #include <sys/wait.h> 8 #include <sys/stat.h> 9 #include <fcntl.h> 10 11 #define TAILLE_BUFFER 1024 /* 1ko de buffer pour lire dans le fichier */ 12 #define TAILLE_MAX_MOT 64 /* mot de 64 carac max... devrait etre 13 * suffisant... On va faire les tests mais on va 14 * tronquer pour ne pas allourdir le code */ 15 16 char *traduire_mot(const char *mot, const char *src_lg, const char *dst_lg) 17 { 18 /* les descripteurs pour les deux tubes. Les noms sont donnée point de vue 19 du processus père. on envoie le mot a traduire dans emission et on 20 recoit le mot traduit dans reception 21 */ 22 int emission[2]; 23 int reception[2]; 24 int pid; 25 26 /* création du premier tube */ 27 if (pipe(emission) == -1) 28 { 29 perror("creation du premier tube"); 30 return NULL; 31 } 32 33 /* création du deuxième tube */ 34 if (pipe(reception) == -1) 35 { 36 perror("creation du deuxieme tube"); 37 return NULL; 38 } 39 40 /* Création du processus fils */ 41 pid = fork(); 42 43 if (pid == 0) 44 { 45 char nom_commande[64]; /* 64 caractères sont amplement suffisants */ 46 /* dans le fils */ 47 /* on a pas besoin de l'entree du tube d'emission et de la sortie du tube 48 * de reception */ 49 close(emission[1]); 50 close(reception[0]); 51 52 /* redirection des e/s */ 53 close(0); /* on ferme l'entrée standard */ 54 dup(emission[0]); /* on redirige l'entrée standard i.e. read(0,...) 55 * devient équivalent à read(emission[0],...) */ 56 close(emission[0]); /* on a plus besoin du descripteur emission[0] car le 57 * descripteur 0 "pointe" sur la sortie du tube */ 58
59 close(1); /* on ferme la sortie standard */ 60 dup(reception[1]); /* on redirige la sortie standard i.e. write(1,...) 61 * devient équivalent à write(reception[1],...) */ 62 close(reception[1]); /* on a plus besoin du descripteur reception[1] car 63 * le descripteur 1 "pointe" sur l'entrée du tube */ 64 65 /* la redirection des entrées/sorties est effectuée, on peut lancer le 66 * programme */ 67 /* il faut construire son nom. Ce nom est consitué du mot "trad" suivi de 68 * "-", src_lg, "-" puis enfin dst_lg. */ 69 70 strcpy(nom_commande, "./trad-"); 71 strcat(nom_commande, src_lg); 72 strcat(nom_commande, "-"); 73 strcat(nom_commande, dst_lg); 74 75 /* le nom de la commande est construit, on a plus qu'a l'executer */ 76 /* on utilise execlp car il est plus adapté a notre cas (on ne passe pas 77 * de paramètre à la commande) */ 78 execlp(nom_commande, nom_commande, NULL); 79 /* si on arrive ici dans le programme, c'est qu'il y a eu un probleme avec execlp */ 80 perror("execution de la commande"); 81 exit(1); /* on quitte le processus fils */ 82 } 83 else 84 { 85 /* pointeur vers le mot traduit, on va allouer l'espace un peu plus 86 * bas... */ 87 char *mot_traduit = NULL; 88 int nb_caracteres_lus = 0; 89 int status; 90 /* dans le père */ 91 /* on a pas besoin de emission[0] ni de reception[1] */ 92 close(emission[0]); 93 close(reception[1]); 94 95 /* on envoie le mot à traduire sur le tube d'emission */ 96 if (write(emission[1], mot, strlen(mot)) < 0) 97 { 98 perror("erreur à l'écriture dans le tube"); 99 /* on va quitter donc il faut tout fermer proprement */ 100 close(emission[1]); 101 close(reception[0]); 102 wait(&status); /* on attends la fin du fils */ 103 return NULL; /* traduction impossible, on retourne null */ 104 } 105 106 /* on ferme le descripteur d'emission */ 107 close(emission[1]); 108 109 /* on alloue de l'espace pour obtenir la réponse... 64 caractères 110 * devraient être suffisant pour tous les mots :) */ 111 mot_traduit = (char *) malloc(64*sizeof(char)); 112 113 if ( (nb_caracteres_lus = read(reception[0], mot_traduit, 63)) < 0) 114 { 115 /* probleme à la lecture... */ 116 perror("probleme à la lecture dans le tube"); 117 /* on va quitter donc il faut tout fermer proprement */ 118 close(emission[1]); 119 close(reception[0]); 120 wait(&status); /* on attends la fin du fils */ 121 free(mot_traduit); /* on oublie pas de désallouer ce qu'on a alloué */ 122 return NULL; /* traduction impossible, on retourne null */ 123 } 124 125 mot_traduit[nb_caracteres_lus] = '\0'; /* on s'assure de la présence du 126 * '\0' à la fin pour construire 127 * une chaine valide */ 128 /* on ferme les descripteurs dont on a plus besoin */
129 close(reception[0]); 130 /* on attends la fin du fils */ 131 wait(&status); 132 /* le fils est fini, on peut renvoyer le mot traduit. Comme il est dans 133 * un espace alloué par malloc(), la fonction appelante pourra s'en 134 * servir. Ce sera à cette fonction de désallouer la mémoire quand elle 135 * n'en aura plus besoin */ 136 return mot_traduit; 137 } 138 /* on arrivera jamais ici... le return est seulement la pour que le 139 * compilateur soit content */ 140 return NULL; 141 } 142 143 144 int traduire_fichier(int fichier_source, int fichier_destination, const char *langue_source, const char *langue_dest 145 { 146 /* comme on ne connait pas la taille du fichier à ouvrir, il va falloir lire 147 * par petit morceaux... */ 148 149 char buffer[taille_buffer]; /* Buffer pour lire dans le fichier */ 150 char mot_courant[taille_max_mot]; /* va servir à écrire le mot courant. */ 151 int nb_carac_lus = 0; /* nombre de caractères lus */ 152 int nb_mot_traduits = 0; 153 char *ptr_mot = mot_courant; 154 155 mot_courant[0] = '\0'; /* on initialise la chaine à une chaine vide */ 156 157 while ((nb_carac_lus = read(fichier_source, buffer, 1024)) > 0) 158 { 159 char *lettre = buffer; 160 161 while (nb_carac_lus > 0) 162 { 163 if (isspace(*lettre)) /* on a un espace */ 164 { 165 if (*mot_courant!= '\0') /* on a construit un mot */ 166 { 167 char *mot_traduit = NULL; 168 *ptr_mot = '\0'; /* on termine la chaine du mot à traduire */ 169 /* on lance la traduction du mot */ 170 mot_traduit = traduire_mot(mot_courant, langue_source, langue_destination); 171 if (mot_traduit!= NULL) /* la traduction s'est effectuée correctement */ 172 { 173 /* on ecrit le mot dans le fichier destination*/ 174 if (write(fichier_destination, mot_traduit, strlen(mot_traduit)) < 0) 175 { 176 perror("probleme d'écriture fichier destination"); 177 free(mot_traduit); /* on libere la mémoire allouée par traduire_mot */ 178 return -1; 179 } 180 else 181 { 182 nb_mot_traduits++; 183 } 184 } 185 free(mot_traduit); /* on libere la mémoire allouée par traduire_mot */ 186 ptr_mot = mot_courant; 187 } 188 /* on écrit le caractere espace dans le fichier destination... */ 189 if (write(fichier_destination, lettre, 1) <= 0) 190 { 191 perror("probleme d'écriture fichier destination (espace)"); 192 return -1; 193 } 194 lettre++; 195 } 196 else if ((ptr_mot - mot_courant) < TAILLE_MAX_MOT-1) /* on écrit les 197 *caractères que si on ne depasse pas la taille de notre buffer, on 198 *tronquera si un mot de plus de 64 caractères apparait. Pas
199 *forcement la meilleure solution, mais elle est sûre et n'obscurcit 200 *pas le code. */ 201 *ptr_mot++ = *lettre++; /* *ptr++ = 'a' va affecter le caractere 'a' 202 *à la zone mémoire pointée par ptr PUIS incrémenter le pointeur */ 203 nb_carac_lus--; 204 } 205 } 206 if (nb_carac_lus!= 0) /* la lecture n'a pas fonctionnée */ 207 { 208 perror("probleme de lecture dans le fichier source"); 209 return -1; 210 } 211 return nb_mot_traduits; 212 } 213 214 int main(int argc, char **argv) 215 { 216 int fichier_source = 0; 217 int fichier_destination = 1; 218 char langue_source[32]; 219 char langue_destination[32]; 220 int i; 221 222 strcpy(langue_source, "FR"); 223 strcpy(langue_destination, "US"); 224 225 for (i = 1; i < argc-1 ; i+=2) 226 { 227 if (strcmp(argv[i], "-i") == 0) 228 { 229 /* ouverture d'un fichier source */ 230 fichier_source = open(argv[i+1], O_RDONLY); 231 if (fichier_source == -1) 232 { 233 perror("ouverture du fichier source"); 234 return 1; 235 } 236 } 237 else if (strcmp(argv[i], "-o") == 0) 238 { 239 /* ouverture d'un fichier destination */ 240 fichier_destination = open(argv[i+1], O_CREAT O_RDWR, 0755); 241 if (fichier_destination == -1) 242 { 243 perror("ouverture du fichier destination"); 244 return 1; 245 } 246 } 247 else if (strcmp(argv[i], "-il") == 0) 248 { 249 strcpy(langue_source, argv[i+1]); 250 } 251 else if (strcmp(argv[i], "-ol") == 0) 252 { 253 strcpy(langue_destination, argv[i+1]); 254 } 255 else 256 { 257 fprintf(stderr, "Mauvais parametre: %s\n", argv[i]); 258 } 259 } 260 261 262 i = traduire_fichier(fichier_source, fichier_destination, langue_source, langue_destination); 263 264 /* on ferme les fichiers dont on s'est servi */ 265 if (fichier_destination!= 1) 266 close(fichier_destination); 267 if (fichier_source!= 0) 268 close(fichier_source);
269 270 if (i == -1) 271 return 1; /* pas besoin d'afficher un message d'erreur, les fonctions précédentes s'en chargent */ 272 273 printf("traduction terminée, %d mot(s) traduit(s)\n", i); 274 return 0; 275 }