--- rpl/src/transliteration.c 2011/05/09 13:52:25 1.26.2.3 +++ rpl/src/transliteration.c 2016/09/27 15:29:40 1.91 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.0.24 - Copyright (C) 1989-2011 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.26 + Copyright (C) 1989-2016 Dr. BERTRAND Joël This file is part of RPL/2. @@ -90,6 +90,20 @@ reencodage(struct_processus *s_etat_proc if ((transcodage = iconv_open(codage_sortie, codage_entree)) == (iconv_t) -1) { + // 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); } @@ -105,7 +119,8 @@ reencodage(struct_processus *s_etat_proc chaine_sortie[0] = d_code_fin_chaine; - if ((buffer_sortie = malloc((d_LONGUEUR + 1) * sizeof(char))) == NULL) + if ((buffer_sortie = malloc((d_LONGUEUR + 1) * sizeof(unsigned char))) + == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(NULL); @@ -120,18 +135,64 @@ 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); + // 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); } } - tampon = (unsigned char *) chaine_sortie; + tampon = chaine_sortie; (*pointeur) = d_code_fin_chaine; if ((chaine_sortie = malloc((strlen(tampon) + strlen(buffer_sortie) + 1) @@ -175,24 +236,17 @@ localisation_courante(struct_processus * int pipes_sortie[2]; int status; - logical1 drapeau_fin; + integer8 i; + integer8 longueur_lecture; + integer8 nombre_arguments; + integer8 nombre_iterations; + integer8 pointeur; - long i; - long nombre_arguments; pid_t pid; - sigset_t oldset; - sigset_t set; - - struct sigaction action_passee; - 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; @@ -216,7 +270,6 @@ localisation_courante(struct_processus * arguments[2] = NULL; nombre_arguments = 2; - drapeau_fin = d_faux; if (pipe(pipes_entree) != 0) { @@ -236,15 +289,8 @@ localisation_courante(struct_processus * return; } - sigfillset(&set); - pthread_sigmask(SIG_BLOCK, &set, &oldset); - verrouillage_threads_concurrents(s_etat_processus); pid = fork(); - deverrouillage_threads_concurrents(s_etat_processus); - - pthread_sigmask(SIG_SETMASK, &oldset, NULL); - sigpending(&set); if (pid < 0) { @@ -372,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; @@ -408,38 +456,42 @@ localisation_courante(struct_processus * */ # ifndef SEMAPHORES_NOMMES - if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) + if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) # else - if (sem_post((*s_etat_processus).semaphore_fork) != 0) + if (sem_post((*s_etat_processus).semaphore_fork) != 0) # endif { (*s_etat_processus).erreur_systeme = d_es_processus; return; } - if (waitpid(pid, &status, 0) == -1) + while(waitpid(pid, &status, 0) == -1) { -# ifndef SEMAPHORES_NOMMES - if (sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) -# else - if (sem_wait((*s_etat_processus).semaphore_fork) == -1) -# 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 - if (sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) + while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0) # else - if (sem_wait((*s_etat_processus).semaphore_fork) == -1) + while(sem_wait((*s_etat_processus).semaphore_fork) != 0) # endif { if (errno != EINTR) @@ -454,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; @@ -464,23 +516,23 @@ localisation_courante(struct_processus * tampon[0] = d_code_fin_chaine; # ifndef SEMAPHORES_NOMMES - if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) + if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) # else - if (sem_post((*s_etat_processus).semaphore_fork) != 0) + if (sem_post((*s_etat_processus).semaphore_fork) != 0) # endif { (*s_etat_processus).erreur_systeme = d_es_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)) == -1) + while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0) # else - while(sem_wait((*s_etat_processus).semaphore_fork) == -1) + while(sem_wait((*s_etat_processus).semaphore_fork) != 0) # endif { if (errno != EINTR) @@ -495,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 = @@ -504,9 +556,9 @@ localisation_courante(struct_processus * } # ifndef SEMAPHORES_NOMMES - if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) + if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) # else - if (sem_post((*s_etat_processus).semaphore_fork) != 0) + if (sem_post((*s_etat_processus).semaphore_fork) != 0) # endif { (*s_etat_processus).erreur_systeme = d_es_processus; @@ -515,9 +567,9 @@ localisation_courante(struct_processus * } # ifndef SEMAPHORES_NOMMES - while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) + while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0) # else - while(sem_wait((*s_etat_processus).semaphore_fork) == -1) + while(sem_wait((*s_etat_processus).semaphore_fork) != 0) # endif { if (errno != EINTR) @@ -565,18 +617,6 @@ localisation_courante(struct_processus * strcpy((*s_etat_processus).localisation, d_locale); } - if (sigaction(SIGINT, &action_passee, NULL) != 0) - { - for(i = 0; i < nombre_arguments; i++) - { - free(arguments[i]); - } - - free(arguments); - (*s_etat_processus).erreur_systeme = d_es_signal; - return; - } - for(i = 0; i < nombre_arguments; i++) { free(arguments[i]); @@ -585,9 +625,9 @@ localisation_courante(struct_processus * free(arguments); # ifndef SEMAPHORES_NOMMES - if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) + if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0) # else - if (sem_post((*s_etat_processus).semaphore_fork) != 0) + if (sem_post((*s_etat_processus).semaphore_fork) != 0) # endif { (*s_etat_processus).erreur_systeme = d_es_processus; @@ -611,9 +651,9 @@ localisation_courante(struct_processus * } # ifndef SEMAPHORES_NOMMES - while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1) + while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0) # else - while(sem_wait((*s_etat_processus).semaphore_fork) == -1) + while(sem_wait((*s_etat_processus).semaphore_fork) != 0) # endif { if (errno != EINTR) @@ -655,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); @@ -686,7 +726,7 @@ transliterated_fprintf(struct_processus } # ifdef OS2 - if ((flux == stdin) || (flux == stdout)) + if ((flux == stderr) || (flux == stdout)) { i = 0; ptr_l = tampon2; @@ -705,7 +745,7 @@ transliterated_fprintf(struct_processus sizeof(unsigned char))) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; - return(NULL); + return(-1); } ptr_e = tampon3; @@ -754,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, ...) { @@ -766,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); @@ -809,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); }