rpl/src/formateur_fichiers.c - diff

Return to formateur_fichiers.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/formateur_fichiers.c between versions 1.58 and 1.93

-version 1.58, 2013/03/19 11:46:11
+version 1.93, 2017/06/20 15:36:13
  Line 1
  /*
  ================================================================================
-   RPL/2 (R) version 4.1.13
+   RPL/2 (R) version 4.1.26
-   Copyright (C) 1989-2013 Dr. BERTRAND Joël
+   Copyright (C) 1989-2017 Dr. BERTRAND Joël
    This file is part of RPL/2.
  Line 19
  ================================================================================
  */
- #define DEBUG_ERREURS
  #include "rpl-conv.h"
  Line 40
  unsigned char *
  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,
-         long *longueur_effective, long *recursivite, logical1 export_fichier)
+         integer8 *longueur_effective, integer8 *recursivite,
+         logical1 export_fichier)
  {
      /*
       * Traitement du format des fichiers formatés :
- Line 78  formateur_fichier(struct_processus *s_et
+ Line 79  formateur_fichier(struct_processus *s_et
      logical1                    format_degenere;
      logical1                    presence_signe;
-     unsigned long int           longueur_chaine_traitee;
      struct_liste_chainee        *l_atome;
+     struct_liste_chainee        *l_compteur;
      struct_liste_chainee        *l_element_courant;
      struct_liste_chainee        *l_element_courant_format;
      struct_liste_chainee        *l_liste1;
      struct_liste_chainee        *l_liste2;
+     struct_liste_chainee        *l_tmp;
+     struct_objet                *s_format_tmp;
      struct_objet                *s_sous_objet;
      struct_objet                *s_sous_objet_1;
      struct_objet                *s_sous_objet_2;
- Line 95  formateur_fichier(struct_processus *s_et
+ Line 97  formateur_fichier(struct_processus *s_et
      unsigned char               *chaine;
      unsigned char               *chaine_fonction;
      unsigned char               *chaine_formatee;
+     unsigned char               *chaine_offset;
      unsigned char               *chaine_tampon;
      unsigned char               *chaine_sauvegarde;
      unsigned char               *format_chaine;
- Line 103  formateur_fichier(struct_processus *s_et
+ Line 106  formateur_fichier(struct_processus *s_et
      unsigned char               tampon[64 + 1];
      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_objet;
      integer8                    longueur_reelle_chaine;
      integer8                    longueur_totale;
      integer8                    position_1;
- Line 233  formateur_fichier(struct_processus *s_et
+ Line 239  formateur_fichier(struct_processus *s_et
                                      .instruction_courante[1]
                                      == '-')) ? d_vrai : d_faux;
+                             (*s_etat_processus).type_en_cours = NON;
                              recherche_type(s_etat_processus);
                              if ((*s_etat_processus).erreur_execution != d_ex)
- Line 292  formateur_fichier(struct_processus *s_et
+ Line 299  formateur_fichier(struct_processus *s_et
                                      if ((strcmp(chaine_fonction, "AND") == 0) ||
                                              (strcmp(chaine_fonction, "XOR") ==
 ) || (strcmp(chaine_fonction, "OR")
-                                             == 0))
+                                             == 0) || (strcmp(chaine_fonction,
+                                             "EQV") == 0))
                                      {
                                          autorisation_parenthese = d_vrai;
                                      }
- Line 319  formateur_fichier(struct_processus *s_et
+ Line 327  formateur_fichier(struct_processus *s_et
                                              || (strcmp(chaine_fonction, "AND")
                                              == 0) || (strcmp(chaine_fonction,
                                              "XOR") == 0) || (strcmp(
-                                             chaine_fonction, "OR") == 0))
+                                             chaine_fonction, "OR") == 0) ||
+                                             (strcmp(chaine_fonction, "EQV")
+                                             == 0))
                                      {
                                          autorisation_parenthese = d_vrai;
                                      }
- Line 400  formateur_fichier(struct_processus *s_et
+ Line 410  formateur_fichier(struct_processus *s_et
                                      "'%s'", (unsigned char *)
                                      (*s_sous_objet_1).objet);
+                             (*s_etat_processus).type_en_cours = NON;
                              recherche_type(s_etat_processus);
                              if ((*s_etat_processus).erreur_execution != d_ex)
- Line 457  formateur_fichier(struct_processus *s_et
+ Line 468  formateur_fichier(struct_processus *s_et
                                      if ((strcmp(chaine_fonction, "AND") == 0) ||
                                              (strcmp(chaine_fonction, "XOR") ==
 ) || (strcmp(chaine_fonction, "OR")
-                                             == 0))
+                                             == 0) || (strcmp(chaine_fonction,
+                                             "EQV") == 0))
                                      {
                                          autorisation_parenthese = d_vrai;
                                      }
- Line 474  formateur_fichier(struct_processus *s_et
+ Line 486  formateur_fichier(struct_processus *s_et
                                              || (strcmp(chaine_fonction, "AND")
                                              == 0) || (strcmp(chaine_fonction,
                                              "XOR") == 0) || (strcmp(
-                                             chaine_fonction, "OR") == 0))
+                                             chaine_fonction, "OR") == 0) ||
+                                             (strcmp(chaine_fonction, "EQV")
+                                             == 0))
                                      {
                                          autorisation_parenthese = d_vrai;
                                      }
- Line 715  formateur_fichier(struct_processus *s_et
+ Line 729  formateur_fichier(struct_processus *s_et
                                  "XOR") == 0) || (strcmp((*((struct_fonction *)
                                  (*(*l_element_courant).donnee).objet))
                                  .nom_fonction,
-                                 "AND") == 0))
+                                 "AND") == 0) || (strcmp((*((struct_fonction *)
+                                 (*(*l_element_courant).donnee).objet))
+                                 .nom_fonction, "EQV") == 0))
                          {
                              if (depilement(s_etat_processus,
                                      &((*s_etat_processus)
- Line 928  formateur_fichier(struct_processus *s_et
+ Line 944  formateur_fichier(struct_processus *s_et
                          ptrl = chaine_sauvegarde;
                          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;
- Line 1000  formateur_fichier(struct_processus *s_et
+ Line 1016  formateur_fichier(struct_processus *s_et
              if (format_sortie == 'N')
              {
-                 sprintf(tampon, "%llX", (*((logical8 *)
+                 sprintf(tampon, "%llX", (unsigned long long) (*((logical8 *)
                          ((*s_objet).objet))));
                  strcpy(base, "h");
              }
- Line 1010  formateur_fichier(struct_processus *s_et
+ Line 1026  formateur_fichier(struct_processus *s_et
                  {
                      case 2:
                      {
-                         sprintf(tampon, "%llX", (*((logical8 *)
+                         sprintf(tampon, "%llX", (unsigned long long)
-                                 ((*s_objet).objet))));
+                                 (*((logical8 *) ((*s_objet).objet))));
                          chaine = (unsigned char *) malloc((strlen(tampon) + 1)
                                  * sizeof(unsigned char));
- Line 1026  formateur_fichier(struct_processus *s_et
+ Line 1042  formateur_fichier(struct_processus *s_et
                          strcpy(chaine, tampon);
                          tampon[0] = 0;
-                         for(i = 0; i < strlen(chaine); i++)
+                         for(i = 0; i < ((integer8) strlen(chaine)); i++)
                          {
                              switch(chaine[i])
                              {
- Line 1120  formateur_fichier(struct_processus *s_et
+ Line 1136  formateur_fichier(struct_processus *s_et
                      case 8:
                      {
-                         sprintf(tampon, "%llo", (*((logical8 *)
+                         sprintf(tampon, "%llo", (*((unsigned long long *)
                                  ((*s_objet).objet))));
                          strcpy(base, "o");
                          break;
- Line 1128  formateur_fichier(struct_processus *s_et
+ Line 1144  formateur_fichier(struct_processus *s_et
                      case 10:
                      {
-                         sprintf(tampon, "%llu", (*((logical8 *)
+                         sprintf(tampon, "%llu", (*((unsigned long long *)
                                  ((*s_objet).objet))));
                          strcpy(base, "d");
                          break;
- Line 1136  formateur_fichier(struct_processus *s_et
+ Line 1152  formateur_fichier(struct_processus *s_et
                      case 16:
                      {
-                         sprintf(tampon, "%llX", (*((logical8 *)
+                         sprintf(tampon, "%llX", (unsigned long long)
-                                 ((*s_objet).objet))));
+                                 (*((logical8 *) ((*s_objet).objet))));
                          strcpy(base, "h");
                          break;
                      }
- Line 1156  formateur_fichier(struct_processus *s_et
+ Line 1172  formateur_fichier(struct_processus *s_et
                  if ((longueur_champ > 0) && (longueur_champ
                          < (signed) strlen(tampon)))
                  {
-                     ptrl = &(tampon[strlen(tampon) - longueur_champ]);
+                     ptrl = &(tampon[((integer8) strlen(tampon))
+                             - longueur_champ]);
                      ptre = tampon;
                      do
- Line 1228  formateur_fichier(struct_processus *s_et
+ Line 1245  formateur_fichier(struct_processus *s_et
                          (*s_objet).objet, longueur_champ)
                          - ((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)
                  {
                      (*s_etat_processus).erreur_systeme =
- Line 1237  formateur_fichier(struct_processus *s_et
+ Line 1254  formateur_fichier(struct_processus *s_et
                  }
                  strncpy(chaine, (unsigned char *) ((*s_objet).objet),
-                         longueur_reelle_chaine);
+                         (size_t) longueur_reelle_chaine);
                  chaine[longueur_reelle_chaine] = d_code_fin_chaine;
              }
          }
- Line 1529  formateur_fichier(struct_processus *s_et
+ Line 1546  formateur_fichier(struct_processus *s_et
                  }
                  else
                  {
-                     if ((format_chaine = conversion_majuscule((unsigned char *)
+                     if ((format_chaine = conversion_majuscule(
+                             s_etat_processus, (unsigned char *)
                              (*(*l_element_courant_format).donnee).objet))
                              == NULL)
                      {
- Line 1588  formateur_fichier(struct_processus *s_et
+ Line 1606  formateur_fichier(struct_processus *s_et
                          return(NULL);
                      }
-                     position_3 = strlen(format_chaine) - 1;
+                     position_3 = ((integer8) strlen(format_chaine)) - 1;
                      if (format_chaine[position_3] != ')')
                      {
- Line 1623  formateur_fichier(struct_processus *s_et
+ Line 1641  formateur_fichier(struct_processus *s_et
                      if (format_degenere == d_faux)
                      {
-                         if (sscanf(&(format_chaine[position_1]), "%ld",
+                         if (sscanf(&(format_chaine[position_1]), "%lld",
                                  &longueur) != 1)
                          {
                              free(chaine);
- Line 1641  formateur_fichier(struct_processus *s_et
+ Line 1659  formateur_fichier(struct_processus *s_et
                      if (strcmp(&(format_chaine[position_2]), "*") != 0)
                      {
-                         if (sscanf(&(format_chaine[position_2]), "%ld",
+                         if (sscanf(&(format_chaine[position_2]), "%lld",
                                  &longueur_champ) != 1)
                          {
                              free(chaine);
- Line 1672  formateur_fichier(struct_processus *s_et
+ Line 1690  formateur_fichier(struct_processus *s_et
                      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,
                              (*l_element_courant).donnee, s_format,
                              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 ((*(*l_element_courant).donnee).type == CHN)
                      {
                          chaine = (unsigned char *)
- Line 1877  formateur_fichier(struct_processus *s_et
+ Line 1949  formateur_fichier(struct_processus *s_et
                      else
                      {
                          if ((format_chaine = conversion_majuscule(
+                                 s_etat_processus,
                                  (unsigned char *) (*(*((struct_tableau *)
                                  (*s_format).objet)).elements[i]).objet))
                                  == NULL)
- Line 1936  formateur_fichier(struct_processus *s_et
+ Line 2009  formateur_fichier(struct_processus *s_et
                              return(NULL);
                          }
-                         position_3 = strlen(format_chaine);
+                         position_3 = (integer8) strlen(format_chaine);
                          format_chaine[--position_3] = d_code_fin_chaine;
                          position_2 = position_1;
- Line 1960  formateur_fichier(struct_processus *s_et
+ Line 2033  formateur_fichier(struct_processus *s_et
                          if (format_degenere == d_faux)
                          {
-                             if (sscanf(&(format_chaine[position_1]), "%ld",
+                             if (sscanf(&(format_chaine[position_1]), "%lld",
                                      &longueur) != 1)
                              {
                                  free(chaine);
- Line 1978  formateur_fichier(struct_processus *s_et
+ Line 2051  formateur_fichier(struct_processus *s_et
                          if (strcmp(&(format_chaine[position_2]), "*") != 0)
                          {
-                             if (sscanf(&(format_chaine[position_2]), "%ld",
+                             if (sscanf(&(format_chaine[position_2]), "%lld",
                                      &longueur_champ) != 1)
                              {
                                  free(chaine);
- Line 2874  formateur_fichier(struct_processus *s_et
+ Line 2947  formateur_fichier(struct_processus *s_et
              return(NULL);
          }
-         (*longueur_effective) = strlen(chaine) + 1;
+         (*longueur_effective) = ((integer8) strlen(chaine)) + 1;
      }
      else
      {
- Line 3035  formateur_fichier(struct_processus *s_et
+ Line 3108  formateur_fichier(struct_processus *s_et
           * 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 :
           *      00 : integer*1
           *      01 : integer*2
- Line 3087  formateur_fichier(struct_processus *s_et
+ Line 3165  formateur_fichier(struct_processus *s_et
              (*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;
                  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)) >>
                          (8 * (longueur_champ - i))) & 0xFF;
- Line 3152  formateur_fichier(struct_processus *s_et
+ Line 3230  formateur_fichier(struct_processus *s_et
                      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 =
                              d_es_allocation_memoire;
                      return(NULL);
                  }
-                 memcpy(chaine, chaine_sauvegarde, longueur_champ);
+                 memcpy(chaine, chaine_sauvegarde, (size_t) longueur_champ);
                  longueur_chaine_traitee = longueur_champ;
                  free(chaine_sauvegarde);
              }
- Line 3169  formateur_fichier(struct_processus *s_et
+ Line 3247  formateur_fichier(struct_processus *s_et
              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)
                  {
                      (*s_etat_processus).erreur_systeme =
- Line 3177  formateur_fichier(struct_processus *s_et
+ Line 3255  formateur_fichier(struct_processus *s_et
                      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;
              }
              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)
                  {
                      (*s_etat_processus).erreur_systeme =
- Line 3192  formateur_fichier(struct_processus *s_et
+ Line 3272  formateur_fichier(struct_processus *s_et
                      return(NULL);
                  }
-                 chaine[0] = 0x88;
+                 chaine[0] = (unsigned char) 0x88;
                  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;
              }
              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)
                  {
                      (*s_etat_processus).erreur_systeme =
- Line 3208  formateur_fichier(struct_processus *s_et
+ Line 3289  formateur_fichier(struct_processus *s_et
                      return(NULL);
                  }
-                 chaine[0] = 0x89;
+                 chaine[0] = (unsigned char) 0x89;
                  chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 8)
                          & 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;
              }
              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)
                  {
                      (*s_etat_processus).erreur_systeme =
- Line 3226  formateur_fichier(struct_processus *s_et
+ Line 3308  formateur_fichier(struct_processus *s_et
                      return(NULL);
                  }
-                 chaine[0] = 0x8A;
+                 chaine[0] = (unsigned char) 0x8A;
                  chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 24)
                          & 0xFF);
                  chaine[2] = (unsigned char) ((longueur_chaine_traitee >> 16)
- Line 3235  formateur_fichier(struct_processus *s_et
+ Line 3317  formateur_fichier(struct_processus *s_et
                          & 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;
              }
              else
              {
-                 if ((chaine = malloc((longueur_chaine_traitee + 9)
+                 if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 9)
                          * sizeof(unsigned char))) == NULL)
                  {
                      (*s_etat_processus).erreur_systeme =
- Line 3248  formateur_fichier(struct_processus *s_et
+ Line 3331  formateur_fichier(struct_processus *s_et
                      return(NULL);
                  }
-                 chaine[0] = 0x8B;
+                 chaine[0] = (unsigned char) 0x8B;
                  chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 56)
                          & 0xFF);
                  chaine[2] = (unsigned char) ((longueur_chaine_traitee >> 48)
- Line 3265  formateur_fichier(struct_processus *s_et
+ Line 3348  formateur_fichier(struct_processus *s_et
                          & 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;
              }
- Line 3349  formateur_fichier(struct_processus *s_et
+ Line 3433  formateur_fichier(struct_processus *s_et
                  return(NULL);
              }
-             longueur_fonction = strlen((*((struct_fonction *) (*s_objet).objet))
+             longueur_fonction = (integer8) strlen((*((struct_fonction *)
-                     .nom_fonction);
+                     (*s_objet).objet)).nom_fonction);
              if (longueur_fonction < (1LL << 3))
              {
-                 if ((chaine = malloc((1 + longueur_fonction + 8)
+                 if ((chaine = malloc((1 + ((size_t) longueur_fonction) + 8)
                          * sizeof(unsigned char)))== NULL)
                  {
                      (*s_etat_processus).erreur_systeme =
- Line 3362  formateur_fichier(struct_processus *s_et
+ Line 3446  formateur_fichier(struct_processus *s_et
                      return(NULL);
                  }
-                 chaine[0] = 0xE0 | (longueur_fonction & 0x7);
+                 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 + longueur_fonction + 8)
+                 if ((chaine = malloc((2 + ((size_t) longueur_fonction) + 8)
                          * sizeof(unsigned char)))== NULL)
                  {
                      (*s_etat_processus).erreur_systeme =
- Line 3377  formateur_fichier(struct_processus *s_et
+ Line 3462  formateur_fichier(struct_processus *s_et
                      return(NULL);
                  }
-                 chaine[0] = 0xE0 | 0x08;
+                 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 + longueur_fonction + 8)
+                 if ((chaine = malloc((3 + ((size_t) longueur_fonction) + 8)
                          * sizeof(unsigned char)))== NULL)
                  {
                      (*s_etat_processus).erreur_systeme =
- Line 3393  formateur_fichier(struct_processus *s_et
+ Line 3479  formateur_fichier(struct_processus *s_et
                      return(NULL);
                  }
-                 chaine[0] = 0xE0 | 0x09;
+                 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 + longueur_fonction + 8)
+                 if ((chaine = malloc((5 + ((size_t) longueur_fonction) + 8)
                          * sizeof(unsigned char)))== NULL)
                  {
                      (*s_etat_processus).erreur_systeme =
- Line 3410  formateur_fichier(struct_processus *s_et
+ Line 3497  formateur_fichier(struct_processus *s_et
                      return(NULL);
                  }
-                 chaine[0] = 0xE0 | 0x0A;
+                 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);
- Line 3418  formateur_fichier(struct_processus *s_et
+ Line 3505  formateur_fichier(struct_processus *s_et
                  strcpy(chaine + 5, (*((struct_fonction *) (*s_objet).objet))
                          .nom_fonction);
+                 (*longueur_effective) = 5 + longueur_fonction + 8;
              }
              else
              {
-                 if ((chaine = malloc((9 + longueur_fonction + 8)
+                 if ((chaine = malloc((9 + ((size_t) longueur_fonction) + 8)
                          * sizeof(unsigned char)))== NULL)
                  {
                      (*s_etat_processus).erreur_systeme =
- Line 3429  formateur_fichier(struct_processus *s_et
+ Line 3517  formateur_fichier(struct_processus *s_et
                      return(NULL);
                  }
-                 chaine[0] = 0xE0 | 0x0B;
+                 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);
- Line 3441  formateur_fichier(struct_processus *s_et
+ Line 3529  formateur_fichier(struct_processus *s_et
                  strcpy(chaine + 9, (*((struct_fonction *) (*s_objet).objet))
                          .nom_fonction);
+                 (*longueur_effective) = 9 + longueur_fonction + 8;
              }
              for(i = 1; i <= 8; i++)
              {
-                 chaine[longueur_fonction + i] = (unsigned char)
+                 chaine[(*longueur_effective) - i] = (unsigned char)
                          (((*((struct_fonction *) (*s_objet).objet))
                          .nombre_arguments >> ((8 - i) * 8)) & 0xFF);
              }
-             (*longueur_effective) = longueur_fonction + 9;
          }
          else if (((*s_objet).type == LST) || ((*s_objet).type == ALG)
                  || ((*s_objet).type == RPN))
- Line 3503  formateur_fichier(struct_processus *s_et
+ Line 3590  formateur_fichier(struct_processus *s_et
              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))
              {
-                 chaine[0] = type_binaire | 0x08;
+                 chaine[0] = (unsigned char) (type_binaire | 0x08);
              }
              else if (longueur_liste < (1LL << 16))
              {
-                 chaine[0] = type_binaire | 0x09;
+                 chaine[0] = (unsigned char ) (type_binaire | 0x09);
              }
              else if (longueur_liste < (1LL << 32))
              {
-                 chaine[0] = type_binaire | 0x0A;
+                 chaine[0] = (unsigned char) (type_binaire | 0x0A);
              }
              else
              {
-                 chaine[0] = type_binaire | 0x0B;
+                 chaine[0] = (unsigned char) (type_binaire | 0x0B);
              }
              longueur_totale = 1;
- Line 3532  formateur_fichier(struct_processus *s_et
+ Line 3620  formateur_fichier(struct_processus *s_et
                      {
                          longueur_totale += 1;
-                         if ((chaine = realloc(chaine, longueur_totale *
+                         if ((chaine = realloc(chaine,
+                                 ((size_t) longueur_totale) *
                                  sizeof(unsigned char))) == NULL)
                          {
                              (*s_etat_processus).erreur_systeme =
- Line 3549  formateur_fichier(struct_processus *s_et
+ Line 3638  formateur_fichier(struct_processus *s_et
                      {
                          longueur_totale += 2;
-                         if ((chaine = realloc(chaine, longueur_totale *
+                         if ((chaine = realloc(chaine,
+                                 ((size_t) longueur_totale) *
                                  sizeof(unsigned char))) == NULL)
                          {
                              (*s_etat_processus).erreur_systeme =
- Line 3568  formateur_fichier(struct_processus *s_et
+ Line 3658  formateur_fichier(struct_processus *s_et
                      {
                          longueur_totale += 4;
-                         if ((chaine = realloc(chaine, longueur_totale *
+                         if ((chaine = realloc(chaine,
+                                 ((size_t) longueur_totale) *
                                  sizeof(unsigned char))) == NULL)
                          {
                              (*s_etat_processus).erreur_systeme =
- Line 3591  formateur_fichier(struct_processus *s_et
+ Line 3682  formateur_fichier(struct_processus *s_et
                      {
                          longueur_totale += 8;
-                         if ((chaine = realloc(chaine, longueur_totale *
+                         if ((chaine = realloc(chaine,
+                                 ((size_t) longueur_totale) *
                                  sizeof(unsigned char))) == NULL)
                          {
                              (*s_etat_processus).erreur_systeme =
- Line 3638  formateur_fichier(struct_processus *s_et
+ Line 3730  formateur_fichier(struct_processus *s_et
                          (((*(*l_element_courant_format).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, ' ', '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, '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)
                      {
                          (*s_etat_processus).erreur_systeme =
- Line 3657  formateur_fichier(struct_processus *s_et
+ Line 3767  formateur_fichier(struct_processus *s_et
                      }
                      memcpy(&(chaine[longueur_totale]), chaine_formatee,
-                             (*longueur_effective));
+                             (size_t) (*longueur_effective));
                      longueur_totale += (*longueur_effective);
                      free(chaine_formatee);
                  }
- Line 3671  formateur_fichier(struct_processus *s_et
+ Line 3781  formateur_fichier(struct_processus *s_et
                  }
                  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))
                              == NULL)
                      {
- Line 3734  formateur_fichier(struct_processus *s_et
+ Line 3847  formateur_fichier(struct_processus *s_et
                      if (strcmp(&(format_chaine[position_1]), "(*)") != 0)
                      {
-                         if (sscanf(&(format_chaine[position_1]), "%ld",
+                         if (sscanf(&(format_chaine[position_1]), "%lld",
                                  &longueur) != 1)
                          {
                              free(chaine);
- Line 3754  formateur_fichier(struct_processus *s_et
+ Line 3867  formateur_fichier(struct_processus *s_et
                      }
                      free(format_chaine);
+                     // Construction d'une liste de format
+                     if ((s_format_tmp = allocation(s_etat_processus, LST))
+                             == NULL)
+                     {
+                         return(NULL);
+                     }
+                     if ((*(*l_element_courant).donnee).type == LST)
+                     {
+                         l_compteur = (struct_liste_chainee *)
+                                 (*(*l_element_courant).donnee).objet;
+                         while(l_compteur != NULL)
+                         {
+                             l_tmp = (*s_format_tmp).objet;
+                             if (((*s_format_tmp).objet = allocation_maillon(
+                                     s_etat_processus)) == NULL)
+                             {
+                                 return(NULL);
+                             }
+                             if (((*((struct_liste_chainee *)
+                                     (*s_format_tmp).objet))
+                                     .donnee = copie_objet(s_etat_processus,
+                                     (*l_element_courant_format).donnee, 'P'))
+                                     == NULL)
+                             {
+                                 return(NULL);
+                             }
+                             (*((struct_liste_chainee *) (*s_format_tmp).objet))
+                                     .suivant = l_tmp;
+                             l_compteur = (*l_compteur).suivant;
+                         }
+                     }
+                     else
+                     {
+                         if (((*s_format_tmp).objet = allocation_maillon(
+                                 s_etat_processus)) == NULL)
+                         {
+                             return(NULL);
+                         }
+                         if (((*((struct_liste_chainee *) (*s_format_tmp).objet))
+                                 .donnee = copie_objet(s_etat_processus,
+                                 (*l_element_courant_format).donnee, 'P'))
+                                 == NULL)
+                         {
+                             return(NULL);
+                         }
+                         (*((struct_liste_chainee *) (*s_format_tmp).objet))
+                                 .suivant = NULL;
+                     }
                      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_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,
-                             (longueur_totale + (*longueur_effective))
+                             ((size_t) (longueur_totale + (*longueur_effective)))
                              * sizeof(unsigned char))) == NULL)
                      {
                          (*s_etat_processus).erreur_systeme =
- Line 3775  formateur_fichier(struct_processus *s_et
+ Line 3948  formateur_fichier(struct_processus *s_et
                      }
                      memcpy(&(chaine[longueur_totale]), chaine_formatee,
-                             (*longueur_effective));
+                             (size_t) (*longueur_effective));
                      longueur_totale += (*longueur_effective);
                      free(chaine_formatee);
                  }
+                 l_element_courant_format = (*l_element_courant_format).suivant;
                  nombre_elements++;
                  l_element_courant = (*l_element_courant).suivant;
-                 l_element_courant_format = (*l_element_courant_format).suivant;
              }
              if ((l_element_courant != NULL) ||
- Line 3803  formateur_fichier(struct_processus *s_et
+ Line 3976  formateur_fichier(struct_processus *s_et
  /*
  --------------------------------------------------------------------------------
    Table
+   Bits de poids fort : 1001
  --------------------------------------------------------------------------------
  */
+             chaine = malloc(sizeof(unsigned char));
+             if (chaine == NULL)
+             {
+                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+                 return(NULL);
+             }
+             type_binaire = 0x90;
+             longueur_liste = (*((struct_tableau *) (*s_objet).objet))
+                     .nombre_elements;
+             if (longueur_liste < (1LL << 3))
+             {
+                 chaine[0] = (unsigned char) (type_binaire |
+                         (longueur_liste & 0x7));
+             }
+             else if (longueur_liste < (1LL << 8))
+             {
+                 chaine[0] = (unsigned char) (type_binaire | 0x08);
+             }
+             else if (longueur_liste < (1LL << 16))
+             {
+                 chaine[0] = (unsigned char ) (type_binaire | 0x09);
+             }
+             else if (longueur_liste < (1LL << 32))
+             {
+                 chaine[0] = (unsigned char) (type_binaire | 0x0A);
+             }
+             else
+             {
+                 chaine[0] = (unsigned char) (type_binaire | 0x0B);
+             }
+             longueur_totale = 1;
+             if ((chaine[0] & 0x8) != 0)
+             { // Longueur sur un entier distinct de l'en-tête
+                 switch(chaine[0] & 0x03)
+                 {
+                     case 0x00 :
+                     {
+                         longueur_totale += 1;
+                         if ((chaine = realloc(chaine,
+                                 ((size_t) longueur_totale) *
+                                 sizeof(unsigned char))) == NULL)
+                         {
+                             (*s_etat_processus).erreur_systeme =
+                                     d_es_allocation_memoire;
+                             return(NULL);
+                         }
+                         chaine[longueur_totale - 1] =
+                                 (unsigned char) (longueur_liste & 0xFF);
+                         break;
+                     }
+                     case 0x01 :
+                     {
+                         longueur_totale += 2;
+                         if ((chaine = realloc(chaine,
+                                 ((size_t) longueur_totale) *
+                                 sizeof(unsigned char))) == NULL)
+                         {
+                             (*s_etat_processus).erreur_systeme =
+                                     d_es_allocation_memoire;
+                             return(NULL);
+                         }
+                         chaine[longueur_totale - 2] =
+                                 (unsigned char) ((longueur_liste >> 8) & 0xFF);
+                         chaine[longueur_totale - 1] =
+                                 (unsigned char) (longueur_liste & 0xFF);
+                         break;
+                     }
+                     case 0x02 :
+                     {
+                         longueur_totale += 4;
+                         if ((chaine = realloc(chaine,
+                                 ((size_t) longueur_totale) *
+                                 sizeof(unsigned char))) == NULL)
+                         {
+                             (*s_etat_processus).erreur_systeme =
+                                     d_es_allocation_memoire;
+                             return(NULL);
+                         }
+                         chaine[longueur_totale - 4] =
+                                 (unsigned char) ((longueur_liste >> 24) & 0xFF);
+                         chaine[longueur_totale - 3] =
+                                 (unsigned char) ((longueur_liste >> 16) & 0xFF);
+                         chaine[longueur_totale - 2] =
+                                 (unsigned char) ((longueur_liste >> 8) & 0xFF);
+                         chaine[longueur_totale - 1] =
+                                 (unsigned char) (longueur_liste & 0xFF);
+                         break;
+                     }
+                     case 0x03 :
+                     {
+                         longueur_totale += 8;
+                         if ((chaine = realloc(chaine,
+                                 ((size_t) longueur_totale) *
+                                 sizeof(unsigned char))) == NULL)
+                         {
+                             (*s_etat_processus).erreur_systeme =
+                                     d_es_allocation_memoire;
+                             return(NULL);
+                         }
+                         chaine[longueur_totale - 8] =
+                                 (unsigned char) ((longueur_liste >> 56) & 0xFF);
+                         chaine[longueur_totale - 7] =
+                                 (unsigned char) ((longueur_liste >> 48) & 0xFF);
+                         chaine[longueur_totale - 6] =
+                                 (unsigned char) ((longueur_liste >> 40) & 0xFF);
+                         chaine[longueur_totale - 5] =
+                                 (unsigned char) ((longueur_liste >> 32) & 0xFF);
+                         chaine[longueur_totale - 4] =
+                                 (unsigned char) ((longueur_liste >> 24) & 0xFF);
+                         chaine[longueur_totale - 3] =
+                                 (unsigned char) ((longueur_liste >> 16) & 0xFF);
+                         chaine[longueur_totale - 2] =
+                                 (unsigned char) ((longueur_liste >> 8) & 0xFF);
+                         chaine[longueur_totale - 1] =
+                                 (unsigned char) (longueur_liste & 0xFF);
+                         break;
+                     }
+                     default :
+                     {
+                         BUG(1, printf("Internal format error\n"));
+                     }
+                 }
+             }
+ uprintf("F=%s\n", formateur(s_etat_processus, 0, s_format));
+ uprintf("D=%s\n", formateur(s_etat_processus, 0, s_objet));
+             if ((*s_format).type == CHN)
+             {
+ uprintf("<1>\n");
+                 if ((format_chaine = conversion_majuscule(
+                         s_etat_processus, (unsigned char *)
+                         (*s_format).objet)) == NULL)
+                 {
+                     (*s_etat_processus).erreur_systeme =
+                             d_es_allocation_memoire;
+                     return(NULL);
+                 }
+                 if (strncmp("INTEGER*", format_chaine, 8) == 0)
+                 {
+                     format_sortie = 'I';
+                     position_1 = 8;
+                 }
+                 else if (strncmp("LOGICAL*", format_chaine, 8) == 0)
+                 {
+                     format_sortie = 'L';
+                     position_1 = 8;
+                 }
+                 else if (strncmp("REAL*", format_chaine, 5) == 0)
+                 {
+                     format_sortie = 'R';
+                     position_1 = 5;
+                 }
+                 else if (strncmp("COMPLEX*", format_chaine, 8) == 0)
+                 {
+                     format_sortie = 'C';
+                     position_1 = 8;
+                 }
+                 else if (strncmp("CHARACTER*", format_chaine, 10) == 0)
+                 {
+                     format_sortie = 'S';
+                     position_1 = 10;
+                     format_degenere = d_vrai;
+                 }
+                 else if (strcmp("NATIVE*(*)", format_chaine) == 0)
+                 {
+                     format_sortie = 'N';
+                     position_1 = 7;
+                     format_degenere = d_vrai;
+                 }
+                 else
+                 {
+                     free(chaine);
+                     free(format_chaine);
+                     (*s_etat_processus).erreur_execution =
+                             d_ex_erreur_format_fichier;
+                     return(NULL);
+                 }
+                 if (format_chaine[position_1] == d_code_fin_chaine)
+                 {
+                     free(chaine);
+                     free(format_chaine);
+                     (*s_etat_processus).erreur_execution =
+                             d_ex_erreur_format_fichier;
+                     return(NULL);
+                 }
+                 if (strcmp(&(format_chaine[position_1]), "(*)") != 0)
+                 {
+                     if (sscanf(&(format_chaine[position_1]), "%lld",
+                             &longueur) != 1)
+                     {
+                         free(chaine);
+                         free(format_chaine);
+                         (*s_etat_processus).erreur_execution =
+                                 d_ex_erreur_format_fichier;
+                         return(NULL);
+                     }
+                     longueur_champ = longueur;
+                 }
+                 else
+                 {
+                     longueur_champ = -1;
+                     longueur = -1;
+                 }
+                 free(format_chaine);
+                 if ((s_format_tmp = allocation(s_etat_processus, TBL))
+                         == NULL)
+                 {
+                     return(NULL);
+                 }
+                 (*((struct_tableau *) (*s_format_tmp).objet))
+                         .nombre_elements = (*((struct_tableau *)
+                         (*s_objet).objet)).nombre_elements;
+                 for(i = 0; i < (*((struct_tableau *) (*s_format_tmp).objet))
+                         .nombre_elements; i++)
+                 {
+                     if (((*((struct_tableau *) (*s_format_tmp).objet))
+                             .elements[i] = copie_objet(s_etat_processus,
+                             s_format, 'P')) == NULL)
+                     {
+                         return(NULL);
+                     }
+                 }
+ uprintf("%s\n", formateur(s_etat_processus, 0, s_format));
+                 if ((chaine_formatee = formateur_fichier(s_etat_processus,
+                         s_objet, s_format_tmp,
+                         longueur, longueur_champ,
+                         format_sortie, type, longueur_effective,
+                         recursivite, export_fichier)) == NULL)
+                 {
+                     liberation(s_etat_processus, s_format_tmp);
+                     free(chaine);
+                     return(NULL);
+                 }
+                 liberation(s_etat_processus, s_format_tmp);
+             }
+             else if ((*s_format).type == TBL)
+             {
+ uprintf("<2>\n");
+                 free(chaine);
+                 // A FIXER
+             }
+             else
+             {
+ uprintf("<3>\n");
+                 free(chaine);
+                 (*s_etat_processus).erreur_execution =
+                         d_ex_erreur_format_fichier;
+                 return(NULL);
+             }
+             (*longueur_effective) = longueur_totale;
          }
          else if ((*s_objet).type == MCX)
          {
- Line 3814  formateur_fichier(struct_processus *s_et
+ Line 4271  formateur_fichier(struct_processus *s_et
    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) =
++ (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)
          {
- Line 3823  formateur_fichier(struct_processus *s_et
+ Line 4462  formateur_fichier(struct_processus *s_et
    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) =
++ (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)
          {
- Line 3832  formateur_fichier(struct_processus *s_et
+ Line 4718  formateur_fichier(struct_processus *s_et
    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) =
++ (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)
          {
- Line 3839  formateur_fichier(struct_processus *s_et
+ Line 4936  formateur_fichier(struct_processus *s_et
  /*
  --------------------------------------------------------------------------------
    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)
          {
- Line 3880  formateur_fichier(struct_processus *s_et
+ Line 5081  formateur_fichier(struct_processus *s_et
    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) =
++ (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)
          {
- Line 3889  formateur_fichier(struct_processus *s_et
+ Line 5212  formateur_fichier(struct_processus *s_et
    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) =
++ (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)
          {
- Line 3898  formateur_fichier(struct_processus *s_et
+ Line 5407  formateur_fichier(struct_processus *s_et
    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) =
++ (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
          {
- Line 3920  formateur_fichier(struct_processus *s_et
+ Line 5566  formateur_fichier(struct_processus *s_et
              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)
                  {
                      (*s_etat_processus).erreur_systeme =
- Line 3934  formateur_fichier(struct_processus *s_et
+ Line 5581  formateur_fichier(struct_processus *s_et
                  memcpy(&(chaine[longueur_totale]), tampon, 1);
                  longueur_totale += 1;
              }
-             else if (longueur_totale < (((integer8) 1) << 16))
+             else
              {
                  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))))
                              || (i == 6))
                      {
                          // LSB (4 bits de poids fort)
-                         tampon[0] = (longueur_totale & 0xF0)
+                         tampon[0] = (unsigned char) ((longueur_totale & 0xF0)
                                  | 0x1 /* longueur supérieure à 7 bits */
-                                 | ((i + 1) << 1);
+                                 | ((i + 1) << 1));
                          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)
-                         tampon[i + 2] = ((longueur_totale & 0x0F) << 4)
+                         tampon[i + 2] = (unsigned char)
+                                 (((longueur_totale & 0x0F) << 4)
                                  | 0x1 /* longueur supérieure à 7 bits */
-                                 | ((i + 1) << 1);
+                                 | ((i + 1) << 1));
                          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)
                  {
                      (*s_etat_processus).erreur_systeme =
- Line 3974  formateur_fichier(struct_processus *s_et
+ Line 5646  formateur_fichier(struct_processus *s_et
                  memcpy(&(chaine[longueur_totale]), tampon, 3);
                  longueur_totale += 3;
              }
-             else if (longueur_totale < (((integer8) 1) << 32))
-             {
-             }
              __zone();
              (*longueur_effective) = longueur_totale;
- Line 4012  formateur_fichier(struct_processus *s_et
+ Line 5681  formateur_fichier(struct_processus *s_et
  unsigned char *
  formateur_fichier_nombre(struct_processus *s_etat_processus,
          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               *construction_chaine;
- Line 4152  formateur_fichier_nombre(struct_processu
+ Line 5821  formateur_fichier_nombre(struct_processu
  unsigned char *
  formateur_fichier_reel(struct_processus *s_etat_processus,
          void *valeur_numerique, unsigned char type,
-         long longueur, long longueur_champ,
+         integer8 longueur, integer8 longueur_champ,
          unsigned char format_sortie)
  {
      real8                   mantisse;
      real8                   tampon_reel;
+     integer8                i;
      integer8                tampon_entier;
      long                    correction;
- Line 4170  formateur_fichier_reel(struct_processus
+ Line 5840  formateur_fichier_reel(struct_processus
      unsigned char           mode[3 + 1];
      unsigned char           tampon[16 + 1];
-     unsigned long           i;
      chaine = (unsigned char *) malloc((32 + 1) * sizeof(unsigned char));
      if (chaine == NULL)
- Line 4197  formateur_fichier_reel(struct_processus
+ Line 5865  formateur_fichier_reel(struct_processus
              exposant = 0;
          }
-         mantisse = (*((real8 *) valeur_numerique)) / pow(10, exposant);
+         mantisse = (*((real8 *) valeur_numerique)) / pow(10, (double) exposant);
      }
      else
      {
- Line 4205  formateur_fichier_reel(struct_processus
+ Line 5873  formateur_fichier_reel(struct_processus
          if (tampon_entier > ((integer8) 0))
          {
-             exposant = (long) floor(log10(tampon_entier));
+             exposant = (long) floor(log10((double) tampon_entier));
          }
          else if (tampon_entier < ((integer8) 0))
          {
-             exposant = (long) floor(log10(-tampon_entier));
+             exposant = (long) floor(log10((double) -tampon_entier));
          }
          else
          {
              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;
      if (longueur_utile > longueur_utile_limite)
- Line 4280  formateur_fichier_reel(struct_processus
+ Line 5949  formateur_fichier_reel(struct_processus
          sprintf(format, "%%.%luf", longueur_utile);
-         sprintf(tampon, format, (mantisse * pow(10, exposant)));
+         sprintf(tampon, format, (mantisse * pow(10, (double) exposant)));
          strcpy(chaine, tampon);
      }
      else if (strcmp(mode, "ENG") == 0)
- Line 4303  formateur_fichier_reel(struct_processus
+ Line 5972  formateur_fichier_reel(struct_processus
          longueur_utile -= correction;
          sprintf(format, "%%.%luf", longueur_utile);
-         sprintf(tampon, format, (mantisse * pow(10, correction)));
+         sprintf(tampon, format, (mantisse * pow(10, (double) correction)));
          strcpy(chaine, tampon);
          strcat(chaine, "E");
          sprintf(tampon, "%ld", (exposant - correction));
- Line 4333  formateur_fichier_reel(struct_processus
+ Line 6002  formateur_fichier_reel(struct_processus
              sprintf(tampon, format, *((real8 *) valeur_numerique));
-             i = strlen(tampon) - 1;
+             i = (integer8) (strlen(tampon)) - 1;
              while(tampon[i] == '0')
              {
                  tampon[i] = 0;
- Line 4342  formateur_fichier_reel(struct_processus
+ Line 6011  formateur_fichier_reel(struct_processus
              if (ds_imposition_separateur_decimal == d_faux)
              {
-                 i = strlen(tampon) - 1;
+                 i = ((integer8) strlen(tampon)) - 1;
                  if (tampon[i] == '.')
                  {
                      tampon[i] = 0;
- Line 4357  formateur_fichier_reel(struct_processus
+ Line 6026  formateur_fichier_reel(struct_processus
      {
          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] = '*';
              }
- Line 4379  formateur_fichier_reel(struct_processus
+ Line 6048  formateur_fichier_reel(struct_processus
  unsigned char *
  formateur_fichier_binaire_nombre(struct_processus *s_etat_processus,
          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;
- Line 4413  formateur_fichier_binaire_nombre(struct_
+ Line 6082  formateur_fichier_binaire_nombre(struct_
                      }
                      (*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;
                  }
- Line 4436  formateur_fichier_binaire_nombre(struct_
+ Line 6106  formateur_fichier_binaire_nombre(struct_
                      }
                      (*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;
                  }
- Line 4461  formateur_fichier_binaire_nombre(struct_
+ Line 6132  formateur_fichier_binaire_nombre(struct_
                      }
                      (*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;
                  }
- Line 4482  formateur_fichier_binaire_nombre(struct_
+ Line 6154  formateur_fichier_binaire_nombre(struct_
                      }
                      (*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;
                  }
- Line 4534  formateur_fichier_binaire_nombre(struct_
+ Line 6207  formateur_fichier_binaire_nombre(struct_
                      }
                      else if (type_entree == 'I')
                      {
-                         valeur = (*((integer8 *) valeur_numerique));
+                         valeur = (real8) (*((integer8 *) valeur_numerique));
                      }
                      else
                      {
- Line 4548  formateur_fichier_binaire_nombre(struct_
+ Line 6221  formateur_fichier_binaire_nombre(struct_
                          vinf = nextafter(valeur, 0);
                          vsup = nextafter(valeur, valeur * 2);
                      }
-                     else
+                     else if (valeur < 0)
                      {
                          vinf = nextafter(valeur, valeur * 2);
                          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 =
                                  d_ex_representation;
- Line 4571  formateur_fichier_binaire_nombre(struct_
+ Line 6249  formateur_fichier_binaire_nombre(struct_
                      eq4.r4 = (real4) valeur;
                      (*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;
                  }
- Line 4596  formateur_fichier_binaire_nombre(struct_
+ Line 6274  formateur_fichier_binaire_nombre(struct_
                      if (type_entree == 'I')
                      {
-                         eq8.r8 = (*((integer8 *) valeur_numerique));
+                         eq8.r8 = (real8) (*((integer8 *) valeur_numerique));
                      }
                      else if (type_entree == 'R')
                      {
- Line 4610  formateur_fichier_binaire_nombre(struct_
+ Line 6288  formateur_fichier_binaire_nombre(struct_
                      }
                      (*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;
                  }
- Line 4642  formateur_fichier_binaire_nombre(struct_
+ Line 6320  formateur_fichier_binaire_nombre(struct_
                      unsigned char       *partie_reelle;
                      unsigned char       *partie_imaginaire;
-                     long                limag;
+                     integer8            limag;
-                     long                lreel;
+                     integer8            lreel;
                      real8               zero;
- Line 4716  formateur_fichier_binaire_nombre(struct_
+ Line 6394  formateur_fichier_binaire_nombre(struct_
                          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_imaginaire);
- Line 4727  formateur_fichier_binaire_nombre(struct_
+ Line 6405  formateur_fichier_binaire_nombre(struct_
                          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;
                      free(partie_reelle);
- Line 4742  formateur_fichier_binaire_nombre(struct_
+ Line 6422  formateur_fichier_binaire_nombre(struct_
                      unsigned char       *partie_reelle;
                      unsigned char       *partie_imaginaire;
-                     long                limag;
+                     integer8            limag;
-                     long                lreel;
+                     integer8            lreel;
                      real8               zero;
                      if (type_entree == 'I')
- Line 4815  formateur_fichier_binaire_nombre(struct_
+ Line 6496  formateur_fichier_binaire_nombre(struct_
                          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_imaginaire);
- Line 4826  formateur_fichier_binaire_nombre(struct_
+ Line 6507  formateur_fichier_binaire_nombre(struct_
                          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;
                      free(partie_reelle);
- Line 4892  lecture_fichier_non_formate(struct_proce
+ Line 6575  lecture_fichier_non_formate(struct_proce
      unsigned char               *buffer;
      unsigned char               *flux;
      unsigned char               *ptr;
+     unsigned char               type_objet;
      size_t                      deplacement;
- Line 4938  lecture_fichier_non_formate(struct_proce
+ Line 6622  lecture_fichier_non_formate(struct_proce
          }
      }
-     switch(octets[0] & 0xF0)
+     switch(type_objet = (octets[0] & 0xF0))
      {
          case 0x00:  // Binaire
          {
- Line 5022  lecture_fichier_non_formate(struct_proce
+ Line 6706  lecture_fichier_non_formate(struct_proce
              for(i = 0; i < (signed) deplacement; i++)
              {
                  (*((logical8 *) (*s_objet).objet)) |= ((logical8) octets[i])
-                         << (8 * ((deplacement - 1) - i));
+                         << (8 * ((((signed) deplacement) - 1) - i));
              }
              break;
- Line 5102  lecture_fichier_non_formate(struct_proce
+ Line 6786  lecture_fichier_non_formate(struct_proce
                          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;
- Line 5193  lecture_fichier_non_formate(struct_proce
+ Line 6933  lecture_fichier_non_formate(struct_proce
                          for(i = 0; i < (signed) deplacement; i++)
                          {
                              eq4.i4 |= ((integer4) octets[i]) <<
-                                     (8 * ((deplacement - 1) - i));
+                                     (8 * ((((signed) deplacement) - 1) - i));
                          }
                          (*((real8 *) (*s_objet).objet)) = (real8) eq4.r4;
- Line 5211  lecture_fichier_non_formate(struct_proce
+ Line 6951  lecture_fichier_non_formate(struct_proce
                          for(i = 0; i < (signed) deplacement; i++)
                          {
                              eq8.i8 |= ((integer8) octets[i]) <<
-                                     (8 * ((deplacement - 1) - i));
+                                     (8 * ((((signed) deplacement) - 1) - i));
                          }
                          (*((real8 *) (*s_objet).objet)) = (real8) eq8.r8;
- Line 5304  lecture_fichier_non_formate(struct_proce
+ Line 7044  lecture_fichier_non_formate(struct_proce
                              for(i = 0; i < (signed) deplacement; i++)
                              {
                                  eq4.i4 |= ((integer4) octets[i]) <<
-                                         (8 * ((deplacement - 1) - i));
+                                         (8 * ((((signed) deplacement) - 1)
+                                         - i));
                              }
                              if (j == 0)
- Line 5331  lecture_fichier_non_formate(struct_proce
+ Line 7072  lecture_fichier_non_formate(struct_proce
                              for(i = 0; i < (signed) deplacement; i++)
                              {
                                  eq8.i8 |= ((integer8) octets[i]) <<
-                                         (8 * ((deplacement - 1) - i));
+                                         (8 * ((((signed) deplacement) - 1)
+                                         - i));
                              }
                              if (j == 0)
- Line 5361  lecture_fichier_non_formate(struct_proce
+ Line 7103  lecture_fichier_non_formate(struct_proce
          }
          case 0x40:  // Liste
+         case 0x60:  // Expression
+         case 0x70:  // Expression algébrique
          {
              if ((octets[0] & 0x08) == 0)    // Longueur sur 6 bits
              {
- Line 5545  lecture_fichier_non_formate(struct_proce
+ Line 7289  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;
- Line 5796  lecture_fichier_non_formate(struct_proce
+ Line 7557  lecture_fichier_non_formate(struct_proce
              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 =
                              d_es_allocation_memoire;
- Line 5804  lecture_fichier_non_formate(struct_proce
+ Line 7566  lecture_fichier_non_formate(struct_proce
                  }
                  if (fread(flux, (size_t) sizeof(unsigned char),
-                         longueur, fichier) != (size_t) longueur)
+                         (size_t) longueur, fichier) != (size_t) longueur)
                  {
                      if (feof(fichier))
                      {
- Line 5857  lecture_fichier_non_formate(struct_proce
+ Line 7619  lecture_fichier_non_formate(struct_proce
              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),
+, 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),
+, 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),
+, 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),
+, 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),
+, 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
- Line 6049  lecture_fichier_non_formate(struct_proce
+ Line 8072  lecture_fichier_non_formate(struct_proce
              }
              if (((*((struct_fonction *) (*s_objet).objet)).nom_fonction =
-                     malloc((longueur + 1) * sizeof(unsigned char))) == NULL)
+                     malloc((((size_t) longueur) + 1) * sizeof(unsigned char)))
+                     == NULL)
              {
                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                  return(NULL);
- Line 6059  lecture_fichier_non_formate(struct_proce
+ Line 8083  lecture_fichier_non_formate(struct_proce
              {
                  if (fread((unsigned char *) (*((struct_fonction *) (*s_objet)
                          .objet)).nom_fonction, (size_t) sizeof(unsigned char),
-                         longueur, fichier) != (unsigned) longueur)
+                         (size_t) longueur, fichier) != (unsigned) longueur)
                  {
                      if (feof(fichier))
                      {
- Line 6154  lecture_fichier_non_formate(struct_proce
+ Line 8178  lecture_fichier_non_formate(struct_proce
          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,
                      fichier) != deplacement)

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.58
changed lines
	Added in v.1.93