--- rpl/src/transliteration.c 2013/02/26 19:56:18 1.63 +++ rpl/src/transliteration.c 2016/03/16 11:15:22 1.90 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.1.12 - Copyright (C) 1989-2013 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.25 + Copyright (C) 1989-2016 Dr. BERTRAND Joël This file is part of RPL/2. @@ -135,8 +135,40 @@ reencodage(struct_processus *s_etat_proc &longueur_entree, (char **) &pointeur, &longueur_sortie)) == (size_t) -1) { - // On autorise les erreurs EINVAL et EILSEQ - if (errno == EILSEQ) + // On autorise les erreurs EINVAL si le caractère suivant est non + // nul : la séquence d'entrée est continue sur le bloc suivant. + + if (errno == EINVAL) + { + if ((*(buffer_entree + 1)) == d_code_fin_chaine) + { + free(buffer_sortie); + free(chaine_sortie); + + // On affiche une erreur ici car la fonction d'affichage + // de l'erreur utilise la macro printf() donc une + // opération de translitération qui échouera elle aussi. + // Le positionnement de l'erreur permet de sortir du + // programme. + + if ((*s_etat_processus).langue == 'F') + { + fprintf(stderr, "+++Erreur : Erreur de transcodage\n"); + } + else + { + fprintf(stderr, "+++Error : Transcodage error\n"); + } + + (*s_etat_processus).erreur_execution = + d_ex_erreur_transcodage; + return(NULL); + } + } + + // Si la séquence d'entrée est invalide, on reçoit une erreur + // EILSEQ. + else if (errno == EILSEQ) { free(buffer_sortie); free(chaine_sortie); @@ -204,17 +236,17 @@ localisation_courante(struct_processus * int pipes_sortie[2]; int status; - long i; - long nombre_arguments; + integer8 i; + integer8 longueur_lecture; + integer8 nombre_arguments; + integer8 nombre_iterations; + integer8 pointeur; + pid_t pid; unsigned char *tampon; - unsigned long longueur_lecture; - unsigned long nombre_iterations; - unsigned long pointeur; - if ((arguments = malloc(3 * sizeof(char **))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -259,7 +291,6 @@ localisation_courante(struct_processus * verrouillage_threads_concurrents(s_etat_processus); pid = fork(); - deverrouillage_threads_concurrents(s_etat_processus); if (pid < 0) { @@ -387,6 +418,8 @@ localisation_courante(struct_processus * } else { + deverrouillage_threads_concurrents(s_etat_processus); + if (close(pipes_entree[0]) != 0) { (*s_etat_processus).erreur_systeme = d_es_processus; @@ -432,23 +465,27 @@ localisation_courante(struct_processus * return; } - if (waitpid(pid, &status, 0) == -1) + while(waitpid(pid, &status, 0) == -1) { -# ifndef SEMAPHORES_NOMMES - while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0) -# else - while(sem_wait((*s_etat_processus).semaphore_fork) != 0) -# endif + if (errno != EINTR) { - if (errno != EINTR) +# ifndef SEMAPHORES_NOMMES + while(sem_wait(&((*s_etat_processus).semaphore_fork)) + != 0) +# else + while(sem_wait((*s_etat_processus).semaphore_fork) != 0) +# endif { - (*s_etat_processus).erreur_systeme = d_es_processus; - return; + if (errno != EINTR) + { + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } } - } - (*s_etat_processus).erreur_systeme = d_es_processus; - return; + (*s_etat_processus).erreur_systeme = d_es_processus; + return; + } } # ifndef SEMAPHORES_NOMMES @@ -469,7 +506,7 @@ localisation_courante(struct_processus * pointeur = 0; nombre_iterations = 1; - if ((tampon = malloc((longueur_lecture + 1) * + if ((tampon = malloc(((size_t) (longueur_lecture + 1)) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -488,9 +525,9 @@ localisation_courante(struct_processus * return; } - while((ios = read_atomic(s_etat_processus, + while((ios = (int) read_atomic(s_etat_processus, pipes_sortie[0], &(tampon[pointeur]), - longueur_lecture)) > 0) + (size_t) longueur_lecture)) > 0) { # ifndef SEMAPHORES_NOMMES while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0) @@ -510,7 +547,7 @@ localisation_courante(struct_processus * nombre_iterations++; if ((tampon = realloc(tampon, - ((nombre_iterations * longueur_lecture) + 1) * + ((size_t) ((nombre_iterations * longueur_lecture) + 1)) * sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = @@ -658,7 +695,7 @@ transliterated_fprintf(struct_processus unsigned long i; # endif - if (valsprintf(&tampon, format, arguments) < 0) + if (valsprintf(s_etat_processus, &tampon, format, arguments) < 0) { va_end(arguments); @@ -757,6 +794,22 @@ transliterated_fprintf(struct_processus int +std_fprintf(file *flux, const char *format, ...) +{ + int ios; + + va_list arguments; + + va_start(arguments, format); + ios = vfprintf(flux, format, arguments); + va_end(arguments); + + // Pas de parenthèses pour ne pas appeler la macro. + return ios; +} + + +int tex_fprintf(struct_processus *s_etat_processus, file *flux, const char *format, ...) { @@ -769,7 +822,7 @@ tex_fprintf(struct_processus *s_etat_pro va_start(arguments, format); - if (valsprintf(&tampon, format, arguments) < 0) + if (valsprintf(s_etat_processus, &tampon, format, arguments) < 0) { va_end(arguments); @@ -812,14 +865,35 @@ tex_fprintf(struct_processus *s_etat_pro #undef readline unsigned char * -readline_wrapper(unsigned char *invite) +readline_wrapper(struct_processus *s_etat_processus, unsigned char *invite) { - unsigned char *chaine; + unsigned char *rpl_chaine; + unsigned char *sys_chaine; + + association_etat_processus_readline(s_etat_processus); + sys_chaine = readline(invite); - chaine = readline(invite); +# ifdef OS2 printf("\r"); +# endif + + if (sys_chaine == NULL) + { + return(NULL); + } + + if ((rpl_chaine = rpl_malloc(s_etat_processus, (strlen(sys_chaine) + 1) * + sizeof(unsigned char *))) == NULL) + { + sys_free(sys_chaine); + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return(NULL); + } + + strcpy(rpl_chaine, sys_chaine); + sys_free(sys_chaine); - return(chaine); + return(rpl_chaine); }