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

Diff for /rpl/src/transliteration.c between versions 1.45 and 1.72

version 1.45, 2011/09/26 15:57:18 version 1.72, 2013/09/06 10:30:57
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.4    RPL/2 (R) version 4.1.16
   Copyright (C) 1989-2011 Dr. BERTRAND Joël    Copyright (C) 1989-2013 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 121  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);
             }              }
Line 176  localisation_courante(struct_processus * Line 236  localisation_courante(struct_processus *
     int                         pipes_sortie[2];      int                         pipes_sortie[2];
     int                         status;      int                         status;
   
     long                        i;      integer8                    i;
     long                        nombre_arguments;      integer8                    longueur_lecture;
       integer8                    nombre_arguments;
       integer8                    nombre_iterations;
       integer8                    pointeur;
   
     pid_t                       pid;  
   
     struct sigaction            action_passee;      pid_t                       pid;
   
     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 443  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 462  localisation_courante(struct_processus * Line 520  localisation_courante(struct_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)) != 0)                  while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
Line 484  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 554  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 675  transliterated_fprintf(struct_processus Line 721  transliterated_fprintf(struct_processus
     }      }
   
 #   ifdef OS2  #   ifdef OS2
     if ((flux == stdin) || (flux == stdout))      if ((flux == stderr) || (flux == stdout))
     {      {
         i = 0;          i = 0;
         ptr_l = tampon2;          ptr_l = tampon2;
Line 694  transliterated_fprintf(struct_processus Line 740  transliterated_fprintf(struct_processus
                 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(NULL);              return(-1);
         }          }
   
         ptr_e = tampon3;          ptr_e = tampon3;
Removed from v.1.45  
changed lines
  Added in v.1.72

CVSweb interface <joel.bertrand@systella.fr>