Diff for /rpl/src/transliteration.c between versions 1.19 and 1.78

version 1.19, 2010/08/26 17:49:34 version 1.78, 2015/01/05 15:32:25
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.18    RPL/2 (R) version 4.1.20
   Copyright (C) 1989-2010 Dr. BERTRAND Joël    Copyright (C) 1989-2015 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 90  reencodage(struct_processus *s_etat_proc Line 90  reencodage(struct_processus *s_etat_proc
     if ((transcodage = iconv_open(codage_sortie, codage_entree)) ==      if ((transcodage = iconv_open(codage_sortie, codage_entree)) ==
             (iconv_t) -1)              (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;          (*s_etat_processus).erreur_execution = d_ex_erreur_transcodage;
         return(NULL);          return(NULL);
     }      }
Line 105  reencodage(struct_processus *s_etat_proc Line 119  reencodage(struct_processus *s_etat_proc
   
     chaine_sortie[0] = d_code_fin_chaine;      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;          (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
         return(NULL);          return(NULL);
Line 120  reencodage(struct_processus *s_etat_proc Line 135  reencodage(struct_processus *s_etat_proc
                 &longueur_entree, (char **) &pointeur, &longueur_sortie))                  &longueur_entree, (char **) &pointeur, &longueur_sortie))
                 == (size_t) -1)                  == (size_t) -1)
         {          {
             // On autorise les erreurs EINVAL et EILSEQ              // On autorise les erreurs EINVAL si le caractère suivant est non
             if (errno == EILSEQ)              // 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(buffer_sortie);
                 free(chaine_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;                  (*s_etat_processus).erreur_execution = d_ex_erreur_transcodage;
                 return(NULL);                  return(NULL);
             }              }
         }          }
   
         tampon = (unsigned char *) chaine_sortie;          tampon = chaine_sortie;
         (*pointeur) = d_code_fin_chaine;          (*pointeur) = d_code_fin_chaine;
   
         if ((chaine_sortie = malloc((strlen(tampon) + strlen(buffer_sortie) + 1)          if ((chaine_sortie = malloc((strlen(tampon) + strlen(buffer_sortie) + 1)
Line 158  reencodage(struct_processus *s_etat_proc Line 219  reencodage(struct_processus *s_etat_proc
 ================================================================================  ================================================================================
   Entrées :    Entrées :
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
     Sorties :
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   iorties :  
   Effets de bord : néant    Effets de bord : néant
 ================================================================================  ================================================================================
 */  */
Line 175  localisation_courante(struct_processus * Line 236  localisation_courante(struct_processus *
     int                         pipes_sortie[2];      int                         pipes_sortie[2];
     int                         status;      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;      pid_t                       pid;
   
     sigset_t                    oldset;  
     sigset_t                    set;  
   
     struct sigaction            action_passee;  
   
     unsigned char               *tampon;      unsigned char               *tampon;
   
     unsigned long               longueur_lecture;  
     unsigned long               nombre_iterations;  
     unsigned long               pointeur;  
   
     if ((arguments = malloc(3 * sizeof(char **))) == NULL)      if ((arguments = malloc(3 * sizeof(char **))) == NULL)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;          (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 216  localisation_courante(struct_processus * Line 270  localisation_courante(struct_processus *
     arguments[2] = NULL;      arguments[2] = NULL;
   
     nombre_arguments = 2;      nombre_arguments = 2;
     drapeau_fin = d_faux;  
   
     if (pipe(pipes_entree) != 0)      if (pipe(pipes_entree) != 0)
     {      {
Line 236  localisation_courante(struct_processus * Line 289  localisation_courante(struct_processus *
         return;          return;
     }      }
   
     sigfillset(&set);  
     pthread_sigmask(SIG_BLOCK, &set, &oldset);  
   
     verrouillage_threads_concurrents(s_etat_processus);      verrouillage_threads_concurrents(s_etat_processus);
     pid = fork();      pid = fork();
     deverrouillage_threads_concurrents(s_etat_processus);      deverrouillage_threads_concurrents(s_etat_processus);
   
     pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
     sigpending(&set);  
   
     if (pid < 0)      if (pid < 0)
     {      {
         if (close(pipes_entree[0]) != 0)          if (close(pipes_entree[0]) != 0)
Line 408  localisation_courante(struct_processus * Line 455  localisation_courante(struct_processus *
              */               */
   
 #           ifndef SEMAPHORES_NOMMES  #           ifndef SEMAPHORES_NOMMES
             if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)                  if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
 #           else  #           else
             if (sem_post((*s_etat_processus).semaphore_fork) != 0)                  if (sem_post((*s_etat_processus).semaphore_fork) != 0)
 #           endif  #           endif
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
Line 420  localisation_courante(struct_processus * Line 467  localisation_courante(struct_processus *
             if (waitpid(pid, &status, 0) == -1)              if (waitpid(pid, &status, 0) == -1)
             {              {
 #               ifndef SEMAPHORES_NOMMES  #               ifndef SEMAPHORES_NOMMES
                 if (sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                      while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #               else  #               else
                 if (sem_wait((*s_etat_processus).semaphore_fork) == -1)                      while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #               endif  #               endif
                 {                  {
                     if (errno != EINTR)                      if (errno != EINTR)
Line 437  localisation_courante(struct_processus * Line 484  localisation_courante(struct_processus *
             }              }
   
 #           ifndef SEMAPHORES_NOMMES  #           ifndef SEMAPHORES_NOMMES
             if (sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                  while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #           else  #           else
             if (sem_wait((*s_etat_processus).semaphore_fork) == -1)                  while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #           endif  #           endif
             {              {
                 if (errno != EINTR)                  if (errno != EINTR)
Line 454  localisation_courante(struct_processus * Line 501  localisation_courante(struct_processus *
         pointeur = 0;          pointeur = 0;
         nombre_iterations = 1;          nombre_iterations = 1;
   
         if ((tampon = malloc((longueur_lecture + 1) *          if ((tampon = malloc(((size_t) (longueur_lecture + 1)) *
                 sizeof(unsigned char))) == NULL)                  sizeof(unsigned char))) == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 464  localisation_courante(struct_processus * Line 511  localisation_courante(struct_processus *
         tampon[0] = d_code_fin_chaine;          tampon[0] = d_code_fin_chaine;
   
 #       ifndef SEMAPHORES_NOMMES  #       ifndef SEMAPHORES_NOMMES
         if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)              if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
 #       else  #       else
         if (sem_post((*s_etat_processus).semaphore_fork) != 0)              if (sem_post((*s_etat_processus).semaphore_fork) != 0)
 #       endif  #       endif
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
             return;              return;
         }          }
   
         while((ios = read_atomic(s_etat_processus,          while((ios = (int) read_atomic(s_etat_processus,
                 pipes_sortie[0], &(tampon[pointeur]),                  pipes_sortie[0], &(tampon[pointeur]),
                 longueur_lecture)) > 0)                  (size_t) longueur_lecture)) > 0)
         {          {
 #           ifndef SEMAPHORES_NOMMES  #           ifndef SEMAPHORES_NOMMES
             while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                  while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #           else  #           else
             while(sem_wait((*s_etat_processus).semaphore_fork) == -1)                  while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #           endif  #           endif
             {              {
                 if (errno != EINTR)                  if (errno != EINTR)
Line 495  localisation_courante(struct_processus * Line 542  localisation_courante(struct_processus *
             nombre_iterations++;              nombre_iterations++;
   
             if ((tampon = realloc(tampon,              if ((tampon = realloc(tampon,
                     ((nombre_iterations * longueur_lecture) + 1) *                      ((size_t) ((nombre_iterations * longueur_lecture) + 1)) *
                     sizeof(unsigned char))) == NULL)                      sizeof(unsigned char))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme =                  (*s_etat_processus).erreur_systeme =
Line 504  localisation_courante(struct_processus * Line 551  localisation_courante(struct_processus *
             }              }
   
 #           ifndef SEMAPHORES_NOMMES  #           ifndef SEMAPHORES_NOMMES
             if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)                  if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
 #           else  #           else
             if (sem_post((*s_etat_processus).semaphore_fork) != 0)                  if (sem_post((*s_etat_processus).semaphore_fork) != 0)
 #           endif  #           endif
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
Line 515  localisation_courante(struct_processus * Line 562  localisation_courante(struct_processus *
         }          }
   
 #       ifndef SEMAPHORES_NOMMES  #       ifndef SEMAPHORES_NOMMES
         while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)              while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #       else  #       else
         while(sem_wait((*s_etat_processus).semaphore_fork) == -1)              while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #       endif  #       endif
         {          {
             if (errno != EINTR)              if (errno != EINTR)
Line 565  localisation_courante(struct_processus * Line 612  localisation_courante(struct_processus *
             strcpy((*s_etat_processus).localisation, d_locale);              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++)          for(i = 0; i < nombre_arguments; i++)
         {          {
             free(arguments[i]);              free(arguments[i]);
Line 585  localisation_courante(struct_processus * Line 620  localisation_courante(struct_processus *
         free(arguments);          free(arguments);
   
 #       ifndef SEMAPHORES_NOMMES  #       ifndef SEMAPHORES_NOMMES
         if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)              if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
 #       else  #       else
         if (sem_post((*s_etat_processus).semaphore_fork) != 0)              if (sem_post((*s_etat_processus).semaphore_fork) != 0)
 #       endif  #       endif
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
Line 611  localisation_courante(struct_processus * Line 646  localisation_courante(struct_processus *
         }          }
   
 #       ifndef SEMAPHORES_NOMMES  #       ifndef SEMAPHORES_NOMMES
         while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)              while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #       else  #       else
         while(sem_wait((*s_etat_processus).semaphore_fork) == -1)              while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #       endif  #       endif
         {          {
             if (errno != EINTR)              if (errno != EINTR)
Line 686  transliterated_fprintf(struct_processus Line 721  transliterated_fprintf(struct_processus
     }      }
   
 #   ifdef OS2  #   ifdef OS2
     i = 0;      if ((flux == stderr) || (flux == stdout))
     ptr_l = tampon2;  
   
     while((*ptr_l) != d_code_fin_chaine)  
     {  
         if ((*ptr_l) == '\n')  
         {  
             i++;  
         }  
   
         ptr_l++;  
     }  
   
     if ((tampon3 = malloc((strlen(tampon2) + i + 1) * sizeof(unsigned char)))  
             == NULL)  
     {      {
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;          i = 0;
         return(NULL);          ptr_l = tampon2;
     }  
   
     ptr_e = tampon3;          while((*ptr_l) != d_code_fin_chaine)
     ptr_l = tampon2;          {
               if ((*ptr_l) == '\n')
               {
                   i++;
               }
   
     while((*ptr_l) != d_code_fin_chaine)              ptr_l++;
     {          }
         (*ptr_e) = (*ptr_l);  
   
         if ((*ptr_l) == '\n')          if ((tampon3 = malloc((strlen(tampon2) + i + 1) *
                   sizeof(unsigned char))) == NULL)
         {          {
             (*(++ptr_e)) = '\r';              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             ptr_e++;              return(-1);
             ptr_l++;  
         }          }
         else  
           ptr_e = tampon3;
           ptr_l = tampon2;
   
           while((*ptr_l) != d_code_fin_chaine)
         {          {
             ptr_e++;              (*ptr_e) = (*ptr_l);
             ptr_l++;  
               if ((*ptr_l) == '\n')
               {
                   (*(++ptr_e)) = '\r';
                   ptr_e++;
                   ptr_l++;
               }
               else
               {
                   ptr_e++;
                   ptr_l++;
               }
         }          }
     }  
   
     (*ptr_e) = d_code_fin_chaine;          (*ptr_e) = d_code_fin_chaine;
   
     free(tampon2);          free(tampon2);
     tampon2 = tampon3;          tampon2 = tampon3;
       }
 #   endif  #   endif
   
 #   ifdef SunOS  #   ifdef SunOS
Line 803  tex_fprintf(struct_processus *s_etat_pro Line 841  tex_fprintf(struct_processus *s_etat_pro
     return(ios);      return(ios);
 }  }
   
   #undef readline
   
 unsigned char *  unsigned char *
 readline_wrapper(unsigned char *invite)  readline_wrapper(unsigned char *invite)
 {  {
     unsigned char       *chaine;      unsigned char       *chaine;
     unsigned char       *i;  
   
     chaine = readline(invite);      chaine = readline(invite);
     printf("\r");      printf("\r");

Removed from v.1.19  
changed lines
  Added in v.1.78


CVSweb interface <joel.bertrand@systella.fr>