[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.55 and 1.85

version 1.55, 2013/03/15 11:37:25 version 1.85, 2015/03/26 16:12:31
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.13    RPL/2 (R) version 4.1.21
   Copyright (C) 1989-2013 Dr. BERTRAND Joël    Copyright (C) 1989-2015 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 19 Line 19
 ================================================================================  ================================================================================
 */  */
   
 #define DEBUG_ERREURS  
 #include "rpl-conv.h"  #include "rpl-conv.h"
   
   
Line 40 Line 40
   
 unsigned char *  unsigned char *
 formateur_fichier(struct_processus *s_etat_processus, struct_objet *s_objet,  formateur_fichier(struct_processus *s_etat_processus, struct_objet *s_objet,
         struct_objet *s_format, long longueur, long longueur_champ,          struct_objet *s_format, integer8 longueur, integer8 longueur_champ,
         unsigned char format_sortie, unsigned char type,          unsigned char format_sortie, unsigned char type,
         long *longueur_effective, long *recursivite, logical1 export_fichier)          integer8 *longueur_effective, integer8 *recursivite,
           logical1 export_fichier)
 {  {
     /*      /*
      * Traitement du format des fichiers formatés :       * Traitement du format des fichiers formatés :
Line 62  formateur_fichier(struct_processus *s_et Line 63  formateur_fichier(struct_processus *s_et
      *   "binary*X(*)"       *   "binary*X(*)"
      *   "binary*X(Y)"  (X est la base : 2, 8, 10, 16)       *   "binary*X(Y)"  (X est la base : 2, 8, 10, 16)
      *   "character*(*)"       *   "character*(*)"
      *   "character*(Y)" }       *   "character*(Y)"
        *   "native*(*)" }
      *       *
      * Traitement du format des fichiers non formatés :       * Traitement du format des fichiers non formatés :
      *       *
Line 70  formateur_fichier(struct_processus *s_et Line 72  formateur_fichier(struct_processus *s_et
      *   "real*4", "real*8", ["real*16",]       *   "real*4", "real*8", ["real*16",]
      *   "complex*8", "complex*16", ["complex*32",]       *   "complex*8", "complex*16", ["complex*32",]
      *   "logical*1", "logical*2", "logical*4", logical*8",       *   "logical*1", "logical*2", "logical*4", logical*8",
      *   "character*n" "character*(*)" }       *   "character*n" "character*(*)" "native*(*)" }
      */       */
   
     logical1                    autorisation_parenthese;      logical1                    autorisation_parenthese;
     logical1                    format_degenere;      logical1                    format_degenere;
     logical1                    presence_signe;      logical1                    presence_signe;
   
     long                        longueur_chaine_traitee;  
   
     struct_liste_chainee        *l_atome;      struct_liste_chainee        *l_atome;
     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_objet                *s_format_tmp;
     struct_objet                *s_sous_objet;      struct_objet                *s_sous_objet;
     struct_objet                *s_sous_objet_1;      struct_objet                *s_sous_objet_1;
     struct_objet                *s_sous_objet_2;      struct_objet                *s_sous_objet_2;
Line 94  formateur_fichier(struct_processus *s_et Line 95  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 102  formateur_fichier(struct_processus *s_et Line 104  formateur_fichier(struct_processus *s_et
     unsigned char               tampon[64 + 1];      unsigned char               tampon[64 + 1];
     unsigned char               type_binaire;      unsigned char               type_binaire;
   
     unsigned long               i;      integer8                    i;
     unsigned long               j;      integer8                    j;
     unsigned long               nombre_arguments;      integer8                    nombre_arguments;
     unsigned long               nombre_arguments_fonction;      integer8                    nombre_arguments_fonction;
     unsigned long               nombre_colonnes;      integer8                    nombre_colonnes;
     unsigned long               nombre_elements;      integer8                    nombre_elements;
     unsigned long               nombre_lignes;      integer8                    nombre_lignes;
   
       integer8                    longueur_chaine_traitee;
       integer8                    longueur_element;
       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                    masque_binaire;  
     integer8                    position_1;      integer8                    position_1;
     integer8                    position_2;      integer8                    position_2;
     integer8                    position_3;      integer8                    position_3;
Line 132  formateur_fichier(struct_processus *s_et Line 137  formateur_fichier(struct_processus *s_et
   
         strcpy(base, " ");          strcpy(base, " ");
   
         masque_binaire = 0;  
   
         if ((*s_objet).type == ALG)          if ((*s_objet).type == ALG)
         {          {
   
Line 143  formateur_fichier(struct_processus *s_et Line 146  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie != 'N')
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_format_fichier;
                   return(NULL);
               }
   
             l_element_courant = (struct_liste_chainee *) (*s_objet).objet;              l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
   
             while(l_element_courant != NULL)              while(l_element_courant != NULL)
Line 227  formateur_fichier(struct_processus *s_et Line 237  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 286  formateur_fichier(struct_processus *s_et Line 297  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 313  formateur_fichier(struct_processus *s_et Line 325  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 394  formateur_fichier(struct_processus *s_et Line 408  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 451  formateur_fichier(struct_processus *s_et Line 466  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 468  formateur_fichier(struct_processus *s_et Line 484  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 709  formateur_fichier(struct_processus *s_et Line 727  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 922  formateur_fichier(struct_processus *s_et Line 942  formateur_fichier(struct_processus *s_et
                         ptrl = chaine_sauvegarde;                          ptrl = chaine_sauvegarde;
                         ptre = (unsigned char *) (*s_sous_objet).objet;                          ptre = (unsigned char *) (*s_sous_objet).objet;
   
                         for(ptrl++, i = strlen(chaine_sauvegarde) - 2; i > 0;                          for(ptrl++, i = ((integer8) strlen(chaine_sauvegarde))
                                 i--, *ptre++ = *ptrl++);                                  - 2; i > 0; i--, *ptre++ = *ptrl++);
   
                         (*ptre) = d_code_fin_chaine;                          (*ptre) = d_code_fin_chaine;
   
Line 985  formateur_fichier(struct_processus *s_et Line 1005  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
             if (format_sortie != 'B')              if ((format_sortie != 'B') && (format_sortie != 'N'))
             {              {
                 (*s_etat_processus).erreur_execution =                  (*s_etat_processus).erreur_execution =
                         d_ex_erreur_format_fichier;                          d_ex_erreur_format_fichier;
                 return(NULL);                  return(NULL);
             }              }
   
             masque_binaire = masque_entiers_binaires(s_etat_processus);              if (format_sortie == 'N')
   
             if ((test_cfsf(s_etat_processus, 43) == d_faux) &&  
                     (test_cfsf(s_etat_processus, 44) == d_faux))  
             {              {
                   sprintf(tampon, "%llX", (unsigned long long) (*((logical8 *)
 /*                          ((*s_objet).objet))));
 -- Base décimale ---------------------------------------------------------------                  strcpy(base, "h");
 */  
   
                 sprintf(tampon, "%llu", (*((logical8 *)  
                         ((*s_objet).objet))) & masque_binaire);  
                 strcpy(base, "d");  
             }              }
             else if ((test_cfsf(s_etat_processus, 43) == d_vrai) &&              else
                     (test_cfsf(s_etat_processus, 44) == d_faux))  
             {              {
                   switch(longueur)
                   {
                       case 2:
                       {
                           sprintf(tampon, "%llX", (unsigned long long)
                                   (*((logical8 *) ((*s_objet).objet))));
   
 /*                          chaine = (unsigned char *) malloc((strlen(tampon) + 1)
 -- Base octale -----------------------------------------------------------------                                  * sizeof(unsigned char));
 */  
   
                 sprintf(tampon, "%llo", (*((logical8 *)                          if (chaine == NULL)
                         ((*s_objet).objet))) & masque_binaire);                          {
                 strcpy(base, "o");                              (*s_etat_processus).erreur_systeme =
             }                                      d_es_allocation_memoire;
             else if (test_cfsf(s_etat_processus, 44) == d_vrai)                              return(NULL);
             {                          }
   
 /*                          strcpy(chaine, tampon);
 -- Bases hexadécimale et binaire -----------------------------------------------                          tampon[0] = 0;
 */  
   
                 sprintf(tampon, "%llX", (*((logical8 *)                          for(i = 0; i < ((integer8) strlen(chaine)); i++)
                         ((*s_objet).objet))) & masque_binaire);                          {
                               switch(chaine[i])
                               {
                                   case '0' :
                                   {
                                       strcat(tampon, (i != 0) ? "0000" : "0");
                                       break;
                                   }
                                   case '1' :
                                   {
                                       strcat(tampon, (i != 0) ? "0001" : "1");
                                       break;
                                   }
                                   case '2' :
                                   {
                                       strcat(tampon, (i != 0) ? "0010" : "10");
                                       break;
                                   }
                                   case '3' :
                                   {
                                       strcat(tampon, (i != 0) ? "0011" : "11");
                                   break;
                                   }
                                   case '4' :
                                   {
                                       strcat(tampon, (i != 0) ? "0100" : "100");
                                       break;
                                   }
                                   case '5' :
                                   {
                                       strcat(tampon, (i != 0) ? "0101" : "101");
                                       break;
                                   }
                                   case '6' :
                                   {
                                       strcat(tampon, (i != 0) ? "0110" : "110");
                                       break;
                                   }
                                   case '7' :
                                   {
                                       strcat(tampon, (i != 0) ? "0111" : "111");
                                       break;
                                   }
                                   case '8' :
                                   {
                                       strcat(tampon, "1000");
                                       break;
                                   }
                                   case '9' :
                                   {
                                       strcat(tampon, "1001");
                                       break;
                                   }
                                   case 'A' :
                                   {
                                       strcat(tampon, "1010");
                                       break;
                                   }
                                   case 'B' :
                                   {
                                       strcat(tampon, "1011");
                                       break;
                                   }
                                   case 'C' :
                                   {
                                       strcat(tampon, "1100");
                                       break;
                                   }
                                   case 'D' :
                                   {
                                       strcat(tampon, "1101");
                                       break;
                                   }
                                   case 'E' :
                                   {
                                       strcat(tampon, "1110");
                                       break;
                                   }
                                   case 'F' :
                                   {
                                       strcat(tampon, "1111");
                                       break;
                                   }
                               }
                           }
   
                 if (test_cfsf(s_etat_processus, 43) == d_vrai)                          free(chaine);
                 {                          strcpy(base, "b");
                     strcpy(base, "h");                          break;
                 }                      }
                 else  
                 {  
                     chaine = (unsigned char *) malloc((strlen(tampon) + 1)  
                             * sizeof(unsigned char));  
   
                     if (chaine == NULL)                      case 8:
                     {                      {
                         (*s_etat_processus).erreur_systeme =                          sprintf(tampon, "%llo", (*((unsigned long long *)
                                 d_es_allocation_memoire;                                  ((*s_objet).objet))));
                         return(NULL);                          strcpy(base, "o");
                           break;
                     }                      }
   
                     strcpy(chaine, tampon);                      case 10:
                     tampon[0] = 0;                      {
                           sprintf(tampon, "%llu", (*((unsigned long long *)
                                   ((*s_objet).objet))));
                           strcpy(base, "d");
                           break;
                       }
   
                     for(i = 0; i < strlen(chaine); i++)                      case 16:
                     {                      {
                         switch(chaine[i])                          sprintf(tampon, "%llX", (unsigned long long)
                         {                                  (*((logical8 *) ((*s_objet).objet))));
                             case '0' :                          strcpy(base, "h");
                             {                          break;
                                 strcat(tampon, (i != 0) ? "0000" : "0");  
                                 break;  
                             }  
                             case '1' :  
                             {  
                                     strcat(tampon, (i != 0) ? "0001" : "1");  
                                 break;  
                             }  
                             case '2' :  
                             {  
                                 strcat(tampon, (i != 0) ? "0010" : "10");  
                                 break;  
                             }  
                             case '3' :  
                             {  
                                 strcat(tampon, (i != 0) ? "0011" : "11");  
                                 break;  
                             }  
                             case '4' :  
                             {  
                                 strcat(tampon, (i != 0) ? "0100" : "100");  
                                 break;  
                             }  
                             case '5' :  
                             {  
                                 strcat(tampon, (i != 0) ? "0101" : "101");  
                                 break;  
                             }  
                             case '6' :  
                             {  
                                 strcat(tampon, (i != 0) ? "0110" : "110");  
                                 break;  
                             }  
                             case '7' :  
                             {  
                                 strcat(tampon, (i != 0) ? "0111" : "111");  
                                 break;  
                             }  
                             case '8' :  
                             {  
                                 strcat(tampon, "1000");  
                                 break;  
                             }  
                             case '9' :  
                             {  
                                 strcat(tampon, "1001");  
                                 break;  
                             }  
                             case 'A' :  
                             {  
                                 strcat(tampon, "1010");  
                                 break;  
                             }  
                             case 'B' :  
                             {  
                                 strcat(tampon, "1011");  
                                 break;  
                             }  
                             case 'C' :  
                             {  
                                 strcat(tampon, "1100");  
                                 break;  
                             }  
                             case 'D' :  
                             {  
                                 strcat(tampon, "1101");  
                                 break;  
                             }  
                             case 'E' :  
                             {  
                                 strcat(tampon, "1110");  
                                 break;  
                             }  
                             case 'F' :  
                             {  
                                 strcat(tampon, "1111");  
                                 break;  
                             }  
                         }  
                     }                      }
   
                     free(chaine);                      default:
                     strcpy(base, "b");                      {
                           (*s_etat_processus).erreur_execution =
                                   d_ex_erreur_format_fichier;
                           return(NULL);
                       }
                   }
               }
   
               if (format_sortie == 'B')
               {
                   if ((longueur_champ > 0) && (longueur_champ
                           < (signed) strlen(tampon)))
                   {
                       ptrl = &(tampon[((integer8) strlen(tampon))
                               - longueur_champ]);
                       ptre = tampon;
   
                       do
                       {
                           *ptre++ = *ptrl++;
                       } while((*ptrl) != d_code_fin_chaine);
   
                       (*ptre) = d_code_fin_chaine;
                 }                  }
             }              }
   
Line 1162  formateur_fichier(struct_processus *s_et Line 1206  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
             if (format_sortie != 'C')              if ((format_sortie != 'C') && (format_sortie != 'N'))
             {              {
                 (*s_etat_processus).erreur_execution =                  (*s_etat_processus).erreur_execution =
                         d_ex_erreur_format_fichier;                          d_ex_erreur_format_fichier;
Line 1172  formateur_fichier(struct_processus *s_et Line 1216  formateur_fichier(struct_processus *s_et
             longueur_reelle_chaine = longueur_chaine(s_etat_processus,              longueur_reelle_chaine = longueur_chaine(s_etat_processus,
                     (unsigned char *) (*s_objet).objet);                      (unsigned char *) (*s_objet).objet);
   
               if (format_sortie == 'N')
               {
                   longueur_champ = -1;
               }
   
             if ((longueur_champ == -1) || (longueur_reelle_chaine <              if ((longueur_champ == -1) || (longueur_reelle_chaine <
                     longueur_champ))                      longueur_champ))
             {              {
Line 1194  formateur_fichier(struct_processus *s_et Line 1243  formateur_fichier(struct_processus *s_et
                         (*s_objet).objet, longueur_champ)                          (*s_objet).objet, longueur_champ)
                         - ((unsigned char *) (*s_objet).objet);                          - ((unsigned char *) (*s_objet).objet);
   
                 if ((chaine = malloc((longueur_reelle_chaine + 1) *                  if ((chaine = malloc((((size_t) longueur_reelle_chaine) + 1) *
                         sizeof(unsigned char))) == NULL)                          sizeof(unsigned char))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
Line 1203  formateur_fichier(struct_processus *s_et Line 1252  formateur_fichier(struct_processus *s_et
                 }                  }
   
                 strncpy(chaine, (unsigned char *) ((*s_objet).objet),                  strncpy(chaine, (unsigned char *) ((*s_objet).objet),
                         longueur_reelle_chaine);                          (size_t) longueur_reelle_chaine);
                 chaine[longueur_reelle_chaine] = d_code_fin_chaine;                  chaine[longueur_reelle_chaine] = d_code_fin_chaine;
             }              }
         }          }
Line 1216  formateur_fichier(struct_processus *s_et Line 1265  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'S';
               }
   
             if ((format_sortie != 'S') && (format_sortie != 'F') &&              if ((format_sortie != 'S') && (format_sortie != 'F') &&
                     (format_sortie != 'I') && (format_sortie != 'E'))                      (format_sortie != 'I') && (format_sortie != 'E'))
             {              {
Line 1253  formateur_fichier(struct_processus *s_et Line 1307  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie != 'N')
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_format_fichier;
                   return(NULL);
               }
   
             l_element_courant = (struct_liste_chainee *) ((*s_objet).objet);              l_element_courant = (struct_liste_chainee *) ((*s_objet).objet);
             chaine_sauvegarde = chaine;              chaine_sauvegarde = chaine;
   
Line 1335  formateur_fichier(struct_processus *s_et Line 1396  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'S';
               }
   
             if ((format_sortie != 'S') && (format_sortie != 'F') &&              if ((format_sortie != 'S') && (format_sortie != 'F') &&
                     (format_sortie != 'I') && (format_sortie != 'E'))                      (format_sortie != 'I') && (format_sortie != 'E'))
             {              {
Line 1372  formateur_fichier(struct_processus *s_et Line 1438  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie != 'N')
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_format_fichier;
                   return(NULL);
               }
   
             chaine = (unsigned char *) malloc((strlen((*((struct_fonction *)              chaine = (unsigned char *) malloc((strlen((*((struct_fonction *)
                     ((*s_objet).objet))).nom_fonction) + 1) *                      ((*s_objet).objet))).nom_fonction) + 1) *
                     sizeof(unsigned char));                      sizeof(unsigned char));
Line 1419  formateur_fichier(struct_processus *s_et Line 1492  formateur_fichier(struct_processus *s_et
                 {                  {
                     chaine_sauvegarde = chaine;                      chaine_sauvegarde = chaine;
   
                     if ((chaine_formatee = formateur_fichier(s_etat_processus,                      if (format_sortie != 'N')
                             (*l_element_courant).donnee,  
                             (*l_element_courant_format).donnee,  
                             0, 0, ' ', 'F', longueur_effective, recursivite,  
                             export_fichier)) == NULL)  
                     {                      {
                         return(NULL);                          if ((chaine_formatee =
                                   formateur_fichier(s_etat_processus,
                                   (*l_element_courant).donnee,
                                   (*l_element_courant_format).donnee,
                                   0, 0, ' ', 'F', longueur_effective, recursivite,
                                   export_fichier)) == NULL)
                           {
                               return(NULL);
                           }
                       }
                       else
                       {
                           if ((chaine_formatee =
                                   formateur_fichier(s_etat_processus,
                                   (*l_element_courant).donnee,
                                   (*l_element_courant_format).donnee,
                                   0, 0, 'N', 'F', longueur_effective, recursivite,
                                   export_fichier)) == NULL)
                           {
                               return(NULL);
                           }
                     }                      }
   
                     chaine = (unsigned char *) malloc((strlen(chaine_formatee)                      chaine = (unsigned char *) malloc((strlen(chaine_formatee)
Line 1455  formateur_fichier(struct_processus *s_et Line 1544  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 1498  formateur_fichier(struct_processus *s_et Line 1588  formateur_fichier(struct_processus *s_et
                         position_1 = 10;                          position_1 = 10;
                         format_degenere = d_vrai;                          format_degenere = d_vrai;
                     }                      }
                       else if (strcmp("NATIVE*(*)", format_chaine) == 0)
                       {
                           format_sortie = 'N';
                           position_1 = 7;
                           format_degenere = d_vrai;
                       }
                     else                      else
                     {                      {
                         free(chaine);                          free(chaine);
Line 1508  formateur_fichier(struct_processus *s_et Line 1604  formateur_fichier(struct_processus *s_et
                         return(NULL);                          return(NULL);
                     }                      }
   
                     position_3 = strlen(format_chaine) - 1;                      position_3 = ((integer8) strlen(format_chaine)) - 1;
   
                     if (format_chaine[position_3] != ')')                      if (format_chaine[position_3] != ')')
                     {                      {
Line 1543  formateur_fichier(struct_processus *s_et Line 1639  formateur_fichier(struct_processus *s_et
   
                     if (format_degenere == d_faux)                      if (format_degenere == d_faux)
                     {                      {
                         if (sscanf(&(format_chaine[position_1]), "%ld",                          if (sscanf(&(format_chaine[position_1]), "%lld",
                                 &longueur) != 1)                                  &longueur) != 1)
                         {                          {
                             free(chaine);                              free(chaine);
Line 1561  formateur_fichier(struct_processus *s_et Line 1657  formateur_fichier(struct_processus *s_et
   
                     if (strcmp(&(format_chaine[position_2]), "*") != 0)                      if (strcmp(&(format_chaine[position_2]), "*") != 0)
                     {                      {
                         if (sscanf(&(format_chaine[position_2]), "%ld",                          if (sscanf(&(format_chaine[position_2]), "%lld",
                                 &longueur_champ) != 1)                                  &longueur_champ) != 1)
                         {                          {
                             free(chaine);                              free(chaine);
Line 1578  formateur_fichier(struct_processus *s_et Line 1674  formateur_fichier(struct_processus *s_et
                     }                      }
   
                     if ((longueur >= 0) && (longueur_champ >= 0) && (longueur >                      if ((longueur >= 0) && (longueur_champ >= 0) && (longueur >
                             longueur_champ))                              longueur_champ) && (format_sortie != 'B'))
                     {                      {
                         free(chaine);                          free(chaine);
                         free(format_chaine);                          free(format_chaine);
Line 1592  formateur_fichier(struct_processus *s_et Line 1688  formateur_fichier(struct_processus *s_et
                                   
                     chaine_sauvegarde = chaine;                      chaine_sauvegarde = chaine;
   
                       // Si le format_sortie vaut 'N', on remplace le format par
                       // { "native*(*)" }. L'intérêt est de pouvoir traiter une
                       // liste par un format "native*(*)".
   
                       if ((format_sortie == 'N') && ((*(*l_element_courant)
                               .donnee).type == LST))
                       {
                           if ((s_format_tmp = allocation(s_etat_processus, LST))
                                   == NULL)
                           {
                               return(NULL);
                           }
   
                           if (((*s_format_tmp).objet = allocation_maillon(
                                   s_etat_processus)) == NULL)
                           {
                               return(NULL);
                           }
   
                           (*((struct_liste_chainee *) (*s_format_tmp).objet))
                                   .suivant = NULL;
   
                           if (((*((struct_liste_chainee *) (*s_format_tmp).objet))
                                   .donnee = allocation(s_etat_processus, CHN))
                                   == NULL)
                           {
                               return(NULL);
                           }
   
                           if (((*(*((struct_liste_chainee *) (*s_format_tmp)
                                   .objet)).donnee).objet = malloc(11 *
                                   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,
                             (*l_element_courant).donnee, s_format,                              (*l_element_courant).donnee, s_format,
                             longueur, longueur_champ, format_sortie, type,                              longueur, longueur_champ, format_sortie, type,
                             longueur_effective, recursivite, export_fichier))                              longueur_effective, recursivite, export_fichier))
                             == NULL)                              == NULL)
                     {                      {
                           liberation(s_etat_processus, s_format_tmp);
                         free(chaine);                          free(chaine);
                         return(NULL);                          return(NULL);
                     }                      }
   
                       liberation(s_etat_processus, s_format_tmp);
   
                     if ((*(*l_element_courant).donnee).type == CHN)                      if ((*(*l_element_courant).donnee).type == CHN)
                     {                      {
                         chaine = (unsigned char *)                          chaine = (unsigned char *)
Line 1665  formateur_fichier(struct_processus *s_et Line 1815  formateur_fichier(struct_processus *s_et
   
                 nombre_elements++;                  nombre_elements++;
                 l_element_courant = (*l_element_courant).suivant;                  l_element_courant = (*l_element_courant).suivant;
                 l_element_courant_format = (*l_element_courant_format).suivant;  
                   if (format_sortie != 'N')
                   {
                       l_element_courant_format =
                               (*l_element_courant_format).suivant;
                   }
             }              }
   
             if ((l_element_courant != NULL) ||              // Dans le cas où le format de sortie n'est pas du type
                     (l_element_courant_format != NULL))              // NATIVE*(*), on vérifie que tous les éléments du format et
               // de la liste d'arguments ont été consommés.
   
               if (format_sortie != 'N')
             {              {
                 free(chaine);                  if ((l_element_courant != NULL) ||
                           (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);
                   }
             }              }
   
             chaine_sauvegarde = chaine;              chaine_sauvegarde = chaine;
Line 1701  formateur_fichier(struct_processus *s_et Line 1863  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
             if ((*s_format).type != TBL)              if (((*s_format).type != TBL) && (format_sortie != 'N'))
             {              {
                 (*s_etat_processus).erreur_execution =                  (*s_etat_processus).erreur_execution =
                         d_ex_erreur_format_fichier;                          d_ex_erreur_format_fichier;
                 return(NULL);                  return(NULL);
             }              }
   
             l_element_courant = (struct_liste_chainee *) (*s_objet).objet;              if (format_sortie != 'N')
             l_element_courant_format = (struct_liste_chainee *)  
                     (*s_format).objet;  
   
             if ((*((struct_tableau *) (*s_objet).objet)).nombre_elements !=  
                     (*((struct_tableau *) (*s_format).objet)).nombre_elements)  
             {              {
                 (*s_etat_processus).erreur_execution =                  if ((*((struct_tableau *) (*s_objet).objet)).nombre_elements !=
                         d_ex_erreur_format_fichier;                          (*((struct_tableau *) (*s_format).objet))
                 return(NULL);                          .nombre_elements)
                   {
                       (*s_etat_processus).erreur_execution =
                               d_ex_erreur_format_fichier;
                       return(NULL);
                   }
             }              }
   
             chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));              chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
Line 1733  formateur_fichier(struct_processus *s_et Line 1895  formateur_fichier(struct_processus *s_et
             for(i = 0; i < (*((struct_tableau *) (*s_objet).objet))              for(i = 0; i < (*((struct_tableau *) (*s_objet).objet))
                     .nombre_elements; i++)                      .nombre_elements; i++)
             {              {
                 if ((((*(*((struct_tableau *) (*s_format).objet))                  if (format_sortie != 'N')
                         .elements[i]).type == LST) &&  
                         ((*(*((struct_tableau *) (*s_objet).objet)).elements[i])  
                         .type == LST)) ||  
                         (((*(*((struct_tableau *) (*s_format).objet))  
                         .elements[i]).type == TBL) &&  
                         ((*(*((struct_tableau *) (*s_objet).objet)).elements[i])  
                         .type == TBL)))  
                 {                  {
                     chaine_sauvegarde = chaine;                      if ((((*(*((struct_tableau *) (*s_format).objet))
                               .elements[i]).type == LST) &&
                     if ((chaine_formatee = formateur_fichier(s_etat_processus,                              ((*(*((struct_tableau *) (*s_objet).objet))
                             (*l_element_courant).donnee,                              .elements[i]).type == LST)) ||
                             (*l_element_courant_format).donnee,                              (((*(*((struct_tableau *) (*s_format).objet))
                             0, 0, ' ', 'F', longueur_effective, recursivite,                              .elements[i]).type == TBL) &&
                             export_fichier)) == NULL)                              ((*(*((struct_tableau *) (*s_objet).objet))
                               .elements[i]).type == TBL)))
                     {                      {
                         return(NULL);                          chaine_sauvegarde = chaine;
                     }  
   
                     chaine = (unsigned char *) malloc((strlen(chaine_formatee)  
                             + strlen(chaine_sauvegarde) + 2)  
                             * sizeof(unsigned char));  
   
                     if (chaine == NULL)  
                     {  
                         (*s_etat_processus).erreur_systeme =  
                                 d_es_allocation_memoire;  
                         return(NULL);  
                     }  
   
                     strcpy(chaine, chaine_sauvegarde);  
                     free(chaine_sauvegarde);  
                     strcat(chaine, " ");  
                     strcat(chaine, chaine_formatee);  
                     free(chaine_formatee);  
                 }  
                 else if ((*(*((struct_tableau *) (*s_format).objet))  
                         .elements[i]).type != CHN)  
                 {  
                     free(chaine);  
   
                     (*s_etat_processus).erreur_execution =                          if ((chaine_formatee = formateur_fichier(
                             d_ex_erreur_format_fichier;                                  s_etat_processus,
                     return(NULL);                                  (*(*((struct_tableau *) (*s_objet).objet))
                 }                                  .elements[i]).objet,
                 else                                  (*(*((struct_tableau *) (*s_format).objet))
                 {                                  .elements[i]).objet,
                     if ((format_chaine = conversion_majuscule((unsigned char *)                                  0, 0, ' ', 'F', longueur_effective, recursivite,
                             (*(*((struct_tableau *) (*s_format).objet))                                  export_fichier)) == NULL)
                             .elements[i]).objet)) == NULL)                          {
                     {                              return(NULL);
                         (*s_etat_processus).erreur_systeme =                          }
                                 d_es_allocation_memoire;  
                         return(NULL);  
                     }  
   
                     format_degenere = d_faux;                          if ((chaine = (unsigned char *) malloc((strlen(
                                   chaine_formatee) + strlen(chaine_sauvegarde)
                                   + 2) * sizeof(unsigned char))) == NULL)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_allocation_memoire;
                               return(NULL);
                           }
   
                     if (strncmp("STANDARD*", format_chaine, 9) == 0)                          strcpy(chaine, chaine_sauvegarde);
                     {                          free(chaine_sauvegarde);
                         format_sortie = 'S';                          strcat(chaine, " ");
                         position_1 = 9;                          strcat(chaine, chaine_formatee);
                         format_degenere = d_vrai;                          free(chaine_formatee);
                     }  
                     else if (strncmp("BINARY*", format_chaine, 7) == 0)  
                     {  
                         format_sortie = 'B';  
                         position_1 = 7;  
                     }  
                     else if (strncmp("FIXED*", format_chaine, 6) == 0)  
                     {  
                         format_sortie = 'F';  
                         position_1 = 6;  
                     }  
                     else if (strncmp("SCIENTIFIC*", format_chaine, 11) == 0)  
                     {  
                         format_sortie = 'I';  
                         position_1 = 11;  
                     }  
                     else if (strncmp("ENGINEER*", format_chaine, 9) == 0)  
                     {  
                         format_sortie = 'E';  
                         position_1 = 9;  
                     }  
                     else if (strncmp("CHARACTER*", format_chaine, 10) == 0)  
                     {  
                         format_sortie = 'C';  
                         position_1 = 10;  
                         format_degenere = d_vrai;  
                     }                      }
                     else                      else if ((*(*((struct_tableau *) (*s_format).objet))
                               .elements[i]).type != CHN)
                     {                      {
                         free(chaine);                          free(chaine);
                         free(format_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);
                     }                      }
                       else
                       {
                           if ((format_chaine = conversion_majuscule(
                                   s_etat_processus,
                                   (unsigned char *) (*(*((struct_tableau *)
                                   (*s_format).objet)).elements[i]).objet))
                                   == NULL)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_allocation_memoire;
                               return(NULL);
                           }
   
                     position_3 = strlen(format_chaine);                          format_degenere = d_faux;
                     format_chaine[--position_3] = d_code_fin_chaine;  
   
                     position_2 = position_1;  
   
                     while(format_chaine[position_2] != '(')                          if (strncmp("STANDARD*", format_chaine, 9) == 0)
                     {                          {
                         if (format_chaine[position_2] == d_code_fin_chaine)                              format_sortie = 'S';
                               position_1 = 9;
                               format_degenere = d_vrai;
                           }
                           else if (strncmp("BINARY*", format_chaine, 7) == 0)
                           {
                               format_sortie = 'B';
                               position_1 = 7;
                           }
                           else if (strncmp("FIXED*", format_chaine, 6) == 0)
                           {
                               format_sortie = 'F';
                               position_1 = 6;
                           }
                           else if (strncmp("SCIENTIFIC*", format_chaine, 11) == 0)
                           {
                               format_sortie = 'I';
                               position_1 = 11;
                           }
                           else if (strncmp("ENGINEER*", format_chaine, 9) == 0)
                           {
                               format_sortie = 'E';
                               position_1 = 9;
                           }
                           else if (strncmp("CHARACTER*", format_chaine, 10) == 0)
                           {
                               format_sortie = 'C';
                               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(chaine);
                             free(format_chaine);                              free(format_chaine);
Line 1851  formateur_fichier(struct_processus *s_et Line 2007  formateur_fichier(struct_processus *s_et
                             return(NULL);                              return(NULL);
                         }                          }
   
                         position_2++;                          position_3 = (integer8) strlen(format_chaine);
                     }                          format_chaine[--position_3] = d_code_fin_chaine;
   
                     format_chaine[position_2++] = d_code_fin_chaine;                          position_2 = position_1;
   
                     if (format_degenere == d_faux)                          while(format_chaine[position_2] != '(')
                     {  
                         if (sscanf(&(format_chaine[position_1]), "%ld",  
                                 &longueur) != 1)  
                         {                          {
                             free(chaine);                              if (format_chaine[position_2] == d_code_fin_chaine)
                             free(format_chaine);                              {
                                   free(chaine);
                                   free(format_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);
                               }
   
                               position_2++;
                         }                          }
                     }  
                     else  
                     {  
                         longueur = -1;  
                     }  
   
                     if (strcmp(&(format_chaine[position_2]), "*") != 0)                          format_chaine[position_2++] = d_code_fin_chaine;
                     {  
                         if (sscanf(&(format_chaine[position_2]), "%ld",                          if (format_degenere == d_faux)
                                 &longueur_champ) != 1)                          {
                               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);
                               }
                           }
                           else
                           {
                               longueur = -1;
                           }
   
                           if (strcmp(&(format_chaine[position_2]), "*") != 0)
                           {
                               if (sscanf(&(format_chaine[position_2]), "%lld",
                                       &longueur_champ) != 1)
                               {
                                   free(chaine);
                                   free(format_chaine);
   
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_erreur_format_fichier;
                                   return(NULL);
                               }
                           }
                           else
                           {
                               longueur_champ = -1;
                           }
   
                           if ((longueur >= 0) && (longueur_champ >= 0) &&
                                   (longueur > longueur_champ))
                         {                          {
                             free(chaine);                              free(chaine);
                             free(format_chaine);                              free(format_chaine);
Line 1886  formateur_fichier(struct_processus *s_et Line 2075  formateur_fichier(struct_processus *s_et
                                     d_ex_erreur_format_fichier;                                      d_ex_erreur_format_fichier;
                             return(NULL);                              return(NULL);
                         }                          }
                     }  
                     else  
                     {  
                         longueur_champ = -1;  
                     }  
   
                     if ((longueur >= 0) && (longueur_champ >= 0) && (longueur >  
                             longueur_champ))  
                     {  
                         free(chaine);  
                         free(format_chaine);                          free(format_chaine);
                       
                           chaine_sauvegarde = chaine;
   
                         (*s_etat_processus).erreur_execution =                          if ((chaine_formatee = formateur_fichier(
                                 d_ex_erreur_format_fichier;                                  s_etat_processus, (*((struct_tableau *)
                         return(NULL);                                  (*s_objet).objet)).elements[i], s_format,
                                   longueur, longueur_champ, format_sortie, type,
                                   longueur_effective, recursivite,
                                   export_fichier)) == NULL)
                           {
                               return(NULL);
                           }
                     }                      }
                   }
                     free(format_chaine);                  else // NATIVE*(*)
                                   {
                     chaine_sauvegarde = chaine;                      chaine_sauvegarde = chaine;
   
                     if ((chaine_formatee = formateur_fichier(s_etat_processus,                      if ((chaine_formatee = formateur_fichier(
                             (*((struct_tableau *) (*s_objet).objet))                              s_etat_processus, (*((struct_tableau *)
                             .elements[i], s_format,                              (*s_objet).objet)).elements[i], s_format,
                             longueur, longueur_champ, format_sortie, type,                              longueur, longueur_champ, format_sortie, type,
                             longueur_effective, recursivite, export_fichier))                              longueur_effective, recursivite,
                             == NULL)                              export_fichier)) == NULL)
                     {                      {
                         return(NULL);                          return(NULL);
                     }                      }
                   }
   
                     if ((*(*((struct_tableau *) (*s_objet).objet))                  if ((*(*((struct_tableau *) (*s_objet).objet))
                             .elements[i]).type == CHN)                          .elements[i]).type == CHN)
                     {                  {
                         chaine = (unsigned char *)                      chaine = (unsigned char *)
                                 malloc((strlen(chaine_formatee)                              malloc((strlen(chaine_formatee)
                                 + strlen(chaine_sauvegarde) + 4)                              + strlen(chaine_sauvegarde) + 4)
                                 * sizeof(unsigned char));                              * sizeof(unsigned char));
   
                         if (chaine == NULL)  
                         {  
                             (*s_etat_processus).erreur_systeme =  
                                     d_es_allocation_memoire;  
                             return(NULL);  
                         }  
   
                         strcpy(chaine, chaine_sauvegarde);                      if (chaine == NULL)
                         free(chaine_sauvegarde);  
                         strcat(chaine, " \"");  
                         strcat(chaine, chaine_formatee);  
                         free(chaine_formatee);  
                         strcat(chaine, "\"");  
                     }  
                     else if ((*(*((struct_tableau *) (*s_objet).objet))  
                             .elements[i]).type == NOM)  
                     {                      {
                         chaine = (unsigned char *)                          (*s_etat_processus).erreur_systeme =
                                 malloc((strlen(chaine_formatee)                                  d_es_allocation_memoire;
                                 + strlen(chaine_sauvegarde) + 2)                          return(NULL);
                                 * sizeof(unsigned char));                      }
   
                         if (chaine == NULL)                      strcpy(chaine, chaine_sauvegarde);
                         {                      free(chaine_sauvegarde);
                             (*s_etat_processus).erreur_systeme =                      strcat(chaine, " \"");
                                     d_es_allocation_memoire;                      strcat(chaine, chaine_formatee);
                             return(NULL);                      free(chaine_formatee);
                         }                      strcat(chaine, "\"");
                   }
                   else if ((*(*((struct_tableau *) (*s_objet).objet))
                           .elements[i]).type == NOM)
                   {
                       chaine = (unsigned char *)
                               malloc((strlen(chaine_formatee)
                               + strlen(chaine_sauvegarde) + 2)
                               * sizeof(unsigned char));
   
                         sprintf(chaine, "%s %s", chaine_sauvegarde,                      if (chaine == NULL)
                                 chaine_formatee);  
                         free(chaine_formatee);  
                     }  
                     else  
                     {                      {
                         chaine = (unsigned char *)                          (*s_etat_processus).erreur_systeme =
                                 malloc((strlen(chaine_formatee)                                  d_es_allocation_memoire;
                                 + strlen(chaine_sauvegarde) + 2)                          return(NULL);
                                 * sizeof(unsigned char));                      }
   
                         if (chaine == NULL)                      sprintf(chaine, "%s %s", chaine_sauvegarde,
                         {                              chaine_formatee);
                             (*s_etat_processus).erreur_systeme =                      free(chaine_formatee);
                                     d_es_allocation_memoire;                  }
                             return(NULL);                  else
                         }                  {
                       chaine = (unsigned char *)
                               malloc((strlen(chaine_formatee)
                               + strlen(chaine_sauvegarde) + 2)
                               * sizeof(unsigned char));
   
                         strcpy(chaine, chaine_sauvegarde);                      if (chaine == NULL)
                         free(chaine_sauvegarde);                      {
                         strcat(chaine, " ");                          (*s_etat_processus).erreur_systeme =
                         strcat(chaine, chaine_formatee);                                  d_es_allocation_memoire;
                         free(chaine_formatee);                          return(NULL);
                     }                      }
   
                       strcpy(chaine, chaine_sauvegarde);
                       free(chaine_sauvegarde);
                       strcat(chaine, " ");
                       strcat(chaine, chaine_formatee);
                       free(chaine_formatee);
                 }                  }
             }              }
   
Line 2004  formateur_fichier(struct_processus *s_et Line 2192  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'S';
               }
   
             if ((format_sortie != 'S') && (format_sortie != 'F') &&              if ((format_sortie != 'S') && (format_sortie != 'F') &&
                     (format_sortie != 'I') && (format_sortie != 'E'))                      (format_sortie != 'I') && (format_sortie != 'E'))
             {              {
Line 2147  formateur_fichier(struct_processus *s_et Line 2340  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'S';
               }
   
             if ((format_sortie != 'S') && (format_sortie != 'F') &&              if ((format_sortie != 'S') && (format_sortie != 'F') &&
                     (format_sortie != 'I') && (format_sortie != 'E'))                      (format_sortie != 'I') && (format_sortie != 'E'))
             {              {
Line 2289  formateur_fichier(struct_processus *s_et Line 2487  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'S';
               }
   
             if ((format_sortie != 'S') && (format_sortie != 'F') &&              if ((format_sortie != 'S') && (format_sortie != 'F') &&
                     (format_sortie != 'I') && (format_sortie != 'E'))                      (format_sortie != 'I') && (format_sortie != 'E'))
             {              {
Line 2431  formateur_fichier(struct_processus *s_et Line 2634  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie != 'N')
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_format_fichier;
                   return(NULL);
               }
   
             chaine = (unsigned char *) malloc((strlen((*((struct_nom *)              chaine = (unsigned char *) malloc((strlen((*((struct_nom *)
                     (*s_objet).objet)).nom) + 3) * sizeof(unsigned char));                      (*s_objet).objet)).nom) + 3) * sizeof(unsigned char));
   
Line 2451  formateur_fichier(struct_processus *s_et Line 2661  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'S';
               }
   
             if ((format_sortie != 'S') && (format_sortie != 'F') &&              if ((format_sortie != 'S') && (format_sortie != 'F') &&
                     (format_sortie != 'I') && (format_sortie != 'E'))                      (format_sortie != 'I') && (format_sortie != 'E'))
             {              {
Line 2488  formateur_fichier(struct_processus *s_et Line 2703  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'S';
               }
   
             if ((format_sortie != 'S') && (format_sortie != 'F') &&              if ((format_sortie != 'S') && (format_sortie != 'F') &&
                     (format_sortie != 'I') && (format_sortie != 'E'))                      (format_sortie != 'I') && (format_sortie != 'E'))
             {              {
Line 2564  formateur_fichier(struct_processus *s_et Line 2784  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'S';
               }
   
             if ((format_sortie != 'S') && (format_sortie != 'F') &&              if ((format_sortie != 'S') && (format_sortie != 'F') &&
                     (format_sortie != 'I') && (format_sortie != 'E'))                      (format_sortie != 'I') && (format_sortie != 'E'))
             {              {
Line 2639  formateur_fichier(struct_processus *s_et Line 2864  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'S';
               }
   
             if ((format_sortie != 'S') && (format_sortie != 'F') &&              if ((format_sortie != 'S') && (format_sortie != 'F') &&
                     (format_sortie != 'I') && (format_sortie != 'E'))                      (format_sortie != 'I') && (format_sortie != 'E'))
             {              {
Line 2715  formateur_fichier(struct_processus *s_et Line 2945  formateur_fichier(struct_processus *s_et
             return(NULL);              return(NULL);
         }          }
   
         (*longueur_effective) = strlen(chaine) + 1;          (*longueur_effective) = ((integer8) strlen(chaine)) + 1;
     }      }
     else      else
     {      {
Line 2873  formateur_fichier(struct_processus *s_et Line 3103  formateur_fichier(struct_processus *s_et
          * 1101 10 11               matrice complex*16 (dimensions integer*4)           * 1101 10 11               matrice complex*16 (dimensions integer*4)
          * 1101 11 11               matrice complex*16 (dimensions integer*8)           * 1101 11 11               matrice complex*16 (dimensions integer*8)
          *           *
            * 1110 0 XXX               fonction de longueur XXX
            * 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 2899  formateur_fichier(struct_processus *s_et Line 3137  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'L';
                   longueur_champ = 8;
               }
   
             if (format_sortie != 'L')              if (format_sortie != 'L')
             {              {
                 (*s_etat_processus).erreur_execution =                  (*s_etat_processus).erreur_execution =
Line 2919  formateur_fichier(struct_processus *s_et Line 3163  formateur_fichier(struct_processus *s_et
   
             (*longueur_effective) = longueur_champ + 1;              (*longueur_effective) = longueur_champ + 1;
   
             if ((chaine = malloc((*longueur_effective) * sizeof(unsigned char)))              if ((chaine = malloc(((size_t) (*longueur_effective))
                     == 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(NULL);
             }              }
   
             chaine[0] = longueur_champ;              chaine[0] = (unsigned char) longueur_champ;
   
             for(i = 1; i <= (unsigned) (*longueur_effective); i++)              for(i = 1; i <= (*longueur_effective); i++)
             {              {
                 chaine[i] = ((*((logical8 *) (*s_objet).objet)) >>                  chaine[i] = ((*((logical8 *) (*s_objet).objet)) >>
                         (8 * (longueur_champ - i))) & 0xFF;                          (8 * (longueur_champ - i))) & 0xFF;
Line 2945  formateur_fichier(struct_processus *s_et Line 3189  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'S';
                   longueur_champ = -1;
               }
   
               if (format_sortie != 'S')
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_format_fichier;
                   return(NULL);
               }
   
             longueur_reelle_chaine = longueur_chaine(s_etat_processus,              longueur_reelle_chaine = longueur_chaine(s_etat_processus,
                     (unsigned char *) (*s_objet).objet);                      (unsigned char *) (*s_objet).objet);
   
Line 2971  formateur_fichier(struct_processus *s_et Line 3228  formateur_fichier(struct_processus *s_et
                     return(NULL);                      return(NULL);
                 }                  }
   
                 if ((chaine = malloc(longueur_champ * sizeof(unsigned char)))                  if ((chaine = malloc(((size_t) longueur_champ)
                             == NULL)                          * sizeof(unsigned char))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
                             d_es_allocation_memoire;                              d_es_allocation_memoire;
                     return(NULL);                      return(NULL);
                 }                  }
   
                 memcpy(chaine, chaine_sauvegarde, longueur_champ);                  memcpy(chaine, chaine_sauvegarde, (size_t) longueur_champ);
                 longueur_chaine_traitee = longueur_champ;                  longueur_chaine_traitee = longueur_champ;
                 free(chaine_sauvegarde);                  free(chaine_sauvegarde);
             }              }
Line 2988  formateur_fichier(struct_processus *s_et Line 3245  formateur_fichier(struct_processus *s_et
   
             if (longueur_chaine_traitee < (1LL << 3))              if (longueur_chaine_traitee < (1LL << 3))
             {              {
                 if ((chaine = malloc((longueur_chaine_traitee + 1)                  if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 1)
                         * sizeof(unsigned char))) == NULL)                          * sizeof(unsigned char))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
Line 2996  formateur_fichier(struct_processus *s_et Line 3253  formateur_fichier(struct_processus *s_et
                     return(NULL);                      return(NULL);
                 }                  }
   
                 chaine[0] = 0x80 | (longueur_chaine_traitee & 0x7);                  chaine[0] = (unsigned char) (0x80 |
                           (longueur_chaine_traitee & 0x7));
   
                 memcpy(chaine + 1, chaine_sauvegarde, longueur_chaine_traitee);                  memcpy(chaine + 1, chaine_sauvegarde,
                           (size_t) longueur_chaine_traitee);
                 longueur_totale = longueur_chaine_traitee + 1;                  longueur_totale = longueur_chaine_traitee + 1;
             }              }
             else if (longueur_chaine_traitee < (1LL << 8))              else if (longueur_chaine_traitee < (1LL << 8))
             {              {
                 if ((chaine = malloc((longueur_chaine_traitee + 2)                  if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 2)
                         * sizeof(unsigned char))) == NULL)                          * sizeof(unsigned char))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
Line 3011  formateur_fichier(struct_processus *s_et Line 3270  formateur_fichier(struct_processus *s_et
                     return(NULL);                      return(NULL);
                 }                  }
   
                 chaine[0] = 0x88;                  chaine[0] = (unsigned char) 0x88;
                 chaine[1] = (unsigned char) (longueur_chaine_traitee & 0xFF);                  chaine[1] = (unsigned char) (longueur_chaine_traitee & 0xFF);
   
                 memcpy(chaine + 2, chaine_sauvegarde, longueur_chaine_traitee);                  memcpy(chaine + 2, chaine_sauvegarde,
                           (size_t) longueur_chaine_traitee);
                 longueur_totale = longueur_chaine_traitee + 2;                  longueur_totale = longueur_chaine_traitee + 2;
             }              }
             else if (longueur_chaine_traitee < (1LL << 16))              else if (longueur_chaine_traitee < (1LL << 16))
             {              {
                 if ((chaine = malloc((longueur_chaine_traitee + 3)                  if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 3)
                         * sizeof(unsigned char))) == NULL)                          * sizeof(unsigned char))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
Line 3027  formateur_fichier(struct_processus *s_et Line 3287  formateur_fichier(struct_processus *s_et
                     return(NULL);                      return(NULL);
                 }                  }
   
                 chaine[0] = 0x89;                  chaine[0] = (unsigned char) 0x89;
                 chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 8)                  chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 8)
                         & 0xFF);                          & 0xFF);
                 chaine[2] = (unsigned char) (longueur_chaine_traitee & 0xFF);                  chaine[2] = (unsigned char) (longueur_chaine_traitee & 0xFF);
   
                 memcpy(chaine + 3, chaine_sauvegarde, longueur_chaine_traitee);                  memcpy(chaine + 3, chaine_sauvegarde,
                           (size_t) longueur_chaine_traitee);
                 longueur_totale = longueur_chaine_traitee + 3;                  longueur_totale = longueur_chaine_traitee + 3;
             }              }
             else if (longueur_chaine_traitee < (1LL << 32))              else if (longueur_chaine_traitee < (1LL << 32))
             {              {
                 if ((chaine = malloc((longueur_chaine_traitee + 5)                  if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 5)
                         * sizeof(unsigned char))) == NULL)                          * sizeof(unsigned char))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
Line 3045  formateur_fichier(struct_processus *s_et Line 3306  formateur_fichier(struct_processus *s_et
                     return(NULL);                      return(NULL);
                 }                  }
   
                 chaine[0] = 0x8A;                  chaine[0] = (unsigned char) 0x8A;
                 chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 24)                  chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 24)
                         & 0xFF);                          & 0xFF);
                 chaine[2] = (unsigned char) ((longueur_chaine_traitee >> 16)                  chaine[2] = (unsigned char) ((longueur_chaine_traitee >> 16)
Line 3054  formateur_fichier(struct_processus *s_et Line 3315  formateur_fichier(struct_processus *s_et
                         & 0xFF);                          & 0xFF);
                 chaine[4] = (unsigned char) (longueur_chaine_traitee & 0xFF);                  chaine[4] = (unsigned char) (longueur_chaine_traitee & 0xFF);
   
                 memcpy(chaine + 5, chaine_sauvegarde, longueur_chaine_traitee);                  memcpy(chaine + 5, chaine_sauvegarde,
                           (size_t) longueur_chaine_traitee);
                 longueur_totale = longueur_chaine_traitee + 5;                  longueur_totale = longueur_chaine_traitee + 5;
             }              }
             else              else
             {              {
                 if ((chaine = malloc((longueur_chaine_traitee + 9)                  if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 9)
                         * sizeof(unsigned char))) == NULL)                          * sizeof(unsigned char))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
Line 3067  formateur_fichier(struct_processus *s_et Line 3329  formateur_fichier(struct_processus *s_et
                     return(NULL);                      return(NULL);
                 }                  }
   
                 chaine[0] = 0x8B;                  chaine[0] = (unsigned char) 0x8B;
                 chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 56)                  chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 56)
                         & 0xFF);                          & 0xFF);
                 chaine[2] = (unsigned char) ((longueur_chaine_traitee >> 48)                  chaine[2] = (unsigned char) ((longueur_chaine_traitee >> 48)
Line 3084  formateur_fichier(struct_processus *s_et Line 3346  formateur_fichier(struct_processus *s_et
                         & 0xFF);                          & 0xFF);
                 chaine[8] = (unsigned char) (longueur_chaine_traitee & 0xFF);                  chaine[8] = (unsigned char) (longueur_chaine_traitee & 0xFF);
   
                 memcpy(chaine + 9, chaine_sauvegarde, longueur_chaine_traitee);                  memcpy(chaine + 9, chaine_sauvegarde,
                           (size_t) longueur_chaine_traitee);
                 longueur_totale = longueur_chaine_traitee + 9;                  longueur_totale = longueur_chaine_traitee + 9;
             }              }
   
Line 3100  formateur_fichier(struct_processus *s_et Line 3363  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'C';
                   longueur = 8;
               }
   
             if (format_sortie != 'C')              if (format_sortie != 'C')
             {              {
                 (*s_etat_processus).erreur_execution =                  (*s_etat_processus).erreur_execution =
Line 3124  formateur_fichier(struct_processus *s_et Line 3393  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'I';
                   longueur = 8;
               }
   
             if ((format_sortie != 'I') && (format_sortie != 'R')              if ((format_sortie != 'I') && (format_sortie != 'R')
                     && (format_sortie != 'C'))                      && (format_sortie != 'C'))
             {              {
Line 3145  formateur_fichier(struct_processus *s_et Line 3420  formateur_fichier(struct_processus *s_et
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Fonction    Fonction
     Poids fort 1110
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie != 'N')
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_format_fichier;
                   return(NULL);
               }
   
               longueur_fonction = (integer8) strlen((*((struct_fonction *)
                       (*s_objet).objet)).nom_fonction);
   
               if (longueur_fonction < (1LL << 3))
               {
                   if ((chaine = malloc((1 + ((size_t) longueur_fonction) + 8)
                           * sizeof(unsigned char)))== NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = (unsigned char) (0xE0 | (longueur_fonction & 0x7));
   
                   strcpy(chaine + 1, (*((struct_fonction *) (*s_objet).objet))
                           .nom_fonction);
                   (*longueur_effective) = 1 + longueur_fonction + 8;
               }
               else if (longueur_fonction < (1LL << 8))
               {
                   if ((chaine = malloc((2 + ((size_t) longueur_fonction) + 8)
                           * sizeof(unsigned char)))== NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = (unsigned char) (0xE0 | 0x08);
                   chaine[1] = (unsigned char) (longueur_fonction & 0xFF);
   
                   strcpy(chaine + 2, (*((struct_fonction *) (*s_objet).objet))
                           .nom_fonction);
                   (*longueur_effective) = 2 + longueur_fonction + 8;
               }
               else if (longueur_fonction < (1LL << 16))
               {
                   if ((chaine = malloc((3 + ((size_t) longueur_fonction) + 8)
                           * sizeof(unsigned char)))== NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = (unsigned char ) (0xE0 | 0x09);
                   chaine[1] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
                   chaine[2] = (unsigned char) (longueur_fonction & 0xFF);
   
                   strcpy(chaine + 3, (*((struct_fonction *) (*s_objet).objet))
                           .nom_fonction);
                   (*longueur_effective) = 3 + longueur_fonction + 9;
               }
               else if (longueur_fonction < (1LL << 32))
               {
                   if ((chaine = malloc((5 + ((size_t) longueur_fonction) + 8)
                           * sizeof(unsigned char)))== NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = (unsigned char) (0xE0 | 0x0A);
                   chaine[1] = (unsigned char) ((longueur_fonction >> 24) & 0xFF);
                   chaine[2] = (unsigned char) ((longueur_fonction >> 16) & 0xFF);
                   chaine[3] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
                   chaine[4] = (unsigned char) (longueur_fonction & 0xFF);
   
                   strcpy(chaine + 5, (*((struct_fonction *) (*s_objet).objet))
                           .nom_fonction);
                   (*longueur_effective) = 5 + longueur_fonction + 8;
               }
               else
               {
                   if ((chaine = malloc((9 + ((size_t) longueur_fonction) + 8)
                           * sizeof(unsigned char)))== NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = (unsigned char) (0xE0 | 0x0B);
                   chaine[1] = (unsigned char) ((longueur_fonction >> 56) & 0xFF);
                   chaine[2] = (unsigned char) ((longueur_fonction >> 48) & 0xFF);
                   chaine[3] = (unsigned char) ((longueur_fonction >> 40) & 0xFF);
                   chaine[4] = (unsigned char) ((longueur_fonction >> 32) & 0xFF);
                   chaine[5] = (unsigned char) ((longueur_fonction >> 24) & 0xFF);
                   chaine[6] = (unsigned char) ((longueur_fonction >> 16) & 0xFF);
                   chaine[7] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
                   chaine[8] = (unsigned char) (longueur_fonction & 0xFF);
   
                   strcpy(chaine + 9, (*((struct_fonction *) (*s_objet).objet))
                           .nom_fonction);
                   (*longueur_effective) = 9 + longueur_fonction + 8;
               }
   
               for(i = 1; i <= 8; i++)
               {
                   chaine[(*longueur_effective) - i] = (unsigned char)
                           (((*((struct_fonction *) (*s_objet).objet))
                           .nombre_arguments >> ((8 - i) * 8)) & 0xFF);
               }
         }          }
         else if (((*s_objet).type == LST) || ((*s_objet).type == ALG)          else if (((*s_objet).type == LST) || ((*s_objet).type == ALG)
                 || ((*s_objet).type == RPN))                  || ((*s_objet).type == RPN))
Line 3200  formateur_fichier(struct_processus *s_et Line 3588  formateur_fichier(struct_processus *s_et
   
             if (longueur_liste < (1LL << 3))              if (longueur_liste < (1LL << 3))
             {              {
                 chaine[0] = type_binaire | (longueur_liste & 0x7);                  chaine[0] = (unsigned char) (type_binaire |
                           (longueur_liste & 0x7));
             }              }
             else if (longueur_liste < (1LL << 8))              else if (longueur_liste < (1LL << 8))
             {              {
                 chaine[0] = type_binaire | 0x08;                  chaine[0] = (unsigned char) (type_binaire | 0x08);
             }              }
             else if (longueur_liste < (1LL << 16))              else if (longueur_liste < (1LL << 16))
             {              {
                 chaine[0] = type_binaire | 0x09;                  chaine[0] = (unsigned char ) (type_binaire | 0x09);
             }              }
             else if (longueur_liste < (1LL << 32))              else if (longueur_liste < (1LL << 32))
             {              {
                 chaine[0] = type_binaire | 0x0A;                  chaine[0] = (unsigned char) (type_binaire | 0x0A);
             }              }
             else              else
             {              {
                 chaine[0] = type_binaire | 0x0B;                  chaine[0] = (unsigned char) (type_binaire | 0x0B);
             }              }
   
             longueur_totale = 1;              longueur_totale = 1;
Line 3229  formateur_fichier(struct_processus *s_et Line 3618  formateur_fichier(struct_processus *s_et
                     {                      {
                         longueur_totale += 1;                          longueur_totale += 1;
   
                         if ((chaine = realloc(chaine, longueur_totale *                          if ((chaine = realloc(chaine,
                                   ((size_t) longueur_totale) *
                                 sizeof(unsigned char))) == NULL)                                  sizeof(unsigned char))) == NULL)
                         {                          {
                             (*s_etat_processus).erreur_systeme =                              (*s_etat_processus).erreur_systeme =
Line 3246  formateur_fichier(struct_processus *s_et Line 3636  formateur_fichier(struct_processus *s_et
                     {                      {
                         longueur_totale += 2;                          longueur_totale += 2;
   
                         if ((chaine = realloc(chaine, longueur_totale *                          if ((chaine = realloc(chaine,
                                   ((size_t) longueur_totale) *
                                 sizeof(unsigned char))) == NULL)                                  sizeof(unsigned char))) == NULL)
                         {                          {
                             (*s_etat_processus).erreur_systeme =                              (*s_etat_processus).erreur_systeme =
Line 3265  formateur_fichier(struct_processus *s_et Line 3656  formateur_fichier(struct_processus *s_et
                     {                      {
                         longueur_totale += 4;                          longueur_totale += 4;
   
                         if ((chaine = realloc(chaine, longueur_totale *                          if ((chaine = realloc(chaine,
                                   ((size_t) longueur_totale) *
                                 sizeof(unsigned char))) == NULL)                                  sizeof(unsigned char))) == NULL)
                         {                          {
                             (*s_etat_processus).erreur_systeme =                              (*s_etat_processus).erreur_systeme =
Line 3288  formateur_fichier(struct_processus *s_et Line 3680  formateur_fichier(struct_processus *s_et
                     {                      {
                         longueur_totale += 8;                          longueur_totale += 8;
   
                         if ((chaine = realloc(chaine, longueur_totale *                          if ((chaine = realloc(chaine,
                                   ((size_t) longueur_totale) *
                                 sizeof(unsigned char))) == NULL)                                  sizeof(unsigned char))) == NULL)
                         {                          {
                             (*s_etat_processus).erreur_systeme =                              (*s_etat_processus).erreur_systeme =
Line 3335  formateur_fichier(struct_processus *s_et Line 3728  formateur_fichier(struct_processus *s_et
                         (((*(*l_element_courant_format).donnee).type == TBL)                          (((*(*l_element_courant_format).donnee).type == TBL)
                         && ((*(*l_element_courant).donnee).type == TBL)))                          && ((*(*l_element_courant).donnee).type == TBL)))
                 {                  {
                     if ((chaine_formatee = formateur_fichier(s_etat_processus,                      if (format_sortie != 'N')
                             (*l_element_courant).donnee,  
                             (*l_element_courant_format).donnee, 0, 0, ' ', 'U',  
                             longueur_effective, recursivite, export_fichier))  
                             == NULL)  
                     {                      {
                         return(NULL);                          if ((chaine_formatee = formateur_fichier(
                                   s_etat_processus,
                                   (*l_element_courant).donnee,
                                   (*l_element_courant_format).donnee,
                                   0, 0, ' ', 'U', longueur_effective, recursivite,
                                   export_fichier)) == NULL)
                           {
                               free(chaine);
                               return(NULL);
                           }
                       }
                       else
                       {
                           if ((chaine_formatee = formateur_fichier(
                                   s_etat_processus,
                                   (*l_element_courant).donnee,
                                   (*l_element_courant_format).donnee,
                                   0, 0, 'N', 'U', longueur_effective, recursivite,
                                   export_fichier)) == NULL)
                           {
                               free(chaine);
                               return(NULL);
                           }
                     }                      }
   
                     if ((chaine = realloc(chaine, (longueur_totale +                      if ((chaine = realloc(chaine, ((size_t) (longueur_totale +
                             (*longueur_effective)) * sizeof(unsigned char)))                              (*longueur_effective))) * sizeof(unsigned char)))
                             == NULL)                              == NULL)
                     {                      {
                         (*s_etat_processus).erreur_systeme =                          (*s_etat_processus).erreur_systeme =
Line 3354  formateur_fichier(struct_processus *s_et Line 3765  formateur_fichier(struct_processus *s_et
                     }                      }
   
                     memcpy(&(chaine[longueur_totale]), chaine_formatee,                      memcpy(&(chaine[longueur_totale]), chaine_formatee,
                             (*longueur_effective));                              (size_t) (*longueur_effective));
                     longueur_totale += (*longueur_effective);                      longueur_totale += (*longueur_effective);
                     free(chaine_formatee);                      free(chaine_formatee);
                 }                  }
Line 3368  formateur_fichier(struct_processus *s_et Line 3779  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 3403  formateur_fichier(struct_processus *s_et Line 3817  formateur_fichier(struct_processus *s_et
                         position_1 = 10;                          position_1 = 10;
                         format_degenere = d_vrai;                          format_degenere = d_vrai;
                     }                      }
                       else if (strcmp("NATIVE*(*)", format_chaine) == 0)
                       {
                           format_sortie = 'N';
                           position_1 = 7;
                           format_degenere = d_vrai;
                       }
                     else                      else
                     {                      {
                         free(chaine);                          free(chaine);
Line 3425  formateur_fichier(struct_processus *s_et Line 3845  formateur_fichier(struct_processus *s_et
   
                     if (strcmp(&(format_chaine[position_1]), "(*)") != 0)                      if (strcmp(&(format_chaine[position_1]), "(*)") != 0)
                     {                      {
                         if (sscanf(&(format_chaine[position_1]), "%ld",                          if (sscanf(&(format_chaine[position_1]), "%lld",
                                 &longueur) != 1)                                  &longueur) != 1)
                         {                          {
                             free(chaine);                              free(chaine);
Line 3445  formateur_fichier(struct_processus *s_et Line 3865  formateur_fichier(struct_processus *s_et
                     }                      }
   
                     free(format_chaine);                      free(format_chaine);
                   
                       // Si le format_sortie vaut 'N', on remplace le format par
                       // { "native*(*)" }. L'intérêt est de pouvoir traiter une
                       // liste par un format "native*(*)".
   
                       if ((format_sortie == 'N') && ((*(*l_element_courant)
                               .donnee).type == LST))
                       {
                           if ((s_format_tmp = allocation(s_etat_processus, LST))
                                   == NULL)
                           {
                               return(NULL);
                           }
   
                           if (((*s_format_tmp).objet = allocation_maillon(
                                   s_etat_processus)) == NULL)
                           {
                               return(NULL);
                           }
   
                           (*((struct_liste_chainee *) (*s_format_tmp).objet))
                                   .suivant = NULL;
   
                           if (((*((struct_liste_chainee *) (*s_format_tmp).objet))
                                   .donnee = allocation(s_etat_processus, CHN))
                                   == NULL)
                           {
                               return(NULL);
                           }
   
                           if (((*(*((struct_liste_chainee *) (*s_format_tmp)
                                   .objet)).donnee).objet = malloc(11 *
                                   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,
                             (*l_element_courant).donnee, s_format,                              (*l_element_courant).donnee, s_format_tmp,
                             longueur, longueur_champ, format_sortie, type,                              longueur, longueur_champ, format_sortie, type,
                             longueur_effective, recursivite, export_fichier))                              longueur_effective, recursivite, export_fichier))
                             == NULL)                              == NULL)
                     {                      {
                           liberation(s_etat_processus, s_format_tmp);
                         free(chaine);                          free(chaine);
                         return(NULL);                          return(NULL);
                     }                      }
   
                       liberation(s_etat_processus, s_format_tmp);
   
                     if ((chaine = realloc(chaine,                      if ((chaine = realloc(chaine,
                             (longueur_totale + (*longueur_effective))                              ((size_t) (longueur_totale + (*longueur_effective)))
                             * sizeof(unsigned char))) == NULL)                              * sizeof(unsigned char))) == NULL)
                     {                      {
                         (*s_etat_processus).erreur_systeme =                          (*s_etat_processus).erreur_systeme =
Line 3466  formateur_fichier(struct_processus *s_et Line 3940  formateur_fichier(struct_processus *s_et
                     }                      }
   
                     memcpy(&(chaine[longueur_totale]), chaine_formatee,                      memcpy(&(chaine[longueur_totale]), chaine_formatee,
                             (*longueur_effective));                              (size_t) (*longueur_effective));
                     longueur_totale += (*longueur_effective);                      longueur_totale += (*longueur_effective);
                     free(chaine_formatee);                      free(chaine_formatee);
                 }                  }
   
                   if (format_sortie != 'N')
                   {
                       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;
                 l_element_courant_format = (*l_element_courant_format).suivant;  
             }              }
   
             if ((l_element_courant != NULL) ||              if (format_sortie != 'N')
                     (l_element_courant_format != NULL))  
             {              {
                 free(chaine);                  if ((l_element_courant != NULL) ||
                           (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 3494  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"));
                       }
                   }
               }
   
               if ((*s_format).type == CHN)
               {
                   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);
   
                   for(i = 0; i < longueur_liste; i++)
                   {
                       if ((chaine_formatee = formateur_fichier(s_etat_processus,
                               (*((struct_tableau *) (*s_objet).objet))
                               .elements[i], (*s_format).objet,
                               longueur, longueur_champ,
                               format_sortie, type, longueur_effective,
                               recursivite, export_fichier)) == NULL)
                       {
                           free(chaine);
                           return(NULL);
                       }
                   }
               }
               else if ((*s_format).type == TBL)
               {
               }
               else
               {
                   free(chaine);
   
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_format_fichier;
                   return(NULL);
               }
   
               // A FIXER
   
   
               /*
               while((l_element_courant != NULL) &&
                       (l_element_courant_format != NULL))
               {
                   if ((((*(*l_element_courant_format).donnee).type == LST)
                           && ((*(*l_element_courant).donnee).type == LST)) ||
                           (((*(*l_element_courant_format).donnee).type == TBL)
                           && ((*(*l_element_courant).donnee).type == TBL)))
                   {
                       if (format_sortie != 'N')
                       {
                           if ((chaine_formatee = formateur_fichier(
                                   s_etat_processus,
                                   (*l_element_courant).donnee,
                                   (*l_element_courant_format).donnee,
                                   0, 0, ' ', 'U', longueur_effective, recursivite,
                                   export_fichier)) == NULL)
                           {
                               return(NULL);
                           }
                       }
                       else
                       {
                           if ((chaine_formatee = formateur_fichier(
                                   s_etat_processus,
                                   (*l_element_courant).donnee,
                                   (*l_element_courant_format).donnee,
                                   0, 0, 'N', 'U', longueur_effective, recursivite,
                                   export_fichier)) == NULL)
                           {
                               return(NULL);
                           }
                       }
   
                       if ((chaine = realloc(chaine, ((size_t) (longueur_totale +
                               (*longueur_effective))) * sizeof(unsigned char)))
                               == NULL)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return(NULL);
                       }
   
                       memcpy(&(chaine[longueur_totale]), chaine_formatee,
                               (size_t) (*longueur_effective));
                       longueur_totale += (*longueur_effective);
                       free(chaine_formatee);
                   }
                   else if ((*(*l_element_courant_format).donnee).type != CHN)
                   {
                       free(chaine);
   
                       (*s_etat_processus).erreur_execution =
                               d_ex_erreur_format_fichier;
                       return(NULL);
                   }
                   else
                   {
                       if ((format_chaine = conversion_majuscule(
                               s_etat_processus, (unsigned char *)
                               (*(*l_element_courant_format).donnee).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);
   
                       // Si le format_sortie vaut 'N', on remplace le format par
                       // { "native*(*)" }. L'intérêt est de pouvoir traiter une
                       // liste par un format "native*(*)".
   
                       if ((format_sortie == 'N') && ((*(*l_element_courant)
                               .donnee).type == LST))
                       {
                           if ((s_format_tmp = allocation(s_etat_processus, LST))
                                   == NULL)
                           {
                               return(NULL);
                           }
   
                           if (((*s_format_tmp).objet = allocation_maillon(
                                   s_etat_processus)) == NULL)
                           {
                               return(NULL);
                           }
   
                           (*((struct_liste_chainee *) (*s_format_tmp).objet))
                                   .suivant = NULL;
   
                           if (((*((struct_liste_chainee *) (*s_format_tmp).objet))
                                   .donnee = allocation(s_etat_processus, CHN))
                                   == NULL)
                           {
                               return(NULL);
                           }
   
                           if (((*(*((struct_liste_chainee *) (*s_format_tmp)
                                   .objet)).donnee).objet = malloc(11 *
                                   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,
                               (*l_element_courant).donnee, 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);
   
                       if ((chaine = realloc(chaine,
                               ((size_t) (longueur_totale + (*longueur_effective)))
                               * sizeof(unsigned char))) == NULL)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return(NULL);
                       }
   
                       memcpy(&(chaine[longueur_totale]), chaine_formatee,
                               (size_t) (*longueur_effective));
                       longueur_totale += (*longueur_effective);
                       free(chaine_formatee);
                   }
   
                   if (format_sortie != 'N')
                   {
                       l_element_courant_format =
                               (*l_element_courant_format).suivant;
                   }
   
                   nombre_elements++;
                   l_element_courant = (*l_element_courant).suivant;
               }
   
               if (format_sortie != 'N')
               {
                   if ((l_element_courant != NULL) ||
                           (l_element_courant_format != NULL))
                   {
                       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 3505  formateur_fichier(struct_processus *s_et Line 4492  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 3514  formateur_fichier(struct_processus *s_et Line 4683  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 3523  formateur_fichier(struct_processus *s_et Line 4939  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 3530  formateur_fichier(struct_processus *s_et Line 5157  formateur_fichier(struct_processus *s_et
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Nom    Nom
     Poids fort 0101
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
               if (format_sortie != 'N')
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_format_fichier;
                   return(NULL);
               }
   
               longueur_fonction = (integer8) strlen((*((struct_nom *)
                       (*s_objet).objet)).nom);
   
               if (longueur_fonction < (1LL << 3))
               {
                   if ((chaine = malloc((1 + ((size_t) longueur_fonction) + 1)
                           * sizeof(unsigned char)))== NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = (unsigned char) (0x50 | (longueur_fonction & 0x7));
   
                   strcpy(chaine + 1, (*((struct_nom *) (*s_objet).objet)).nom);
                   (*longueur_effective) = longueur_fonction + 2;
               }
               else if (longueur_fonction < (1LL << 8))
               {
                   if ((chaine = malloc((2 + ((size_t) longueur_fonction) + 1)
                           * sizeof(unsigned char)))== NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = (unsigned char) (0x50 | 0x08);
                   chaine[1] = (unsigned char) (longueur_fonction & 0xFF);
   
                   strcpy(chaine + 2, (*((struct_nom *) (*s_objet).objet)).nom);
                   (*longueur_effective) = longueur_fonction + 3;
               }
               else if (longueur_fonction < (1LL << 16))
               {
                   if ((chaine = malloc((3 + ((size_t) longueur_fonction) + 1)
                           * sizeof(unsigned char)))== NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = (unsigned char) (0x50 | 0x09);
                   chaine[1] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
                   chaine[2] = (unsigned char) (longueur_fonction & 0xFF);
   
                   strcpy(chaine + 3, (*((struct_nom *) (*s_objet).objet)).nom);
                   (*longueur_effective) = longueur_fonction + 4;
               }
               else if (longueur_fonction < (1LL << 32))
               {
                   if ((chaine = malloc((5 + ((size_t) longueur_fonction) + 1)
                           * sizeof(unsigned char)))== NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = (unsigned char) (0xE0 | 0x0A);
                   chaine[1] = (unsigned char) ((longueur_fonction >> 24) & 0xFF);
                   chaine[2] = (unsigned char) ((longueur_fonction >> 16) & 0xFF);
                   chaine[3] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
                   chaine[4] = (unsigned char) (longueur_fonction & 0xFF);
   
                   strcpy(chaine + 5, (*((struct_nom *) (*s_objet).objet)).nom);
                   (*longueur_effective) = longueur_fonction + 6;
               }
               else
               {
                   if ((chaine = malloc((9 + ((size_t) longueur_fonction) + 1)
                           * sizeof(unsigned char)))== NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = (unsigned char) (0xE0 | 0x0B);
                   chaine[1] = (unsigned char) ((longueur_fonction >> 56) & 0xFF);
                   chaine[2] = (unsigned char) ((longueur_fonction >> 48) & 0xFF);
                   chaine[3] = (unsigned char) ((longueur_fonction >> 40) & 0xFF);
                   chaine[4] = (unsigned char) ((longueur_fonction >> 32) & 0xFF);
                   chaine[5] = (unsigned char) ((longueur_fonction >> 24) & 0xFF);
                   chaine[6] = (unsigned char) ((longueur_fonction >> 16) & 0xFF);
                   chaine[7] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
                   chaine[8] = (unsigned char) (longueur_fonction & 0xFF);
   
                   strcpy(chaine + 9, (*((struct_nom *) (*s_objet).objet)).nom);
                   (*longueur_effective) = longueur_fonction + 10;
               }
   
               chaine[(*longueur_effective) - 1] = ((*((struct_nom *)
                       (*s_objet).objet)).symbole == d_vrai) ? 0xFF : 0x00;
         }          }
         else if ((*s_objet).type == REL)          else if ((*s_objet).type == REL)
         {          {
Line 3543  formateur_fichier(struct_processus *s_et Line 5274  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'R';
                   longueur = 8;
               }
   
             if ((format_sortie != 'R') && (format_sortie != 'C'))              if ((format_sortie != 'R') && (format_sortie != 'C'))
             {              {
                 (*s_etat_processus).erreur_execution =                  (*s_etat_processus).erreur_execution =
Line 3565  formateur_fichier(struct_processus *s_et Line 5302  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 3574  formateur_fichier(struct_processus *s_et Line 5433  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 3583  formateur_fichier(struct_processus *s_et Line 5628  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 3605  formateur_fichier(struct_processus *s_et Line 5787  formateur_fichier(struct_processus *s_et
   
             if (longueur_totale < (((integer8) 1) << 7))              if (longueur_totale < (((integer8) 1) << 7))
             {              {
                 tampon[0] = ((longueur_totale + 1) << 1) & 0xFF;                  tampon[0] = (unsigned char) (((longueur_totale + 1) << 1)
                           & 0xFF);
   
                 if ((chaine = realloc(chaine, (longueur_totale + 1)                  if ((chaine = realloc(chaine, (((size_t) longueur_totale) + 1)
                         * sizeof(unsigned char))) == NULL)                          * sizeof(unsigned char))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
Line 3619  formateur_fichier(struct_processus *s_et Line 5802  formateur_fichier(struct_processus *s_et
                 memcpy(&(chaine[longueur_totale]), tampon, 1);                  memcpy(&(chaine[longueur_totale]), tampon, 1);
                 longueur_totale += 1;                  longueur_totale += 1;
             }              }
             else if (longueur_totale < (((integer8) 1) << 16))              else
             {              {
                 longueur_totale++;                  longueur_totale++;
   
                 for(i = 0; i < 7; i++)                  // i = { 0 (16 bits) 2 (32 bits) 6 (64 bits) }
   
                   i = 0;
   
                   for(;;)
                 {                  {
                     if ((longueur_totale < (((integer8) 1) << (8 * (i + 2))))                      if ((longueur_totale < (((integer8) 1) << (8 * (i + 2))))
                             || (i == 6))                              || (i == 6))
                     {                      {
                         // LSB (4 bits de poids fort)                          // LSB (4 bits de poids fort)
                         tampon[0] = (longueur_totale & 0xF0)                          tampon[0] = (unsigned char) ((longueur_totale & 0xF0)
                                 | 0x1 /* longueur supérieure à 7 bits */                                  | 0x1 /* longueur supérieure à 7 bits */
                                 | ((i + 1) << 1);                                  | ((i + 1) << 1));
   
                         for(j = 0; j <= i; j++)                          for(j = 0; j <= i; j++)
                         {                          {
                             tampon[(i - j) + 1] =                              tampon[(i - j) + 1] = (unsigned char)
                                     (longueur_totale >> (8 * (j + 1)))                                      ((longueur_totale >> (8 * (j + 1)))
                                     & 0xFF;                                      & 0xFF);
                         }                          }
   
                         // LSB (4 bits de poids faible)                          // LSB (4 bits de poids faible)
                         tampon[i + 2] = ((longueur_totale & 0x0F) << 4)                          tampon[i + 2] = (unsigned char)
                                   (((longueur_totale & 0x0F) << 4)
                                 | 0x1 /* longueur supérieure à 7 bits */                                  | 0x1 /* longueur supérieure à 7 bits */
                                 | ((i + 1) << 1);                                  | ((i + 1) << 1));
                         break;                          break;
                     }                      }
   
                       switch(i)
                       {
                           case 0 :
                           {
                               i = 2;
                               break;
                           }
   
                           case 2 :
                           {
                               i = 6;
                               break;
                           }
                       }
                 }                  }
   
                 if ((chaine = realloc(chaine, (longueur_totale + 3)                  // i = 0 => +3 (16 bits)
                   // i = 2 => +5 (32 bits)
                   // i = 6 => +9 (64 bits)
   
                   if ((chaine = realloc(chaine, (((size_t) longueur_totale)
                           + ((i == 0) ? 3 : ((i == 2) ? 5 : 9)))
                         * sizeof(unsigned char))) == NULL)                          * sizeof(unsigned char))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
Line 3659  formateur_fichier(struct_processus *s_et Line 5867  formateur_fichier(struct_processus *s_et
                 memcpy(&(chaine[longueur_totale]), tampon, 3);                  memcpy(&(chaine[longueur_totale]), tampon, 3);
                 longueur_totale += 3;                  longueur_totale += 3;
             }              }
             else if (longueur_totale < (((integer8) 1) << 32))  
             {  
             }  
   
             __zone();              __zone();
             (*longueur_effective) = longueur_totale;              (*longueur_effective) = longueur_totale;
Line 3697  formateur_fichier(struct_processus *s_et Line 5902  formateur_fichier(struct_processus *s_et
 unsigned char *  unsigned char *
 formateur_fichier_nombre(struct_processus *s_etat_processus,  formateur_fichier_nombre(struct_processus *s_etat_processus,
         void *valeur_numerique, unsigned char type,          void *valeur_numerique, unsigned char type,
         long longueur, long longueur_champ, unsigned char format)          integer8 longueur, integer8 longueur_champ, unsigned char format)
 {  {
     unsigned char               *chaine;      unsigned char               *chaine;
     unsigned char               *construction_chaine;      unsigned char               *construction_chaine;
Line 3837  formateur_fichier_nombre(struct_processu Line 6042  formateur_fichier_nombre(struct_processu
 unsigned char *  unsigned char *
 formateur_fichier_reel(struct_processus *s_etat_processus,  formateur_fichier_reel(struct_processus *s_etat_processus,
         void *valeur_numerique, unsigned char type,          void *valeur_numerique, unsigned char type,
         long longueur, long longueur_champ,          integer8 longueur, integer8 longueur_champ,
         unsigned char format_sortie)          unsigned char format_sortie)
 {  {
     real8                   mantisse;      real8                   mantisse;
     real8                   tampon_reel;      real8                   tampon_reel;
   
       integer8                i;
     integer8                tampon_entier;      integer8                tampon_entier;
   
     long                    correction;      long                    correction;
Line 3855  formateur_fichier_reel(struct_processus Line 6061  formateur_fichier_reel(struct_processus
     unsigned char           mode[3 + 1];      unsigned char           mode[3 + 1];
     unsigned char           tampon[16 + 1];      unsigned char           tampon[16 + 1];
   
     unsigned long           i;  
   
     chaine = (unsigned char *) malloc((32 + 1) * sizeof(unsigned char));      chaine = (unsigned char *) malloc((32 + 1) * sizeof(unsigned char));
   
     if (chaine == NULL)      if (chaine == NULL)
Line 3882  formateur_fichier_reel(struct_processus Line 6086  formateur_fichier_reel(struct_processus
             exposant = 0;              exposant = 0;
         }          }
   
         mantisse = (*((real8 *) valeur_numerique)) / pow(10, exposant);          mantisse = (*((real8 *) valeur_numerique)) / pow(10, (double) exposant);
     }      }
     else      else
     {      {
Line 3890  formateur_fichier_reel(struct_processus Line 6094  formateur_fichier_reel(struct_processus
   
         if (tampon_entier > ((integer8) 0))          if (tampon_entier > ((integer8) 0))
         {          {
             exposant = (long) floor(log10(tampon_entier));              exposant = (long) floor(log10((double) tampon_entier));
         }          }
         else if (tampon_entier < ((integer8) 0))          else if (tampon_entier < ((integer8) 0))
         {          {
             exposant = (long) floor(log10(-tampon_entier));              exposant = (long) floor(log10((double) -tampon_entier));
         }          }
         else          else
         {          {
             exposant = 0;              exposant = 0;
         }          }
   
         mantisse = (*((integer8 *) valeur_numerique)) / pow(10, exposant);          mantisse = ((real8) (*((integer8 *) valeur_numerique))) /
                   pow(10, (double) exposant);
     }      }
   
     longueur_utile = longueur;      longueur_utile = (long) longueur;
     longueur_utile_limite = 15;      longueur_utile_limite = 15;
   
     if (longueur_utile > longueur_utile_limite)      if (longueur_utile > longueur_utile_limite)
Line 3965  formateur_fichier_reel(struct_processus Line 6170  formateur_fichier_reel(struct_processus
   
         sprintf(format, "%%.%luf", longueur_utile);          sprintf(format, "%%.%luf", longueur_utile);
   
         sprintf(tampon, format, (mantisse * pow(10, exposant)));          sprintf(tampon, format, (mantisse * pow(10, (double) exposant)));
         strcpy(chaine, tampon);          strcpy(chaine, tampon);
     }      }
     else if (strcmp(mode, "ENG") == 0)      else if (strcmp(mode, "ENG") == 0)
Line 3988  formateur_fichier_reel(struct_processus Line 6193  formateur_fichier_reel(struct_processus
         longueur_utile -= correction;          longueur_utile -= correction;
         sprintf(format, "%%.%luf", longueur_utile);          sprintf(format, "%%.%luf", longueur_utile);
   
         sprintf(tampon, format, (mantisse * pow(10, correction)));          sprintf(tampon, format, (mantisse * pow(10, (double) correction)));
         strcpy(chaine, tampon);          strcpy(chaine, tampon);
         strcat(chaine, "E");          strcat(chaine, "E");
         sprintf(tampon, "%ld", (exposant - correction));          sprintf(tampon, "%ld", (exposant - correction));
Line 4018  formateur_fichier_reel(struct_processus Line 6223  formateur_fichier_reel(struct_processus
   
             sprintf(tampon, format, *((real8 *) valeur_numerique));              sprintf(tampon, format, *((real8 *) valeur_numerique));
   
             i = strlen(tampon) - 1;              i = (integer8) (strlen(tampon)) - 1;
             while(tampon[i] == '0')              while(tampon[i] == '0')
             {              {
                 tampon[i] = 0;                  tampon[i] = 0;
Line 4027  formateur_fichier_reel(struct_processus Line 6232  formateur_fichier_reel(struct_processus
   
             if (ds_imposition_separateur_decimal == d_faux)              if (ds_imposition_separateur_decimal == d_faux)
             {              {
                 i = strlen(tampon) - 1;                  i = ((integer8) strlen(tampon)) - 1;
                 if (tampon[i] == '.')                  if (tampon[i] == '.')
                 {                  {
                     tampon[i] = 0;                      tampon[i] = 0;
Line 4042  formateur_fichier_reel(struct_processus Line 6247  formateur_fichier_reel(struct_processus
     {      {
         if (strlen(chaine) > (size_t) longueur_champ)          if (strlen(chaine) > (size_t) longueur_champ)
         {          {
             for(i = 0; i < (unsigned long) longueur_champ; i++)              for(i = 0; i < longueur_champ; i++)
             {              {
                 chaine[i] = '*';                  chaine[i] = '*';
             }              }
Line 4064  formateur_fichier_reel(struct_processus Line 6269  formateur_fichier_reel(struct_processus
 unsigned char *  unsigned char *
 formateur_fichier_binaire_nombre(struct_processus *s_etat_processus,  formateur_fichier_binaire_nombre(struct_processus *s_etat_processus,
         void *valeur_numerique, unsigned char type_entree,          void *valeur_numerique, unsigned char type_entree,
         unsigned char type, long longueur, long *longueur_conversion)          unsigned char type, integer8 longueur, integer8 *longueur_conversion)
 {  {
     unsigned char               *chaine;      unsigned char               *chaine;
   
Line 4098  formateur_fichier_binaire_nombre(struct_ Line 6303  formateur_fichier_binaire_nombre(struct_
                     }                      }
   
                     (*longueur_conversion) = 2;                      (*longueur_conversion) = 2;
                     chaine[0] = 0x10;                      chaine[0] = (unsigned char) 0x10;
                     chaine[1] = (*((integer8 *) valeur_numerique)) & 0xFF;                      chaine[1] = (unsigned char) ((*((integer8 *)
                               valeur_numerique)) & 0xFF);
                     break;                      break;
                 }                  }
   
Line 4121  formateur_fichier_binaire_nombre(struct_ Line 6327  formateur_fichier_binaire_nombre(struct_
                     }                      }
   
                     (*longueur_conversion) = 3;                      (*longueur_conversion) = 3;
                     chaine[0] = 0x11;                      chaine[0] = (unsigned char) 0x11;
                     chaine[1] = ((*((integer8 *) valeur_numerique)) >> 8)                      chaine[1] = ((unsigned char) ((*((integer8 *)
                             & 0xFF;                              valeur_numerique)) >> 8) & 0xFF);
                     chaine[2] = (*((integer8 *) valeur_numerique)) & 0xFF;                      chaine[2] = (unsigned char) ((*((integer8 *)
                               valeur_numerique)) & 0xFF);
                     break;                      break;
                 }                  }
   
Line 4146  formateur_fichier_binaire_nombre(struct_ Line 6353  formateur_fichier_binaire_nombre(struct_
                     }                      }
   
                     (*longueur_conversion) = 5;                      (*longueur_conversion) = 5;
                     chaine[0] = 0x12;                      chaine[0] = (unsigned char) 0x12;
                     chaine[1] = ((*((integer8 *) valeur_numerique)) >> 24)                      chaine[1] = (unsigned char) (((*((integer8 *)
                             & 0xFF;                              valeur_numerique)) >> 24) & 0xFF);
                     chaine[2] = ((*((integer8 *) valeur_numerique)) >> 16)                      chaine[2] = (unsigned char) (((*((integer8 *)
                             & 0xFF;                              valeur_numerique)) >> 16) & 0xFF);
                     chaine[3] = ((*((integer8 *) valeur_numerique)) >> 8)                      chaine[3] = (unsigned char) (((*((integer8 *)
                             & 0xFF;                              valeur_numerique)) >> 8) & 0xFF);
                     chaine[4] = (*((integer8 *) valeur_numerique)) & 0xFF;                      chaine[4] = (unsigned char) ((*((integer8 *)
                               valeur_numerique)) & 0xFF);
                     break;                      break;
                 }                  }
   
Line 4167  formateur_fichier_binaire_nombre(struct_ Line 6375  formateur_fichier_binaire_nombre(struct_
                     }                      }
   
                     (*longueur_conversion) = 9;                      (*longueur_conversion) = 9;
                     chaine[0] = 0x13;                      chaine[0] = (unsigned char) 0x13;
                     chaine[1] = ((*((integer8 *) valeur_numerique)) >> 56)                      chaine[1] = (unsigned char) (((*((integer8 *)
                             & 0xFF;                              valeur_numerique)) >> 56) & 0xFF);
                     chaine[2] = ((*((integer8 *) valeur_numerique)) >> 48)                      chaine[2] = (unsigned char) (((*((integer8 *)
                             & 0xFF;                              valeur_numerique)) >> 48) & 0xFF);
                     chaine[3] = ((*((integer8 *) valeur_numerique)) >> 40)                      chaine[3] = (unsigned char) (((*((integer8 *)
                             & 0xFF;                              valeur_numerique)) >> 40) & 0xFF);
                     chaine[4] = ((*((integer8 *) valeur_numerique)) >> 32)                      chaine[4] = (unsigned char) (((*((integer8 *)
                             & 0xFF;                              valeur_numerique)) >> 32) & 0xFF);
                     chaine[5] = ((*((integer8 *) valeur_numerique)) >> 24)                      chaine[5] = (unsigned char) (((*((integer8 *)
                             & 0xFF;                              valeur_numerique)) >> 24) & 0xFF);
                     chaine[6] = ((*((integer8 *) valeur_numerique)) >> 16)                      chaine[6] = (unsigned char) (((*((integer8 *)
                             & 0xFF;                              valeur_numerique)) >> 16) & 0xFF);
                     chaine[7] = ((*((integer8 *) valeur_numerique)) >> 8)                      chaine[7] = (unsigned char) (((*((integer8 *)
                             & 0xFF;                              valeur_numerique)) >> 8) & 0xFF);
                     chaine[8] = (*((integer8 *) valeur_numerique)) & 0xFF;                      chaine[8] = (unsigned char) ((*((integer8 *)
                               valeur_numerique)) & 0xFF);
                     break;                      break;
                 }                  }
   
Line 4219  formateur_fichier_binaire_nombre(struct_ Line 6428  formateur_fichier_binaire_nombre(struct_
                     }                      }
                     else if (type_entree == 'I')                      else if (type_entree == 'I')
                     {                      {
                         valeur = (*((integer8 *) valeur_numerique));                          valeur = (real8) (*((integer8 *) valeur_numerique));
                     }                      }
                     else                      else
                     {                      {
Line 4233  formateur_fichier_binaire_nombre(struct_ Line 6442  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;
Line 4256  formateur_fichier_binaire_nombre(struct_ Line 6470  formateur_fichier_binaire_nombre(struct_
   
                     eq4.r4 = (real4) valeur;                      eq4.r4 = (real4) valeur;
                     (*longueur_conversion) = 5;                      (*longueur_conversion) = 5;
                     chaine[0] = 0x14;                      chaine[0] = (unsigned char) 0x14;
                     chaine[1] = (eq4.i4 >> 24) & 0xFF;                      chaine[1] = (unsigned char) ((eq4.i4 >> 24) & 0xFF);
                     chaine[2] = (eq4.i4 >> 16) & 0xFF;                      chaine[2] = (unsigned char) ((eq4.i4 >> 16) & 0xFF);
                     chaine[3] = (eq4.i4 >> 8) & 0xFF;                      chaine[3] = (unsigned char) ((eq4.i4 >> 8) & 0xFF);
                     chaine[4] = eq4.i4 & 0xFF;                      chaine[4] = (unsigned char) (eq4.i4 & 0xFF);
                     break;                      break;
                 }                  }
   
Line 4281  formateur_fichier_binaire_nombre(struct_ Line 6495  formateur_fichier_binaire_nombre(struct_
   
                     if (type_entree == 'I')                      if (type_entree == 'I')
                     {                      {
                         eq8.r8 = (*((integer8 *) valeur_numerique));                          eq8.r8 = (real8) (*((integer8 *) valeur_numerique));
                     }                      }
                     else if (type_entree == 'R')                      else if (type_entree == 'R')
                     {                      {
Line 4295  formateur_fichier_binaire_nombre(struct_ Line 6509  formateur_fichier_binaire_nombre(struct_
                     }                      }
   
                     (*longueur_conversion) = 9;                      (*longueur_conversion) = 9;
                     chaine[0] = 0x15;                      chaine[0] = (unsigned char) (0x15);
                     chaine[1] = (eq8.i8 >> 56) & 0xFF;                      chaine[1] = (unsigned char) ((eq8.i8 >> 56) & 0xFF);
                     chaine[2] = (eq8.i8 >> 48) & 0xFF;                      chaine[2] = (unsigned char) ((eq8.i8 >> 48) & 0xFF);
                     chaine[3] = (eq8.i8 >> 40) & 0xFF;                      chaine[3] = (unsigned char) ((eq8.i8 >> 40) & 0xFF);
                     chaine[4] = (eq8.i8 >> 32) & 0xFF;                      chaine[4] = (unsigned char) ((eq8.i8 >> 32) & 0xFF);
                     chaine[5] = (eq8.i8 >> 24) & 0xFF;                      chaine[5] = (unsigned char) ((eq8.i8 >> 24) & 0xFF);
                     chaine[6] = (eq8.i8 >> 16) & 0xFF;                      chaine[6] = (unsigned char) ((eq8.i8 >> 16) & 0xFF);
                     chaine[7] = (eq8.i8 >> 8) & 0xFF;                      chaine[7] = (unsigned char) ((eq8.i8 >> 8) & 0xFF);
                     chaine[8] = eq8.i8 & 0xFF;                      chaine[8] = (unsigned char) (eq8.i8 & 0xFF);
                     break;                      break;
                 }                  }
   
Line 4327  formateur_fichier_binaire_nombre(struct_ Line 6541  formateur_fichier_binaire_nombre(struct_
                     unsigned char       *partie_reelle;                      unsigned char       *partie_reelle;
                     unsigned char       *partie_imaginaire;                      unsigned char       *partie_imaginaire;
   
                     long                limag;                      integer8            limag;
                     long                lreel;                      integer8            lreel;
   
                     real8               zero;                      real8               zero;
   
Line 4401  formateur_fichier_binaire_nombre(struct_ Line 6615  formateur_fichier_binaire_nombre(struct_
                         return(NULL);                          return(NULL);
                     }                      }
   
                     if ((chaine = malloc((lreel + limag - 1) *                      if ((chaine = malloc((((size_t) lreel) + ((size_t) limag)
                             sizeof(unsigned char))) == NULL)                              - 1) * sizeof(unsigned char))) == NULL)
                     {                      {
                         free(partie_reelle);                          free(partie_reelle);
                         free(partie_imaginaire);                          free(partie_imaginaire);
Line 4412  formateur_fichier_binaire_nombre(struct_ Line 6626  formateur_fichier_binaire_nombre(struct_
                         return(NULL);                          return(NULL);
                     }                      }
   
                     chaine[0] = 0x18;                      chaine[0] = (unsigned char) 0x18;
                     memcpy(chaine + 1, partie_reelle + 1, lreel - 1);                      memcpy(chaine + 1, partie_reelle + 1,
                     memcpy(chaine + lreel, partie_imaginaire + 1, limag - 1);                              ((size_t) lreel) - 1);
                       memcpy(chaine + lreel, partie_imaginaire + 1,
                               ((size_t) limag) - 1);
                     (*longueur_conversion) = lreel + limag - 1;                      (*longueur_conversion) = lreel + limag - 1;
   
                     free(partie_reelle);                      free(partie_reelle);
Line 4427  formateur_fichier_binaire_nombre(struct_ Line 6643  formateur_fichier_binaire_nombre(struct_
                     unsigned char       *partie_reelle;                      unsigned char       *partie_reelle;
                     unsigned char       *partie_imaginaire;                      unsigned char       *partie_imaginaire;
   
                     long                limag;                      integer8            limag;
                     long                lreel;                      integer8            lreel;
   
                     real8               zero;                      real8               zero;
   
                     if (type_entree == 'I')                      if (type_entree == 'I')
Line 4500  formateur_fichier_binaire_nombre(struct_ Line 6717  formateur_fichier_binaire_nombre(struct_
                         return(NULL);                          return(NULL);
                     }                      }
   
                     if ((chaine = malloc((lreel + limag - 1) *                      if ((chaine = malloc((((size_t) lreel) + ((size_t) limag)
                             sizeof(unsigned char))) == NULL)                              - 1) * sizeof(unsigned char))) == NULL)
                     {                      {
                         free(partie_reelle);                          free(partie_reelle);
                         free(partie_imaginaire);                          free(partie_imaginaire);
Line 4511  formateur_fichier_binaire_nombre(struct_ Line 6728  formateur_fichier_binaire_nombre(struct_
                         return(NULL);                          return(NULL);
                     }                      }
   
                     chaine[0] = 0x19;                      chaine[0] = (unsigned char) 0x19;
                     memcpy(chaine + 1, partie_reelle + 1, lreel - 1);                      memcpy(chaine + 1, partie_reelle + 1,
                     memcpy(chaine + lreel, partie_imaginaire + 1, limag - 1);                              ((size_t) lreel) - 1);
                       memcpy(chaine + lreel, partie_imaginaire + 1,
                               ((size_t) limag) - 1);
                     (*longueur_conversion) = lreel + limag - 1;                      (*longueur_conversion) = lreel + limag - 1;
   
                     free(partie_reelle);                      free(partie_reelle);
Line 4577  lecture_fichier_non_formate(struct_proce Line 6796  lecture_fichier_non_formate(struct_proce
     unsigned char               *buffer;      unsigned char               *buffer;
     unsigned char               *flux;      unsigned char               *flux;
     unsigned char               *ptr;      unsigned char               *ptr;
       unsigned char               type_objet;
   
     size_t                      deplacement;      size_t                      deplacement;
   
Line 4623  lecture_fichier_non_formate(struct_proce Line 6843  lecture_fichier_non_formate(struct_proce
         }          }
     }      }
   
     switch(octets[0] & 0xF0)      switch(type_objet = (octets[0] & 0xF0))
     {      {
         case 0x00:  // Binaire          case 0x00:  // Binaire
         {          {
Line 4707  lecture_fichier_non_formate(struct_proce Line 6927  lecture_fichier_non_formate(struct_proce
             for(i = 0; i < (signed) deplacement; i++)              for(i = 0; i < (signed) deplacement; i++)
             {              {
                 (*((logical8 *) (*s_objet).objet)) |= ((logical8) octets[i])                  (*((logical8 *) (*s_objet).objet)) |= ((logical8) octets[i])
                         << (8 * ((deplacement - 1) - i));                          << (8 * ((((signed) deplacement) - 1) - i));
             }              }
   
             break;              break;
Line 4787  lecture_fichier_non_formate(struct_proce Line 7007  lecture_fichier_non_formate(struct_proce
                         return(NULL);                          return(NULL);
                     }                      }
   
                     (*((integer8 *) (*s_objet).objet)) = 0;                      // Récupération des données avec extension de signe.
   
                     for(i = 0; i < (signed) deplacement; i++)  
                     {                      {
                         (*((integer8 *) (*s_objet).objet)) |=                          integer1        i1;
                                 ((integer8) octets[i])                          integer2        i2;
                                 << (8 * ((deplacement - 1) - i));                          integer4        i4;
                           integer8        i8;
   
                           i1 = 0;
                           i2 = 0;
                           i4 = 0;
                           i8 = 0;
   
                           for(i = 0; i < (signed) deplacement; i++)
                           {
                               switch(deplacement)
                               {
                                   case 1:
                                       i1 = (integer1) octets[0];
                                   break;
   
                                   case 2:
                                       i2 |= (integer2) (((integer8) octets[i]) <<
                                               (8 * ((((signed) deplacement) - 1)
                                               - i)));
                                   break;
   
                                   case 4:
                                       i4 |= (integer4) (((integer8) octets[i]) <<
                                               (8 * ((((signed) deplacement) - 1)
                                               - i)));
                                   break;
   
                                   case 8:
                                       i8 |= (integer8) (((integer8) octets[i]) <<
                                               (8 * ((((signed) deplacement) - 1)
                                               - i)));
                                   break;
                               }
                           }
   
                           switch(deplacement)
                           {
                               case 1:
                                   (*((integer8 *) (*s_objet).objet)) =
                                           (integer8) i1;
                               break;
   
                               case 2:
                                   (*((integer8 *) (*s_objet).objet)) =
                                           (integer8) i2;
                               break;
   
                               case 4:
                                   (*((integer8 *) (*s_objet).objet)) =
                                           (integer8) i4;
                               break;
   
                               case 8:
                                   (*((integer8 *) (*s_objet).objet)) =
                                           (integer8) i8;
                               break;
                           }
                     }                      }
   
                     break;                      break;
Line 4878  lecture_fichier_non_formate(struct_proce Line 7154  lecture_fichier_non_formate(struct_proce
                         for(i = 0; i < (signed) deplacement; i++)                          for(i = 0; i < (signed) deplacement; i++)
                         {                          {
                             eq4.i4 |= ((integer4) octets[i]) <<                              eq4.i4 |= ((integer4) octets[i]) <<
                                     (8 * ((deplacement - 1) - i));                                      (8 * ((((signed) deplacement) - 1) - i));
                         }                          }
   
                         (*((real8 *) (*s_objet).objet)) = (real8) eq4.r4;                          (*((real8 *) (*s_objet).objet)) = (real8) eq4.r4;
Line 4896  lecture_fichier_non_formate(struct_proce Line 7172  lecture_fichier_non_formate(struct_proce
                         for(i = 0; i < (signed) deplacement; i++)                          for(i = 0; i < (signed) deplacement; i++)
                         {                          {
                             eq8.i8 |= ((integer8) octets[i]) <<                              eq8.i8 |= ((integer8) octets[i]) <<
                                     (8 * ((deplacement - 1) - i));                                      (8 * ((((signed) deplacement) - 1) - i));
                         }                          }
   
                         (*((real8 *) (*s_objet).objet)) = (real8) eq8.r8;                          (*((real8 *) (*s_objet).objet)) = (real8) eq8.r8;
Line 4989  lecture_fichier_non_formate(struct_proce Line 7265  lecture_fichier_non_formate(struct_proce
                             for(i = 0; i < (signed) deplacement; i++)                              for(i = 0; i < (signed) deplacement; i++)
                             {                              {
                                 eq4.i4 |= ((integer4) octets[i]) <<                                  eq4.i4 |= ((integer4) octets[i]) <<
                                         (8 * ((deplacement - 1) - i));                                          (8 * ((((signed) deplacement) - 1)
                                           - i));
                             }                              }
   
                             if (j == 0)                              if (j == 0)
Line 5016  lecture_fichier_non_formate(struct_proce Line 7293  lecture_fichier_non_formate(struct_proce
                             for(i = 0; i < (signed) deplacement; i++)                              for(i = 0; i < (signed) deplacement; i++)
                             {                              {
                                 eq8.i8 |= ((integer8) octets[i]) <<                                  eq8.i8 |= ((integer8) octets[i]) <<
                                         (8 * ((deplacement - 1) - i));                                          (8 * ((((signed) deplacement) - 1)
                                           - i));
                             }                              }
   
                             if (j == 0)                              if (j == 0)
Line 5046  lecture_fichier_non_formate(struct_proce Line 7324  lecture_fichier_non_formate(struct_proce
         }          }
   
         case 0x40:  // Liste          case 0x40:  // Liste
           case 0x60:  // Expression
           case 0x70:  // Expression algébrique
         {          {
             if ((octets[0] & 0x08) == 0)    // Longueur sur 6 bits              if ((octets[0] & 0x08) == 0)    // Longueur sur 6 bits
             {              {
Line 5230  lecture_fichier_non_formate(struct_proce Line 7510  lecture_fichier_non_formate(struct_proce
                 }                  }
             }              }
   
             if ((s_objet = allocation(s_etat_processus, LST)) == NULL)              if (type_objet == 0x40)
             {              {
                 return(NULL);                  if ((s_objet = allocation(s_etat_processus, LST)) == NULL)
                   {
                       return(NULL);
                   }
               }
               else if (type_objet == 0x60)
               {
                   if ((s_objet = allocation(s_etat_processus, RPN)) == NULL)
                   {
                       return(NULL);
                   }
               }
               else
               {
                   if ((s_objet = allocation(s_etat_processus, ALG)) == NULL)
                   {
                       return(NULL);
                   }
             }              }
   
             l_element_courant = NULL;              l_element_courant = NULL;
Line 5481  lecture_fichier_non_formate(struct_proce Line 7778  lecture_fichier_non_formate(struct_proce
   
             if (longueur_buffer < 0)              if (longueur_buffer < 0)
             {              {
                 if ((flux = malloc(longueur * sizeof(unsigned char))) == NULL)                  if ((flux = malloc(((size_t) longueur) * sizeof(unsigned char)))
                           == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
                             d_es_allocation_memoire;                              d_es_allocation_memoire;
Line 5489  lecture_fichier_non_formate(struct_proce Line 7787  lecture_fichier_non_formate(struct_proce
                 }                  }
   
                 if (fread(flux, (size_t) sizeof(unsigned char),                  if (fread(flux, (size_t) sizeof(unsigned char),
                         longueur, fichier) != (size_t) longueur)                          (size_t) longueur, fichier) != (size_t) longueur)
                 {                  {
                     if (feof(fichier))                      if (feof(fichier))
                     {                      {
Line 5542  lecture_fichier_non_formate(struct_proce Line 7840  lecture_fichier_non_formate(struct_proce
             break;              break;
         }          }
   
           case 0x50:  // Nom
           {
               if ((octets[0] & 0x08) == 0)    // Longueur sur 6 bits
               {
                   longueur = (octets[0] & 0x07);
               }
               else
               {
                   switch(octets[0] & 0x07)
                   {
                       case 0x00:          // Longueur sur 8 bits
                       {
                           if (longueur_buffer < 0)
                           {
                               if (fread(octets, (size_t) sizeof(unsigned char),
                                       1, fichier) != 1)
                               {
                                   if (feof(fichier))
                                   {
                                       (*s_etat_processus).erreur_execution =
                                               d_ex_syntaxe;
                                   }
                                   else
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_erreur_fichier;
                                   }
   
                                   return(NULL);
                               }
                           }
                           else
                           {
                               if ((longueur_buffer - (ptr - buffer)) >= 1)
                               {
                                   octets[0] = *ptr++;
                               }
                               else
                               {
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_syntaxe;
                                   return(NULL);
                               }
                           }
   
                           longueur = octets[0];
                           break;
                       }
   
                       case 0x01:          // Longueur sur 16 bits
                       {
                           if (longueur_buffer < 0)
                           {
                               if (fread(octets, (size_t) sizeof(unsigned char),
                                       2, fichier) != 2)
                               {
                                   if (feof(fichier))
                                   {
                                       (*s_etat_processus).erreur_execution =
                                               d_ex_syntaxe;
                                   }
                                   else
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_erreur_fichier;
                                   }
   
                                   return(NULL);
                               }
                           }
                           else
                           {
                               if ((longueur_buffer - (ptr - buffer)) >= 2)
                               {
                                   for(j = 0; j < 2; octets[j++] = *ptr++);
                               }
                               else
                               {
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_syntaxe;
                                   return(NULL);
                               }
                           }
   
                           longueur = (((integer8) (octets[0])) << 8)
                                   | ((integer8) (octets[1]));
                           break;
                       }
   
                       case 0x02:          // Longueur sur 32 bits
                       {
                           if (longueur_buffer < 0)
                           {
                               if (fread(octets, (size_t) sizeof(unsigned char),
                                       4, fichier) != 4)
                               {
                                   if (feof(fichier))
                                   {
                                       (*s_etat_processus).erreur_execution =
                                               d_ex_syntaxe;
                                   }
                                   else
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_erreur_fichier;
                                   }
   
                                   return(NULL);
                               }
                           }
                           else
                           {
                               if ((longueur_buffer - (ptr - buffer)) >= 4)
                               {
                                   for(j = 0; j < 4; octets[j++] = *ptr++);
                               }
                               else
                               {
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_syntaxe;
                                   return(NULL);
                               }
                           }
   
                           longueur = (((integer8) (octets[0])) << 24)
                                   | (((integer8) (octets[1])) << 16)
                                   | (((integer8) (octets[2])) << 8)
                                   | ((integer8) (octets[3]));
                           break;
                       }
   
                       case 0x03:          // Longueur sur 64 bits
                       {
                           if (longueur_buffer < 0)
                           {
                               if (fread(octets, (size_t) sizeof(unsigned char),
                                       8, fichier) != 8)
                               {
                                   if (feof(fichier))
                                   {
                                       (*s_etat_processus).erreur_execution =
                                               d_ex_syntaxe;
                                   }
                                   else
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_erreur_fichier;
                                   }
   
                                   return(NULL);
                               }
                           }
                           else
                           {
                               if ((longueur_buffer - (ptr - buffer)) >= 8)
                               {
                                   for(j = 0; j < 8; octets[j++] = *ptr++);
                               }
                               else
                               {
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_syntaxe;
                                   return(NULL);
                               }
                           }
   
                           longueur = (((integer8) (octets[0])) << 56)
                                   | (((integer8) (octets[1])) << 48)
                                   | (((integer8) (octets[2])) << 40)
                                   | (((integer8) (octets[3])) << 32)
                                   | (((integer8) (octets[4])) << 24)
                                   | (((integer8) (octets[5])) << 16)
                                   | (((integer8) (octets[6])) << 8)
                                   | ((integer8) (octets[7]));
                           break;
                       }
   
                       default:
                       {
                           (*s_etat_processus).erreur_execution = d_ex_syntaxe;
                           return(NULL);
                       }
                   }
               }
   
               if ((s_objet = allocation(s_etat_processus, NOM)) == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return(NULL);
               }
   
               if (((*((struct_nom *) (*s_objet).objet)).nom =
                       malloc((((size_t) longueur) + 1) * sizeof(unsigned char)))
                       == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return(NULL);
               }
   
               if (longueur_buffer < 0)
               {
                   if (fread((unsigned char *) (*((struct_nom *) (*s_objet)
                           .objet)).nom, (size_t) sizeof(unsigned char),
                           (size_t) longueur, fichier) != (unsigned) longueur)
                   {
                       if (feof(fichier))
                       {
                           (*s_etat_processus).erreur_execution =
                                   d_ex_syntaxe;
                       }
                       else
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_erreur_fichier;
                       }
   
                       liberation(s_etat_processus, s_objet);
                       return(NULL);
                   }
   
                   if (fread(octets, (size_t) sizeof(unsigned char),
                           1, fichier) != 1)
                   {
                       if (feof(fichier))
                       {
                           (*s_etat_processus).erreur_execution =
                                   d_ex_syntaxe;
                       }
                       else
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_erreur_fichier;
                       }
   
                       liberation(s_etat_processus, s_objet);
                       return(NULL);
                   }
               }
               else
               {
                   if ((longueur_buffer - (ptr - buffer)) >= (longueur + 1))
                   {
                       for(j = 0; j < longueur; (*((struct_nom *)
                               (*s_objet).objet)).nom[j] = *ptr++);
                       octets[0] = *ptr++;
                   }
                   else
                   {
                       liberation(s_etat_processus, s_objet);
                       (*s_etat_processus).erreur_execution = d_ex_syntaxe;
                       return(NULL);
                   }
               }
   
               (*((struct_nom *) (*s_objet).objet)).nom[longueur] =
                       d_code_fin_chaine;
               (*((struct_nom *) (*s_objet).objet)).symbole =
                       (octets[0] == 0xFF) ? d_vrai : d_faux;
               break;
           }
   
           case 0xE0:  // Fonction
           {
               if ((octets[0] & 0x08) == 0)    // Longueur sur 6 bits
               {
                   longueur = (octets[0] & 0x07);
               }
               else
               {
                   switch(octets[0] & 0x07)
                   {
                       case 0x00:          // Longueur sur 8 bits
                       {
                           if (longueur_buffer < 0)
                           {
                               if (fread(octets, (size_t) sizeof(unsigned char),
                                       1, fichier) != 1)
                               {
                                   if (feof(fichier))
                                   {
                                       (*s_etat_processus).erreur_execution =
                                               d_ex_syntaxe;
                                   }
                                   else
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_erreur_fichier;
                                   }
   
                                   return(NULL);
                               }
                           }
                           else
                           {
                               if ((longueur_buffer - (ptr - buffer)) >= 1)
                               {
                                   octets[0] = *ptr++;
                               }
                               else
                               {
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_syntaxe;
                                   return(NULL);
                               }
                           }
   
                           longueur = octets[0];
                           break;
                       }
   
                       case 0x01:          // Longueur sur 16 bits
                       {
                           if (longueur_buffer < 0)
                           {
                               if (fread(octets, (size_t) sizeof(unsigned char),
                                       2, fichier) != 2)
                               {
                                   if (feof(fichier))
                                   {
                                       (*s_etat_processus).erreur_execution =
                                               d_ex_syntaxe;
                                   }
                                   else
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_erreur_fichier;
                                   }
   
                                   return(NULL);
                               }
                           }
                           else
                           {
                               if ((longueur_buffer - (ptr - buffer)) >= 2)
                               {
                                   for(j = 0; j < 2; octets[j++] = *ptr++);
                               }
                               else
                               {
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_syntaxe;
                                   return(NULL);
                               }
                           }
   
                           longueur = (((integer8) (octets[0])) << 8)
                                   | ((integer8) (octets[1]));
                           break;
                       }
   
                       case 0x02:          // Longueur sur 32 bits
                       {
                           if (longueur_buffer < 0)
                           {
                               if (fread(octets, (size_t) sizeof(unsigned char),
                                       4, fichier) != 4)
                               {
                                   if (feof(fichier))
                                   {
                                       (*s_etat_processus).erreur_execution =
                                               d_ex_syntaxe;
                                   }
                                   else
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_erreur_fichier;
                                   }
   
                                   return(NULL);
                               }
                           }
                           else
                           {
                               if ((longueur_buffer - (ptr - buffer)) >= 4)
                               {
                                   for(j = 0; j < 4; octets[j++] = *ptr++);
                               }
                               else
                               {
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_syntaxe;
                                   return(NULL);
                               }
                           }
   
                           longueur = (((integer8) (octets[0])) << 24)
                                   | (((integer8) (octets[1])) << 16)
                                   | (((integer8) (octets[2])) << 8)
                                   | ((integer8) (octets[3]));
                           break;
                       }
   
                       case 0x03:          // Longueur sur 64 bits
                       {
                           if (longueur_buffer < 0)
                           {
                               if (fread(octets, (size_t) sizeof(unsigned char),
                                       8, fichier) != 8)
                               {
                                   if (feof(fichier))
                                   {
                                       (*s_etat_processus).erreur_execution =
                                               d_ex_syntaxe;
                                   }
                                   else
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_erreur_fichier;
                                   }
   
                                   return(NULL);
                               }
                           }
                           else
                           {
                               if ((longueur_buffer - (ptr - buffer)) >= 8)
                               {
                                   for(j = 0; j < 8; octets[j++] = *ptr++);
                               }
                               else
                               {
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_syntaxe;
                                   return(NULL);
                               }
                           }
   
                           longueur = (((integer8) (octets[0])) << 56)
                                   | (((integer8) (octets[1])) << 48)
                                   | (((integer8) (octets[2])) << 40)
                                   | (((integer8) (octets[3])) << 32)
                                   | (((integer8) (octets[4])) << 24)
                                   | (((integer8) (octets[5])) << 16)
                                   | (((integer8) (octets[6])) << 8)
                                   | ((integer8) (octets[7]));
                           break;
                       }
   
                       default:
                       {
                           (*s_etat_processus).erreur_execution = d_ex_syntaxe;
                           return(NULL);
                       }
                   }
               }
   
               if ((s_objet = allocation(s_etat_processus, FCT)) == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return(NULL);
               }
   
               if (((*((struct_fonction *) (*s_objet).objet)).nom_fonction =
                       malloc((((size_t) longueur) + 1) * sizeof(unsigned char)))
                       == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return(NULL);
               }
   
               if (longueur_buffer < 0)
               {
                   if (fread((unsigned char *) (*((struct_fonction *) (*s_objet)
                           .objet)).nom_fonction, (size_t) sizeof(unsigned char),
                           (size_t) longueur, fichier) != (unsigned) longueur)
                   {
                       if (feof(fichier))
                       {
                           (*s_etat_processus).erreur_execution =
                                   d_ex_syntaxe;
                       }
                       else
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_erreur_fichier;
                       }
   
                       liberation(s_etat_processus, s_objet);
                       return(NULL);
                   }
   
                   if (fread(octets, (size_t) sizeof(unsigned char),
                           8, fichier) != 8)
                   {
                       if (feof(fichier))
                       {
                           (*s_etat_processus).erreur_execution =
                                   d_ex_syntaxe;
                       }
                       else
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_erreur_fichier;
                       }
   
                       liberation(s_etat_processus, s_objet);
                       return(NULL);
                   }
               }
               else
               {
                   if ((longueur_buffer - (ptr - buffer)) >= (longueur + 8))
                   {
                       for(j = 0; j < longueur; (*((struct_fonction *)
                               (*s_objet).objet)).nom_fonction[j] = *ptr++);
                       for(j = 0; j < 8; octets[j++] = *ptr++);
                   }
                   else
                   {
                       liberation(s_etat_processus, s_objet);
                       (*s_etat_processus).erreur_execution = d_ex_syntaxe;
                       return(NULL);
                   }
               }
   
               (*((struct_fonction *) (*s_objet).objet)).nom_fonction[longueur] =
                       d_code_fin_chaine;
               (*((struct_fonction *) (*s_objet).objet)).nombre_arguments =
                       (((integer8) (octets[0])) << 56)
                       | (((integer8) (octets[1])) << 48)
                       | (((integer8) (octets[2])) << 40)
                       | (((integer8) (octets[3])) << 32)
                       | (((integer8) (octets[4])) << 24)
                       | (((integer8) (octets[5])) << 16)
                       | (((integer8) (octets[6])) << 8)
                       | ((integer8) (octets[7]));
               break;
           }
   
         default:          default:
         {          {
             (*s_etat_processus).erreur_execution = d_ex_syntaxe;              (*s_etat_processus).erreur_execution = d_ex_syntaxe;
Line 5572  lecture_fichier_non_formate(struct_proce Line 8399  lecture_fichier_non_formate(struct_proce
   
         if ((octets[0] & 0x01) != 0)          if ((octets[0] & 0x01) != 0)
         {          {
             deplacement = ((octets[0] & 0x0F) >> 1) + 1;              deplacement = (size_t) (((octets[0] & 0x0F) >> 1) + 1);
   
             if (fread(octets, (size_t) sizeof(unsigned char), deplacement,              if (fread(octets, (size_t) sizeof(unsigned char), deplacement,
                     fichier) != deplacement)                      fichier) != deplacement)
Removed from v.1.55  
changed lines
  Added in v.1.85

CVSweb interface <joel.bertrand@systella.fr>