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

Diff for /rpl/src/formateur_fichiers.c between versions 1.73 and 1.107

version 1.73, 2013/06/21 14:15:52 version 1.107, 2024/01/17 16:57:10
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.15    RPL/2 (R) version 4.1.36
   Copyright (C) 1989-2013 Dr. BERTRAND Joël    Copyright (C) 1989-2024 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 80  formateur_fichier(struct_processus *s_et Line 80  formateur_fichier(struct_processus *s_et
     logical1                    presence_signe;      logical1                    presence_signe;
   
     struct_liste_chainee        *l_atome;      struct_liste_chainee        *l_atome;
       struct_liste_chainee        *l_compteur;
     struct_liste_chainee        *l_element_courant;      struct_liste_chainee        *l_element_courant;
     struct_liste_chainee        *l_element_courant_format;      struct_liste_chainee        *l_element_courant_format;
     struct_liste_chainee        *l_liste1;      struct_liste_chainee        *l_liste1;
     struct_liste_chainee        *l_liste2;      struct_liste_chainee        *l_liste2;
       struct_liste_chainee        *l_tmp;
   
     struct_objet                *s_format_tmp;      struct_objet                *s_format_tmp;
     struct_objet                *s_sous_objet;      struct_objet                *s_sous_objet;
Line 95  formateur_fichier(struct_processus *s_et Line 97  formateur_fichier(struct_processus *s_et
     unsigned char               *chaine;      unsigned char               *chaine;
     unsigned char               *chaine_fonction;      unsigned char               *chaine_fonction;
     unsigned char               *chaine_formatee;      unsigned char               *chaine_formatee;
       unsigned char               *chaine_offset;
     unsigned char               *chaine_tampon;      unsigned char               *chaine_tampon;
     unsigned char               *chaine_sauvegarde;      unsigned char               *chaine_sauvegarde;
     unsigned char               *format_chaine;      unsigned char               *format_chaine;
Line 112  formateur_fichier(struct_processus *s_et Line 115  formateur_fichier(struct_processus *s_et
     integer8                    nombre_lignes;      integer8                    nombre_lignes;
   
     integer8                    longueur_chaine_traitee;      integer8                    longueur_chaine_traitee;
       integer8                    longueur_element;
     integer8                    longueur_fonction;      integer8                    longueur_fonction;
     integer8                    longueur_liste;      integer8                    longueur_liste;
       integer8                    longueur_objet;
     integer8                    longueur_reelle_chaine;      integer8                    longueur_reelle_chaine;
     integer8                    longueur_totale;      integer8                    longueur_totale;
     integer8                    position_1;      integer8                    position_1;
Line 234  formateur_fichier(struct_processus *s_et Line 239  formateur_fichier(struct_processus *s_et
                                     .instruction_courante[1]                                      .instruction_courante[1]
                                     == '-')) ? d_vrai : d_faux;                                      == '-')) ? d_vrai : d_faux;
   
                               (*s_etat_processus).type_en_cours = NON;
                             recherche_type(s_etat_processus);                              recherche_type(s_etat_processus);
   
                             if ((*s_etat_processus).erreur_execution != d_ex)                              if ((*s_etat_processus).erreur_execution != d_ex)
Line 293  formateur_fichier(struct_processus *s_et Line 299  formateur_fichier(struct_processus *s_et
                                     if ((strcmp(chaine_fonction, "AND") == 0) ||                                      if ((strcmp(chaine_fonction, "AND") == 0) ||
                                             (strcmp(chaine_fonction, "XOR") ==                                              (strcmp(chaine_fonction, "XOR") ==
                                             0) || (strcmp(chaine_fonction, "OR")                                              0) || (strcmp(chaine_fonction, "OR")
                                             == 0))                                              == 0) || (strcmp(chaine_fonction,
                                               "EQV") == 0))
                                     {                                      {
                                         autorisation_parenthese = d_vrai;                                          autorisation_parenthese = d_vrai;
                                     }                                      }
Line 320  formateur_fichier(struct_processus *s_et Line 327  formateur_fichier(struct_processus *s_et
                                             || (strcmp(chaine_fonction, "AND")                                              || (strcmp(chaine_fonction, "AND")
                                             == 0) || (strcmp(chaine_fonction,                                              == 0) || (strcmp(chaine_fonction,
                                             "XOR") == 0) || (strcmp(                                              "XOR") == 0) || (strcmp(
                                             chaine_fonction, "OR") == 0))                                              chaine_fonction, "OR") == 0) ||
                                               (strcmp(chaine_fonction, "EQV")
                                               == 0))
                                     {                                      {
                                         autorisation_parenthese = d_vrai;                                          autorisation_parenthese = d_vrai;
                                     }                                      }
Line 401  formateur_fichier(struct_processus *s_et Line 410  formateur_fichier(struct_processus *s_et
                                     "'%s'", (unsigned char *)                                      "'%s'", (unsigned char *)
                                     (*s_sous_objet_1).objet);                                      (*s_sous_objet_1).objet);
   
                               (*s_etat_processus).type_en_cours = NON;
                             recherche_type(s_etat_processus);                              recherche_type(s_etat_processus);
   
                             if ((*s_etat_processus).erreur_execution != d_ex)                              if ((*s_etat_processus).erreur_execution != d_ex)
Line 458  formateur_fichier(struct_processus *s_et Line 468  formateur_fichier(struct_processus *s_et
                                     if ((strcmp(chaine_fonction, "AND") == 0) ||                                      if ((strcmp(chaine_fonction, "AND") == 0) ||
                                             (strcmp(chaine_fonction, "XOR") ==                                              (strcmp(chaine_fonction, "XOR") ==
                                             0) || (strcmp(chaine_fonction, "OR")                                              0) || (strcmp(chaine_fonction, "OR")
                                             == 0))                                              == 0) || (strcmp(chaine_fonction,
                                               "EQV") == 0))
                                     {                                      {
                                         autorisation_parenthese = d_vrai;                                          autorisation_parenthese = d_vrai;
                                     }                                      }
Line 475  formateur_fichier(struct_processus *s_et Line 486  formateur_fichier(struct_processus *s_et
                                             || (strcmp(chaine_fonction, "AND")                                              || (strcmp(chaine_fonction, "AND")
                                             == 0) || (strcmp(chaine_fonction,                                              == 0) || (strcmp(chaine_fonction,
                                             "XOR") == 0) || (strcmp(                                              "XOR") == 0) || (strcmp(
                                             chaine_fonction, "OR") == 0))                                              chaine_fonction, "OR") == 0) ||
                                               (strcmp(chaine_fonction, "EQV")
                                               == 0))
                                     {                                      {
                                         autorisation_parenthese = d_vrai;                                          autorisation_parenthese = d_vrai;
                                     }                                      }
Line 716  formateur_fichier(struct_processus *s_et Line 729  formateur_fichier(struct_processus *s_et
                                 "XOR") == 0) || (strcmp((*((struct_fonction *)                                  "XOR") == 0) || (strcmp((*((struct_fonction *)
                                 (*(*l_element_courant).donnee).objet))                                  (*(*l_element_courant).donnee).objet))
                                 .nom_fonction,                                  .nom_fonction,
                                 "AND") == 0))                                  "AND") == 0) || (strcmp((*((struct_fonction *)
                                   (*(*l_element_courant).donnee).objet))
                                   .nom_fonction, "EQV") == 0))
                         {                          {
                             if (depilement(s_etat_processus,                              if (depilement(s_etat_processus,
                                     &((*s_etat_processus)                                      &((*s_etat_processus)
Line 1531  formateur_fichier(struct_processus *s_et Line 1546  formateur_fichier(struct_processus *s_et
                 }                  }
                 else                  else
                 {                  {
                     if ((format_chaine = conversion_majuscule((unsigned char *)                      if ((format_chaine = conversion_majuscule(
                               s_etat_processus, (unsigned char *)
                             (*(*l_element_courant_format).donnee).objet))                              (*(*l_element_courant_format).donnee).objet))
                             == NULL)                              == NULL)
                     {                      {
Line 1933  formateur_fichier(struct_processus *s_et Line 1949  formateur_fichier(struct_processus *s_et
                     else                      else
                     {                      {
                         if ((format_chaine = conversion_majuscule(                          if ((format_chaine = conversion_majuscule(
                                   s_etat_processus,
                                 (unsigned char *) (*(*((struct_tableau *)                                  (unsigned char *) (*(*((struct_tableau *)
                                 (*s_format).objet)).elements[i]).objet))                                  (*s_format).objet)).elements[i]).objet))
                                 == NULL)                                  == NULL)
Line 2941  formateur_fichier(struct_processus *s_et Line 2958  formateur_fichier(struct_processus *s_et
 #define __zone() \  #define __zone() \
         do { int _i; \          do { int _i; \
             for(_i = 0; _i < longueur_totale; _i++) \              for(_i = 0; _i < longueur_totale; _i++) \
                 printf("%02X ", chaine[_i]); printf("\b\n"); } while(0)                  { printf("%02X ", chaine[_i]); printf("\b\n"); } } while(0)
   
         /*          /*
          * Chaque enregistrement est composé d'une donnée (une liste)           * Chaque enregistrement est composé d'une donnée (une liste)
Line 3091  formateur_fichier(struct_processus *s_et Line 3108  formateur_fichier(struct_processus *s_et
          * 1110 0 XXX               fonction de longueur XXX           * 1110 0 XXX               fonction de longueur XXX
          * 1110 10 LL               fonction de longueur integer*LL           * 1110 10 LL               fonction de longueur integer*LL
          *           *
            * 1111 XXXXX               page 2
            * 1111 XXXXX 000000001     entier long
            * 1111 XXXXX 000000010     réel long
            * 1111 XXXXX 000000011     complexe long
            *
          * Les longueurs indiquées par le champ LL suivent l'en-tête :           * Les longueurs indiquées par le champ LL suivent l'en-tête :
          *      00 : integer*1           *      00 : integer*1
          *      01 : integer*2           *      01 : integer*2
Line 3717  formateur_fichier(struct_processus *s_et Line 3739  formateur_fichier(struct_processus *s_et
                                 0, 0, ' ', 'U', longueur_effective, recursivite,                                  0, 0, ' ', 'U', longueur_effective, recursivite,
                                 export_fichier)) == NULL)                                  export_fichier)) == NULL)
                         {                          {
                               free(chaine);
                             return(NULL);                              return(NULL);
                         }                          }
                     }                      }
Line 3729  formateur_fichier(struct_processus *s_et Line 3752  formateur_fichier(struct_processus *s_et
                                 0, 0, 'N', 'U', longueur_effective, recursivite,                                  0, 0, 'N', 'U', longueur_effective, recursivite,
                                 export_fichier)) == NULL)                                  export_fichier)) == NULL)
                         {                          {
                               free(chaine);
                             return(NULL);                              return(NULL);
                         }                          }
                     }                      }
Line 3757  formateur_fichier(struct_processus *s_et Line 3781  formateur_fichier(struct_processus *s_et
                 }                  }
                 else                  else
                 {                  {
                     if ((format_chaine = conversion_majuscule((unsigned char *)                      format_degenere = d_faux;
   
                       if ((format_chaine = conversion_majuscule(
                               s_etat_processus, (unsigned char *)
                             (*(*l_element_courant_format).donnee).objet))                              (*(*l_element_courant_format).donnee).objet))
                             == NULL)                              == NULL)
                     {                      {
Line 3841  formateur_fichier(struct_processus *s_et Line 3868  formateur_fichier(struct_processus *s_et
   
                     free(format_chaine);                      free(format_chaine);
   
                     // Si le format_sortie vaut 'N', on remplace le format par                      // Construction d'une liste de format
                     // { "native*(*)" }. L'intérêt est de pouvoir traiter une  
                     // liste par un format "native*(*)".  
   
                     if ((format_sortie == 'N') && ((*(*l_element_courant)                      if ((s_format_tmp = allocation(s_etat_processus, LST))
                             .donnee).type == LST))                              == NULL)
                     {                      {
                         if ((s_format_tmp = allocation(s_etat_processus, LST))                          return(NULL);
                                 == NULL)                      }
   
                       if ((*(*l_element_courant).donnee).type == LST)
                       {
                           l_compteur = (struct_liste_chainee *)
                                   (*(*l_element_courant).donnee).objet;
   
                           while(l_compteur != NULL)
                         {                          {
                             return(NULL);                              l_tmp = (*s_format_tmp).objet;
                         }  
   
                               if (((*s_format_tmp).objet = allocation_maillon(
                                       s_etat_processus)) == NULL)
                               {
                                   return(NULL);
                               }
   
                               if (((*((struct_liste_chainee *)
                                       (*s_format_tmp).objet))
                                       .donnee = copie_objet(s_etat_processus,
                                       (*l_element_courant_format).donnee, 'P'))
                                       == NULL)
                               {
                                   return(NULL);
                               }
   
                               (*((struct_liste_chainee *) (*s_format_tmp).objet))
                                       .suivant = l_tmp;
                               l_compteur = (*l_compteur).suivant;
                           }
                       }
                       else
                       {
                         if (((*s_format_tmp).objet = allocation_maillon(                          if (((*s_format_tmp).objet = allocation_maillon(
                                 s_etat_processus)) == NULL)                                  s_etat_processus)) == NULL)
                         {                          {
                             return(NULL);                              return(NULL);
                         }                          }
   
                         (*((struct_liste_chainee *) (*s_format_tmp).objet))  
                                 .suivant = NULL;  
   
                         if (((*((struct_liste_chainee *) (*s_format_tmp).objet))                          if (((*((struct_liste_chainee *) (*s_format_tmp).objet))
                                 .donnee = allocation(s_etat_processus, CHN))                                  .donnee = copie_objet(s_etat_processus,
                                   (*l_element_courant_format).donnee, 'P'))
                                 == NULL)                                  == NULL)
                         {                          {
                             return(NULL);                              return(NULL);
                         }                          }
   
                         if (((*(*((struct_liste_chainee *) (*s_format_tmp)                          (*((struct_liste_chainee *) (*s_format_tmp).objet))
                                 .objet)).donnee).objet = malloc(11 *                                  .suivant = NULL;
                                 sizeof(unsigned char))) == NULL)  
                         {  
                             (*s_etat_processus).erreur_systeme =  
                                     d_es_allocation_memoire;  
                             return(NULL);  
                         }  
   
                         strcpy((unsigned char *) (*(*((struct_liste_chainee *)  
                                 (*s_format_tmp).objet)).donnee).objet,  
                                 "native*(*)");  
                     }  
                     else  
                     {  
                         if ((s_format_tmp = copie_objet(s_etat_processus,  
                                 s_format, 'P')) == NULL)  
                         {  
                             return(NULL);  
                         }  
                     }                      }
   
                     if ((chaine_formatee = formateur_fichier(s_etat_processus,                      if ((chaine_formatee = formateur_fichier(s_etat_processus,
Line 3920  formateur_fichier(struct_processus *s_et Line 3953  formateur_fichier(struct_processus *s_et
                     free(chaine_formatee);                      free(chaine_formatee);
                 }                  }
   
                 if (format_sortie != 'N')                  l_element_courant_format = (*l_element_courant_format).suivant;
                 {  
                     l_element_courant_format =  
                             (*l_element_courant_format).suivant;  
                 }  
   
                 nombre_elements++;                  nombre_elements++;
                 l_element_courant = (*l_element_courant).suivant;                  l_element_courant = (*l_element_courant).suivant;
             }              }
   
             if (format_sortie != 'N')              if ((l_element_courant != NULL) ||
                       (l_element_courant_format != NULL))
             {              {
                 if ((l_element_courant != NULL) ||                  free(chaine);
                         (l_element_courant_format != NULL))  
                 {  
                     free(chaine);  
   
                     (*s_etat_processus).erreur_execution =                  (*s_etat_processus).erreur_execution =
                             d_ex_erreur_format_fichier;                          d_ex_erreur_format_fichier;
                     return(NULL);                  return(NULL);
                 }  
             }              }
   
             (*longueur_effective) = longueur_totale;              (*longueur_effective) = longueur_totale;
Line 3951  formateur_fichier(struct_processus *s_et Line 3976  formateur_fichier(struct_processus *s_et
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Table    Table
     Bits de poids fort : 1001
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               chaine = malloc(sizeof(unsigned char));
   
               if (chaine == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return(NULL);
               }
   
               type_binaire = 0x90;
               longueur_liste = (*((struct_tableau *) (*s_objet).objet))
                       .nombre_elements;
   
               if (longueur_liste < (1LL << 3))
               {
                   chaine[0] = (unsigned char) (type_binaire |
                           (longueur_liste & 0x7));
               }
               else if (longueur_liste < (1LL << 8))
               {
                   chaine[0] = (unsigned char) (type_binaire | 0x08);
               }
               else if (longueur_liste < (1LL << 16))
               {
                   chaine[0] = (unsigned char ) (type_binaire | 0x09);
               }
               else if (longueur_liste < (1LL << 32))
               {
                   chaine[0] = (unsigned char) (type_binaire | 0x0A);
               }
               else
               {
                   chaine[0] = (unsigned char) (type_binaire | 0x0B);
               }
   
               longueur_totale = 1;
   
               if ((chaine[0] & 0x8) != 0)
               { // Longueur sur un entier distinct de l'en-tête
                   switch(chaine[0] & 0x03)
                   {
                       case 0x00 :
                       {
                           longueur_totale += 1;
   
                           if ((chaine = realloc(chaine,
                                   ((size_t) longueur_totale) *
                                   sizeof(unsigned char))) == NULL)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_allocation_memoire;
                               return(NULL);
                           }
   
                           chaine[longueur_totale - 1] =
                                   (unsigned char) (longueur_liste & 0xFF);
                           break;
                       }
   
                       case 0x01 :
                       {
                           longueur_totale += 2;
   
                           if ((chaine = realloc(chaine,
                                   ((size_t) longueur_totale) *
                                   sizeof(unsigned char))) == NULL)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_allocation_memoire;
                               return(NULL);
                           }
   
                           chaine[longueur_totale - 2] =
                                   (unsigned char) ((longueur_liste >> 8) & 0xFF);
                           chaine[longueur_totale - 1] =
                                   (unsigned char) (longueur_liste & 0xFF);
                           break;
                       }
   
                       case 0x02 :
                       {
                           longueur_totale += 4;
   
                           if ((chaine = realloc(chaine,
                                   ((size_t) longueur_totale) *
                                   sizeof(unsigned char))) == NULL)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_allocation_memoire;
                               return(NULL);
                           }
   
                           chaine[longueur_totale - 4] =
                                   (unsigned char) ((longueur_liste >> 24) & 0xFF);
                           chaine[longueur_totale - 3] =
                                   (unsigned char) ((longueur_liste >> 16) & 0xFF);
                           chaine[longueur_totale - 2] =
                                   (unsigned char) ((longueur_liste >> 8) & 0xFF);
                           chaine[longueur_totale - 1] =
                                   (unsigned char) (longueur_liste & 0xFF);
                           break;
                       }
   
                       case 0x03 :
                       {
                           longueur_totale += 8;
   
                           if ((chaine = realloc(chaine,
                                   ((size_t) longueur_totale) *
                                   sizeof(unsigned char))) == NULL)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_allocation_memoire;
                               return(NULL);
                           }
   
                           chaine[longueur_totale - 8] =
                                   (unsigned char) ((longueur_liste >> 56) & 0xFF);
                           chaine[longueur_totale - 7] =
                                   (unsigned char) ((longueur_liste >> 48) & 0xFF);
                           chaine[longueur_totale - 6] =
                                   (unsigned char) ((longueur_liste >> 40) & 0xFF);
                           chaine[longueur_totale - 5] =
                                   (unsigned char) ((longueur_liste >> 32) & 0xFF);
                           chaine[longueur_totale - 4] =
                                   (unsigned char) ((longueur_liste >> 24) & 0xFF);
                           chaine[longueur_totale - 3] =
                                   (unsigned char) ((longueur_liste >> 16) & 0xFF);
                           chaine[longueur_totale - 2] =
                                   (unsigned char) ((longueur_liste >> 8) & 0xFF);
                           chaine[longueur_totale - 1] =
                                   (unsigned char) (longueur_liste & 0xFF);
                           break;
                       }
   
                       default :
                       {
                           BUG(1, printf("Internal format error\n"));
                       }
                   }
               }
   
   uprintf("F=%s\n", formateur(s_etat_processus, 0, s_format));
   uprintf("D=%s\n", formateur(s_etat_processus, 0, s_objet));
               if ((*s_format).type == CHN)
               {
   uprintf("<1>\n");
                   if ((format_chaine = conversion_majuscule(
                           s_etat_processus, (unsigned char *)
                           (*s_format).objet)) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   if (strncmp("INTEGER*", format_chaine, 8) == 0)
                   {
                       format_sortie = 'I';
                       position_1 = 8;
                   }
                   else if (strncmp("LOGICAL*", format_chaine, 8) == 0)
                   {
                       format_sortie = 'L';
                       position_1 = 8;
                   }
                   else if (strncmp("REAL*", format_chaine, 5) == 0)
                   {
                       format_sortie = 'R';
                       position_1 = 5;
                   }
                   else if (strncmp("COMPLEX*", format_chaine, 8) == 0)
                   {
                       format_sortie = 'C';
                       position_1 = 8;
                   }
                   else if (strncmp("CHARACTER*", format_chaine, 10) == 0)
                   {
                       format_sortie = 'S';
                       position_1 = 10;
                       format_degenere = d_vrai;
                   }
                   else if (strcmp("NATIVE*(*)", format_chaine) == 0)
                   {
                       format_sortie = 'N';
                       position_1 = 7;
                       format_degenere = d_vrai;
                   }
                   else
                   {
                       free(chaine);
                       free(format_chaine);
   
                       (*s_etat_processus).erreur_execution =
                               d_ex_erreur_format_fichier;
                       return(NULL);
                   }
   
                   if (format_chaine[position_1] == d_code_fin_chaine)
                   {
                       free(chaine);
                       free(format_chaine);
   
                       (*s_etat_processus).erreur_execution =
                               d_ex_erreur_format_fichier;
                       return(NULL);
                   }
   
                   if (strcmp(&(format_chaine[position_1]), "(*)") != 0)
                   {
                       if (sscanf(&(format_chaine[position_1]), "%lld",
                               &longueur) != 1)
                       {
                           free(chaine);
                           free(format_chaine);
   
                           (*s_etat_processus).erreur_execution =
                                   d_ex_erreur_format_fichier;
                           return(NULL);
                       }
   
                       longueur_champ = longueur;
                   }
                   else
                   {
                       longueur_champ = -1;
                       longueur = -1;
                   }
   
                   free(format_chaine);
   
                   if ((s_format_tmp = allocation(s_etat_processus, TBL))
                           == NULL)
                   {
                       return(NULL);
                   }
   
                   (*((struct_tableau *) (*s_format_tmp).objet))
                           .nombre_elements = (*((struct_tableau *)
                           (*s_objet).objet)).nombre_elements;
   
                   for(i = 0; i < (*((struct_tableau *) (*s_format_tmp).objet))
                           .nombre_elements; i++)
                   {
                       if (((*((struct_tableau *) (*s_format_tmp).objet))
                               .elements[i] = copie_objet(s_etat_processus,
                               s_format, 'P')) == NULL)
                       {
                           return(NULL);
                       }
                   }
   
   uprintf("%s\n", formateur(s_etat_processus, 0, s_format));
                   if ((chaine_formatee = formateur_fichier(s_etat_processus,
                           s_objet, s_format_tmp,
                           longueur, longueur_champ,
                           format_sortie, type, longueur_effective,
                           recursivite, export_fichier)) == NULL)
                   {
                       liberation(s_etat_processus, s_format_tmp);
                       free(chaine);
                       return(NULL);
                   }
   
                   liberation(s_etat_processus, s_format_tmp);
               }
               else if ((*s_format).type == TBL)
               {
   uprintf("<2>\n");
                   free(chaine);
                   // A FIXER
               }
               else
               {
   uprintf("<3>\n");
                   free(chaine);
   
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_format_fichier;
                   return(NULL);
               }
   
               (*longueur_effective) = longueur_totale;
         }          }
         else if ((*s_objet).type == MCX)          else if ((*s_objet).type == MCX)
         {          {
Line 3962  formateur_fichier(struct_processus *s_et Line 4271  formateur_fichier(struct_processus *s_et
   Matrice complexe    Matrice complexe
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'C';
                   longueur = 16;
               }
   
               if (format_sortie != 'C')
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_format_fichier;
                   return(NULL);
               }
   
               longueur_objet = (*((struct_matrice *) (*s_objet).objet))
                       .nombre_lignes * (*((struct_matrice *) (*s_objet).objet))
                       .nombre_colonnes;
   
               if (((*((struct_matrice *) (*s_objet).objet)).nombre_lignes
                       < (1LL << 8)) && ((*((struct_matrice *) (*s_objet).objet))
                       .nombre_colonnes < (1LL << 8)))
               {
                   // Taille sur un octet
                   if ((chaine = malloc((size_t) ((*longueur_effective) =
                           (3 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xD2;
                   chaine[1] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes & 0xFF);
                   chaine[2] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes & 0xFF);
                   chaine_offset = chaine + 3;
               }
               else if (((*((struct_matrice *) (*s_objet).objet)).nombre_lignes
                       < (1LL << 16)) && ((*((struct_matrice *) (*s_objet).objet))
                       .nombre_colonnes < (1LL << 16)))
               {
                   // Taille sur deux octets
                   if ((chaine = malloc((size_t) ((*longueur_effective) =
                           (5 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xD6;
                   chaine[1] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 8) & 0xFF);
                   chaine[2] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes & 0xFF);
                   chaine[3] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 8) & 0xFF);
                   chaine[4] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes & 0xFF);
                   chaine_offset = chaine + 5;
               }
               else if (((*((struct_matrice *) (*s_objet).objet)).nombre_lignes
                       < (1LL << 32)) && ((*((struct_matrice *) (*s_objet).objet))
                       .nombre_colonnes < (1LL << 32)))
               {
                   // Taille sur quatre octets
                   if ((chaine = malloc((size_t) (((*longueur_effective) =
                           9 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xDA;
                   chaine[1] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 24) & 0xFF);
                   chaine[2] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 16) & 0xFF);
                   chaine[3] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 8) & 0xFF);
                   chaine[4] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes & 0xFF);
                   chaine[5] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 24) & 0xFF);
                   chaine[6] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 16) & 0xFF);
                   chaine[7] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 8) & 0xFF);
                   chaine[8] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes & 0xFF);
                   chaine_offset = chaine + 9;
               }
               else
               {
                   // Taille sur huit octets
                   if ((chaine = malloc((size_t) ((*longueur_effective) =
                           (17 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xDE;
                   chaine[1] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 56) & 0xFF);
                   chaine[2] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 48) & 0xFF);
                   chaine[3] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 40) & 0xFF);
                   chaine[4] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 32) & 0xFF);
                   chaine[5] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 24) & 0xFF);
                   chaine[6] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 16) & 0xFF);
                   chaine[7] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 8) & 0xFF);
                   chaine[8] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes & 0xFF);
                   chaine[9] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 56) & 0xFF);
                   chaine[10] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 48) & 0xFF);
                   chaine[11] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 40) & 0xFF);
                   chaine[12] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 32) & 0xFF);
                   chaine[13] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 24) & 0xFF);
                   chaine[14] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 16) & 0xFF);
                   chaine[15] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 8) & 0xFF);
                   chaine[16] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes & 0xFF);
                   chaine_offset = chaine + 17;
               }
   
               switch(longueur)
               {
                   case 8:
                   {
                       break;
                   }
   
                   default:
                   case 16:
                   {
                       chaine[0] |= 0x01;
                       break;
                   }
               }
   
               for(i = 0; i < (*((struct_matrice *) (*s_objet).objet))
                       .nombre_lignes; i++)
               {
                   for(j = 0; j < (*((struct_matrice *) (*s_objet).objet))
                           .nombre_colonnes; j++)
                   {
                       if ((chaine_tampon = formateur_fichier_binaire_nombre(
                               s_etat_processus, &(((complex16 **)
                               (*((struct_matrice *) (*s_objet).objet)).tableau)
                               [i][j]), 'R', format_sortie,
                               longueur, &longueur_element)) == NULL)
                       {
                           free(chaine);
                           return(NULL);
                       }
   
                       memcpy(chaine_offset + (((i * (*((struct_matrice *)
                               (*s_objet).objet)).nombre_colonnes) + j) *
                               longueur), chaine_tampon + 1, (size_t) longueur);
                       free(chaine_tampon);
                   }
               }
         }          }
         else if ((*s_objet).type == MIN)          else if ((*s_objet).type == MIN)
         {          {
Line 3971  formateur_fichier(struct_processus *s_et Line 4462  formateur_fichier(struct_processus *s_et
   Matrice entière    Matrice entière
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'I';
                   longueur = 8;
               }
   
               if ((format_sortie != 'I') && (format_sortie != 'R')
                       && (format_sortie != 'C'))
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_format_fichier;
                   return(NULL);
               }
   
               longueur_objet = (*((struct_matrice *) (*s_objet).objet))
                       .nombre_lignes * (*((struct_matrice *) (*s_objet).objet))
                       .nombre_colonnes;
   
               if (((*((struct_matrice *) (*s_objet).objet)).nombre_lignes
                       < (1LL << 8)) && ((*((struct_matrice *) (*s_objet).objet))
                       .nombre_colonnes < (1LL << 8)))
               {
                   // Taille sur un octet
                   if ((chaine = malloc((size_t) ((*longueur_effective) =
                           (3 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0x00;
                   chaine[1] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes & 0xFF);
                   chaine[2] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes & 0xFF);
                   chaine_offset = chaine + 3;
               }
               else if (((*((struct_matrice *) (*s_objet).objet)).nombre_lignes
                       < (1LL << 16)) && ((*((struct_matrice *) (*s_objet).objet))
                       .nombre_colonnes < (1LL << 16)))
               {
                   // Taille sur deux octets
                   if ((chaine = malloc((size_t) ((*longueur_effective) =
                           (5 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0x04;
                   chaine[1] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 8) & 0xFF);
                   chaine[2] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes & 0xFF);
                   chaine[3] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 8) & 0xFF);
                   chaine[4] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes & 0xFF);
                   chaine_offset = chaine + 5;
               }
               else if (((*((struct_matrice *) (*s_objet).objet)).nombre_lignes
                       < (1LL << 32)) && ((*((struct_matrice *) (*s_objet).objet))
                       .nombre_colonnes < (1LL << 32)))
               {
                   // Taille sur quatre octets
                   if ((chaine = malloc((size_t) (((*longueur_effective) =
                           9 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0x08;
                   chaine[1] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 24) & 0xFF);
                   chaine[2] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 16) & 0xFF);
                   chaine[3] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 8) & 0xFF);
                   chaine[4] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes & 0xFF);
                   chaine[5] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 24) & 0xFF);
                   chaine[6] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 16) & 0xFF);
                   chaine[7] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 8) & 0xFF);
                   chaine[8] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes & 0xFF);
                   chaine_offset = chaine + 9;
               }
               else
               {
                   // Taille sur huit octets
                   if ((chaine = malloc((size_t) ((*longueur_effective) =
                           (17 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0x0C;
                   chaine[1] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 56) & 0xFF);
                   chaine[2] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 48) & 0xFF);
                   chaine[3] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 40) & 0xFF);
                   chaine[4] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 32) & 0xFF);
                   chaine[5] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 24) & 0xFF);
                   chaine[6] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 16) & 0xFF);
                   chaine[7] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 8) & 0xFF);
                   chaine[8] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes & 0xFF);
                   chaine[9] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 56) & 0xFF);
                   chaine[10] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 48) & 0xFF);
                   chaine[11] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 40) & 0xFF);
                   chaine[12] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 32) & 0xFF);
                   chaine[13] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 24) & 0xFF);
                   chaine[14] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 16) & 0xFF);
                   chaine[15] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 8) & 0xFF);
                   chaine[16] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes & 0xFF);
                   chaine_offset = chaine + 17;
               }
   
               switch(format_sortie)
               {
                   default:
                   case 'I':
                   {
                       switch(longueur)
                       {
                           case 1:
                           {
                               break;
                           }
   
                           case 2:
                           {
                               chaine[0] |= 0x01;
                               break;
                           }
   
                           case 4:
                           {
                               chaine[0] |= 0x02;
                               break;
                           }
   
                           default:
                           case 8:
                           {
                               chaine[0] |= 0x03;
                               break;
                           }
                       }
   
                       chaine[0] |= 0x30;
                       break;
                   }
   
                   case 'R':
                   {
                       switch(longueur)
                       {
                           case 4:
                           {
                               break;
                           }
   
                           default:
                           case 8:
                           {
                               chaine[0] |= 0x01;
                               break;
                           }
                       }
   
                       chaine[0] |= 0xC0;
                       break;
                   }
   
                   case 'C':
                   {
                       switch(longueur)
                       {
                           case 8:
                           {
                               break;
                           }
   
                           default:
                           case 16:
                           {
                               chaine[0] |= 0x01;
                               break;
                           }
                       }
   
                       chaine[0] |= 0xD0;
                       break;
                   }
               }
   
               for(i = 0; i < (*((struct_matrice *) (*s_objet).objet))
                       .nombre_lignes; i++)
               {
                   for(j = 0; j < (*((struct_matrice *) (*s_objet).objet))
                           .nombre_colonnes; j++)
                   {
                       if ((chaine_tampon = formateur_fichier_binaire_nombre(
                               s_etat_processus, &(((integer8 **)
                               (*((struct_matrice *) (*s_objet).objet)).tableau)
                               [i][j]), 'I', format_sortie,
                               longueur, &longueur_element)) == NULL)
                       {
                           free(chaine);
                           return(NULL);
                       }
   
                       memcpy(chaine_offset + (((i * (*((struct_matrice *)
                               (*s_objet).objet)).nombre_colonnes) + j) *
                               longueur), chaine_tampon + 1, (size_t) longueur);
                       free(chaine_tampon);
                   }
               }
         }          }
         else if ((*s_objet).type == MRL)          else if ((*s_objet).type == MRL)
         {          {
Line 3980  formateur_fichier(struct_processus *s_et Line 4718  formateur_fichier(struct_processus *s_et
   Matrice réelle    Matrice réelle
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
               if (format_sortie == 'N')
               {
                   format_sortie = 'R';
                   longueur = 8;
               }
   
               if ((format_sortie != 'R') && (format_sortie != 'C'))
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_format_fichier;
                   return(NULL);
               }
   
               longueur_objet = (*((struct_matrice *) (*s_objet).objet))
                       .nombre_lignes * (*((struct_matrice *) (*s_objet).objet))
                       .nombre_colonnes;
   
               if (((*((struct_matrice *) (*s_objet).objet)).nombre_lignes
                       < (1LL << 8)) && ((*((struct_matrice *) (*s_objet).objet))
                       .nombre_colonnes < (1LL << 8)))
               {
                   // Taille sur un octet
                   if ((chaine = malloc((size_t) ((*longueur_effective) =
                           (3 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xC2;
                   chaine[1] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes & 0xFF);
                   chaine[2] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes & 0xFF);
                   chaine_offset = chaine + 3;
               }
               else if (((*((struct_matrice *) (*s_objet).objet)).nombre_lignes
                       < (1LL << 16)) && ((*((struct_matrice *) (*s_objet).objet))
                       .nombre_colonnes < (1LL << 16)))
               {
                   // Taille sur deux octets
                   if ((chaine = malloc((size_t) ((*longueur_effective) =
                           (5 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xC6;
                   chaine[1] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 8) & 0xFF);
                   chaine[2] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes & 0xFF);
                   chaine[3] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 8) & 0xFF);
                   chaine[4] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes & 0xFF);
                   chaine_offset = chaine + 5;
               }
               else if (((*((struct_matrice *) (*s_objet).objet)).nombre_lignes
                       < (1LL << 32)) && ((*((struct_matrice *) (*s_objet).objet))
                       .nombre_colonnes < (1LL << 32)))
               {
                   // Taille sur quatre octets
                   if ((chaine = malloc((size_t) (((*longueur_effective) =
                           9 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xCA;
                   chaine[1] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 24) & 0xFF);
                   chaine[2] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 16) & 0xFF);
                   chaine[3] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 8) & 0xFF);
                   chaine[4] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes & 0xFF);
                   chaine[5] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 24) & 0xFF);
                   chaine[6] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 16) & 0xFF);
                   chaine[7] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 8) & 0xFF);
                   chaine[8] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes & 0xFF);
                   chaine_offset = chaine + 9;
               }
               else
               {
                   // Taille sur huit octets
                   if ((chaine = malloc((size_t) ((*longueur_effective) =
                           (17 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xCE;
                   chaine[1] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 56) & 0xFF);
                   chaine[2] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 48) & 0xFF);
                   chaine[3] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 40) & 0xFF);
                   chaine[4] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 32) & 0xFF);
                   chaine[5] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 24) & 0xFF);
                   chaine[6] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 16) & 0xFF);
                   chaine[7] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 8) & 0xFF);
                   chaine[8] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes & 0xFF);
                   chaine[9] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 56) & 0xFF);
                   chaine[10] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 48) & 0xFF);
                   chaine[11] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 40) & 0xFF);
                   chaine[12] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 32) & 0xFF);
                   chaine[13] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 24) & 0xFF);
                   chaine[14] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 16) & 0xFF);
                   chaine[15] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 8) & 0xFF);
                   chaine[16] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes & 0xFF);
                   chaine_offset = chaine + 17;
               }
   
               switch(format_sortie)
               {
                   default:
                   case 'R':
                   {
                       switch(longueur)
                       {
                           case 4:
                           {
                               break;
                           }
   
                           default:
                           case 8:
                           {
                               chaine[0] |= 0x01;
                               break;
                           }
                       }
   
                       break;
                   }
   
                   case 'C':
                   {
                       switch(longueur)
                       {
                           case 8:
                           {
                               break;
                           }
   
                           default:
                           case 16:
                           {
                               chaine[0] |= 0x01;
                               break;
                           }
                       }
   
                       chaine[0] |= 0x10;
                       break;
                   }
               }
   
               for(i = 0; i < (*((struct_matrice *) (*s_objet).objet))
                       .nombre_lignes; i++)
               {
                   for(j = 0; j < (*((struct_matrice *) (*s_objet).objet))
                           .nombre_colonnes; j++)
                   {
                       if ((chaine_tampon = formateur_fichier_binaire_nombre(
                               s_etat_processus, &(((real8 **)
                               (*((struct_matrice *) (*s_objet).objet)).tableau)
                               [i][j]), 'R', format_sortie,
                               longueur, &longueur_element)) == NULL)
                       {
                           free(chaine);
                           return(NULL);
                       }
   
                       memcpy(chaine_offset + (((i * (*((struct_matrice *)
                               (*s_objet).objet)).nombre_colonnes) + j) *
                               longueur), chaine_tampon + 1, (size_t) longueur);
                       free(chaine_tampon);
                   }
               }
         }          }
         else if ((*s_objet).type == NOM)          else if ((*s_objet).type == NOM)
         {          {
Line 4132  formateur_fichier(struct_processus *s_et Line 5081  formateur_fichier(struct_processus *s_et
   Vecteur complexe    Vecteur complexe
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'C';
                   longueur = 16;
               }
   
               if (format_sortie != 'C')
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_format_fichier;
                   return(NULL);
               }
   
               longueur_objet = (*((struct_vecteur *) (*s_objet).objet)).taille;
   
               if (longueur_objet < (1LL << 8))
               {
                   // Taille sur un octet
                   if ((chaine = malloc((size_t) ((*longueur_effective) =
                           (2 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xB2;
                   chaine[1] = (unsigned char) (longueur_objet & 0xFF);
                   chaine_offset = chaine + 2;
               }
               else if (longueur_objet < (1LL << 16))
               {
                   // Taille sur deux octets
                   if ((chaine = malloc((size_t) ((*longueur_effective) =
                           (3 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xB6;
                   chaine[1] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
                   chaine[2] = (unsigned char) (longueur_objet & 0xFF);
                   chaine_offset = chaine + 3;
               }
               else if (longueur_objet < (1LL << 32))
               {
                   // Taille sur quatre octets
                   if ((chaine = malloc((size_t) (((*longueur_effective) =
                           5 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xBA;
                   chaine[1] = (unsigned char) ((longueur_objet >> 24) & 0xFF);
                   chaine[2] = (unsigned char) ((longueur_objet >> 16) & 0xFF);
                   chaine[3] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
                   chaine[4] = (unsigned char) (longueur_objet & 0xFF);
                   chaine_offset = chaine + 5;
               }
               else
               {
                   // Taille sur huit octets
                   if ((chaine = malloc((size_t) ((*longueur_effective) =
                           (9 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xBE;
                   chaine[1] = (unsigned char) ((longueur_objet >> 56) & 0xFF);
                   chaine[2] = (unsigned char) ((longueur_objet >> 48) & 0xFF);
                   chaine[3] = (unsigned char) ((longueur_objet >> 40) & 0xFF);
                   chaine[4] = (unsigned char) ((longueur_objet >> 32) & 0xFF);
                   chaine[5] = (unsigned char) ((longueur_objet >> 24) & 0xFF);
                   chaine[6] = (unsigned char) ((longueur_objet >> 16) & 0xFF);
                   chaine[7] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
                   chaine[8] = (unsigned char) (longueur_objet & 0xFF);
                   chaine_offset = chaine + 9;
               }
   
               switch(longueur)
               {
                   case 8:
                   {
                       break;
                   }
   
                   default:
                   case 16:
                   {
                       chaine[0] |= 0x01;
                       break;
                   }
               }
   
               for(i = 0; i < longueur_objet; i++)
               {
                   if ((chaine_tampon = formateur_fichier_binaire_nombre(
                           s_etat_processus, &(((complex16 *) (*((struct_vecteur *)
                           (*s_objet).objet)).tableau)[i]), 'C', format_sortie,
                           longueur, &longueur_element)) == NULL)
                   {
                       free(chaine);
                       return(NULL);
                   }
   
                   memcpy(chaine_offset + (i * longueur), chaine_tampon + 1,
                           (size_t) longueur);
                   free(chaine_tampon);
               }
         }          }
         else if ((*s_objet).type == VIN)          else if ((*s_objet).type == VIN)
         {          {
Line 4141  formateur_fichier(struct_processus *s_et Line 5212  formateur_fichier(struct_processus *s_et
   Vecteur entier    Vecteur entier
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'I';
                   longueur = 8;
               }
   
               if ((format_sortie != 'I') && (format_sortie != 'R')
                       && (format_sortie != 'C'))
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_format_fichier;
                   return(NULL);
               }
   
               longueur_objet = (*((struct_vecteur *) (*s_objet).objet)).taille;
   
               if (longueur_objet < (1LL << 8))
               {
                   // Taille sur un octet
                   if ((chaine = malloc((size_t) ((*longueur_effective) =
                           (2 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0x20;
                   chaine[1] = (unsigned char) (longueur_objet & 0xFF);
                   chaine_offset = chaine + 2;
               }
               else if (longueur_objet < (1LL << 16))
               {
                   // Taille sur deux octets
                   if ((chaine = malloc((size_t) ((*longueur_effective) =
                           (3 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0x24;
                   chaine[1] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
                   chaine[2] = (unsigned char) (longueur_objet & 0xFF);
                   chaine_offset = chaine + 3;
               }
               else if (longueur_objet < (1LL << 32))
               {
                   // Taille sur quatre octets
                   if ((chaine = malloc((size_t) (((*longueur_effective) =
                           5 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0x28;
                   chaine[1] = (unsigned char) ((longueur_objet >> 24) & 0xFF);
                   chaine[2] = (unsigned char) ((longueur_objet >> 16) & 0xFF);
                   chaine[3] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
                   chaine[4] = (unsigned char) (longueur_objet & 0xFF);
                   chaine_offset = chaine + 5;
               }
               else
               {
                   // Taille sur huit octets
                   if ((chaine = malloc((size_t) ((*longueur_effective) =
                           (9 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0x2C;
                   chaine[1] = (unsigned char) ((longueur_objet >> 56) & 0xFF);
                   chaine[2] = (unsigned char) ((longueur_objet >> 48) & 0xFF);
                   chaine[3] = (unsigned char) ((longueur_objet >> 40) & 0xFF);
                   chaine[4] = (unsigned char) ((longueur_objet >> 32) & 0xFF);
                   chaine[5] = (unsigned char) ((longueur_objet >> 24) & 0xFF);
                   chaine[6] = (unsigned char) ((longueur_objet >> 16) & 0xFF);
                   chaine[7] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
                   chaine[8] = (unsigned char) (longueur_objet & 0xFF);
                   chaine_offset = chaine + 9;
               }
   
               switch(format_sortie)
               {
                   default:
                   case 'I':
                   {
                       switch(longueur)
                       {
                           case 1:
                           {
                               break;
                           }
   
                           case 2:
                           {
                               chaine[0] |= 0x01;
                               break;
                           }
   
                           case 4:
                           {
                               chaine[0] |= 0x02;
                               break;
                           }
   
                           default:
                           case 8:
                           {
                               chaine[0] |= 0x03;
                               break;
                           }
                       }
   
                       break;
                   }
   
                   case 'R':
                   {
                       switch(longueur)
                       {
                           case 4:
                           {
                               break;
                           }
   
                           default:
                           case 8:
                           {
                               chaine[0] |= 0x01;
                               break;
                           }
                       }
   
                       chaine[0] |= 0x80;
                       break;
                   }
   
                   case 'C':
                   {
                       switch(longueur)
                       {
                           case 8:
                           {
                               break;
                           }
   
                           default:
                           case 16:
                           {
                               chaine[0] |= 0x01;
                               break;
                           }
                       }
   
                       chaine[0] |= 0x90;
                       break;
                   }
               }
   
               for(i = 0; i < longueur_objet; i++)
               {
                   if ((chaine_tampon = formateur_fichier_binaire_nombre(
                           s_etat_processus, &(((integer8 *) (*((struct_vecteur *)
                           (*s_objet).objet)).tableau)[i]), 'I', format_sortie,
                           longueur, &longueur_element)) == NULL)
                   {
                       free(chaine);
                       return(NULL);
                   }
   
                   memcpy(chaine_offset + (i * longueur), chaine_tampon + 1,
                           (size_t) longueur);
                   free(chaine_tampon);
               }
         }          }
         else if ((*s_objet).type == VRL)          else if ((*s_objet).type == VRL)
         {          {
Line 4150  formateur_fichier(struct_processus *s_et Line 5407  formateur_fichier(struct_processus *s_et
   Vecteur réel    Vecteur réel
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'R';
                   longueur = 8;
               }
   
               if ((format_sortie != 'R') && (format_sortie != 'C'))
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_format_fichier;
                   return(NULL);
               }
   
               longueur_objet = (*((struct_vecteur *) (*s_objet).objet)).taille;
   
               if (longueur_objet < (1LL << 8))
               {
                   // Taille sur un octet
                   if ((chaine = malloc((size_t) ((*longueur_effective) =
                           (2 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xA2;
                   chaine[1] = (unsigned char) (longueur_objet & 0xFF);
                   chaine_offset = chaine + 2;
               }
               else if (longueur_objet < (1LL << 16))
               {
                   // Taille sur deux octets
                   if ((chaine = malloc((size_t) ((*longueur_effective) =
                           (3 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xA6;
                   chaine[1] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
                   chaine[2] = (unsigned char) (longueur_objet & 0xFF);
                   chaine_offset = chaine + 3;
               }
               else if (longueur_objet < (1LL << 32))
               {
                   // Taille sur quatre octets
                   if ((chaine = malloc((size_t) (((*longueur_effective) =
                           5 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xAA;
                   chaine[1] = (unsigned char) ((longueur_objet >> 24) & 0xFF);
                   chaine[2] = (unsigned char) ((longueur_objet >> 16) & 0xFF);
                   chaine[3] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
                   chaine[4] = (unsigned char) (longueur_objet & 0xFF);
                   chaine_offset = chaine + 5;
               }
               else
               {
                   // Taille sur huit octets
                   if ((chaine = malloc((size_t) ((*longueur_effective) =
                           (9 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xAE;
                   chaine[1] = (unsigned char) ((longueur_objet >> 56) & 0xFF);
                   chaine[2] = (unsigned char) ((longueur_objet >> 48) & 0xFF);
                   chaine[3] = (unsigned char) ((longueur_objet >> 40) & 0xFF);
                   chaine[4] = (unsigned char) ((longueur_objet >> 32) & 0xFF);
                   chaine[5] = (unsigned char) ((longueur_objet >> 24) & 0xFF);
                   chaine[6] = (unsigned char) ((longueur_objet >> 16) & 0xFF);
                   chaine[7] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
                   chaine[8] = (unsigned char) (longueur_objet & 0xFF);
                   chaine_offset = chaine + 9;
               }
   
               switch(format_sortie)
               {
                   default:
                   case 'R':
                   {
                       break;
                   }
   
                   case 'C':
                   {
                       chaine[0] |= 0x10;
                       break;
                   }
               }
   
               switch(longueur)
               {
                   case 4:
                   {
                       break;
                   }
   
                   default:
                   case 8:
                   {
                       chaine[0] |= 0x01;
                       break;
                   }
               }
   
               for(i = 0; i < longueur_objet; i++)
               {
                   if ((chaine_tampon = formateur_fichier_binaire_nombre(
                           s_etat_processus, &(((real8 *) (*((struct_vecteur *)
                           (*s_objet).objet)).tableau)[i]), 'R', format_sortie,
                           longueur, &longueur_element)) == NULL)
                   {
                       free(chaine);
                       return(NULL);
                   }
   
                   memcpy(chaine_offset + (i * longueur), chaine_tampon + 1,
                           (size_t) longueur);
                   free(chaine_tampon);
               }
         }          }
         else          else
         {          {
Line 4827  formateur_fichier_binaire_nombre(struct_ Line 6221  formateur_fichier_binaire_nombre(struct_
                         vinf = nextafter(valeur, 0);                          vinf = nextafter(valeur, 0);
                         vsup = nextafter(valeur, valeur * 2);                          vsup = nextafter(valeur, valeur * 2);
                     }                      }
                     else                      else if (valeur < 0)
                     {                      {
                         vinf = nextafter(valeur, valeur * 2);                          vinf = nextafter(valeur, valeur * 2);
                         vsup = nextafter(valeur, 0);                          vsup = nextafter(valeur, 0);
                     }                      }
                       else
                       {
                           vinf = valeur;
                           vsup = valeur;
                       }
   
                     if (!((vinf <= ((real4) valeur)) &&                      if (!((((real4) vinf) <= ((real4) valeur)) &&
                             (((real4) valeur) <= vsup)))                              (((real4) valeur) <= ((real4) vsup))))
                     {                      {
                         (*s_etat_processus).erreur_execution =                          (*s_etat_processus).erreur_execution =
                                 d_ex_representation;                                  d_ex_representation;
Removed from v.1.73  
changed lines
  Added in v.1.107

CVSweb interface <joel.bertrand@systella.fr>