[BACK]Return to transliteration.c CVS log [TXT] [DIR] Up to [local] / rpl / src

Diff for /rpl/src/transliteration.c between versions 1.3 and 1.104

version 1.3, 2010/02/10 08:09:30 version 1.104, 2021/03/13 12:50:53
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.10    RPL/2 (R) version 4.1.33
   Copyright (C) 1989-2010 Dr. BERTRAND Joël    Copyright (C) 1989-2021 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 20 Line 20
 */  */
   
   
 #include "rpl.conv.h"  #include "rpl-conv.h"
   #include "tex-conv.h"
   
 #include <stdarg.h>  #include <stdarg.h>
   
 #undef fprintf  #undef fprintf
 #undef printf  #undef printf
   
Line 87  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 102  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 113  reencodage(struct_processus *s_etat_proc Line 131  reencodage(struct_processus *s_etat_proc
         longueur_sortie = d_LONGUEUR;          longueur_sortie = d_LONGUEUR;
         pointeur = buffer_sortie;          pointeur = buffer_sortie;
   
         if ((ios = iconv(transcodage, (char **) &buffer_entree,          if ((ios = iconv(transcodage,
   #       if defined(Linux)
                   (char **)
   #       elif defined(NetBSD)
                   (const char **)
   #       else
                   (char **)
   #       endif
                   &buffer_entree,
                 &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 172  localisation_courante(struct_processus * Line 244  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 213  localisation_courante(struct_processus * Line 278  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 233  localisation_courante(struct_processus * Line 297  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);  
   
     pthread_sigmask(SIG_SETMASK, &oldset, NULL);  
     sigpending(&set);  
   
     if (pid < 0)      if (pid < 0)
     {      {
Line 369  localisation_courante(struct_processus * Line 426  localisation_courante(struct_processus *
     }      }
     else      else
     {      {
           deverrouillage_threads_concurrents(s_etat_processus);
   
         if (close(pipes_entree[0]) != 0)          if (close(pipes_entree[0]) != 0)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
Line 404  localisation_courante(struct_processus * Line 463  localisation_courante(struct_processus *
              * Récupération de la valeur de retour du processus détaché               * Récupération de la valeur de retour du processus détaché
              */               */
   
             if (sem_post(&((*s_etat_processus).semaphore_fork))  #           ifndef SEMAPHORES_NOMMES
                     != 0)                  if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
   #           else
                   if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #           endif
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return;                  return;
             }              }
   
             if (waitpid(pid, &status, 0) == -1)              while(waitpid(pid, &status, 0) == -1)
             {              {
                 if (sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                  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;                          if (errno != EINTR)
                         return;                          {
                               (*s_etat_processus).erreur_systeme = d_es_processus;
                               return;
                           }
                     }                      }
                 }  
   
                 (*s_etat_processus).erreur_systeme = d_es_processus;                      (*s_etat_processus).erreur_systeme = d_es_processus;
                 return;                      return;
                   }
             }              }
   
             if (sem_wait(&((*s_etat_processus).semaphore_fork)) == -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)
                 {                  {
Line 440  localisation_courante(struct_processus * Line 514  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;
             return;              return;
         }          }
   
         if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)          tampon[0] = d_code_fin_chaine;
   
   #       ifndef SEMAPHORES_NOMMES
               if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
   #       else
               if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #       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)
         {          {
             while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -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)
                 {                  {
Line 471  localisation_courante(struct_processus * Line 555  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 479  localisation_courante(struct_processus * Line 563  localisation_courante(struct_processus *
                 return;                  return;
             }              }
   
             if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)  #           ifndef SEMAPHORES_NOMMES
                   if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
   #           else
                   if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #           endif
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return;                  return;
             }              }
         }          }
   
         while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -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)
             {              {
Line 515  localisation_courante(struct_processus * Line 607  localisation_courante(struct_processus *
             return;              return;
         }          }
   
         (*s_etat_processus).localisation = tampon;          if (strlen(tampon) > 0)
   
         if (sigaction(SIGINT, &action_passee, NULL) != 0)  
         {          {
             for(i = 0; i < nombre_arguments; i++)              (*s_etat_processus).localisation = tampon;
           }
           else
           {
               free(tampon);
   
               if (((*s_etat_processus).localisation = malloc((strlen(d_locale)
                       + 1) * sizeof(unsigned char))) == NULL)
             {              {
                 free(arguments[i]);                  (*s_etat_processus).erreur_systeme = d_es_processus;
                   return;
             }              }
   
             free(arguments);              strcpy((*s_etat_processus).localisation, d_locale);
             (*s_etat_processus).erreur_systeme = d_es_signal;  
             return;  
         }          }
   
         for(i = 0; i < nombre_arguments; i++)          for(i = 0; i < nombre_arguments; i++)
Line 536  localisation_courante(struct_processus * Line 632  localisation_courante(struct_processus *
   
         free(arguments);          free(arguments);
   
         if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)  #       ifndef SEMAPHORES_NOMMES
               if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
   #       else
               if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #       endif
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
             return;              return;
Line 546  localisation_courante(struct_processus * Line 646  localisation_courante(struct_processus *
         {          {
             // Le processus fils renvoie une erreur.              // Le processus fils renvoie une erreur.
   
             while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)              free(tampon);
   
               if (((*s_etat_processus).localisation = malloc((strlen(d_locale)
                       + 1) * sizeof(unsigned char))) == NULL)
             {              {
                 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_execution = d_ex_erreur_processus;              strcpy((*s_etat_processus).localisation, d_locale);
             return;  
         }          }
   
         while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -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)
             {              {
Line 578  localisation_courante(struct_processus * Line 681  localisation_courante(struct_processus *
     return;      return;
 }  }
   
 static int  
 vtransliterated_sprintf(char **strp, const char *fmt, va_list ap)  
 {  
     size_t bs, s;  
     char *b = NULL;  
     va_list cap;  
   
     va_copy(cap, ap);  
   
     for(bs = 256;; bs *= 2)  
     {  
         va_copy(ap, cap);  
         if (b != NULL) free(b);  
         if ((b = malloc(sizeof(*b) * bs)) == NULL) return -1;  
         if (((int) (s = vsnprintf(b, bs, fmt, ap))) < 0)  
                 { va_end(ap); free(b); return -1; }  
         va_end(ap);  
         if (s < bs) break;  
     }  
   
     if (((*strp) = realloc(b, ((s = strlen(b)) + 1) * sizeof(*b)))  
             == NULL) { free(b); return -1; }  
     return s;  
 }  
   
 int  int
 transliterated_fprintf(struct_processus *s_etat_processus, file *flux,  transliterated_fprintf(struct_processus *s_etat_processus, file *flux,
         const char *format, ...)          const char *format, ...)
 {  {
     int             ios;      int             ios;
     char            *tampon;  
       unsigned char   *tampon;
     unsigned char   *tampon2;      unsigned char   *tampon2;
   
     va_list         arguments;      va_list         arguments;
   
     va_start(arguments, format);      va_start(arguments, format);
   
     if (vtransliterated_sprintf(&tampon, format, arguments) < 0)  #   ifdef OS2
       unsigned char       *ptr_e;;
       unsigned char       *ptr_l;;
       unsigned char       *tampon3;
   
       unsigned long       i;
   #   endif
   
       if (valsprintf(s_etat_processus, &tampon, format, arguments) < 0)
     {      {
         va_end(arguments);          va_end(arguments);
   
Line 644  transliterated_fprintf(struct_processus Line 733  transliterated_fprintf(struct_processus
         tampon2 = tampon;          tampon2 = tampon;
     }      }
   
   #   ifdef OS2
       if ((flux == stderr) || (flux == stdout))
       {
           i = 0;
           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;
               return(-1);
           }
   
           ptr_e = tampon3;
           ptr_l = tampon2;
   
           while((*ptr_l) != d_code_fin_chaine)
           {
               (*ptr_e) = (*ptr_l);
   
               if ((*ptr_l) == '\n')
               {
                   (*(++ptr_e)) = '\r';
                   ptr_e++;
                   ptr_l++;
               }
               else
               {
                   ptr_e++;
                   ptr_l++;
               }
           }
   
           (*ptr_e) = d_code_fin_chaine;
   
           free(tampon2);
           tampon2 = tampon3;
       }
   #   endif
   
   #   ifdef SunOS
       while((ios = fprintf(flux, "%s", tampon2)) < 0)
       {
           if ((errno != EINTR) && (errno != 0))
           {
               break;
           }
       }
   #   else
       ios = fprintf(flux, "%s", tampon2);
   #   endif
   
       free(tampon2);
   
       return(ios);
   }
   
   
   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, ...)
   {
       int             ios;
   
       unsigned char   *tampon;
       unsigned char   *tampon2;
   
       va_list         arguments;
   
       va_start(arguments, format);
   
       if (valsprintf(s_etat_processus, &tampon, format, arguments) < 0)
       {
           va_end(arguments);
   
           if (s_etat_processus != NULL)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
           }
   
           return(-1);
       }
   
       va_end(arguments);
   
       if ((tampon2 = transliteration(s_etat_processus, tampon,
               d_locale, ds_tex_encodage_3)) == NULL)
       {
           free(tampon);
           return(-1);
       }
   
       free(tampon);
   
 #   ifdef SunOS  #   ifdef SunOS
     while((ios = fprintf(flux, "%s", tampon2)) < 0)      while((ios = fprintf(flux, "%s", tampon2)) < 0)
     {      {
Line 661  transliterated_fprintf(struct_processus Line 870  transliterated_fprintf(struct_processus
     return(ios);      return(ios);
 }  }
   
   #undef readline
   
   unsigned char *
   readline_wrapper(struct_processus *s_etat_processus, unsigned char *invite)
   {
       unsigned char       *rpl_chaine;
       unsigned char       *sys_chaine;
   
       association_etat_processus_readline(s_etat_processus);
       sys_chaine = readline(invite);
   
   #   ifdef OS2
       printf("\r");
   #   endif
   
       if (sys_chaine == NULL)
       {
           return(NULL);
       }
   
       if ((rpl_chaine = malloc((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(rpl_chaine);
   }
   
   
 #define fprintf NULL  #define fprintf NULL
 #define printf NULL  #define printf NULL
   
Removed from v.1.3  
changed lines
  Added in v.1.104

CVSweb interface <joel.bertrand@systella.fr>