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.52 and 1.91

-version 1.52, 2013/03/10 17:01:05
+version 1.91, 2016/09/27 15:29:33
  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-2016 Dr. BERTRAND Joël
    This file is part of RPL/2.
  Line 19
  ================================================================================
  */
  #define DEBUG_ERREURS
  #include "rpl-conv.h"
- Line 40
+ Line 41
  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 62  formateur_fichier(struct_processus *s_et
+ Line 64  formateur_fichier(struct_processus *s_et
       *   "binary*X(*)"
       *   "binary*X(Y)"  (X est la base : 2, 8, 10, 16)
       *   "character*(*)"
-      *   "character*(Y)" }
+      *   "character*(Y)"
+      *   "native*(*)" }
       *
       * Traitement du format des fichiers non formatés :
       *
- Line 70  formateur_fichier(struct_processus *s_et
+ Line 73  formateur_fichier(struct_processus *s_et
       *   "real*4", "real*8", ["real*16",]
       *   "complex*8", "complex*16", ["complex*32",]
       *   "logical*1", "logical*2", "logical*4", logical*8",
-      *   "character*n" "character*(*)" }
+      *   "character*n" "character*(*)" "native*(*)" }
       */
      logical1                    autorisation_parenthese;
      logical1                    format_degenere;
      logical1                    presence_signe;
-     long                        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 94  formateur_fichier(struct_processus *s_et
+ Line 98  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;
      unsigned char               *ptre;
      unsigned char               *ptrl;
      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                    masque_binaire;
      integer8                    position_1;
      integer8                    position_2;
      integer8                    position_3;
- Line 131  formateur_fichier(struct_processus *s_et
+ Line 140  formateur_fichier(struct_processus *s_et
          strcpy(base, " ");
-         masque_binaire = 0;
          if ((*s_objet).type == ALG)
          {
- Line 142  formateur_fichier(struct_processus *s_et
+ Line 149  formateur_fichier(struct_processus *s_et
  --------------------------------------------------------------------------------
  */
+             if (format_sortie != 'N')
+             {
+                 (*s_etat_processus).erreur_execution =
+                         d_ex_erreur_format_fichier;
+                 return(NULL);
+             }
              l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
              while(l_element_courant != NULL)
- Line 226  formateur_fichier(struct_processus *s_et
+ Line 240  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 285  formateur_fichier(struct_processus *s_et
+ Line 300  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 312  formateur_fichier(struct_processus *s_et
+ Line 328  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 393  formateur_fichier(struct_processus *s_et
+ Line 411  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 450  formateur_fichier(struct_processus *s_et
+ Line 469  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 467  formateur_fichier(struct_processus *s_et
+ Line 487  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 708  formateur_fichier(struct_processus *s_et
+ Line 730  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 921  formateur_fichier(struct_processus *s_et
+ Line 945  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 984  formateur_fichier(struct_processus *s_et
+ Line 1008  formateur_fichier(struct_processus *s_et
  --------------------------------------------------------------------------------
  */
-             if (format_sortie != 'B')
+             if ((format_sortie != 'B') && (format_sortie != 'N'))
              {
                  (*s_etat_processus).erreur_execution =
                          d_ex_erreur_format_fichier;
                  return(NULL);
              }
-             masque_binaire = masque_entiers_binaires(s_etat_processus);
+             if (format_sortie == 'N')
-             if ((test_cfsf(s_etat_processus, 43) == d_faux) &&
-                     (test_cfsf(s_etat_processus, 44) == d_faux))
              {
+                 sprintf(tampon, "%llX", (unsigned long long) (*((logical8 *)
- /*
+                         ((*s_objet).objet))));
- -- Base décimale ---------------------------------------------------------------
+                 strcpy(base, "h");
- */
-                 sprintf(tampon, "%llu", (*((logical8 *)
-                         ((*s_objet).objet))) & masque_binaire);
-                 strcpy(base, "d");
              }
-             else if ((test_cfsf(s_etat_processus, 43) == d_vrai) &&
+             else
-                     (test_cfsf(s_etat_processus, 44) == d_faux))
              {
+                 switch(longueur)
+                 {
+                     case 2:
+                     {
+                         sprintf(tampon, "%llX", (unsigned long long)
+                                 (*((logical8 *) ((*s_objet).objet))));
- /*
+                         chaine = (unsigned char *) malloc((strlen(tampon) + 1)
- -- Base octale -----------------------------------------------------------------
+                                 * sizeof(unsigned char));
- */
-                 sprintf(tampon, "%llo", (*((logical8 *)
+                         if (chaine == NULL)
-                         ((*s_objet).objet))) & masque_binaire);
+                         {
-                 strcpy(base, "o");
+                             (*s_etat_processus).erreur_systeme =
-             }
+                                     d_es_allocation_memoire;
-             else if (test_cfsf(s_etat_processus, 44) == d_vrai)
+                             return(NULL);
-             {
+                         }
- /*
+                         strcpy(chaine, tampon);
- -- Bases hexadécimale et binaire -----------------------------------------------
+                         tampon[0] = 0;
- */
-                 sprintf(tampon, "%llX", (*((logical8 *)
+                         for(i = 0; i < ((integer8) strlen(chaine)); i++)
-                         ((*s_objet).objet))) & masque_binaire);
+                         {
+                             switch(chaine[i])
+                             {
+                                 case '0' :
+                                 {
+                                     strcat(tampon, (i != 0) ? "0000" : "0");
+                                     break;
+                                 }
+                                 case '1' :
+                                 {
+                                     strcat(tampon, (i != 0) ? "0001" : "1");
+                                     break;
+                                 }
+                                 case '2' :
+                                 {
+                                     strcat(tampon, (i != 0) ? "0010" : "10");
+                                     break;
+                                 }
+                                 case '3' :
+                                 {
+                                     strcat(tampon, (i != 0) ? "0011" : "11");
+                                 break;
+                                 }
+                                 case '4' :
+                                 {
+                                     strcat(tampon, (i != 0) ? "0100" : "100");
+                                     break;
+                                 }
+                                 case '5' :
+                                 {
+                                     strcat(tampon, (i != 0) ? "0101" : "101");
+                                     break;
+                                 }
+                                 case '6' :
+                                 {
+                                     strcat(tampon, (i != 0) ? "0110" : "110");
+                                     break;
+                                 }
+                                 case '7' :
+                                 {
+                                     strcat(tampon, (i != 0) ? "0111" : "111");
+                                     break;
+                                 }
+                                 case '8' :
+                                 {
+                                     strcat(tampon, "1000");
+                                     break;
+                                 }
+                                 case '9' :
+                                 {
+                                     strcat(tampon, "1001");
+                                     break;
+                                 }
+                                 case 'A' :
+                                 {
+                                     strcat(tampon, "1010");
+                                     break;
+                                 }
+                                 case 'B' :
+                                 {
+                                     strcat(tampon, "1011");
+                                     break;
+                                 }
+                                 case 'C' :
+                                 {
+                                     strcat(tampon, "1100");
+                                     break;
+                                 }
+                                 case 'D' :
+                                 {
+                                     strcat(tampon, "1101");
+                                     break;
+                                 }
+                                 case 'E' :
+                                 {
+                                     strcat(tampon, "1110");
+                                     break;
+                                 }
+                                 case 'F' :
+                                 {
+                                     strcat(tampon, "1111");
+                                     break;
+                                 }
+                             }
+                         }
-                 if (test_cfsf(s_etat_processus, 43) == d_vrai)
+                         free(chaine);
-                 {
+                         strcpy(base, "b");
-                     strcpy(base, "h");
+                         break;
-                 }
+                     }
-                 else
-                 {
-                     chaine = (unsigned char *) malloc((strlen(tampon) + 1)
-                             * sizeof(unsigned char));
-                     if (chaine == NULL)
+                     case 8:
                      {
-                         (*s_etat_processus).erreur_systeme =
+                         sprintf(tampon, "%llo", (*((unsigned long long *)
-                                 d_es_allocation_memoire;
+                                 ((*s_objet).objet))));
-                         return(NULL);
+                         strcpy(base, "o");
+                         break;
                      }
-                     strcpy(chaine, tampon);
+                     case 10:
-                     tampon[0] = 0;
+                     {
+                         sprintf(tampon, "%llu", (*((unsigned long long *)
+                                 ((*s_objet).objet))));
+                         strcpy(base, "d");
+                         break;
+                     }
-                     for(i = 0; i < strlen(chaine); i++)
+                     case 16:
                      {
-                         switch(chaine[i])
+                         sprintf(tampon, "%llX", (unsigned long long)
-                         {
+                                 (*((logical8 *) ((*s_objet).objet))));
-                             case '0' :
+                         strcpy(base, "h");
-                             {
+                         break;
-                                 strcat(tampon, (i != 0) ? "0000" : "0");
-                                 break;
-                             }
-                             case '1' :
-                             {
-                                     strcat(tampon, (i != 0) ? "0001" : "1");
-                                 break;
-                             }
-                             case '2' :
-                             {
-                                 strcat(tampon, (i != 0) ? "0010" : "10");
-                                 break;
-                             }
-                             case '3' :
-                             {
-                                 strcat(tampon, (i != 0) ? "0011" : "11");
-                                 break;
-                             }
-                             case '4' :
-                             {
-                                 strcat(tampon, (i != 0) ? "0100" : "100");
-                                 break;
-                             }
-                             case '5' :
-                             {
-                                 strcat(tampon, (i != 0) ? "0101" : "101");
-                                 break;
-                             }
-                             case '6' :
-                             {
-                                 strcat(tampon, (i != 0) ? "0110" : "110");
-                                 break;
-                             }
-                             case '7' :
-                             {
-                                 strcat(tampon, (i != 0) ? "0111" : "111");
-                                 break;
-                             }
-                             case '8' :
-                             {
-                                 strcat(tampon, "1000");
-                                 break;
-                             }
-                             case '9' :
-                             {
-                                 strcat(tampon, "1001");
-                                 break;
-                             }
-                             case 'A' :
-                             {
-                                 strcat(tampon, "1010");
-                                 break;
-                             }
-                             case 'B' :
-                             {
-                                 strcat(tampon, "1011");
-                                 break;
-                             }
-                             case 'C' :
-                             {
-                                 strcat(tampon, "1100");
-                                 break;
-                             }
-                             case 'D' :
-                             {
-                                 strcat(tampon, "1101");
-                                 break;
-                             }
-                             case 'E' :
-                             {
-                                 strcat(tampon, "1110");
-                                 break;
-                             }
-                             case 'F' :
-                             {
-                                 strcat(tampon, "1111");
-                                 break;
-                             }
-                         }
                      }
-                     free(chaine);
+                     default:
-                     strcpy(base, "b");
+                     {
+                         (*s_etat_processus).erreur_execution =
+                                 d_ex_erreur_format_fichier;
+                         return(NULL);
+                     }
+                 }
+             }
+             if (format_sortie == 'B')
+             {
+                 if ((longueur_champ > 0) && (longueur_champ
+                         < (signed) strlen(tampon)))
+                 {
+                     ptrl = &(tampon[((integer8) strlen(tampon))
+                             - longueur_champ]);
+                     ptre = tampon;
+                     do
+                     {
+                         *ptre++ = *ptrl++;
+                     } while((*ptrl) != d_code_fin_chaine);
+                     (*ptre) = d_code_fin_chaine;
                  }
              }
- Line 1161  formateur_fichier(struct_processus *s_et
+ Line 1209  formateur_fichier(struct_processus *s_et
  --------------------------------------------------------------------------------
  */
-             if (format_sortie != 'C')
+             if ((format_sortie != 'C') && (format_sortie != 'N'))
              {
                  (*s_etat_processus).erreur_execution =
                          d_ex_erreur_format_fichier;
- Line 1171  formateur_fichier(struct_processus *s_et
+ Line 1219  formateur_fichier(struct_processus *s_et
              longueur_reelle_chaine = longueur_chaine(s_etat_processus,
                      (unsigned char *) (*s_objet).objet);
+             if (format_sortie == 'N')
+             {
+                 longueur_champ = -1;
+             }
              if ((longueur_champ == -1) || (longueur_reelle_chaine <
                      longueur_champ))
              {
- Line 1193  formateur_fichier(struct_processus *s_et
+ Line 1246  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 1202  formateur_fichier(struct_processus *s_et
+ Line 1255  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 1215  formateur_fichier(struct_processus *s_et
+ Line 1268  formateur_fichier(struct_processus *s_et
  --------------------------------------------------------------------------------
  */
+             if (format_sortie == 'N')
+             {
+                 format_sortie = 'S';
+             }
              if ((format_sortie != 'S') && (format_sortie != 'F') &&
                      (format_sortie != 'I') && (format_sortie != 'E'))
              {
- Line 1252  formateur_fichier(struct_processus *s_et
+ Line 1310  formateur_fichier(struct_processus *s_et
  --------------------------------------------------------------------------------
  */
+             if (format_sortie != 'N')
+             {
+                 (*s_etat_processus).erreur_execution =
+                         d_ex_erreur_format_fichier;
+                 return(NULL);
+             }
              l_element_courant = (struct_liste_chainee *) ((*s_objet).objet);
              chaine_sauvegarde = chaine;
- Line 1334  formateur_fichier(struct_processus *s_et
+ Line 1399  formateur_fichier(struct_processus *s_et
  --------------------------------------------------------------------------------
  */
+             if (format_sortie == 'N')
+             {
+                 format_sortie = 'S';
+             }
              if ((format_sortie != 'S') && (format_sortie != 'F') &&
                      (format_sortie != 'I') && (format_sortie != 'E'))
              {
- Line 1371  formateur_fichier(struct_processus *s_et
+ Line 1441  formateur_fichier(struct_processus *s_et
  --------------------------------------------------------------------------------
  */
+             if (format_sortie != 'N')
+             {
+                 (*s_etat_processus).erreur_execution =
+                         d_ex_erreur_format_fichier;
+                 return(NULL);
+             }
              chaine = (unsigned char *) malloc((strlen((*((struct_fonction *)
                      ((*s_objet).objet))).nom_fonction) + 1) *
                      sizeof(unsigned char));
- Line 1418  formateur_fichier(struct_processus *s_et
+ Line 1495  formateur_fichier(struct_processus *s_et
                  {
                      chaine_sauvegarde = chaine;
-                     if ((chaine_formatee = formateur_fichier(s_etat_processus,
+                     if (format_sortie != 'N')
-                             (*l_element_courant).donnee,
-                             (*l_element_courant_format).donnee,
-, 0, ' ', 'F', longueur_effective, recursivite,
-                             export_fichier)) == NULL)
                      {
-                         return(NULL);
+                         if ((chaine_formatee =
+                                 formateur_fichier(s_etat_processus,
+                                 (*l_element_courant).donnee,
+                                 (*l_element_courant_format).donnee,
+, 0, ' ', 'F', longueur_effective, recursivite,
+                                 export_fichier)) == NULL)
+                         {
+                             return(NULL);
+                         }
+                     }
+                     else
+                     {
+                         if ((chaine_formatee =
+                                 formateur_fichier(s_etat_processus,
+                                 (*l_element_courant).donnee,
+                                 (*l_element_courant_format).donnee,
+, 0, 'N', 'F', longueur_effective, recursivite,
+                                 export_fichier)) == NULL)
+                         {
+                             return(NULL);
+                         }
                      }
                      chaine = (unsigned char *) malloc((strlen(chaine_formatee)
- Line 1454  formateur_fichier(struct_processus *s_et
+ Line 1547  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 1497  formateur_fichier(struct_processus *s_et
+ Line 1591  formateur_fichier(struct_processus *s_et
                          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);
- Line 1507  formateur_fichier(struct_processus *s_et
+ Line 1607  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 1542  formateur_fichier(struct_processus *s_et
+ Line 1642  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 1560  formateur_fichier(struct_processus *s_et
+ Line 1660  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 1577  formateur_fichier(struct_processus *s_et
+ Line 1677  formateur_fichier(struct_processus *s_et
                      }
                      if ((longueur >= 0) && (longueur_champ >= 0) && (longueur >
-                             longueur_champ))
+                             longueur_champ) && (format_sortie != 'B'))
                      {
                          free(chaine);
                          free(format_chaine);
- Line 1591  formateur_fichier(struct_processus *s_et
+ Line 1691  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 1664  formateur_fichier(struct_processus *s_et
+ Line 1818  formateur_fichier(struct_processus *s_et
                  nombre_elements++;
                  l_element_courant = (*l_element_courant).suivant;
-                 l_element_courant_format = (*l_element_courant_format).suivant;
+                 if (format_sortie != 'N')
+                 {
+                     l_element_courant_format =
+                             (*l_element_courant_format).suivant;
+                 }
              }
-             if ((l_element_courant != NULL) ||
+             // Dans le cas où le format de sortie n'est pas du type
-                     (l_element_courant_format != NULL))
+             // NATIVE*(*), on vérifie que tous les éléments du format et
+             // de la liste d'arguments ont été consommés.
+             if (format_sortie != 'N')
              {
-                 free(chaine);
+                 if ((l_element_courant != NULL) ||
+                         (l_element_courant_format != NULL))
+                 {
+                     free(chaine);
-                 (*s_etat_processus).erreur_execution =
+                     (*s_etat_processus).erreur_execution =
-                         d_ex_erreur_format_fichier;
+                             d_ex_erreur_format_fichier;
-                 return(NULL);
+                     return(NULL);
+                 }
              }
              chaine_sauvegarde = chaine;
- Line 1700  formateur_fichier(struct_processus *s_et
+ Line 1866  formateur_fichier(struct_processus *s_et
  --------------------------------------------------------------------------------
  */
-             if ((*s_format).type != TBL)
+             if (((*s_format).type != TBL) && (format_sortie != 'N'))
              {
                  (*s_etat_processus).erreur_execution =
                          d_ex_erreur_format_fichier;
                  return(NULL);
              }
-             l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
+             if (format_sortie != 'N')
-             l_element_courant_format = (struct_liste_chainee *)
-                     (*s_format).objet;
-             if ((*((struct_tableau *) (*s_objet).objet)).nombre_elements !=
-                     (*((struct_tableau *) (*s_format).objet)).nombre_elements)
              {
-                 (*s_etat_processus).erreur_execution =
+                 if ((*((struct_tableau *) (*s_objet).objet)).nombre_elements !=
-                         d_ex_erreur_format_fichier;
+                         (*((struct_tableau *) (*s_format).objet))
-                 return(NULL);
+                         .nombre_elements)
+                 {
+                     (*s_etat_processus).erreur_execution =
+                             d_ex_erreur_format_fichier;
+                     return(NULL);
+                 }
              }
              chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
- Line 1732  formateur_fichier(struct_processus *s_et
+ Line 1898  formateur_fichier(struct_processus *s_et
              for(i = 0; i < (*((struct_tableau *) (*s_objet).objet))
                      .nombre_elements; i++)
              {
-                 if ((((*(*((struct_tableau *) (*s_format).objet))
+                 if (format_sortie != 'N')
-                         .elements[i]).type == LST) &&
-                         ((*(*((struct_tableau *) (*s_objet).objet)).elements[i])
-                         .type == LST)) ||
-                         (((*(*((struct_tableau *) (*s_format).objet))
-                         .elements[i]).type == TBL) &&
-                         ((*(*((struct_tableau *) (*s_objet).objet)).elements[i])
-                         .type == TBL)))
                  {
-                     chaine_sauvegarde = chaine;
+                     if ((((*(*((struct_tableau *) (*s_format).objet))
+                             .elements[i]).type == LST) &&
-                     if ((chaine_formatee = formateur_fichier(s_etat_processus,
+                             ((*(*((struct_tableau *) (*s_objet).objet))
-                             (*l_element_courant).donnee,
+                             .elements[i]).type == LST)) ||
-                             (*l_element_courant_format).donnee,
+                             (((*(*((struct_tableau *) (*s_format).objet))
-, 0, ' ', 'F', longueur_effective, recursivite,
+                             .elements[i]).type == TBL) &&
-                             export_fichier)) == NULL)
+                             ((*(*((struct_tableau *) (*s_objet).objet))
-                     {
+                             .elements[i]).type == TBL)))
-                         return(NULL);
-                     }
-                     chaine = (unsigned char *) malloc((strlen(chaine_formatee)
-                             + strlen(chaine_sauvegarde) + 2)
-                             * sizeof(unsigned char));
-                     if (chaine == NULL)
                      {
-                         (*s_etat_processus).erreur_systeme =
+                         chaine_sauvegarde = chaine;
-                                 d_es_allocation_memoire;
-                         return(NULL);
-                     }
-                     strcpy(chaine, chaine_sauvegarde);
-                     free(chaine_sauvegarde);
-                     strcat(chaine, " ");
-                     strcat(chaine, chaine_formatee);
-                     free(chaine_formatee);
-                 }
-                 else if ((*(*((struct_tableau *) (*s_format).objet))
-                         .elements[i]).type != CHN)
-                 {
-                     free(chaine);
-                     (*s_etat_processus).erreur_execution =
+                         if ((chaine_formatee = formateur_fichier(
-                             d_ex_erreur_format_fichier;
+                                 s_etat_processus,
-                     return(NULL);
+                                 (*(*((struct_tableau *) (*s_objet).objet))
-                 }
+                                 .elements[i]).objet,
-                 else
+                                 (*(*((struct_tableau *) (*s_format).objet))
-                 {
+                                 .elements[i]).objet,
-                     if ((format_chaine = conversion_majuscule((unsigned char *)
+, 0, ' ', 'F', longueur_effective, recursivite,
-                             (*(*((struct_tableau *) (*s_format).objet))
+                                 export_fichier)) == NULL)
-                             .elements[i]).objet)) == NULL)
+                         {
-                     {
+                             return(NULL);
-                         (*s_etat_processus).erreur_systeme =
+                         }
-                                 d_es_allocation_memoire;
-                         return(NULL);
-                     }
-                     format_degenere = d_faux;
+                         if ((chaine = (unsigned char *) malloc((strlen(
+                                 chaine_formatee) + strlen(chaine_sauvegarde)
+                                 + 2) * sizeof(unsigned char))) == NULL)
+                         {
+                             (*s_etat_processus).erreur_systeme =
+                                     d_es_allocation_memoire;
+                             return(NULL);
+                         }
-                     if (strncmp("STANDARD*", format_chaine, 9) == 0)
+                         strcpy(chaine, chaine_sauvegarde);
-                     {
+                         free(chaine_sauvegarde);
-                         format_sortie = 'S';
+                         strcat(chaine, " ");
-                         position_1 = 9;
+                         strcat(chaine, chaine_formatee);
-                         format_degenere = d_vrai;
+                         free(chaine_formatee);
-                     }
-                     else if (strncmp("BINARY*", format_chaine, 7) == 0)
-                     {
-                         format_sortie = 'B';
-                         position_1 = 7;
-                     }
-                     else if (strncmp("FIXED*", format_chaine, 6) == 0)
-                     {
-                         format_sortie = 'F';
-                         position_1 = 6;
-                     }
-                     else if (strncmp("SCIENTIFIC*", format_chaine, 11) == 0)
-                     {
-                         format_sortie = 'I';
-                         position_1 = 11;
-                     }
-                     else if (strncmp("ENGINEER*", format_chaine, 9) == 0)
-                     {
-                         format_sortie = 'E';
-                         position_1 = 9;
-                     }
-                     else if (strncmp("CHARACTER*", format_chaine, 10) == 0)
-                     {
-                         format_sortie = 'C';
-                         position_1 = 10;
-                         format_degenere = d_vrai;
                      }
-                     else
+                     else if ((*(*((struct_tableau *) (*s_format).objet))
+                             .elements[i]).type != CHN)
                      {
                          free(chaine);
-                         free(format_chaine);
                          (*s_etat_processus).erreur_execution =
                                  d_ex_erreur_format_fichier;
                          return(NULL);
                      }
+                     else
+                     {
+                         if ((format_chaine = conversion_majuscule(
+                                 s_etat_processus,
+                                 (unsigned char *) (*(*((struct_tableau *)
+                                 (*s_format).objet)).elements[i]).objet))
+                                 == NULL)
+                         {
+                             (*s_etat_processus).erreur_systeme =
+                                     d_es_allocation_memoire;
+                             return(NULL);
+                         }
-                     position_3 = strlen(format_chaine);
+                         format_degenere = d_faux;
-                     format_chaine[--position_3] = d_code_fin_chaine;
-                     position_2 = position_1;
-                     while(format_chaine[position_2] != '(')
+                         if (strncmp("STANDARD*", format_chaine, 9) == 0)
-                     {
+                         {
-                         if (format_chaine[position_2] == d_code_fin_chaine)
+                             format_sortie = 'S';
+                             position_1 = 9;
+                             format_degenere = d_vrai;
+                         }
+                         else if (strncmp("BINARY*", format_chaine, 7) == 0)
+                         {
+                             format_sortie = 'B';
+                             position_1 = 7;
+                         }
+                         else if (strncmp("FIXED*", format_chaine, 6) == 0)
+                         {
+                             format_sortie = 'F';
+                             position_1 = 6;
+                         }
+                         else if (strncmp("SCIENTIFIC*", format_chaine, 11) == 0)
+                         {
+                             format_sortie = 'I';
+                             position_1 = 11;
+                         }
+                         else if (strncmp("ENGINEER*", format_chaine, 9) == 0)
+                         {
+                             format_sortie = 'E';
+                             position_1 = 9;
+                         }
+                         else if (strncmp("CHARACTER*", format_chaine, 10) == 0)
+                         {
+                             format_sortie = 'C';
+                             position_1 = 10;
+                             format_degenere = d_vrai;
+                         }
+                         else if (strcmp("NATIVE*(*)", format_chaine) == 0)
+                         {
+                             format_sortie = 'N';
+                             position_1 = 7;
+                             format_degenere = d_vrai;
+                         }
+                         else
                          {
                              free(chaine);
                              free(format_chaine);
- Line 1850  formateur_fichier(struct_processus *s_et
+ Line 2010  formateur_fichier(struct_processus *s_et
                              return(NULL);
                          }
-                         position_2++;
+                         position_3 = (integer8) strlen(format_chaine);
-                     }
+                         format_chaine[--position_3] = d_code_fin_chaine;
-                     format_chaine[position_2++] = d_code_fin_chaine;
+                         position_2 = position_1;
-                     if (format_degenere == d_faux)
+                         while(format_chaine[position_2] != '(')
-                     {
-                         if (sscanf(&(format_chaine[position_1]), "%ld",
-                                 &longueur) != 1)
                          {
-                             free(chaine);
+                             if (format_chaine[position_2] == d_code_fin_chaine)
-                             free(format_chaine);
+                             {
+                                 free(chaine);
+                                 free(format_chaine);
-                             (*s_etat_processus).erreur_execution =
+                                 (*s_etat_processus).erreur_execution =
-                                     d_ex_erreur_format_fichier;
+                                         d_ex_erreur_format_fichier;
-                             return(NULL);
+                                 return(NULL);
+                             }
+                             position_2++;
                          }
-                     }
-                     else
-                     {
-                         longueur = -1;
-                     }
-                     if (strcmp(&(format_chaine[position_2]), "*") != 0)
+                         format_chaine[position_2++] = d_code_fin_chaine;
-                     {
-                         if (sscanf(&(format_chaine[position_2]), "%ld",
+                         if (format_degenere == d_faux)
-                                 &longueur_champ) != 1)
+                         {
+                             if (sscanf(&(format_chaine[position_1]), "%lld",
+                                     &longueur) != 1)
+                             {
+                                 free(chaine);
+                                 free(format_chaine);
+                                 (*s_etat_processus).erreur_execution =
+                                         d_ex_erreur_format_fichier;
+                                 return(NULL);
+                             }
+                         }
+                         else
+                         {
+                             longueur = -1;
+                         }
+                         if (strcmp(&(format_chaine[position_2]), "*") != 0)
+                         {
+                             if (sscanf(&(format_chaine[position_2]), "%lld",
+                                     &longueur_champ) != 1)
+                             {
+                                 free(chaine);
+                                 free(format_chaine);
+                                 (*s_etat_processus).erreur_execution =
+                                         d_ex_erreur_format_fichier;
+                                 return(NULL);
+                             }
+                         }
+                         else
+                         {
+                             longueur_champ = -1;
+                         }
+                         if ((longueur >= 0) && (longueur_champ >= 0) &&
+                                 (longueur > longueur_champ))
                          {
                              free(chaine);
                              free(format_chaine);
- Line 1885  formateur_fichier(struct_processus *s_et
+ Line 2078  formateur_fichier(struct_processus *s_et
                                      d_ex_erreur_format_fichier;
                              return(NULL);
                          }
-                     }
-                     else
-                     {
-                         longueur_champ = -1;
-                     }
-                     if ((longueur >= 0) && (longueur_champ >= 0) && (longueur >
-                             longueur_champ))
-                     {
-                         free(chaine);
                          free(format_chaine);
+                         chaine_sauvegarde = chaine;
-                         (*s_etat_processus).erreur_execution =
+                         if ((chaine_formatee = formateur_fichier(
-                                 d_ex_erreur_format_fichier;
+                                 s_etat_processus, (*((struct_tableau *)
-                         return(NULL);
+                                 (*s_objet).objet)).elements[i], s_format,
+                                 longueur, longueur_champ, format_sortie, type,
+                                 longueur_effective, recursivite,
+                                 export_fichier)) == NULL)
+                         {
+                             return(NULL);
+                         }
                      }
+                 }
-                     free(format_chaine);
+                 else // NATIVE*(*)
+                 {
                      chaine_sauvegarde = chaine;
-                     if ((chaine_formatee = formateur_fichier(s_etat_processus,
+                     if ((chaine_formatee = formateur_fichier(
-                             (*((struct_tableau *) (*s_objet).objet))
+                             s_etat_processus, (*((struct_tableau *)
-                             .elements[i], s_format,
+                             (*s_objet).objet)).elements[i], s_format,
                              longueur, longueur_champ, format_sortie, type,
-                             longueur_effective, recursivite, export_fichier))
+                             longueur_effective, recursivite,
-                             == NULL)
+                             export_fichier)) == NULL)
                      {
                          return(NULL);
                      }
+                 }
-                     if ((*(*((struct_tableau *) (*s_objet).objet))
+                 if ((*(*((struct_tableau *) (*s_objet).objet))
-                             .elements[i]).type == CHN)
+                         .elements[i]).type == CHN)
-                     {
+                 {
-                         chaine = (unsigned char *)
+                     chaine = (unsigned char *)
-                                 malloc((strlen(chaine_formatee)
+                             malloc((strlen(chaine_formatee)
-                                 + strlen(chaine_sauvegarde) + 4)
+                             + strlen(chaine_sauvegarde) + 4)
-                                 * sizeof(unsigned char));
+                             * sizeof(unsigned char));
-                         if (chaine == NULL)
-                         {
-                             (*s_etat_processus).erreur_systeme =
-                                     d_es_allocation_memoire;
-                             return(NULL);
-                         }
-                         strcpy(chaine, chaine_sauvegarde);
+                     if (chaine == NULL)
-                         free(chaine_sauvegarde);
-                         strcat(chaine, " \"");
-                         strcat(chaine, chaine_formatee);
-                         free(chaine_formatee);
-                         strcat(chaine, "\"");
-                     }
-                     else if ((*(*((struct_tableau *) (*s_objet).objet))
-                             .elements[i]).type == NOM)
                      {
-                         chaine = (unsigned char *)
+                         (*s_etat_processus).erreur_systeme =
-                                 malloc((strlen(chaine_formatee)
+                                 d_es_allocation_memoire;
-                                 + strlen(chaine_sauvegarde) + 2)
+                         return(NULL);
-                                 * sizeof(unsigned char));
+                     }
-                         if (chaine == NULL)
+                     strcpy(chaine, chaine_sauvegarde);
-                         {
+                     free(chaine_sauvegarde);
-                             (*s_etat_processus).erreur_systeme =
+                     strcat(chaine, " \"");
-                                     d_es_allocation_memoire;
+                     strcat(chaine, chaine_formatee);
-                             return(NULL);
+                     free(chaine_formatee);
-                         }
+                     strcat(chaine, "\"");
+                 }
+                 else if ((*(*((struct_tableau *) (*s_objet).objet))
+                         .elements[i]).type == NOM)
+                 {
+                     chaine = (unsigned char *)
+                             malloc((strlen(chaine_formatee)
+                             + strlen(chaine_sauvegarde) + 2)
+                             * sizeof(unsigned char));
-                         sprintf(chaine, "%s %s", chaine_sauvegarde,
+                     if (chaine == NULL)
-                                 chaine_formatee);
-                         free(chaine_formatee);
-                     }
-                     else
                      {
-                         chaine = (unsigned char *)
+                         (*s_etat_processus).erreur_systeme =
-                                 malloc((strlen(chaine_formatee)
+                                 d_es_allocation_memoire;
-                                 + strlen(chaine_sauvegarde) + 2)
+                         return(NULL);
-                                 * sizeof(unsigned char));
+                     }
-                         if (chaine == NULL)
+                     sprintf(chaine, "%s %s", chaine_sauvegarde,
-                         {
+                             chaine_formatee);
-                             (*s_etat_processus).erreur_systeme =
+                     free(chaine_formatee);
-                                     d_es_allocation_memoire;
+                 }
-                             return(NULL);
+                 else
-                         }
+                 {
+                     chaine = (unsigned char *)
+                             malloc((strlen(chaine_formatee)
+                             + strlen(chaine_sauvegarde) + 2)
+                             * sizeof(unsigned char));
-                         strcpy(chaine, chaine_sauvegarde);
+                     if (chaine == NULL)
-                         free(chaine_sauvegarde);
+                     {
-                         strcat(chaine, " ");
+                         (*s_etat_processus).erreur_systeme =
-                         strcat(chaine, chaine_formatee);
+                                 d_es_allocation_memoire;
-                         free(chaine_formatee);
+                         return(NULL);
                      }
+                     strcpy(chaine, chaine_sauvegarde);
+                     free(chaine_sauvegarde);
+                     strcat(chaine, " ");
+                     strcat(chaine, chaine_formatee);
+                     free(chaine_formatee);
                  }
              }
- Line 2003  formateur_fichier(struct_processus *s_et
+ Line 2195  formateur_fichier(struct_processus *s_et
  --------------------------------------------------------------------------------
  */
+             if (format_sortie == 'N')
+             {
+                 format_sortie = 'S';
+             }
              if ((format_sortie != 'S') && (format_sortie != 'F') &&
                      (format_sortie != 'I') && (format_sortie != 'E'))
              {
- Line 2146  formateur_fichier(struct_processus *s_et
+ Line 2343  formateur_fichier(struct_processus *s_et
  --------------------------------------------------------------------------------
  */
+             if (format_sortie == 'N')
+             {
+                 format_sortie = 'S';
+             }
              if ((format_sortie != 'S') && (format_sortie != 'F') &&
                      (format_sortie != 'I') && (format_sortie != 'E'))
              {
- Line 2288  formateur_fichier(struct_processus *s_et
+ Line 2490  formateur_fichier(struct_processus *s_et
  --------------------------------------------------------------------------------
  */
+             if (format_sortie == 'N')
+             {
+                 format_sortie = 'S';
+             }
              if ((format_sortie != 'S') && (format_sortie != 'F') &&
                      (format_sortie != 'I') && (format_sortie != 'E'))
              {
- Line 2430  formateur_fichier(struct_processus *s_et
+ Line 2637  formateur_fichier(struct_processus *s_et
  --------------------------------------------------------------------------------
  */
+             if (format_sortie != 'N')
+             {
+                 (*s_etat_processus).erreur_execution =
+                         d_ex_erreur_format_fichier;
+                 return(NULL);
+             }
              chaine = (unsigned char *) malloc((strlen((*((struct_nom *)
                      (*s_objet).objet)).nom) + 3) * sizeof(unsigned char));
- Line 2450  formateur_fichier(struct_processus *s_et
+ Line 2664  formateur_fichier(struct_processus *s_et
  --------------------------------------------------------------------------------
  */
+             if (format_sortie == 'N')
+             {
+                 format_sortie = 'S';
+             }
              if ((format_sortie != 'S') && (format_sortie != 'F') &&
                      (format_sortie != 'I') && (format_sortie != 'E'))
              {
- Line 2487  formateur_fichier(struct_processus *s_et
+ Line 2706  formateur_fichier(struct_processus *s_et
  --------------------------------------------------------------------------------
  */
+             if (format_sortie == 'N')
+             {
+                 format_sortie = 'S';
+             }
              if ((format_sortie != 'S') && (format_sortie != 'F') &&
                      (format_sortie != 'I') && (format_sortie != 'E'))
              {
- Line 2563  formateur_fichier(struct_processus *s_et
+ Line 2787  formateur_fichier(struct_processus *s_et
  --------------------------------------------------------------------------------
  */
+             if (format_sortie == 'N')
+             {
+                 format_sortie = 'S';
+             }
              if ((format_sortie != 'S') && (format_sortie != 'F') &&
                      (format_sortie != 'I') && (format_sortie != 'E'))
              {
- Line 2638  formateur_fichier(struct_processus *s_et
+ Line 2867  formateur_fichier(struct_processus *s_et
  --------------------------------------------------------------------------------
  */
+             if (format_sortie == 'N')
+             {
+                 format_sortie = 'S';
+             }
              if ((format_sortie != 'S') && (format_sortie != 'F') &&
                      (format_sortie != 'I') && (format_sortie != 'E'))
              {
- Line 2714  formateur_fichier(struct_processus *s_et
+ Line 2948  formateur_fichier(struct_processus *s_et
              return(NULL);
          }
-         (*longueur_effective) = strlen(chaine) + 1;
+         (*longueur_effective) = ((integer8) strlen(chaine)) + 1;
      }
      else
      {
- Line 2744  formateur_fichier(struct_processus *s_et
+ Line 2978  formateur_fichier(struct_processus *s_et
           *
           * XXXXXXX0                             longueur sur 7 bits
           * XXXX0011 XXXXXXXX XXXX0011           longueur sur 16 bits
-          * MSB(1/2) LSB      MSB(2/2)
+          * LSB(1/2) MSB      LSB(2/2)
           * XXXX0101 XXXXXXXX XXXXXXXX XXXX0101  longueur sur 24 bits
           * XXXX0111 XXXXXXXX XXXXXXXX XXXXXXXX
           *          XXXX0111                    longueur sur 32 bits
- Line 2872  formateur_fichier(struct_processus *s_et
+ Line 3106  formateur_fichier(struct_processus *s_et
           * 1101 10 11               matrice complex*16 (dimensions integer*4)
           * 1101 11 11               matrice complex*16 (dimensions integer*8)
           *
+          * 1110 0 XXX               fonction de longueur XXX
+          * 1110 10 LL               fonction de longueur integer*LL
+          *
+          * 1111 XXXXX               page 2
+          * 1111 XXXXX 000000001     entier long
+          * 1111 XXXXX 000000010     réel long
+          * 1111 XXXXX 000000011     complexe long
+          *
           * Les longueurs indiquées par le champ LL suivent l'en-tête :
           *      00 : integer*1
           *      01 : integer*2
- Line 2888  formateur_fichier(struct_processus *s_et
+ Line 3130  formateur_fichier(struct_processus *s_et
          chaine_formatee = NULL;
          chaine_sauvegarde = NULL;
-         if ((*s_objet).type == ALG)
+         if ((*s_objet).type == BIN)
          {
  /*
  --------------------------------------------------------------------------------
-   Expression algébrique
+   Entier binaire en base 2, 8, 10 ou 16
+   Poids fort 0000
  --------------------------------------------------------------------------------
  */
-         }
+             if (format_sortie == 'N')
-         else if ((*s_objet).type == BIN)
+             {
-         {
+                 format_sortie = 'L';
+                 longueur_champ = 8;
+             }
- /*
+             if (format_sortie != 'L')
- --------------------------------------------------------------------------------
+             {
-   Entier binaire en base 2, 8, 10 ou 16
+                 (*s_etat_processus).erreur_execution =
- --------------------------------------------------------------------------------
+                         d_ex_erreur_format_fichier;
- */
+                 return(NULL);
+             }
+             if (longueur_champ < 8)
+             {
+                 if ((*((logical8 *) (*s_objet).objet)) >=
+                         ((logical8) 1 << (8 * longueur_champ)))
+                 {
+                     (*s_etat_processus).erreur_execution =
+                             d_ex_representation;
+                     return(NULL);
+                 }
+             }
+             (*longueur_effective) = longueur_champ + 1;
+             if ((chaine = malloc(((size_t) (*longueur_effective))
+                     * sizeof(unsigned char))) == NULL)
+             {
+                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+                 return(NULL);
+             }
+             chaine[0] = (unsigned char) longueur_champ;
+             for(i = 1; i <= (*longueur_effective); i++)
+             {
+                 chaine[i] = ((*((logical8 *) (*s_objet).objet)) >>
+                         (8 * (longueur_champ - i))) & 0xFF;
+             }
          }
          else if ((*s_objet).type == CHN)
          {
- Line 2919  formateur_fichier(struct_processus *s_et
+ Line 3192  formateur_fichier(struct_processus *s_et
  --------------------------------------------------------------------------------
  */
+             if (format_sortie == 'N')
+             {
+                 format_sortie = 'S';
+                 longueur_champ = -1;
+             }
+             if (format_sortie != 'S')
+             {
+                 (*s_etat_processus).erreur_execution =
+                         d_ex_erreur_format_fichier;
+                 return(NULL);
+             }
              longueur_reelle_chaine = longueur_chaine(s_etat_processus,
                      (unsigned char *) (*s_objet).objet);
- Line 2945  formateur_fichier(struct_processus *s_et
+ Line 3231  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 2962  formateur_fichier(struct_processus *s_et
+ Line 3248  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 2970  formateur_fichier(struct_processus *s_et
+ Line 3256  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 2985  formateur_fichier(struct_processus *s_et
+ Line 3273  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 3001  formateur_fichier(struct_processus *s_et
+ Line 3290  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 3019  formateur_fichier(struct_processus *s_et
+ Line 3309  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 3028  formateur_fichier(struct_processus *s_et
+ Line 3318  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 3041  formateur_fichier(struct_processus *s_et
+ Line 3332  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 3058  formateur_fichier(struct_processus *s_et
+ Line 3349  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 3074  formateur_fichier(struct_processus *s_et
+ Line 3366  formateur_fichier(struct_processus *s_et
  --------------------------------------------------------------------------------
  */
+             if (format_sortie == 'N')
+             {
+                 format_sortie = 'C';
+                 longueur = 8;
+             }
              if (format_sortie != 'C')
              {
                  (*s_etat_processus).erreur_execution =
- Line 3088  formateur_fichier(struct_processus *s_et
+ Line 3386  formateur_fichier(struct_processus *s_et
                  return(NULL);
              }
          }
-         else if ((*s_objet).type == RPN)
-         {
- /*
- --------------------------------------------------------------------------------
-   Définition
- --------------------------------------------------------------------------------
- */
-         }
          else if ((*s_objet).type == INT)
          {
- Line 3107  formateur_fichier(struct_processus *s_et
+ Line 3396  formateur_fichier(struct_processus *s_et
  --------------------------------------------------------------------------------
  */
+             if (format_sortie == 'N')
+             {
+                 format_sortie = 'I';
+                 longueur = 8;
+             }
              if ((format_sortie != 'I') && (format_sortie != 'R')
                      && (format_sortie != 'C'))
              {
- Line 3128  formateur_fichier(struct_processus *s_et
+ Line 3423  formateur_fichier(struct_processus *s_et
  /*
  --------------------------------------------------------------------------------
    Fonction
+   Poids fort 1110
  --------------------------------------------------------------------------------
  */
+             if (format_sortie != 'N')
+             {
+                 (*s_etat_processus).erreur_execution =
+                         d_ex_erreur_format_fichier;
+                 return(NULL);
+             }
+             longueur_fonction = (integer8) strlen((*((struct_fonction *)
+                     (*s_objet).objet)).nom_fonction);
+             if (longueur_fonction < (1LL << 3))
+             {
+                 if ((chaine = malloc((1 + ((size_t) longueur_fonction) + 8)
+                         * sizeof(unsigned char)))== NULL)
+                 {
+                     (*s_etat_processus).erreur_systeme =
+                             d_es_allocation_memoire;
+                     return(NULL);
+                 }
+                 chaine[0] = (unsigned char) (0xE0 | (longueur_fonction & 0x7));
+                 strcpy(chaine + 1, (*((struct_fonction *) (*s_objet).objet))
+                         .nom_fonction);
+                 (*longueur_effective) = 1 + longueur_fonction + 8;
+             }
+             else if (longueur_fonction < (1LL << 8))
+             {
+                 if ((chaine = malloc((2 + ((size_t) longueur_fonction) + 8)
+                         * sizeof(unsigned char)))== NULL)
+                 {
+                     (*s_etat_processus).erreur_systeme =
+                             d_es_allocation_memoire;
+                     return(NULL);
+                 }
+                 chaine[0] = (unsigned char) (0xE0 | 0x08);
+                 chaine[1] = (unsigned char) (longueur_fonction & 0xFF);
+                 strcpy(chaine + 2, (*((struct_fonction *) (*s_objet).objet))
+                         .nom_fonction);
+                 (*longueur_effective) = 2 + longueur_fonction + 8;
+             }
+             else if (longueur_fonction < (1LL << 16))
+             {
+                 if ((chaine = malloc((3 + ((size_t) longueur_fonction) + 8)
+                         * sizeof(unsigned char)))== NULL)
+                 {
+                     (*s_etat_processus).erreur_systeme =
+                             d_es_allocation_memoire;
+                     return(NULL);
+                 }
+                 chaine[0] = (unsigned char ) (0xE0 | 0x09);
+                 chaine[1] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
+                 chaine[2] = (unsigned char) (longueur_fonction & 0xFF);
+                 strcpy(chaine + 3, (*((struct_fonction *) (*s_objet).objet))
+                         .nom_fonction);
+                 (*longueur_effective) = 3 + longueur_fonction + 9;
+             }
+             else if (longueur_fonction < (1LL << 32))
+             {
+                 if ((chaine = malloc((5 + ((size_t) longueur_fonction) + 8)
+                         * sizeof(unsigned char)))== NULL)
+                 {
+                     (*s_etat_processus).erreur_systeme =
+                             d_es_allocation_memoire;
+                     return(NULL);
+                 }
+                 chaine[0] = (unsigned char) (0xE0 | 0x0A);
+                 chaine[1] = (unsigned char) ((longueur_fonction >> 24) & 0xFF);
+                 chaine[2] = (unsigned char) ((longueur_fonction >> 16) & 0xFF);
+                 chaine[3] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
+                 chaine[4] = (unsigned char) (longueur_fonction & 0xFF);
+                 strcpy(chaine + 5, (*((struct_fonction *) (*s_objet).objet))
+                         .nom_fonction);
+                 (*longueur_effective) = 5 + longueur_fonction + 8;
+             }
+             else
+             {
+                 if ((chaine = malloc((9 + ((size_t) longueur_fonction) + 8)
+                         * sizeof(unsigned char)))== NULL)
+                 {
+                     (*s_etat_processus).erreur_systeme =
+                             d_es_allocation_memoire;
+                     return(NULL);
+                 }
+                 chaine[0] = (unsigned char) (0xE0 | 0x0B);
+                 chaine[1] = (unsigned char) ((longueur_fonction >> 56) & 0xFF);
+                 chaine[2] = (unsigned char) ((longueur_fonction >> 48) & 0xFF);
+                 chaine[3] = (unsigned char) ((longueur_fonction >> 40) & 0xFF);
+                 chaine[4] = (unsigned char) ((longueur_fonction >> 32) & 0xFF);
+                 chaine[5] = (unsigned char) ((longueur_fonction >> 24) & 0xFF);
+                 chaine[6] = (unsigned char) ((longueur_fonction >> 16) & 0xFF);
+                 chaine[7] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
+                 chaine[8] = (unsigned char) (longueur_fonction & 0xFF);
+                 strcpy(chaine + 9, (*((struct_fonction *) (*s_objet).objet))
+                         .nom_fonction);
+                 (*longueur_effective) = 9 + longueur_fonction + 8;
+             }
+             for(i = 1; i <= 8; i++)
+             {
+                 chaine[(*longueur_effective) - i] = (unsigned char)
+                         (((*((struct_fonction *) (*s_objet).objet))
+                         .nombre_arguments >> ((8 - i) * 8)) & 0xFF);
+             }
          }
-         else if ((*s_objet).type == LST)
+         else if (((*s_objet).type == LST) || ((*s_objet).type == ALG)
+                 || ((*s_objet).type == RPN))
          {
  /*
  --------------------------------------------------------------------------------
    Liste
    Poids fort 0100
+   Expression algébrique
+   Poids fort 0111
+   Définition
+   Poids fort 0110
  --------------------------------------------------------------------------------
  */
- Line 3150  formateur_fichier(struct_processus *s_et
+ Line 3565  formateur_fichier(struct_processus *s_et
                  return(NULL);
              }
+             if ((*s_objet).type == LST)
+             {
+                 type_binaire = 0x40;
+             }
+             else if ((*s_objet).type == RPN)
+             {
+                 type_binaire = 0x60;
+             }
+             else // ALG
+             {
+                 type_binaire = 0x70;
+             }
              // Calcul de la longueur de la liste.
              longueur_liste = 0;
- Line 3163  formateur_fichier(struct_processus *s_et
+ Line 3591  formateur_fichier(struct_processus *s_et
              if (longueur_liste < (1LL << 3))
              {
-                 chaine[0] = 0x40 | (longueur_liste & 0x7);
+                 chaine[0] = (unsigned char) (type_binaire |
+                         (longueur_liste & 0x7));
              }
              else if (longueur_liste < (1LL << 8))
              {
-                 chaine[0] = 0x48;
+                 chaine[0] = (unsigned char) (type_binaire | 0x08);
              }
              else if (longueur_liste < (1LL << 16))
              {
-                 chaine[0] = 0x49;
+                 chaine[0] = (unsigned char ) (type_binaire | 0x09);
              }
              else if (longueur_liste < (1LL << 32))
              {
-                 chaine[0] = 0x4A;
+                 chaine[0] = (unsigned char) (type_binaire | 0x0A);
              }
              else
              {
-                 chaine[0] = 0x4B;
+                 chaine[0] = (unsigned char) (type_binaire | 0x0B);
              }
              longueur_totale = 1;
- Line 3192  formateur_fichier(struct_processus *s_et
+ Line 3621  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 3209  formateur_fichier(struct_processus *s_et
+ Line 3639  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 3228  formateur_fichier(struct_processus *s_et
+ Line 3659  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 3251  formateur_fichier(struct_processus *s_et
+ Line 3683  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 3298  formateur_fichier(struct_processus *s_et
+ Line 3731  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 3317  formateur_fichier(struct_processus *s_et
+ Line 3768  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 3331  formateur_fichier(struct_processus *s_et
+ Line 3782  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 3366  formateur_fichier(struct_processus *s_et
+ Line 3820  formateur_fichier(struct_processus *s_et
                          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);
- Line 3388  formateur_fichier(struct_processus *s_et
+ Line 3848  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 3408  formateur_fichier(struct_processus *s_et
+ Line 3868  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 3429  formateur_fichier(struct_processus *s_et
+ Line 3949  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 3457  formateur_fichier(struct_processus *s_et
+ Line 3977  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 3468  formateur_fichier(struct_processus *s_et
+ Line 4272  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 3477  formateur_fichier(struct_processus *s_et
+ Line 4463  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 3486  formateur_fichier(struct_processus *s_et
+ Line 4719  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 3493  formateur_fichier(struct_processus *s_et
+ Line 4937  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 3506  formateur_fichier(struct_processus *s_et
+ Line 5054  formateur_fichier(struct_processus *s_et
  --------------------------------------------------------------------------------
  */
+             if (format_sortie == 'N')
+             {
+                 format_sortie = 'R';
+                 longueur = 8;
+             }
              if ((format_sortie != 'R') && (format_sortie != 'C'))
              {
                  (*s_etat_processus).erreur_execution =
- Line 3528  formateur_fichier(struct_processus *s_et
+ Line 5082  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 3537  formateur_fichier(struct_processus *s_et
+ Line 5213  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 3546  formateur_fichier(struct_processus *s_et
+ Line 5408  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 3568  formateur_fichier(struct_processus *s_et
+ Line 5567  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 3582  formateur_fichier(struct_processus *s_et
+ Line 5582  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))
                      {
-                         // MSB (4 bits de poids fort)
+                         // LSB (4 bits de poids fort)
-                         tampon[0] = ((longueur_totale >> 8) & 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] = (longueur_totale >> (j + 1))
+                             tampon[(i - j) + 1] = (unsigned char)
-                                     & 0xFF;
+                                     ((longueur_totale >> (8 * (j + 1)))
+                                     & 0xFF);
                          }
-                         // MSB (4 bits de poids faible)
+                         // LSB (4 bits de poids faible)
-                         tampon[i + 2] = (((longueur_totale >> 8) & 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 3621  formateur_fichier(struct_processus *s_et
+ Line 5647  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 3659  formateur_fichier(struct_processus *s_et
+ Line 5682  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 3799  formateur_fichier_nombre(struct_processu
+ Line 5822  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 3817  formateur_fichier_reel(struct_processus
+ Line 5841  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 3844  formateur_fichier_reel(struct_processus
+ Line 5866  formateur_fichier_reel(struct_processus
              exposant = 0;
          }
-         mantisse = (*((real8 *) valeur_numerique)) / pow(10, exposant);
+         mantisse = (*((real8 *) valeur_numerique)) / pow(10, (double) exposant);
      }
      else
      {
- Line 3852  formateur_fichier_reel(struct_processus
+ Line 5874  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 3927  formateur_fichier_reel(struct_processus
+ Line 5950  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 3950  formateur_fichier_reel(struct_processus
+ Line 5973  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 3980  formateur_fichier_reel(struct_processus
+ Line 6003  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 3989  formateur_fichier_reel(struct_processus
+ Line 6012  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 4004  formateur_fichier_reel(struct_processus
+ Line 6027  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 4026  formateur_fichier_reel(struct_processus
+ Line 6049  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 4060  formateur_fichier_binaire_nombre(struct_
+ Line 6083  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 4083  formateur_fichier_binaire_nombre(struct_
+ Line 6107  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;
                  }
                  case 4:
                  {
                      if ((*((integer8 *) valeur_numerique)) !=
-                             ((integer2) (*((integer8 *) valeur_numerique))))
+                             ((integer4) (*((integer8 *) valeur_numerique))))
                      {
                          (*s_etat_processus).erreur_execution =
                                  d_ex_representation;
- Line 4108  formateur_fichier_binaire_nombre(struct_
+ Line 6133  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 4129  formateur_fichier_binaire_nombre(struct_
+ Line 6155  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 4181  formateur_fichier_binaire_nombre(struct_
+ Line 6208  formateur_fichier_binaire_nombre(struct_
                      }
                      else if (type_entree == 'I')
                      {
-                         valeur = (*((integer8 *) valeur_numerique));
+                         valeur = (real8) (*((integer8 *) valeur_numerique));
                      }
                      else
                      {
- Line 4195  formateur_fichier_binaire_nombre(struct_
+ Line 6222  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 4218  formateur_fichier_binaire_nombre(struct_
+ Line 6250  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 4243  formateur_fichier_binaire_nombre(struct_
+ Line 6275  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 4257  formateur_fichier_binaire_nombre(struct_
+ Line 6289  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 4289  formateur_fichier_binaire_nombre(struct_
+ Line 6321  formateur_fichier_binaire_nombre(struct_
                      unsigned char       *partie_reelle;
                      unsigned char       *partie_imaginaire;
-                     long                limag;
+                     integer8            limag;
-                     long                lreel;
+                     integer8            lreel;
                      real8               zero;
- Line 4363  formateur_fichier_binaire_nombre(struct_
+ Line 6395  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 4374  formateur_fichier_binaire_nombre(struct_
+ Line 6406  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 4389  formateur_fichier_binaire_nombre(struct_
+ Line 6423  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 4462  formateur_fichier_binaire_nombre(struct_
+ Line 6497  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 4473  formateur_fichier_binaire_nombre(struct_
+ Line 6508  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 4525  lecture_fichier_non_formate(struct_proce
+ Line 6562  lecture_fichier_non_formate(struct_proce
  {
      file                        *fichier;
+     int                         j;
      integer8                    i;
      integer8                    longueur;
- Line 4535  lecture_fichier_non_formate(struct_proce
+ Line 6574  lecture_fichier_non_formate(struct_proce
      unsigned char               octets[8];
      unsigned char               *buffer;
+     unsigned char               *flux;
      unsigned char               *ptr;
+     unsigned char               type_objet;
      size_t                      deplacement;
- Line 4547  lecture_fichier_non_formate(struct_proce
+ Line 6588  lecture_fichier_non_formate(struct_proce
      }
      else
      {
-         buffer = argument;
+         buffer = (*((unsigned char **) argument));
          ptr = buffer;
          fichier = NULL;
      }
      if (longueur_buffer < 0)
      {
          if (fread(octets, (size_t) sizeof(unsigned char),
 , fichier) != 1)
          {
-             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
+             if (feof(fichier))
+             {
+                 (*s_etat_processus).erreur_execution = d_ex_syntaxe;
+             }
+             else
+             {
+                 (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
+             }
              return(NULL);
          }
      }
      else
      {
-         octets[0] = *ptr++;
+         if ((longueur_buffer - (ptr - buffer)) >= 1)
+         {
+             octets[0] = *ptr++;
+         }
+         else
+         {
+             (*s_etat_processus).erreur_execution = d_ex_syntaxe;
+             return(NULL);
+         }
      }
-     switch(octets[0] & 0xF0)
+     switch(type_objet = (octets[0] & 0xF0))
      {
-         case 0x10:  // Scalaire
+         case 0x00:  // Binaire
          {
-             switch(octets[0] & 0x0C)
+             switch(octets[0] & 0x0F)
              {
-                 case 0x00:  // Entier
+                 case 0x01:  // logical*1
                  {
-                     if ((s_objet = allocation(s_etat_processus, INT)) == NULL)
+                     deplacement = 1;
+                     break;
+                 }
+                 case 0x02:  // logical*2
+                 {
+                     deplacement = 2;
+                     break;
+                 }
+                 case 0x04:  // logical*4
+                 {
+                     deplacement = 4;
+                     break;
+                 }
+                 case 0x08:  // logical*8
+                 {
+                     deplacement = 8;
+                     break;
+                 }
+                 default:
+                 {
+                     (*s_etat_processus).erreur_execution =
+                             d_ex_syntaxe;
+                     return(NULL);
+                 }
+             }
+             if (longueur_buffer < 0)
+             {
+                 if (fread(octets, (size_t) sizeof(unsigned char),
+                         deplacement, fichier) != deplacement)
+                 {
+                     if (feof(fichier))
                      {
-                         return(NULL);
+                         (*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)) >=
+                         (ssize_t) deplacement)
+                 {
+                     for(i = 0; i < (signed) deplacement; i++)
+                     {
+                         octets[i] = *ptr++;
+                     }
+                 }
+                 else
+                 {
+                     (*s_etat_processus).erreur_execution = d_ex_syntaxe;
+                     return(NULL);
+                 }
+             }
+             if ((s_objet = allocation(s_etat_processus, BIN)) == NULL)
+             {
+                 return(NULL);
+             }
+             (*((logical8 *) (*s_objet).objet)) = 0;
+             for(i = 0; i < (signed) deplacement; i++)
+             {
+                 (*((logical8 *) (*s_objet).objet)) |= ((logical8) octets[i])
+                         << (8 * ((((signed) deplacement) - 1) - i));
+             }
+             break;
+         }
+         case 0x10:  // Scalaire
+         {
+             switch(octets[0] & 0x0C)
+             {
+                 case 0x00:  // Entier
+                 {
                      switch(octets[0] & 0x03)
                      {
                          case 0x00:  // integer*1
- Line 4612  lecture_fichier_non_formate(struct_proce
+ Line 6751  lecture_fichier_non_formate(struct_proce
                          if (fread(octets, (size_t) sizeof(unsigned char),
                                  deplacement, fichier) != deplacement)
                          {
-                             (*s_etat_processus).erreur_systeme =
+                             if (feof(fichier))
-                                     d_es_erreur_fichier;
+                             {
+                                 (*s_etat_processus).erreur_execution =
+                                         d_ex_syntaxe;
+                             }
+                             else
+                             {
+                                 (*s_etat_processus).erreur_systeme =
+                                         d_es_erreur_fichier;
+                             }
                              return(NULL);
                          }
                      }
                      else
                      {
-                         for(i = 0; i < (signed) deplacement; i++)
+                         if ((longueur_buffer - (ptr - buffer)) >=
+                                 (ssize_t) deplacement)
+                         {
+                             for(i = 0; i < (signed) deplacement; i++)
+                             {
+                                 octets[i] = *ptr++;
+                             }
+                         }
+                         else
                          {
-                             octets[i] = *ptr++;
+                             (*s_etat_processus).erreur_execution = d_ex_syntaxe;
+                             return(NULL);
                          }
                      }
-                     (*((integer8 *) (*s_objet).objet)) = 0;
+                     if ((s_objet = allocation(s_etat_processus, INT)) == NULL)
+                     {
+                         return(NULL);
+                     }
+                     // Récupération des données avec extension de signe.
-                     for(i = 0; i < (signed) deplacement; i++)
                      {
-                         (*((integer8 *) (*s_objet).objet)) |=
+                         integer1        i1;
-                                 octets[i] << (8 * ((deplacement - 1) - i));
+                         integer2        i2;
+                         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 4638  lecture_fichier_non_formate(struct_proce
+ Line 6857  lecture_fichier_non_formate(struct_proce
                  case 0x04:  // Réel
                  {
-                     if ((s_objet = allocation(s_etat_processus, REL)) == NULL)
-                     {
-                         return(NULL);
-                     }
                      switch(octets[0] & 0x03)
                      {
                          case 0x00:  // real*4
- Line 4670  lecture_fichier_non_formate(struct_proce
+ Line 6884  lecture_fichier_non_formate(struct_proce
                          if (fread(octets, (size_t) sizeof(unsigned char),
                                  deplacement, fichier) != deplacement)
                          {
-                             (*s_etat_processus).erreur_systeme =
+                             if (feof(fichier))
-                                     d_es_erreur_fichier;
+                             {
+                                 (*s_etat_processus).erreur_execution =
+                                         d_ex_syntaxe;
+                             }
+                             else
+                             {
+                                 (*s_etat_processus).erreur_systeme =
+                                         d_es_erreur_fichier;
+                             }
                              return(NULL);
                          }
                      }
                      else
                      {
-                         for(i = 0; i < (signed) deplacement; i++)
+                         if ((longueur_buffer - (ptr - buffer)) >=
+                                 (ssize_t) deplacement)
                          {
-                             octets[i] = *ptr++;
+                             for(i = 0; i < (signed) deplacement; i++)
+                             {
+                                 octets[i] = *ptr++;
+                             }
                          }
+                         else
+                         {
+                             (*s_etat_processus).erreur_execution =
+                                     d_ex_syntaxe;
+                             return(NULL);
+                         }
+                     }
+                     if ((s_objet = allocation(s_etat_processus, REL)) == NULL)
+                     {
+                         return(NULL);
                      }
                      if (deplacement == 4)
- Line 4696  lecture_fichier_non_formate(struct_proce
+ Line 6934  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 4714  lecture_fichier_non_formate(struct_proce
+ Line 6952  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 4725  lecture_fichier_non_formate(struct_proce
+ Line 6963  lecture_fichier_non_formate(struct_proce
                  case 0x08:  // Complexe
                  {
+                     switch(octets[0] & 0x03)
+                     {
+                         case 0x00:  // complex*8
+                         {
+                             deplacement = 4;
+                             break;
+                         }
+                         case 0x01:  // complex*16
+                         {
+                             deplacement = 8;
+                             break;
+                         }
+                         default:
+                         {
+                             (*s_etat_processus).erreur_execution =
+                                     d_ex_syntaxe;
+                             return(NULL);
+                         }
+                     }
                      if ((s_objet = allocation(s_etat_processus, CPL)) == NULL)
                      {
                          return(NULL);
                      }
+                     for(j = 0; j < 2; j++)
+                     {
+                         if (longueur_buffer < 0)
+                         {
+                             if (fread(octets, (size_t) sizeof(unsigned char),
+                                     deplacement, fichier) != deplacement)
+                             {
+                                 liberation(s_etat_processus, s_objet);
+                                 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)) >=
+                                     (ssize_t) deplacement)
+                             {
+                                 for(i = 0; i < (signed) deplacement; i++)
+                                 {
+                                     octets[i] = *ptr++;
+                                 }
+                             }
+                             else
+                             {
+                                 liberation(s_etat_processus, s_objet);
+                                 (*s_etat_processus).erreur_execution =
+                                         d_ex_syntaxe;
+                                 return(NULL);
+                             }
+                         }
+                         if (deplacement == 4)
+                         {
+                             union
+                             {
+                                 real4       r4;
+                                 integer4    i4;
+                             } eq4;
+                             eq4.i4 = 0;
+                             for(i = 0; i < (signed) deplacement; i++)
+                             {
+                                 eq4.i4 |= ((integer4) octets[i]) <<
+                                         (8 * ((((signed) deplacement) - 1)
+                                         - i));
+                             }
+                             if (j == 0)
+                             {
+                                 (*((complex16 *) (*s_objet).objet))
+                                         .partie_reelle = (real8) eq4.r4;
+                             }
+                             else
+                             {
+                                 (*((complex16 *) (*s_objet).objet))
+                                         .partie_imaginaire = (real8) eq4.r4;
+                             }
+                         }
+                         else
+                         {
+                             union
+                             {
+                                 real8       r8;
+                                 integer8    i8;
+                             } eq8;
+                             eq8.i8 = 0;
+                             for(i = 0; i < (signed) deplacement; i++)
+                             {
+                                 eq8.i8 |= ((integer8) octets[i]) <<
+                                         (8 * ((((signed) deplacement) - 1)
+                                         - i));
+                             }
+                             if (j == 0)
+                             {
+                                 (*((complex16 *) (*s_objet).objet))
+                                         .partie_reelle = (real8) eq8.r8;
+                             }
+                             else
+                             {
+                                 (*((complex16 *) (*s_objet).objet))
+                                         .partie_imaginaire = (real8) eq8.r8;
+                             }
+                         }
+                     }
                      break;
                  }
- Line 4744  lecture_fichier_non_formate(struct_proce
+ Line 7104  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 4760  lecture_fichier_non_formate(struct_proce
+ Line 7122  lecture_fichier_non_formate(struct_proce
                              if (fread(octets, (size_t) sizeof(unsigned char),
 , fichier) != 1)
                              {
-                                 (*s_etat_processus).erreur_systeme =
+                                 if (feof(fichier))
-                                         d_es_erreur_fichier;
+                                 {
+                                     (*s_etat_processus).erreur_execution =
+                                             d_ex_syntaxe;
+                                 }
+                                 else
+                                 {
+                                     (*s_etat_processus).erreur_systeme =
+                                             d_es_erreur_fichier;
+                                 }
                                  return(NULL);
                              }
                          }
                          else
                          {
-                             octets[0] = *ptr++;
+                             if ((longueur_buffer - (ptr - buffer)) >= 1)
+                             {
+                                 octets[0] = *ptr++;
+                             }
+                             else
+                             {
+                                 (*s_etat_processus).erreur_execution =
+                                         d_ex_syntaxe;
+                                 return(NULL);
+                             }
                          }
                          longueur = octets[0];
- Line 4781  lecture_fichier_non_formate(struct_proce
+ Line 7161  lecture_fichier_non_formate(struct_proce
                              if (fread(octets, (size_t) sizeof(unsigned char),
 , fichier) != 2)
                              {
-                                 (*s_etat_processus).erreur_systeme =
+                                 if (feof(fichier))
-                                         d_es_erreur_fichier;
+                                 {
+                                     (*s_etat_processus).erreur_execution =
+                                             d_ex_syntaxe;
+                                 }
+                                 else
+                                 {
+                                     (*s_etat_processus).erreur_systeme =
+                                             d_es_erreur_fichier;
+                                 }
                                  return(NULL);
                              }
                          }
                          else
                          {
-                             octets[0] = *ptr++;
+                             if ((longueur_buffer - (ptr - buffer)) >= 2)
-                             octets[1] = *ptr++;
+                             {
+                                 for(j = 0; j < 2; octets[j++] = *ptr++);
+                             }
+                             else
+                             {
+                                 (*s_etat_processus).erreur_execution =
+                                         d_ex_syntaxe;
+                                 return(NULL);
+                             }
                          }
                          longueur = (((integer8) (octets[0])) << 8)
- Line 4804  lecture_fichier_non_formate(struct_proce
+ Line 7201  lecture_fichier_non_formate(struct_proce
                              if (fread(octets, (size_t) sizeof(unsigned char),
 , fichier) != 4)
                              {
-                                 (*s_etat_processus).erreur_systeme =
+                                 if (feof(fichier))
-                                         d_es_erreur_fichier;
+                                 {
+                                     (*s_etat_processus).erreur_execution =
+                                             d_ex_syntaxe;
+                                 }
+                                 else
+                                 {
+                                     (*s_etat_processus).erreur_systeme =
+                                             d_es_erreur_fichier;
+                                 }
                                  return(NULL);
                              }
                          }
                          else
                          {
-                             octets[0] = *ptr++;
+                             if ((longueur_buffer - (ptr - buffer)) >= 4)
-                             octets[1] = *ptr++;
+                             {
-                             octets[2] = *ptr++;
+                                 for(j = 0; j < 4; octets[j++] = *ptr++);
-                             octets[3] = *ptr++;
+                             }
+                             else
+                             {
+                                 (*s_etat_processus).erreur_execution =
+                                         d_ex_syntaxe;
+                                 return(NULL);
+                             }
                          }
                          longueur = (((integer8) (octets[0])) << 24)
- Line 4831  lecture_fichier_non_formate(struct_proce
+ Line 7243  lecture_fichier_non_formate(struct_proce
                              if (fread(octets, (size_t) sizeof(unsigned char),
 , fichier) != 8)
                              {
-                                 (*s_etat_processus).erreur_systeme =
+                                 if (feof(fichier))
-                                         d_es_erreur_fichier;
+                                 {
+                                     (*s_etat_processus).erreur_execution =
+                                             d_ex_syntaxe;
+                                 }
+                                 else
+                                 {
+                                     (*s_etat_processus).erreur_systeme =
+                                             d_es_erreur_fichier;
+                                 }
                                  return(NULL);
                              }
                          }
                          else
                          {
-                             octets[0] = *ptr++;
+                             if ((longueur_buffer - (ptr - buffer)) >= 8)
-                             octets[1] = *ptr++;
+                             {
-                             octets[2] = *ptr++;
+                                 for(j = 0; j < 8; octets[j++] = *ptr++);
-                             octets[3] = *ptr++;
+                             }
-                             octets[4] = *ptr++;
+                             else
-                             octets[5] = *ptr++;
+                             {
-                             octets[6] = *ptr++;
+                                 (*s_etat_processus).erreur_execution =
-                             octets[7] = *ptr++;
+                                         d_ex_syntaxe;
+                                 return(NULL);
+                             }
                          }
                          longueur = (((integer8) (octets[0])) << 56)
- Line 4867  lecture_fichier_non_formate(struct_proce
+ Line 7290  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 4933  lecture_fichier_non_formate(struct_proce
+ Line 7373  lecture_fichier_non_formate(struct_proce
          case 0x80:  // Chaîne de caractères
          {
-             s_objet = NULL;
+             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 (longueur_buffer < 0)
+             {
+                 if ((flux = malloc(((size_t) longueur) * sizeof(unsigned char)))
+                         == NULL)
+                 {
+                     (*s_etat_processus).erreur_systeme =
+                             d_es_allocation_memoire;
+                     return(NULL);
+                 }
+                 if (fread(flux, (size_t) sizeof(unsigned char),
+                         (size_t) longueur, fichier) != (size_t) longueur)
+                 {
+                     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)) < longueur)
+                 {
+                     (*s_etat_processus).erreur_execution =
+                             d_ex_syntaxe;
+                     return(NULL);
+                 }
+                 flux = ptr;
+                 ptr += longueur;
+             }
+             if ((s_objet = allocation(s_etat_processus, CHN)) == NULL)
+             {
+                 if (longueur_buffer < 0)
+                 {
+                     free(flux);
+                 }
+                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+                 return(NULL);
+             }
+             if (((*s_objet).objet = analyse_flux(s_etat_processus, flux,
+                     longueur)) == NULL)
+             {
+                 return(NULL);
+             }
+             if (longueur_buffer < 0)
+             {
+                 free(flux);
+             }
+             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
+             {
+                 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, FCT)) == NULL)
+             {
+                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+                 return(NULL);
+             }
+             if (((*((struct_fonction *) (*s_objet).objet)).nom_fonction =
+                     malloc((((size_t) longueur) + 1) * sizeof(unsigned char)))
+                     == NULL)
+             {
+                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+                 return(NULL);
+             }
+             if (longueur_buffer < 0)
+             {
+                 if (fread((unsigned char *) (*((struct_fonction *) (*s_objet)
+                         .objet)).nom_fonction, (size_t) sizeof(unsigned char),
+                         (size_t) longueur, fichier) != (unsigned) longueur)
+                 {
+                     if (feof(fichier))
+                     {
+                         (*s_etat_processus).erreur_execution =
+                                 d_ex_syntaxe;
+                     }
+                     else
+                     {
+                         (*s_etat_processus).erreur_systeme =
+                                 d_es_erreur_fichier;
+                     }
+                     liberation(s_etat_processus, s_objet);
+                     return(NULL);
+                 }
+                 if (fread(octets, (size_t) sizeof(unsigned char),
+, fichier) != 8)
+                 {
+                     if (feof(fichier))
+                     {
+                         (*s_etat_processus).erreur_execution =
+                                 d_ex_syntaxe;
+                     }
+                     else
+                     {
+                         (*s_etat_processus).erreur_systeme =
+                                 d_es_erreur_fichier;
+                     }
+                     liberation(s_etat_processus, s_objet);
+                     return(NULL);
+                 }
+             }
+             else
+             {
+                 if ((longueur_buffer - (ptr - buffer)) >= (longueur + 8))
+                 {
+                     for(j = 0; j < longueur; (*((struct_fonction *)
+                             (*s_objet).objet)).nom_fonction[j] = *ptr++);
+                     for(j = 0; j < 8; octets[j++] = *ptr++);
+                 }
+                 else
+                 {
+                     liberation(s_etat_processus, s_objet);
+                     (*s_etat_processus).erreur_execution = d_ex_syntaxe;
+                     return(NULL);
+                 }
+             }
+             (*((struct_fonction *) (*s_objet).objet)).nom_fonction[longueur] =
+                     d_code_fin_chaine;
+             (*((struct_fonction *) (*s_objet).objet)).nombre_arguments =
+                     (((integer8) (octets[0])) << 56)
+                     | (((integer8) (octets[1])) << 48)
+                     | (((integer8) (octets[2])) << 40)
+                     | (((integer8) (octets[3])) << 32)
+                     | (((integer8) (octets[4])) << 24)
+                     | (((integer8) (octets[5])) << 16)
+                     | (((integer8) (octets[6])) << 8)
+                     | ((integer8) (octets[7]));
              break;
          }
- Line 4953  lecture_fichier_non_formate(struct_proce
+ Line 8165  lecture_fichier_non_formate(struct_proce
          {
              liberation(s_etat_processus, s_objet);
-             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
+             if (feof(fichier))
+             {
+                 (*s_etat_processus).erreur_execution = d_ex_syntaxe;
+             }
+             else
+             {
+                 (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
+             }
              return(NULL);
          }
          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)
              {
                  liberation(s_etat_processus, s_objet);
-                 (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
+                 if (feof(fichier))
+                 {
+                     (*s_etat_processus).erreur_execution = d_ex_syntaxe;
+                 }
+                 else
+                 {
+                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
+                 }
                  return(NULL);
              }
          }
      }
+     if (longueur_buffer >= 0)
+     {
+         (*((unsigned char **) argument)) = ptr;
+     }
      return(s_objet);
  }

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.52
changed lines
	Added in v.1.91