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

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

version 1.52, 2013/03/10 17:01:05 version 1.73, 2013/06/21 14:15:52
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.13    RPL/2 (R) version 4.1.15
   Copyright (C) 1989-2013 Dr. BERTRAND Joël    Copyright (C) 1989-2013 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
Line 19 Line 19
 ================================================================================  ================================================================================
 */  */
   
 #define DEBUG_ERREURS  
 #include "rpl-conv.h"  #include "rpl-conv.h"
   
   
Line 40 Line 40
   
 unsigned char *  unsigned char *
 formateur_fichier(struct_processus *s_etat_processus, struct_objet *s_objet,  formateur_fichier(struct_processus *s_etat_processus, struct_objet *s_objet,
         struct_objet *s_format, long longueur, long longueur_champ,          struct_objet *s_format, integer8 longueur, integer8 longueur_champ,
         unsigned char format_sortie, unsigned char type,          unsigned char format_sortie, unsigned char type,
         long *longueur_effective, long *recursivite, logical1 export_fichier)          integer8 *longueur_effective, integer8 *recursivite,
           logical1 export_fichier)
 {  {
     /*      /*
      * Traitement du format des fichiers formatés :       * Traitement du format des fichiers formatés :
Line 62  formateur_fichier(struct_processus *s_et Line 63  formateur_fichier(struct_processus *s_et
      *   "binary*X(*)"       *   "binary*X(*)"
      *   "binary*X(Y)"  (X est la base : 2, 8, 10, 16)       *   "binary*X(Y)"  (X est la base : 2, 8, 10, 16)
      *   "character*(*)"       *   "character*(*)"
      *   "character*(Y)" }       *   "character*(Y)"
        *   "native*(*)" }
      *       *
      * Traitement du format des fichiers non formatés :       * Traitement du format des fichiers non formatés :
      *       *
Line 70  formateur_fichier(struct_processus *s_et Line 72  formateur_fichier(struct_processus *s_et
      *   "real*4", "real*8", ["real*16",]       *   "real*4", "real*8", ["real*16",]
      *   "complex*8", "complex*16", ["complex*32",]       *   "complex*8", "complex*16", ["complex*32",]
      *   "logical*1", "logical*2", "logical*4", logical*8",       *   "logical*1", "logical*2", "logical*4", logical*8",
      *   "character*n" "character*(*)" }       *   "character*n" "character*(*)" "native*(*)" }
      */       */
   
     logical1                    autorisation_parenthese;      logical1                    autorisation_parenthese;
     logical1                    format_degenere;      logical1                    format_degenere;
     logical1                    presence_signe;      logical1                    presence_signe;
   
     long                        longueur_chaine_traitee;  
   
     struct_liste_chainee        *l_atome;      struct_liste_chainee        *l_atome;
     struct_liste_chainee        *l_element_courant;      struct_liste_chainee        *l_element_courant;
     struct_liste_chainee        *l_element_courant_format;      struct_liste_chainee        *l_element_courant_format;
     struct_liste_chainee        *l_liste1;      struct_liste_chainee        *l_liste1;
     struct_liste_chainee        *l_liste2;      struct_liste_chainee        *l_liste2;
   
       struct_objet                *s_format_tmp;
     struct_objet                *s_sous_objet;      struct_objet                *s_sous_objet;
     struct_objet                *s_sous_objet_1;      struct_objet                *s_sous_objet_1;
     struct_objet                *s_sous_objet_2;      struct_objet                *s_sous_objet_2;
Line 100  formateur_fichier(struct_processus *s_et Line 101  formateur_fichier(struct_processus *s_et
     unsigned char               *ptre;      unsigned char               *ptre;
     unsigned char               *ptrl;      unsigned char               *ptrl;
     unsigned char               tampon[64 + 1];      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_fonction;
     integer8                    longueur_liste;      integer8                    longueur_liste;
     integer8                    longueur_reelle_chaine;      integer8                    longueur_reelle_chaine;
     integer8                    longueur_totale;      integer8                    longueur_totale;
     integer8                    masque_binaire;  
     integer8                    position_1;      integer8                    position_1;
     integer8                    position_2;      integer8                    position_2;
     integer8                    position_3;      integer8                    position_3;
Line 131  formateur_fichier(struct_processus *s_et Line 134  formateur_fichier(struct_processus *s_et
   
         strcpy(base, " ");          strcpy(base, " ");
   
         masque_binaire = 0;  
   
         if ((*s_objet).type == ALG)          if ((*s_objet).type == ALG)
         {          {
   
Line 142  formateur_fichier(struct_processus *s_et Line 143  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie != 'N')
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_format_fichier;
                   return(NULL);
               }
   
             l_element_courant = (struct_liste_chainee *) (*s_objet).objet;              l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
   
             while(l_element_courant != NULL)              while(l_element_courant != NULL)
Line 921  formateur_fichier(struct_processus *s_et Line 929  formateur_fichier(struct_processus *s_et
                         ptrl = chaine_sauvegarde;                          ptrl = chaine_sauvegarde;
                         ptre = (unsigned char *) (*s_sous_objet).objet;                          ptre = (unsigned char *) (*s_sous_objet).objet;
   
                         for(ptrl++, i = strlen(chaine_sauvegarde) - 2; i > 0;                          for(ptrl++, i = ((integer8) strlen(chaine_sauvegarde))
                                 i--, *ptre++ = *ptrl++);                                  - 2; i > 0; i--, *ptre++ = *ptrl++);
   
                         (*ptre) = d_code_fin_chaine;                          (*ptre) = d_code_fin_chaine;
   
Line 984  formateur_fichier(struct_processus *s_et Line 992  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
             if (format_sortie != 'B')              if ((format_sortie != 'B') && (format_sortie != 'N'))
             {              {
                 (*s_etat_processus).erreur_execution =                  (*s_etat_processus).erreur_execution =
                         d_ex_erreur_format_fichier;                          d_ex_erreur_format_fichier;
                 return(NULL);                  return(NULL);
             }              }
   
             masque_binaire = masque_entiers_binaires(s_etat_processus);              if (format_sortie == 'N')
   
             if ((test_cfsf(s_etat_processus, 43) == d_faux) &&  
                     (test_cfsf(s_etat_processus, 44) == d_faux))  
             {              {
                   sprintf(tampon, "%llX", (unsigned long long) (*((logical8 *)
 /*                          ((*s_objet).objet))));
 -- Base décimale ---------------------------------------------------------------                  strcpy(base, "h");
 */  
   
                 sprintf(tampon, "%llu", (*((logical8 *)  
                         ((*s_objet).objet))) & masque_binaire);  
                 strcpy(base, "d");  
             }              }
             else if ((test_cfsf(s_etat_processus, 43) == d_vrai) &&              else
                     (test_cfsf(s_etat_processus, 44) == d_faux))  
             {              {
                   switch(longueur)
                   {
                       case 2:
                       {
                           sprintf(tampon, "%llX", (unsigned long long)
                                   (*((logical8 *) ((*s_objet).objet))));
   
 /*                          chaine = (unsigned char *) malloc((strlen(tampon) + 1)
 -- Base octale -----------------------------------------------------------------                                  * sizeof(unsigned char));
 */  
   
                 sprintf(tampon, "%llo", (*((logical8 *)                          if (chaine == NULL)
                         ((*s_objet).objet))) & masque_binaire);                          {
                 strcpy(base, "o");                              (*s_etat_processus).erreur_systeme =
             }                                      d_es_allocation_memoire;
             else if (test_cfsf(s_etat_processus, 44) == d_vrai)                              return(NULL);
             {                          }
   
 /*                          strcpy(chaine, tampon);
 -- Bases hexadécimale et binaire -----------------------------------------------                          tampon[0] = 0;
 */  
   
                 sprintf(tampon, "%llX", (*((logical8 *)                          for(i = 0; i < ((integer8) strlen(chaine)); i++)
                         ((*s_objet).objet))) & masque_binaire);                          {
                               switch(chaine[i])
                               {
                                   case '0' :
                                   {
                                       strcat(tampon, (i != 0) ? "0000" : "0");
                                       break;
                                   }
                                   case '1' :
                                   {
                                       strcat(tampon, (i != 0) ? "0001" : "1");
                                       break;
                                   }
                                   case '2' :
                                   {
                                       strcat(tampon, (i != 0) ? "0010" : "10");
                                       break;
                                   }
                                   case '3' :
                                   {
                                       strcat(tampon, (i != 0) ? "0011" : "11");
                                   break;
                                   }
                                   case '4' :
                                   {
                                       strcat(tampon, (i != 0) ? "0100" : "100");
                                       break;
                                   }
                                   case '5' :
                                   {
                                       strcat(tampon, (i != 0) ? "0101" : "101");
                                       break;
                                   }
                                   case '6' :
                                   {
                                       strcat(tampon, (i != 0) ? "0110" : "110");
                                       break;
                                   }
                                   case '7' :
                                   {
                                       strcat(tampon, (i != 0) ? "0111" : "111");
                                       break;
                                   }
                                   case '8' :
                                   {
                                       strcat(tampon, "1000");
                                       break;
                                   }
                                   case '9' :
                                   {
                                       strcat(tampon, "1001");
                                       break;
                                   }
                                   case 'A' :
                                   {
                                       strcat(tampon, "1010");
                                       break;
                                   }
                                   case 'B' :
                                   {
                                       strcat(tampon, "1011");
                                       break;
                                   }
                                   case 'C' :
                                   {
                                       strcat(tampon, "1100");
                                       break;
                                   }
                                   case 'D' :
                                   {
                                       strcat(tampon, "1101");
                                       break;
                                   }
                                   case 'E' :
                                   {
                                       strcat(tampon, "1110");
                                       break;
                                   }
                                   case 'F' :
                                   {
                                       strcat(tampon, "1111");
                                       break;
                                   }
                               }
                           }
   
                 if (test_cfsf(s_etat_processus, 43) == d_vrai)                          free(chaine);
                 {                          strcpy(base, "b");
                     strcpy(base, "h");                          break;
                 }                      }
                 else  
                 {  
                     chaine = (unsigned char *) malloc((strlen(tampon) + 1)  
                             * sizeof(unsigned char));  
   
                     if (chaine == NULL)                      case 8:
                     {                      {
                         (*s_etat_processus).erreur_systeme =                          sprintf(tampon, "%llo", (*((unsigned long long *)
                                 d_es_allocation_memoire;                                  ((*s_objet).objet))));
                         return(NULL);                          strcpy(base, "o");
                           break;
                     }                      }
   
                     strcpy(chaine, tampon);                      case 10:
                     tampon[0] = 0;                      {
                           sprintf(tampon, "%llu", (*((unsigned long long *)
                                   ((*s_objet).objet))));
                           strcpy(base, "d");
                           break;
                       }
   
                     for(i = 0; i < strlen(chaine); i++)                      case 16:
                     {                      {
                         switch(chaine[i])                          sprintf(tampon, "%llX", (unsigned long long)
                         {                                  (*((logical8 *) ((*s_objet).objet))));
                             case '0' :                          strcpy(base, "h");
                             {                          break;
                                 strcat(tampon, (i != 0) ? "0000" : "0");  
                                 break;  
                             }  
                             case '1' :  
                             {  
                                     strcat(tampon, (i != 0) ? "0001" : "1");  
                                 break;  
                             }  
                             case '2' :  
                             {  
                                 strcat(tampon, (i != 0) ? "0010" : "10");  
                                 break;  
                             }  
                             case '3' :  
                             {  
                                 strcat(tampon, (i != 0) ? "0011" : "11");  
                                 break;  
                             }  
                             case '4' :  
                             {  
                                 strcat(tampon, (i != 0) ? "0100" : "100");  
                                 break;  
                             }  
                             case '5' :  
                             {  
                                 strcat(tampon, (i != 0) ? "0101" : "101");  
                                 break;  
                             }  
                             case '6' :  
                             {  
                                 strcat(tampon, (i != 0) ? "0110" : "110");  
                                 break;  
                             }  
                             case '7' :  
                             {  
                                 strcat(tampon, (i != 0) ? "0111" : "111");  
                                 break;  
                             }  
                             case '8' :  
                             {  
                                 strcat(tampon, "1000");  
                                 break;  
                             }  
                             case '9' :  
                             {  
                                 strcat(tampon, "1001");  
                                 break;  
                             }  
                             case 'A' :  
                             {  
                                 strcat(tampon, "1010");  
                                 break;  
                             }  
                             case 'B' :  
                             {  
                                 strcat(tampon, "1011");  
                                 break;  
                             }  
                             case 'C' :  
                             {  
                                 strcat(tampon, "1100");  
                                 break;  
                             }  
                             case 'D' :  
                             {  
                                 strcat(tampon, "1101");  
                                 break;  
                             }  
                             case 'E' :  
                             {  
                                 strcat(tampon, "1110");  
                                 break;  
                             }  
                             case 'F' :  
                             {  
                                 strcat(tampon, "1111");  
                                 break;  
                             }  
                         }  
                     }                      }
   
                     free(chaine);                      default:
                     strcpy(base, "b");                      {
                           (*s_etat_processus).erreur_execution =
                                   d_ex_erreur_format_fichier;
                           return(NULL);
                       }
                   }
               }
   
               if (format_sortie == 'B')
               {
                   if ((longueur_champ > 0) && (longueur_champ
                           < (signed) strlen(tampon)))
                   {
                       ptrl = &(tampon[((integer8) strlen(tampon))
                               - longueur_champ]);
                       ptre = tampon;
   
                       do
                       {
                           *ptre++ = *ptrl++;
                       } while((*ptrl) != d_code_fin_chaine);
   
                       (*ptre) = d_code_fin_chaine;
                 }                  }
             }              }
   
Line 1161  formateur_fichier(struct_processus *s_et Line 1193  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
             if (format_sortie != 'C')              if ((format_sortie != 'C') && (format_sortie != 'N'))
             {              {
                 (*s_etat_processus).erreur_execution =                  (*s_etat_processus).erreur_execution =
                         d_ex_erreur_format_fichier;                          d_ex_erreur_format_fichier;
Line 1171  formateur_fichier(struct_processus *s_et Line 1203  formateur_fichier(struct_processus *s_et
             longueur_reelle_chaine = longueur_chaine(s_etat_processus,              longueur_reelle_chaine = longueur_chaine(s_etat_processus,
                     (unsigned char *) (*s_objet).objet);                      (unsigned char *) (*s_objet).objet);
   
               if (format_sortie == 'N')
               {
                   longueur_champ = -1;
               }
   
             if ((longueur_champ == -1) || (longueur_reelle_chaine <              if ((longueur_champ == -1) || (longueur_reelle_chaine <
                     longueur_champ))                      longueur_champ))
             {              {
Line 1193  formateur_fichier(struct_processus *s_et Line 1230  formateur_fichier(struct_processus *s_et
                         (*s_objet).objet, longueur_champ)                          (*s_objet).objet, longueur_champ)
                         - ((unsigned char *) (*s_objet).objet);                          - ((unsigned char *) (*s_objet).objet);
   
                 if ((chaine = malloc((longueur_reelle_chaine + 1) *                  if ((chaine = malloc((((size_t) longueur_reelle_chaine) + 1) *
                         sizeof(unsigned char))) == NULL)                          sizeof(unsigned char))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
Line 1202  formateur_fichier(struct_processus *s_et Line 1239  formateur_fichier(struct_processus *s_et
                 }                  }
   
                 strncpy(chaine, (unsigned char *) ((*s_objet).objet),                  strncpy(chaine, (unsigned char *) ((*s_objet).objet),
                         longueur_reelle_chaine);                          (size_t) longueur_reelle_chaine);
                 chaine[longueur_reelle_chaine] = d_code_fin_chaine;                  chaine[longueur_reelle_chaine] = d_code_fin_chaine;
             }              }
         }          }
Line 1215  formateur_fichier(struct_processus *s_et Line 1252  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'S';
               }
   
             if ((format_sortie != 'S') && (format_sortie != 'F') &&              if ((format_sortie != 'S') && (format_sortie != 'F') &&
                     (format_sortie != 'I') && (format_sortie != 'E'))                      (format_sortie != 'I') && (format_sortie != 'E'))
             {              {
Line 1252  formateur_fichier(struct_processus *s_et Line 1294  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie != 'N')
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_format_fichier;
                   return(NULL);
               }
   
             l_element_courant = (struct_liste_chainee *) ((*s_objet).objet);              l_element_courant = (struct_liste_chainee *) ((*s_objet).objet);
             chaine_sauvegarde = chaine;              chaine_sauvegarde = chaine;
   
Line 1334  formateur_fichier(struct_processus *s_et Line 1383  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'S';
               }
   
             if ((format_sortie != 'S') && (format_sortie != 'F') &&              if ((format_sortie != 'S') && (format_sortie != 'F') &&
                     (format_sortie != 'I') && (format_sortie != 'E'))                      (format_sortie != 'I') && (format_sortie != 'E'))
             {              {
Line 1371  formateur_fichier(struct_processus *s_et Line 1425  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie != 'N')
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_format_fichier;
                   return(NULL);
               }
   
             chaine = (unsigned char *) malloc((strlen((*((struct_fonction *)              chaine = (unsigned char *) malloc((strlen((*((struct_fonction *)
                     ((*s_objet).objet))).nom_fonction) + 1) *                      ((*s_objet).objet))).nom_fonction) + 1) *
                     sizeof(unsigned char));                      sizeof(unsigned char));
Line 1418  formateur_fichier(struct_processus *s_et Line 1479  formateur_fichier(struct_processus *s_et
                 {                  {
                     chaine_sauvegarde = chaine;                      chaine_sauvegarde = chaine;
   
                     if ((chaine_formatee = formateur_fichier(s_etat_processus,                      if (format_sortie != 'N')
                             (*l_element_courant).donnee,  
                             (*l_element_courant_format).donnee,  
                             0, 0, ' ', 'F', longueur_effective, recursivite,  
                             export_fichier)) == NULL)  
                     {                      {
                         return(NULL);                          if ((chaine_formatee =
                                   formateur_fichier(s_etat_processus,
                                   (*l_element_courant).donnee,
                                   (*l_element_courant_format).donnee,
                                   0, 0, ' ', 'F', longueur_effective, recursivite,
                                   export_fichier)) == NULL)
                           {
                               return(NULL);
                           }
                       }
                       else
                       {
                           if ((chaine_formatee =
                                   formateur_fichier(s_etat_processus,
                                   (*l_element_courant).donnee,
                                   (*l_element_courant_format).donnee,
                                   0, 0, 'N', 'F', longueur_effective, recursivite,
                                   export_fichier)) == NULL)
                           {
                               return(NULL);
                           }
                     }                      }
   
                     chaine = (unsigned char *) malloc((strlen(chaine_formatee)                      chaine = (unsigned char *) malloc((strlen(chaine_formatee)
Line 1497  formateur_fichier(struct_processus *s_et Line 1574  formateur_fichier(struct_processus *s_et
                         position_1 = 10;                          position_1 = 10;
                         format_degenere = d_vrai;                          format_degenere = d_vrai;
                     }                      }
                       else if (strcmp("NATIVE*(*)", format_chaine) == 0)
                       {
                           format_sortie = 'N';
                           position_1 = 7;
                           format_degenere = d_vrai;
                       }
                     else                      else
                     {                      {
                         free(chaine);                          free(chaine);
Line 1507  formateur_fichier(struct_processus *s_et Line 1590  formateur_fichier(struct_processus *s_et
                         return(NULL);                          return(NULL);
                     }                      }
   
                     position_3 = strlen(format_chaine) - 1;                      position_3 = ((integer8) strlen(format_chaine)) - 1;
   
                     if (format_chaine[position_3] != ')')                      if (format_chaine[position_3] != ')')
                     {                      {
Line 1542  formateur_fichier(struct_processus *s_et Line 1625  formateur_fichier(struct_processus *s_et
   
                     if (format_degenere == d_faux)                      if (format_degenere == d_faux)
                     {                      {
                         if (sscanf(&(format_chaine[position_1]), "%ld",                          if (sscanf(&(format_chaine[position_1]), "%lld",
                                 &longueur) != 1)                                  &longueur) != 1)
                         {                          {
                             free(chaine);                              free(chaine);
Line 1560  formateur_fichier(struct_processus *s_et Line 1643  formateur_fichier(struct_processus *s_et
   
                     if (strcmp(&(format_chaine[position_2]), "*") != 0)                      if (strcmp(&(format_chaine[position_2]), "*") != 0)
                     {                      {
                         if (sscanf(&(format_chaine[position_2]), "%ld",                          if (sscanf(&(format_chaine[position_2]), "%lld",
                                 &longueur_champ) != 1)                                  &longueur_champ) != 1)
                         {                          {
                             free(chaine);                              free(chaine);
Line 1577  formateur_fichier(struct_processus *s_et Line 1660  formateur_fichier(struct_processus *s_et
                     }                      }
   
                     if ((longueur >= 0) && (longueur_champ >= 0) && (longueur >                      if ((longueur >= 0) && (longueur_champ >= 0) && (longueur >
                             longueur_champ))                              longueur_champ) && (format_sortie != 'B'))
                     {                      {
                         free(chaine);                          free(chaine);
                         free(format_chaine);                          free(format_chaine);
Line 1591  formateur_fichier(struct_processus *s_et Line 1674  formateur_fichier(struct_processus *s_et
                                   
                     chaine_sauvegarde = chaine;                      chaine_sauvegarde = chaine;
   
                       // Si le format_sortie vaut 'N', on remplace le format par
                       // { "native*(*)" }. L'intérêt est de pouvoir traiter une
                       // liste par un format "native*(*)".
   
                       if ((format_sortie == 'N') && ((*(*l_element_courant)
                               .donnee).type == LST))
                       {
                           if ((s_format_tmp = allocation(s_etat_processus, LST))
                                   == NULL)
                           {
                               return(NULL);
                           }
   
                           if (((*s_format_tmp).objet = allocation_maillon(
                                   s_etat_processus)) == NULL)
                           {
                               return(NULL);
                           }
   
                           (*((struct_liste_chainee *) (*s_format_tmp).objet))
                                   .suivant = NULL;
   
                           if (((*((struct_liste_chainee *) (*s_format_tmp).objet))
                                   .donnee = allocation(s_etat_processus, CHN))
                                   == NULL)
                           {
                               return(NULL);
                           }
   
                           if (((*(*((struct_liste_chainee *) (*s_format_tmp)
                                   .objet)).donnee).objet = malloc(11 *
                                   sizeof(unsigned char))) == NULL)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_allocation_memoire;
                               return(NULL);
                           }
   
                           strcpy((unsigned char *) (*(*((struct_liste_chainee *)
                                   (*s_format_tmp).objet)).donnee).objet,
                                   "native*(*)");
                       }
                       else
                       {
                           if ((s_format_tmp = copie_objet(s_etat_processus,
                                   s_format, 'P')) == NULL)
                           {
                               return(NULL);
                           }
                       }
   
                     if ((chaine_formatee = formateur_fichier(s_etat_processus,                      if ((chaine_formatee = formateur_fichier(s_etat_processus,
                             (*l_element_courant).donnee, s_format,                              (*l_element_courant).donnee, s_format,
                             longueur, longueur_champ, format_sortie, type,                              longueur, longueur_champ, format_sortie, type,
                             longueur_effective, recursivite, export_fichier))                              longueur_effective, recursivite, export_fichier))
                             == NULL)                              == NULL)
                     {                      {
                           liberation(s_etat_processus, s_format_tmp);
                         free(chaine);                          free(chaine);
                         return(NULL);                          return(NULL);
                     }                      }
   
                       liberation(s_etat_processus, s_format_tmp);
   
                     if ((*(*l_element_courant).donnee).type == CHN)                      if ((*(*l_element_courant).donnee).type == CHN)
                     {                      {
                         chaine = (unsigned char *)                          chaine = (unsigned char *)
Line 1664  formateur_fichier(struct_processus *s_et Line 1801  formateur_fichier(struct_processus *s_et
   
                 nombre_elements++;                  nombre_elements++;
                 l_element_courant = (*l_element_courant).suivant;                  l_element_courant = (*l_element_courant).suivant;
                 l_element_courant_format = (*l_element_courant_format).suivant;  
                   if (format_sortie != 'N')
                   {
                       l_element_courant_format =
                               (*l_element_courant_format).suivant;
                   }
             }              }
   
             if ((l_element_courant != NULL) ||              // Dans le cas où le format de sortie n'est pas du type
                     (l_element_courant_format != NULL))              // NATIVE*(*), on vérifie que tous les éléments du format et
               // de la liste d'arguments ont été consommés.
   
               if (format_sortie != 'N')
             {              {
                 free(chaine);                  if ((l_element_courant != NULL) ||
                           (l_element_courant_format != NULL))
                   {
                       free(chaine);
   
                 (*s_etat_processus).erreur_execution =                      (*s_etat_processus).erreur_execution =
                         d_ex_erreur_format_fichier;                              d_ex_erreur_format_fichier;
                 return(NULL);                      return(NULL);
                   }
             }              }
   
             chaine_sauvegarde = chaine;              chaine_sauvegarde = chaine;
Line 1700  formateur_fichier(struct_processus *s_et Line 1849  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
             if ((*s_format).type != TBL)              if (((*s_format).type != TBL) && (format_sortie != 'N'))
             {              {
                 (*s_etat_processus).erreur_execution =                  (*s_etat_processus).erreur_execution =
                         d_ex_erreur_format_fichier;                          d_ex_erreur_format_fichier;
                 return(NULL);                  return(NULL);
             }              }
   
             l_element_courant = (struct_liste_chainee *) (*s_objet).objet;              if (format_sortie != 'N')
             l_element_courant_format = (struct_liste_chainee *)  
                     (*s_format).objet;  
   
             if ((*((struct_tableau *) (*s_objet).objet)).nombre_elements !=  
                     (*((struct_tableau *) (*s_format).objet)).nombre_elements)  
             {              {
                 (*s_etat_processus).erreur_execution =                  if ((*((struct_tableau *) (*s_objet).objet)).nombre_elements !=
                         d_ex_erreur_format_fichier;                          (*((struct_tableau *) (*s_format).objet))
                 return(NULL);                          .nombre_elements)
                   {
                       (*s_etat_processus).erreur_execution =
                               d_ex_erreur_format_fichier;
                       return(NULL);
                   }
             }              }
   
             chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));              chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
Line 1732  formateur_fichier(struct_processus *s_et Line 1881  formateur_fichier(struct_processus *s_et
             for(i = 0; i < (*((struct_tableau *) (*s_objet).objet))              for(i = 0; i < (*((struct_tableau *) (*s_objet).objet))
                     .nombre_elements; i++)                      .nombre_elements; i++)
             {              {
                 if ((((*(*((struct_tableau *) (*s_format).objet))                  if (format_sortie != 'N')
                         .elements[i]).type == LST) &&  
                         ((*(*((struct_tableau *) (*s_objet).objet)).elements[i])  
                         .type == LST)) ||  
                         (((*(*((struct_tableau *) (*s_format).objet))  
                         .elements[i]).type == TBL) &&  
                         ((*(*((struct_tableau *) (*s_objet).objet)).elements[i])  
                         .type == TBL)))  
                 {                  {
                     chaine_sauvegarde = chaine;                      if ((((*(*((struct_tableau *) (*s_format).objet))
                               .elements[i]).type == LST) &&
                     if ((chaine_formatee = formateur_fichier(s_etat_processus,                              ((*(*((struct_tableau *) (*s_objet).objet))
                             (*l_element_courant).donnee,                              .elements[i]).type == LST)) ||
                             (*l_element_courant_format).donnee,                              (((*(*((struct_tableau *) (*s_format).objet))
                             0, 0, ' ', 'F', longueur_effective, recursivite,                              .elements[i]).type == TBL) &&
                             export_fichier)) == NULL)                              ((*(*((struct_tableau *) (*s_objet).objet))
                               .elements[i]).type == TBL)))
                     {                      {
                         return(NULL);                          chaine_sauvegarde = chaine;
                     }  
   
                     chaine = (unsigned char *) malloc((strlen(chaine_formatee)  
                             + strlen(chaine_sauvegarde) + 2)  
                             * sizeof(unsigned char));  
   
                     if (chaine == NULL)  
                     {  
                         (*s_etat_processus).erreur_systeme =  
                                 d_es_allocation_memoire;  
                         return(NULL);  
                     }  
   
                     strcpy(chaine, chaine_sauvegarde);  
                     free(chaine_sauvegarde);  
                     strcat(chaine, " ");  
                     strcat(chaine, chaine_formatee);  
                     free(chaine_formatee);  
                 }  
                 else if ((*(*((struct_tableau *) (*s_format).objet))  
                         .elements[i]).type != CHN)  
                 {  
                     free(chaine);  
   
                     (*s_etat_processus).erreur_execution =                          if ((chaine_formatee = formateur_fichier(
                             d_ex_erreur_format_fichier;                                  s_etat_processus,
                     return(NULL);                                  (*(*((struct_tableau *) (*s_objet).objet))
                 }                                  .elements[i]).objet,
                 else                                  (*(*((struct_tableau *) (*s_format).objet))
                 {                                  .elements[i]).objet,
                     if ((format_chaine = conversion_majuscule((unsigned char *)                                  0, 0, ' ', 'F', longueur_effective, recursivite,
                             (*(*((struct_tableau *) (*s_format).objet))                                  export_fichier)) == NULL)
                             .elements[i]).objet)) == NULL)                          {
                     {                              return(NULL);
                         (*s_etat_processus).erreur_systeme =                          }
                                 d_es_allocation_memoire;  
                         return(NULL);  
                     }  
   
                     format_degenere = d_faux;                          if ((chaine = (unsigned char *) malloc((strlen(
                                   chaine_formatee) + strlen(chaine_sauvegarde)
                                   + 2) * sizeof(unsigned char))) == NULL)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_allocation_memoire;
                               return(NULL);
                           }
   
                     if (strncmp("STANDARD*", format_chaine, 9) == 0)                          strcpy(chaine, chaine_sauvegarde);
                     {                          free(chaine_sauvegarde);
                         format_sortie = 'S';                          strcat(chaine, " ");
                         position_1 = 9;                          strcat(chaine, chaine_formatee);
                         format_degenere = d_vrai;                          free(chaine_formatee);
                     }  
                     else if (strncmp("BINARY*", format_chaine, 7) == 0)  
                     {  
                         format_sortie = 'B';  
                         position_1 = 7;  
                     }  
                     else if (strncmp("FIXED*", format_chaine, 6) == 0)  
                     {  
                         format_sortie = 'F';  
                         position_1 = 6;  
                     }  
                     else if (strncmp("SCIENTIFIC*", format_chaine, 11) == 0)  
                     {  
                         format_sortie = 'I';  
                         position_1 = 11;  
                     }  
                     else if (strncmp("ENGINEER*", format_chaine, 9) == 0)  
                     {  
                         format_sortie = 'E';  
                         position_1 = 9;  
                     }  
                     else if (strncmp("CHARACTER*", format_chaine, 10) == 0)  
                     {  
                         format_sortie = 'C';  
                         position_1 = 10;  
                         format_degenere = d_vrai;  
                     }                      }
                     else                      else if ((*(*((struct_tableau *) (*s_format).objet))
                               .elements[i]).type != CHN)
                     {                      {
                         free(chaine);                          free(chaine);
                         free(format_chaine);  
   
                         (*s_etat_processus).erreur_execution =                          (*s_etat_processus).erreur_execution =
                                 d_ex_erreur_format_fichier;                                  d_ex_erreur_format_fichier;
                         return(NULL);                          return(NULL);
                     }                      }
                       else
                       {
                           if ((format_chaine = conversion_majuscule(
                                   (unsigned char *) (*(*((struct_tableau *)
                                   (*s_format).objet)).elements[i]).objet))
                                   == NULL)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_allocation_memoire;
                               return(NULL);
                           }
   
                     position_3 = strlen(format_chaine);                          format_degenere = d_faux;
                     format_chaine[--position_3] = d_code_fin_chaine;  
   
                     position_2 = position_1;  
   
                     while(format_chaine[position_2] != '(')                          if (strncmp("STANDARD*", format_chaine, 9) == 0)
                     {                          {
                         if (format_chaine[position_2] == d_code_fin_chaine)                              format_sortie = 'S';
                               position_1 = 9;
                               format_degenere = d_vrai;
                           }
                           else if (strncmp("BINARY*", format_chaine, 7) == 0)
                           {
                               format_sortie = 'B';
                               position_1 = 7;
                           }
                           else if (strncmp("FIXED*", format_chaine, 6) == 0)
                           {
                               format_sortie = 'F';
                               position_1 = 6;
                           }
                           else if (strncmp("SCIENTIFIC*", format_chaine, 11) == 0)
                           {
                               format_sortie = 'I';
                               position_1 = 11;
                           }
                           else if (strncmp("ENGINEER*", format_chaine, 9) == 0)
                           {
                               format_sortie = 'E';
                               position_1 = 9;
                           }
                           else if (strncmp("CHARACTER*", format_chaine, 10) == 0)
                           {
                               format_sortie = 'C';
                               position_1 = 10;
                               format_degenere = d_vrai;
                           }
                           else if (strcmp("NATIVE*(*)", format_chaine) == 0)
                           {
                               format_sortie = 'N';
                               position_1 = 7;
                               format_degenere = d_vrai;
                           }
                           else
                         {                          {
                             free(chaine);                              free(chaine);
                             free(format_chaine);                              free(format_chaine);
Line 1850  formateur_fichier(struct_processus *s_et Line 1992  formateur_fichier(struct_processus *s_et
                             return(NULL);                              return(NULL);
                         }                          }
   
                         position_2++;                          position_3 = (integer8) strlen(format_chaine);
                     }                          format_chaine[--position_3] = d_code_fin_chaine;
   
                     format_chaine[position_2++] = d_code_fin_chaine;                          position_2 = position_1;
   
                     if (format_degenere == d_faux)                          while(format_chaine[position_2] != '(')
                     {  
                         if (sscanf(&(format_chaine[position_1]), "%ld",  
                                 &longueur) != 1)  
                         {                          {
                             free(chaine);                              if (format_chaine[position_2] == d_code_fin_chaine)
                             free(format_chaine);                              {
                                   free(chaine);
                                   free(format_chaine);
   
                             (*s_etat_processus).erreur_execution =                                  (*s_etat_processus).erreur_execution =
                                     d_ex_erreur_format_fichier;                                          d_ex_erreur_format_fichier;
                             return(NULL);                                  return(NULL);
                               }
   
                               position_2++;
                         }                          }
                     }  
                     else  
                     {  
                         longueur = -1;  
                     }  
   
                     if (strcmp(&(format_chaine[position_2]), "*") != 0)                          format_chaine[position_2++] = d_code_fin_chaine;
                     {  
                         if (sscanf(&(format_chaine[position_2]), "%ld",                          if (format_degenere == d_faux)
                                 &longueur_champ) != 1)                          {
                               if (sscanf(&(format_chaine[position_1]), "%lld",
                                       &longueur) != 1)
                               {
                                   free(chaine);
                                   free(format_chaine);
   
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_erreur_format_fichier;
                                   return(NULL);
                               }
                           }
                           else
                           {
                               longueur = -1;
                           }
   
                           if (strcmp(&(format_chaine[position_2]), "*") != 0)
                           {
                               if (sscanf(&(format_chaine[position_2]), "%lld",
                                       &longueur_champ) != 1)
                               {
                                   free(chaine);
                                   free(format_chaine);
   
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_erreur_format_fichier;
                                   return(NULL);
                               }
                           }
                           else
                           {
                               longueur_champ = -1;
                           }
   
                           if ((longueur >= 0) && (longueur_champ >= 0) &&
                                   (longueur > longueur_champ))
                         {                          {
                             free(chaine);                              free(chaine);
                             free(format_chaine);                              free(format_chaine);
Line 1885  formateur_fichier(struct_processus *s_et Line 2060  formateur_fichier(struct_processus *s_et
                                     d_ex_erreur_format_fichier;                                      d_ex_erreur_format_fichier;
                             return(NULL);                              return(NULL);
                         }                          }
                     }  
                     else  
                     {  
                         longueur_champ = -1;  
                     }  
   
                     if ((longueur >= 0) && (longueur_champ >= 0) && (longueur >  
                             longueur_champ))  
                     {  
                         free(chaine);  
                         free(format_chaine);                          free(format_chaine);
                       
                           chaine_sauvegarde = chaine;
   
                         (*s_etat_processus).erreur_execution =                          if ((chaine_formatee = formateur_fichier(
                                 d_ex_erreur_format_fichier;                                  s_etat_processus, (*((struct_tableau *)
                         return(NULL);                                  (*s_objet).objet)).elements[i], s_format,
                                   longueur, longueur_champ, format_sortie, type,
                                   longueur_effective, recursivite,
                                   export_fichier)) == NULL)
                           {
                               return(NULL);
                           }
                     }                      }
                   }
                     free(format_chaine);                  else // NATIVE*(*)
                                   {
                     chaine_sauvegarde = chaine;                      chaine_sauvegarde = chaine;
   
                     if ((chaine_formatee = formateur_fichier(s_etat_processus,                      if ((chaine_formatee = formateur_fichier(
                             (*((struct_tableau *) (*s_objet).objet))                              s_etat_processus, (*((struct_tableau *)
                             .elements[i], s_format,                              (*s_objet).objet)).elements[i], s_format,
                             longueur, longueur_champ, format_sortie, type,                              longueur, longueur_champ, format_sortie, type,
                             longueur_effective, recursivite, export_fichier))                              longueur_effective, recursivite,
                             == NULL)                              export_fichier)) == NULL)
                     {                      {
                         return(NULL);                          return(NULL);
                     }                      }
                   }
   
                     if ((*(*((struct_tableau *) (*s_objet).objet))                  if ((*(*((struct_tableau *) (*s_objet).objet))
                             .elements[i]).type == CHN)                          .elements[i]).type == CHN)
                     {                  {
                         chaine = (unsigned char *)                      chaine = (unsigned char *)
                                 malloc((strlen(chaine_formatee)                              malloc((strlen(chaine_formatee)
                                 + strlen(chaine_sauvegarde) + 4)                              + strlen(chaine_sauvegarde) + 4)
                                 * sizeof(unsigned char));                              * sizeof(unsigned char));
   
                         if (chaine == NULL)  
                         {  
                             (*s_etat_processus).erreur_systeme =  
                                     d_es_allocation_memoire;  
                             return(NULL);  
                         }  
   
                         strcpy(chaine, chaine_sauvegarde);                      if (chaine == NULL)
                         free(chaine_sauvegarde);  
                         strcat(chaine, " \"");  
                         strcat(chaine, chaine_formatee);  
                         free(chaine_formatee);  
                         strcat(chaine, "\"");  
                     }  
                     else if ((*(*((struct_tableau *) (*s_objet).objet))  
                             .elements[i]).type == NOM)  
                     {                      {
                         chaine = (unsigned char *)                          (*s_etat_processus).erreur_systeme =
                                 malloc((strlen(chaine_formatee)                                  d_es_allocation_memoire;
                                 + strlen(chaine_sauvegarde) + 2)                          return(NULL);
                                 * sizeof(unsigned char));                      }
   
                         if (chaine == NULL)                      strcpy(chaine, chaine_sauvegarde);
                         {                      free(chaine_sauvegarde);
                             (*s_etat_processus).erreur_systeme =                      strcat(chaine, " \"");
                                     d_es_allocation_memoire;                      strcat(chaine, chaine_formatee);
                             return(NULL);                      free(chaine_formatee);
                         }                      strcat(chaine, "\"");
                   }
                   else if ((*(*((struct_tableau *) (*s_objet).objet))
                           .elements[i]).type == NOM)
                   {
                       chaine = (unsigned char *)
                               malloc((strlen(chaine_formatee)
                               + strlen(chaine_sauvegarde) + 2)
                               * sizeof(unsigned char));
   
                         sprintf(chaine, "%s %s", chaine_sauvegarde,                      if (chaine == NULL)
                                 chaine_formatee);  
                         free(chaine_formatee);  
                     }  
                     else  
                     {                      {
                         chaine = (unsigned char *)                          (*s_etat_processus).erreur_systeme =
                                 malloc((strlen(chaine_formatee)                                  d_es_allocation_memoire;
                                 + strlen(chaine_sauvegarde) + 2)                          return(NULL);
                                 * sizeof(unsigned char));                      }
   
                         if (chaine == NULL)                      sprintf(chaine, "%s %s", chaine_sauvegarde,
                         {                              chaine_formatee);
                             (*s_etat_processus).erreur_systeme =                      free(chaine_formatee);
                                     d_es_allocation_memoire;                  }
                             return(NULL);                  else
                         }                  {
                       chaine = (unsigned char *)
                               malloc((strlen(chaine_formatee)
                               + strlen(chaine_sauvegarde) + 2)
                               * sizeof(unsigned char));
   
                         strcpy(chaine, chaine_sauvegarde);                      if (chaine == NULL)
                         free(chaine_sauvegarde);                      {
                         strcat(chaine, " ");                          (*s_etat_processus).erreur_systeme =
                         strcat(chaine, chaine_formatee);                                  d_es_allocation_memoire;
                         free(chaine_formatee);                          return(NULL);
                     }                      }
   
                       strcpy(chaine, chaine_sauvegarde);
                       free(chaine_sauvegarde);
                       strcat(chaine, " ");
                       strcat(chaine, chaine_formatee);
                       free(chaine_formatee);
                 }                  }
             }              }
   
Line 2003  formateur_fichier(struct_processus *s_et Line 2177  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'S';
               }
   
             if ((format_sortie != 'S') && (format_sortie != 'F') &&              if ((format_sortie != 'S') && (format_sortie != 'F') &&
                     (format_sortie != 'I') && (format_sortie != 'E'))                      (format_sortie != 'I') && (format_sortie != 'E'))
             {              {
Line 2146  formateur_fichier(struct_processus *s_et Line 2325  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'S';
               }
   
             if ((format_sortie != 'S') && (format_sortie != 'F') &&              if ((format_sortie != 'S') && (format_sortie != 'F') &&
                     (format_sortie != 'I') && (format_sortie != 'E'))                      (format_sortie != 'I') && (format_sortie != 'E'))
             {              {
Line 2288  formateur_fichier(struct_processus *s_et Line 2472  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'S';
               }
   
             if ((format_sortie != 'S') && (format_sortie != 'F') &&              if ((format_sortie != 'S') && (format_sortie != 'F') &&
                     (format_sortie != 'I') && (format_sortie != 'E'))                      (format_sortie != 'I') && (format_sortie != 'E'))
             {              {
Line 2430  formateur_fichier(struct_processus *s_et Line 2619  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie != 'N')
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_format_fichier;
                   return(NULL);
               }
   
             chaine = (unsigned char *) malloc((strlen((*((struct_nom *)              chaine = (unsigned char *) malloc((strlen((*((struct_nom *)
                     (*s_objet).objet)).nom) + 3) * sizeof(unsigned char));                      (*s_objet).objet)).nom) + 3) * sizeof(unsigned char));
   
Line 2450  formateur_fichier(struct_processus *s_et Line 2646  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'S';
               }
   
             if ((format_sortie != 'S') && (format_sortie != 'F') &&              if ((format_sortie != 'S') && (format_sortie != 'F') &&
                     (format_sortie != 'I') && (format_sortie != 'E'))                      (format_sortie != 'I') && (format_sortie != 'E'))
             {              {
Line 2487  formateur_fichier(struct_processus *s_et Line 2688  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'S';
               }
   
             if ((format_sortie != 'S') && (format_sortie != 'F') &&              if ((format_sortie != 'S') && (format_sortie != 'F') &&
                     (format_sortie != 'I') && (format_sortie != 'E'))                      (format_sortie != 'I') && (format_sortie != 'E'))
             {              {
Line 2563  formateur_fichier(struct_processus *s_et Line 2769  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'S';
               }
   
             if ((format_sortie != 'S') && (format_sortie != 'F') &&              if ((format_sortie != 'S') && (format_sortie != 'F') &&
                     (format_sortie != 'I') && (format_sortie != 'E'))                      (format_sortie != 'I') && (format_sortie != 'E'))
             {              {
Line 2638  formateur_fichier(struct_processus *s_et Line 2849  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'S';
               }
   
             if ((format_sortie != 'S') && (format_sortie != 'F') &&              if ((format_sortie != 'S') && (format_sortie != 'F') &&
                     (format_sortie != 'I') && (format_sortie != 'E'))                      (format_sortie != 'I') && (format_sortie != 'E'))
             {              {
Line 2714  formateur_fichier(struct_processus *s_et Line 2930  formateur_fichier(struct_processus *s_et
             return(NULL);              return(NULL);
         }          }
   
         (*longueur_effective) = strlen(chaine) + 1;          (*longueur_effective) = ((integer8) strlen(chaine)) + 1;
     }      }
     else      else
     {      {
Line 2744  formateur_fichier(struct_processus *s_et Line 2960  formateur_fichier(struct_processus *s_et
          *           *
          * XXXXXXX0                             longueur sur 7 bits           * XXXXXXX0                             longueur sur 7 bits
          * XXXX0011 XXXXXXXX XXXX0011           longueur sur 16 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           * XXXX0101 XXXXXXXX XXXXXXXX XXXX0101  longueur sur 24 bits
          * XXXX0111 XXXXXXXX XXXXXXXX XXXXXXXX           * XXXX0111 XXXXXXXX XXXXXXXX XXXXXXXX
          *          XXXX0111                    longueur sur 32 bits           *          XXXX0111                    longueur sur 32 bits
Line 2872  formateur_fichier(struct_processus *s_et Line 3088  formateur_fichier(struct_processus *s_et
          * 1101 10 11               matrice complex*16 (dimensions integer*4)           * 1101 10 11               matrice complex*16 (dimensions integer*4)
          * 1101 11 11               matrice complex*16 (dimensions integer*8)           * 1101 11 11               matrice complex*16 (dimensions integer*8)
          *           *
            * 1110 0 XXX               fonction de longueur XXX
            * 1110 10 LL               fonction de longueur integer*LL
            *
          * Les longueurs indiquées par le champ LL suivent l'en-tête :           * Les longueurs indiquées par le champ LL suivent l'en-tête :
          *      00 : integer*1           *      00 : integer*1
          *      01 : integer*2           *      01 : integer*2
Line 2888  formateur_fichier(struct_processus *s_et Line 3107  formateur_fichier(struct_processus *s_et
         chaine_formatee = NULL;          chaine_formatee = NULL;
         chaine_sauvegarde = 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)          else if ((*s_objet).type == CHN)
         {          {
Line 2919  formateur_fichier(struct_processus *s_et Line 3169  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'S';
                   longueur_champ = -1;
               }
   
               if (format_sortie != 'S')
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_format_fichier;
                   return(NULL);
               }
   
             longueur_reelle_chaine = longueur_chaine(s_etat_processus,              longueur_reelle_chaine = longueur_chaine(s_etat_processus,
                     (unsigned char *) (*s_objet).objet);                      (unsigned char *) (*s_objet).objet);
   
Line 2945  formateur_fichier(struct_processus *s_et Line 3208  formateur_fichier(struct_processus *s_et
                     return(NULL);                      return(NULL);
                 }                  }
   
                 if ((chaine = malloc(longueur_champ * sizeof(unsigned char)))                  if ((chaine = malloc(((size_t) longueur_champ)
                             == NULL)                          * sizeof(unsigned char))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
                             d_es_allocation_memoire;                              d_es_allocation_memoire;
                     return(NULL);                      return(NULL);
                 }                  }
   
                 memcpy(chaine, chaine_sauvegarde, longueur_champ);                  memcpy(chaine, chaine_sauvegarde, (size_t) longueur_champ);
                 longueur_chaine_traitee = longueur_champ;                  longueur_chaine_traitee = longueur_champ;
                 free(chaine_sauvegarde);                  free(chaine_sauvegarde);
             }              }
Line 2962  formateur_fichier(struct_processus *s_et Line 3225  formateur_fichier(struct_processus *s_et
   
             if (longueur_chaine_traitee < (1LL << 3))              if (longueur_chaine_traitee < (1LL << 3))
             {              {
                 if ((chaine = malloc((longueur_chaine_traitee + 1)                  if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 1)
                         * sizeof(unsigned char))) == NULL)                          * sizeof(unsigned char))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
Line 2970  formateur_fichier(struct_processus *s_et Line 3233  formateur_fichier(struct_processus *s_et
                     return(NULL);                      return(NULL);
                 }                  }
   
                 chaine[0] = 0x80 | (longueur_chaine_traitee & 0x7);                  chaine[0] = (unsigned char) (0x80 |
                           (longueur_chaine_traitee & 0x7));
   
                 memcpy(chaine + 1, chaine_sauvegarde, longueur_chaine_traitee);                  memcpy(chaine + 1, chaine_sauvegarde,
                           (size_t) longueur_chaine_traitee);
                 longueur_totale = longueur_chaine_traitee + 1;                  longueur_totale = longueur_chaine_traitee + 1;
             }              }
             else if (longueur_chaine_traitee < (1LL << 8))              else if (longueur_chaine_traitee < (1LL << 8))
             {              {
                 if ((chaine = malloc((longueur_chaine_traitee + 2)                  if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 2)
                         * sizeof(unsigned char))) == NULL)                          * sizeof(unsigned char))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
Line 2985  formateur_fichier(struct_processus *s_et Line 3250  formateur_fichier(struct_processus *s_et
                     return(NULL);                      return(NULL);
                 }                  }
   
                 chaine[0] = 0x88;                  chaine[0] = (unsigned char) 0x88;
                 chaine[1] = (unsigned char) (longueur_chaine_traitee & 0xFF);                  chaine[1] = (unsigned char) (longueur_chaine_traitee & 0xFF);
   
                 memcpy(chaine + 2, chaine_sauvegarde, longueur_chaine_traitee);                  memcpy(chaine + 2, chaine_sauvegarde,
                           (size_t) longueur_chaine_traitee);
                 longueur_totale = longueur_chaine_traitee + 2;                  longueur_totale = longueur_chaine_traitee + 2;
             }              }
             else if (longueur_chaine_traitee < (1LL << 16))              else if (longueur_chaine_traitee < (1LL << 16))
             {              {
                 if ((chaine = malloc((longueur_chaine_traitee + 3)                  if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 3)
                         * sizeof(unsigned char))) == NULL)                          * sizeof(unsigned char))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
Line 3001  formateur_fichier(struct_processus *s_et Line 3267  formateur_fichier(struct_processus *s_et
                     return(NULL);                      return(NULL);
                 }                  }
   
                 chaine[0] = 0x89;                  chaine[0] = (unsigned char) 0x89;
                 chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 8)                  chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 8)
                         & 0xFF);                          & 0xFF);
                 chaine[2] = (unsigned char) (longueur_chaine_traitee & 0xFF);                  chaine[2] = (unsigned char) (longueur_chaine_traitee & 0xFF);
   
                 memcpy(chaine + 3, chaine_sauvegarde, longueur_chaine_traitee);                  memcpy(chaine + 3, chaine_sauvegarde,
                           (size_t) longueur_chaine_traitee);
                 longueur_totale = longueur_chaine_traitee + 3;                  longueur_totale = longueur_chaine_traitee + 3;
             }              }
             else if (longueur_chaine_traitee < (1LL << 32))              else if (longueur_chaine_traitee < (1LL << 32))
             {              {
                 if ((chaine = malloc((longueur_chaine_traitee + 5)                  if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 5)
                         * sizeof(unsigned char))) == NULL)                          * sizeof(unsigned char))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
Line 3019  formateur_fichier(struct_processus *s_et Line 3286  formateur_fichier(struct_processus *s_et
                     return(NULL);                      return(NULL);
                 }                  }
   
                 chaine[0] = 0x8A;                  chaine[0] = (unsigned char) 0x8A;
                 chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 24)                  chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 24)
                         & 0xFF);                          & 0xFF);
                 chaine[2] = (unsigned char) ((longueur_chaine_traitee >> 16)                  chaine[2] = (unsigned char) ((longueur_chaine_traitee >> 16)
Line 3028  formateur_fichier(struct_processus *s_et Line 3295  formateur_fichier(struct_processus *s_et
                         & 0xFF);                          & 0xFF);
                 chaine[4] = (unsigned char) (longueur_chaine_traitee & 0xFF);                  chaine[4] = (unsigned char) (longueur_chaine_traitee & 0xFF);
   
                 memcpy(chaine + 5, chaine_sauvegarde, longueur_chaine_traitee);                  memcpy(chaine + 5, chaine_sauvegarde,
                           (size_t) longueur_chaine_traitee);
                 longueur_totale = longueur_chaine_traitee + 5;                  longueur_totale = longueur_chaine_traitee + 5;
             }              }
             else              else
             {              {
                 if ((chaine = malloc((longueur_chaine_traitee + 9)                  if ((chaine = malloc((((size_t) longueur_chaine_traitee) + 9)
                         * sizeof(unsigned char))) == NULL)                          * sizeof(unsigned char))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
Line 3041  formateur_fichier(struct_processus *s_et Line 3309  formateur_fichier(struct_processus *s_et
                     return(NULL);                      return(NULL);
                 }                  }
   
                 chaine[0] = 0x8B;                  chaine[0] = (unsigned char) 0x8B;
                 chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 56)                  chaine[1] = (unsigned char) ((longueur_chaine_traitee >> 56)
                         & 0xFF);                          & 0xFF);
                 chaine[2] = (unsigned char) ((longueur_chaine_traitee >> 48)                  chaine[2] = (unsigned char) ((longueur_chaine_traitee >> 48)
Line 3058  formateur_fichier(struct_processus *s_et Line 3326  formateur_fichier(struct_processus *s_et
                         & 0xFF);                          & 0xFF);
                 chaine[8] = (unsigned char) (longueur_chaine_traitee & 0xFF);                  chaine[8] = (unsigned char) (longueur_chaine_traitee & 0xFF);
   
                 memcpy(chaine + 9, chaine_sauvegarde, longueur_chaine_traitee);                  memcpy(chaine + 9, chaine_sauvegarde,
                           (size_t) longueur_chaine_traitee);
                 longueur_totale = longueur_chaine_traitee + 9;                  longueur_totale = longueur_chaine_traitee + 9;
             }              }
   
Line 3074  formateur_fichier(struct_processus *s_et Line 3343  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'C';
                   longueur = 8;
               }
   
             if (format_sortie != 'C')              if (format_sortie != 'C')
             {              {
                 (*s_etat_processus).erreur_execution =                  (*s_etat_processus).erreur_execution =
Line 3088  formateur_fichier(struct_processus *s_et Line 3363  formateur_fichier(struct_processus *s_et
                 return(NULL);                  return(NULL);
             }              }
         }          }
         else if ((*s_objet).type == RPN)  
         {  
   
 /*  
 --------------------------------------------------------------------------------  
   Définition  
 --------------------------------------------------------------------------------  
 */  
         }  
         else if ((*s_objet).type == INT)          else if ((*s_objet).type == INT)
         {          {
   
Line 3107  formateur_fichier(struct_processus *s_et Line 3373  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'I';
                   longueur = 8;
               }
   
             if ((format_sortie != 'I') && (format_sortie != 'R')              if ((format_sortie != 'I') && (format_sortie != 'R')
                     && (format_sortie != 'C'))                      && (format_sortie != 'C'))
             {              {
Line 3128  formateur_fichier(struct_processus *s_et Line 3400  formateur_fichier(struct_processus *s_et
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Fonction    Fonction
     Poids fort 1110
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie != 'N')
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_format_fichier;
                   return(NULL);
               }
   
               longueur_fonction = (integer8) strlen((*((struct_fonction *)
                       (*s_objet).objet)).nom_fonction);
   
               if (longueur_fonction < (1LL << 3))
               {
                   if ((chaine = malloc((1 + ((size_t) longueur_fonction) + 8)
                           * sizeof(unsigned char)))== NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = (unsigned char) (0xE0 | (longueur_fonction & 0x7));
   
                   strcpy(chaine + 1, (*((struct_fonction *) (*s_objet).objet))
                           .nom_fonction);
                   (*longueur_effective) = 1 + longueur_fonction + 8;
               }
               else if (longueur_fonction < (1LL << 8))
               {
                   if ((chaine = malloc((2 + ((size_t) longueur_fonction) + 8)
                           * sizeof(unsigned char)))== NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = (unsigned char) (0xE0 | 0x08);
                   chaine[1] = (unsigned char) (longueur_fonction & 0xFF);
   
                   strcpy(chaine + 2, (*((struct_fonction *) (*s_objet).objet))
                           .nom_fonction);
                   (*longueur_effective) = 2 + longueur_fonction + 8;
               }
               else if (longueur_fonction < (1LL << 16))
               {
                   if ((chaine = malloc((3 + ((size_t) longueur_fonction) + 8)
                           * sizeof(unsigned char)))== NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = (unsigned char ) (0xE0 | 0x09);
                   chaine[1] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
                   chaine[2] = (unsigned char) (longueur_fonction & 0xFF);
   
                   strcpy(chaine + 3, (*((struct_fonction *) (*s_objet).objet))
                           .nom_fonction);
                   (*longueur_effective) = 3 + longueur_fonction + 9;
               }
               else if (longueur_fonction < (1LL << 32))
               {
                   if ((chaine = malloc((5 + ((size_t) longueur_fonction) + 8)
                           * sizeof(unsigned char)))== NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = (unsigned char) (0xE0 | 0x0A);
                   chaine[1] = (unsigned char) ((longueur_fonction >> 24) & 0xFF);
                   chaine[2] = (unsigned char) ((longueur_fonction >> 16) & 0xFF);
                   chaine[3] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
                   chaine[4] = (unsigned char) (longueur_fonction & 0xFF);
   
                   strcpy(chaine + 5, (*((struct_fonction *) (*s_objet).objet))
                           .nom_fonction);
                   (*longueur_effective) = 5 + longueur_fonction + 8;
               }
               else
               {
                   if ((chaine = malloc((9 + ((size_t) longueur_fonction) + 8)
                           * sizeof(unsigned char)))== NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = (unsigned char) (0xE0 | 0x0B);
                   chaine[1] = (unsigned char) ((longueur_fonction >> 56) & 0xFF);
                   chaine[2] = (unsigned char) ((longueur_fonction >> 48) & 0xFF);
                   chaine[3] = (unsigned char) ((longueur_fonction >> 40) & 0xFF);
                   chaine[4] = (unsigned char) ((longueur_fonction >> 32) & 0xFF);
                   chaine[5] = (unsigned char) ((longueur_fonction >> 24) & 0xFF);
                   chaine[6] = (unsigned char) ((longueur_fonction >> 16) & 0xFF);
                   chaine[7] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
                   chaine[8] = (unsigned char) (longueur_fonction & 0xFF);
   
                   strcpy(chaine + 9, (*((struct_fonction *) (*s_objet).objet))
                           .nom_fonction);
                   (*longueur_effective) = 9 + longueur_fonction + 8;
               }
   
               for(i = 1; i <= 8; i++)
               {
                   chaine[(*longueur_effective) - i] = (unsigned char)
                           (((*((struct_fonction *) (*s_objet).objet))
                           .nombre_arguments >> ((8 - i) * 8)) & 0xFF);
               }
         }          }
         else if ((*s_objet).type == LST)          else if (((*s_objet).type == LST) || ((*s_objet).type == ALG)
                   || ((*s_objet).type == RPN))
         {          {
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Liste    Liste
   Poids fort 0100    Poids fort 0100
   
     Expression algébrique
     Poids fort 0111
   
     Définition
     Poids fort 0110
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 3150  formateur_fichier(struct_processus *s_et Line 3542  formateur_fichier(struct_processus *s_et
                 return(NULL);                  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.              // Calcul de la longueur de la liste.
   
             longueur_liste = 0;              longueur_liste = 0;
Line 3163  formateur_fichier(struct_processus *s_et Line 3568  formateur_fichier(struct_processus *s_et
   
             if (longueur_liste < (1LL << 3))              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))              else if (longueur_liste < (1LL << 8))
             {              {
                 chaine[0] = 0x48;                  chaine[0] = (unsigned char) (type_binaire | 0x08);
             }              }
             else if (longueur_liste < (1LL << 16))              else if (longueur_liste < (1LL << 16))
             {              {
                 chaine[0] = 0x49;                  chaine[0] = (unsigned char ) (type_binaire | 0x09);
             }              }
             else if (longueur_liste < (1LL << 32))              else if (longueur_liste < (1LL << 32))
             {              {
                 chaine[0] = 0x4A;                  chaine[0] = (unsigned char) (type_binaire | 0x0A);
             }              }
             else              else
             {              {
                 chaine[0] = 0x4B;                  chaine[0] = (unsigned char) (type_binaire | 0x0B);
             }              }
   
             longueur_totale = 1;              longueur_totale = 1;
Line 3192  formateur_fichier(struct_processus *s_et Line 3598  formateur_fichier(struct_processus *s_et
                     {                      {
                         longueur_totale += 1;                          longueur_totale += 1;
   
                         if ((chaine = realloc(chaine, longueur_totale *                          if ((chaine = realloc(chaine,
                                   ((size_t) longueur_totale) *
                                 sizeof(unsigned char))) == NULL)                                  sizeof(unsigned char))) == NULL)
                         {                          {
                             (*s_etat_processus).erreur_systeme =                              (*s_etat_processus).erreur_systeme =
Line 3209  formateur_fichier(struct_processus *s_et Line 3616  formateur_fichier(struct_processus *s_et
                     {                      {
                         longueur_totale += 2;                          longueur_totale += 2;
   
                         if ((chaine = realloc(chaine, longueur_totale *                          if ((chaine = realloc(chaine,
                                   ((size_t) longueur_totale) *
                                 sizeof(unsigned char))) == NULL)                                  sizeof(unsigned char))) == NULL)
                         {                          {
                             (*s_etat_processus).erreur_systeme =                              (*s_etat_processus).erreur_systeme =
Line 3228  formateur_fichier(struct_processus *s_et Line 3636  formateur_fichier(struct_processus *s_et
                     {                      {
                         longueur_totale += 4;                          longueur_totale += 4;
   
                         if ((chaine = realloc(chaine, longueur_totale *                          if ((chaine = realloc(chaine,
                                   ((size_t) longueur_totale) *
                                 sizeof(unsigned char))) == NULL)                                  sizeof(unsigned char))) == NULL)
                         {                          {
                             (*s_etat_processus).erreur_systeme =                              (*s_etat_processus).erreur_systeme =
Line 3251  formateur_fichier(struct_processus *s_et Line 3660  formateur_fichier(struct_processus *s_et
                     {                      {
                         longueur_totale += 8;                          longueur_totale += 8;
   
                         if ((chaine = realloc(chaine, longueur_totale *                          if ((chaine = realloc(chaine,
                                   ((size_t) longueur_totale) *
                                 sizeof(unsigned char))) == NULL)                                  sizeof(unsigned char))) == NULL)
                         {                          {
                             (*s_etat_processus).erreur_systeme =                              (*s_etat_processus).erreur_systeme =
Line 3298  formateur_fichier(struct_processus *s_et Line 3708  formateur_fichier(struct_processus *s_et
                         (((*(*l_element_courant_format).donnee).type == TBL)                          (((*(*l_element_courant_format).donnee).type == TBL)
                         && ((*(*l_element_courant).donnee).type == TBL)))                          && ((*(*l_element_courant).donnee).type == TBL)))
                 {                  {
                     if ((chaine_formatee = formateur_fichier(s_etat_processus,                      if (format_sortie != 'N')
                             (*l_element_courant).donnee,  
                             (*l_element_courant_format).donnee, 0, 0, ' ', 'U',  
                             longueur_effective, recursivite, export_fichier))  
                             == NULL)  
                     {                      {
                         return(NULL);                          if ((chaine_formatee = formateur_fichier(
                                   s_etat_processus,
                                   (*l_element_courant).donnee,
                                   (*l_element_courant_format).donnee,
                                   0, 0, ' ', 'U', longueur_effective, recursivite,
                                   export_fichier)) == NULL)
                           {
                               return(NULL);
                           }
                       }
                       else
                       {
                           if ((chaine_formatee = formateur_fichier(
                                   s_etat_processus,
                                   (*l_element_courant).donnee,
                                   (*l_element_courant_format).donnee,
                                   0, 0, 'N', 'U', longueur_effective, recursivite,
                                   export_fichier)) == NULL)
                           {
                               return(NULL);
                           }
                     }                      }
   
                     if ((chaine = realloc(chaine, (longueur_totale +                      if ((chaine = realloc(chaine, ((size_t) (longueur_totale +
                             (*longueur_effective)) * sizeof(unsigned char)))                              (*longueur_effective))) * sizeof(unsigned char)))
                             == NULL)                              == NULL)
                     {                      {
                         (*s_etat_processus).erreur_systeme =                          (*s_etat_processus).erreur_systeme =
Line 3317  formateur_fichier(struct_processus *s_et Line 3743  formateur_fichier(struct_processus *s_et
                     }                      }
   
                     memcpy(&(chaine[longueur_totale]), chaine_formatee,                      memcpy(&(chaine[longueur_totale]), chaine_formatee,
                             (*longueur_effective));                              (size_t) (*longueur_effective));
                     longueur_totale += (*longueur_effective);                      longueur_totale += (*longueur_effective);
                     free(chaine_formatee);                      free(chaine_formatee);
                 }                  }
Line 3366  formateur_fichier(struct_processus *s_et Line 3792  formateur_fichier(struct_processus *s_et
                         position_1 = 10;                          position_1 = 10;
                         format_degenere = d_vrai;                          format_degenere = d_vrai;
                     }                      }
                       else if (strcmp("NATIVE*(*)", format_chaine) == 0)
                       {
                           format_sortie = 'N';
                           position_1 = 7;
                           format_degenere = d_vrai;
                       }
                     else                      else
                     {                      {
                         free(chaine);                          free(chaine);
Line 3388  formateur_fichier(struct_processus *s_et Line 3820  formateur_fichier(struct_processus *s_et
   
                     if (strcmp(&(format_chaine[position_1]), "(*)") != 0)                      if (strcmp(&(format_chaine[position_1]), "(*)") != 0)
                     {                      {
                         if (sscanf(&(format_chaine[position_1]), "%ld",                          if (sscanf(&(format_chaine[position_1]), "%lld",
                                 &longueur) != 1)                                  &longueur) != 1)
                         {                          {
                             free(chaine);                              free(chaine);
Line 3408  formateur_fichier(struct_processus *s_et Line 3840  formateur_fichier(struct_processus *s_et
                     }                      }
   
                     free(format_chaine);                      free(format_chaine);
                   
                       // Si le format_sortie vaut 'N', on remplace le format par
                       // { "native*(*)" }. L'intérêt est de pouvoir traiter une
                       // liste par un format "native*(*)".
   
                       if ((format_sortie == 'N') && ((*(*l_element_courant)
                               .donnee).type == LST))
                       {
                           if ((s_format_tmp = allocation(s_etat_processus, LST))
                                   == NULL)
                           {
                               return(NULL);
                           }
   
                           if (((*s_format_tmp).objet = allocation_maillon(
                                   s_etat_processus)) == NULL)
                           {
                               return(NULL);
                           }
   
                           (*((struct_liste_chainee *) (*s_format_tmp).objet))
                                   .suivant = NULL;
   
                           if (((*((struct_liste_chainee *) (*s_format_tmp).objet))
                                   .donnee = allocation(s_etat_processus, CHN))
                                   == NULL)
                           {
                               return(NULL);
                           }
   
                           if (((*(*((struct_liste_chainee *) (*s_format_tmp)
                                   .objet)).donnee).objet = malloc(11 *
                                   sizeof(unsigned char))) == NULL)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_allocation_memoire;
                               return(NULL);
                           }
   
                           strcpy((unsigned char *) (*(*((struct_liste_chainee *)
                                   (*s_format_tmp).objet)).donnee).objet,
                                   "native*(*)");
                       }
                       else
                       {
                           if ((s_format_tmp = copie_objet(s_etat_processus,
                                   s_format, 'P')) == NULL)
                           {
                               return(NULL);
                           }
                       }
   
                     if ((chaine_formatee = formateur_fichier(s_etat_processus,                      if ((chaine_formatee = formateur_fichier(s_etat_processus,
                             (*l_element_courant).donnee, s_format,                              (*l_element_courant).donnee, s_format_tmp,
                             longueur, longueur_champ, format_sortie, type,                              longueur, longueur_champ, format_sortie, type,
                             longueur_effective, recursivite, export_fichier))                              longueur_effective, recursivite, export_fichier))
                             == NULL)                              == NULL)
                     {                      {
                           liberation(s_etat_processus, s_format_tmp);
                         free(chaine);                          free(chaine);
                         return(NULL);                          return(NULL);
                     }                      }
   
                       liberation(s_etat_processus, s_format_tmp);
   
                     if ((chaine = realloc(chaine,                      if ((chaine = realloc(chaine,
                             (longueur_totale + (*longueur_effective))                              ((size_t) (longueur_totale + (*longueur_effective)))
                             * sizeof(unsigned char))) == NULL)                              * sizeof(unsigned char))) == NULL)
                     {                      {
                         (*s_etat_processus).erreur_systeme =                          (*s_etat_processus).erreur_systeme =
Line 3429  formateur_fichier(struct_processus *s_et Line 3915  formateur_fichier(struct_processus *s_et
                     }                      }
   
                     memcpy(&(chaine[longueur_totale]), chaine_formatee,                      memcpy(&(chaine[longueur_totale]), chaine_formatee,
                             (*longueur_effective));                              (size_t) (*longueur_effective));
                     longueur_totale += (*longueur_effective);                      longueur_totale += (*longueur_effective);
                     free(chaine_formatee);                      free(chaine_formatee);
                 }                  }
   
                   if (format_sortie != 'N')
                   {
                       l_element_courant_format =
                               (*l_element_courant_format).suivant;
                   }
   
                 nombre_elements++;                  nombre_elements++;
                 l_element_courant = (*l_element_courant).suivant;                  l_element_courant = (*l_element_courant).suivant;
                 l_element_courant_format = (*l_element_courant_format).suivant;  
             }              }
   
             if ((l_element_courant != NULL) ||              if (format_sortie != 'N')
                     (l_element_courant_format != NULL))  
             {              {
                 free(chaine);                  if ((l_element_courant != NULL) ||
                           (l_element_courant_format != NULL))
                   {
                       free(chaine);
   
                 (*s_etat_processus).erreur_execution =                      (*s_etat_processus).erreur_execution =
                         d_ex_erreur_format_fichier;                              d_ex_erreur_format_fichier;
                 return(NULL);                      return(NULL);
                   }
             }              }
   
             (*longueur_effective) = longueur_totale;              (*longueur_effective) = longueur_totale;
Line 3493  formateur_fichier(struct_processus *s_et Line 3987  formateur_fichier(struct_processus *s_et
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Nom    Nom
     Poids fort 0101
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
               if (format_sortie != 'N')
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_format_fichier;
                   return(NULL);
               }
   
               longueur_fonction = (integer8) strlen((*((struct_nom *)
                       (*s_objet).objet)).nom);
   
               if (longueur_fonction < (1LL << 3))
               {
                   if ((chaine = malloc((1 + ((size_t) longueur_fonction) + 1)
                           * sizeof(unsigned char)))== NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = (unsigned char) (0x50 | (longueur_fonction & 0x7));
   
                   strcpy(chaine + 1, (*((struct_nom *) (*s_objet).objet)).nom);
                   (*longueur_effective) = longueur_fonction + 2;
               }
               else if (longueur_fonction < (1LL << 8))
               {
                   if ((chaine = malloc((2 + ((size_t) longueur_fonction) + 1)
                           * sizeof(unsigned char)))== NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = (unsigned char) (0x50 | 0x08);
                   chaine[1] = (unsigned char) (longueur_fonction & 0xFF);
   
                   strcpy(chaine + 2, (*((struct_nom *) (*s_objet).objet)).nom);
                   (*longueur_effective) = longueur_fonction + 3;
               }
               else if (longueur_fonction < (1LL << 16))
               {
                   if ((chaine = malloc((3 + ((size_t) longueur_fonction) + 1)
                           * sizeof(unsigned char)))== NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = (unsigned char) (0x50 | 0x09);
                   chaine[1] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
                   chaine[2] = (unsigned char) (longueur_fonction & 0xFF);
   
                   strcpy(chaine + 3, (*((struct_nom *) (*s_objet).objet)).nom);
                   (*longueur_effective) = longueur_fonction + 4;
               }
               else if (longueur_fonction < (1LL << 32))
               {
                   if ((chaine = malloc((5 + ((size_t) longueur_fonction) + 1)
                           * sizeof(unsigned char)))== NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = (unsigned char) (0xE0 | 0x0A);
                   chaine[1] = (unsigned char) ((longueur_fonction >> 24) & 0xFF);
                   chaine[2] = (unsigned char) ((longueur_fonction >> 16) & 0xFF);
                   chaine[3] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
                   chaine[4] = (unsigned char) (longueur_fonction & 0xFF);
   
                   strcpy(chaine + 5, (*((struct_nom *) (*s_objet).objet)).nom);
                   (*longueur_effective) = longueur_fonction + 6;
               }
               else
               {
                   if ((chaine = malloc((9 + ((size_t) longueur_fonction) + 1)
                           * sizeof(unsigned char)))== NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = (unsigned char) (0xE0 | 0x0B);
                   chaine[1] = (unsigned char) ((longueur_fonction >> 56) & 0xFF);
                   chaine[2] = (unsigned char) ((longueur_fonction >> 48) & 0xFF);
                   chaine[3] = (unsigned char) ((longueur_fonction >> 40) & 0xFF);
                   chaine[4] = (unsigned char) ((longueur_fonction >> 32) & 0xFF);
                   chaine[5] = (unsigned char) ((longueur_fonction >> 24) & 0xFF);
                   chaine[6] = (unsigned char) ((longueur_fonction >> 16) & 0xFF);
                   chaine[7] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
                   chaine[8] = (unsigned char) (longueur_fonction & 0xFF);
   
                   strcpy(chaine + 9, (*((struct_nom *) (*s_objet).objet)).nom);
                   (*longueur_effective) = longueur_fonction + 10;
               }
   
               chaine[(*longueur_effective) - 1] = ((*((struct_nom *)
                       (*s_objet).objet)).symbole == d_vrai) ? 0xFF : 0x00;
         }          }
         else if ((*s_objet).type == REL)          else if ((*s_objet).type == REL)
         {          {
Line 3506  formateur_fichier(struct_processus *s_et Line 4104  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'R';
                   longueur = 8;
               }
   
             if ((format_sortie != 'R') && (format_sortie != 'C'))              if ((format_sortie != 'R') && (format_sortie != 'C'))
             {              {
                 (*s_etat_processus).erreur_execution =                  (*s_etat_processus).erreur_execution =
Line 3568  formateur_fichier(struct_processus *s_et Line 4172  formateur_fichier(struct_processus *s_et
   
             if (longueur_totale < (((integer8) 1) << 7))              if (longueur_totale < (((integer8) 1) << 7))
             {              {
                 tampon[0] = ((longueur_totale + 1) << 1) & 0xFF;                  tampon[0] = (unsigned char) (((longueur_totale + 1) << 1)
                           & 0xFF);
   
                 if ((chaine = realloc(chaine, (longueur_totale + 1)                  if ((chaine = realloc(chaine, (((size_t) longueur_totale) + 1)
                         * sizeof(unsigned char))) == NULL)                          * sizeof(unsigned char))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
Line 3582  formateur_fichier(struct_processus *s_et Line 4187  formateur_fichier(struct_processus *s_et
                 memcpy(&(chaine[longueur_totale]), tampon, 1);                  memcpy(&(chaine[longueur_totale]), tampon, 1);
                 longueur_totale += 1;                  longueur_totale += 1;
             }              }
             else if (longueur_totale < (((integer8) 1) << 16))              else
             {              {
                 longueur_totale++;                  longueur_totale++;
   
                 for(i = 0; i < 7; i++)                  // i = { 0 (16 bits) 2 (32 bits) 6 (64 bits) }
   
                   i = 0;
   
                   for(;;)
                 {                  {
                     if ((longueur_totale < (((integer8) 1) << (8 * (i + 2))))                      if ((longueur_totale < (((integer8) 1) << (8 * (i + 2))))
                             || (i == 6))                              || (i == 6))
                     {                      {
                         // 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 */                                  | 0x1 /* longueur supérieure à 7 bits */
                                 | ((i + 1) << 1);                                  | ((i + 1) << 1));
   
                         for(j = 0; j <= i; j++)                          for(j = 0; j <= i; j++)
                         {                          {
                             tampon[(i - j) + 1] = (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 */                                  | 0x1 /* longueur supérieure à 7 bits */
                                 | ((i + 1) << 1);                                  | ((i + 1) << 1));
                         break;                          break;
                     }                      }
   
                       switch(i)
                       {
                           case 0 :
                           {
                               i = 2;
                               break;
                           }
   
                           case 2 :
                           {
                               i = 6;
                               break;
                           }
                       }
                 }                  }
   
                 if ((chaine = realloc(chaine, (longueur_totale + 3)                  // i = 0 => +3 (16 bits)
                   // i = 2 => +5 (32 bits)
                   // i = 6 => +9 (64 bits)
   
                   if ((chaine = realloc(chaine, (((size_t) longueur_totale)
                           + ((i == 0) ? 3 : ((i == 2) ? 5 : 9)))
                         * sizeof(unsigned char))) == NULL)                          * sizeof(unsigned char))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
Line 3621  formateur_fichier(struct_processus *s_et Line 4252  formateur_fichier(struct_processus *s_et
                 memcpy(&(chaine[longueur_totale]), tampon, 3);                  memcpy(&(chaine[longueur_totale]), tampon, 3);
                 longueur_totale += 3;                  longueur_totale += 3;
             }              }
             else if (longueur_totale < (((integer8) 1) << 32))  
             {  
             }  
   
             __zone();              __zone();
             (*longueur_effective) = longueur_totale;              (*longueur_effective) = longueur_totale;
Line 3659  formateur_fichier(struct_processus *s_et Line 4287  formateur_fichier(struct_processus *s_et
 unsigned char *  unsigned char *
 formateur_fichier_nombre(struct_processus *s_etat_processus,  formateur_fichier_nombre(struct_processus *s_etat_processus,
         void *valeur_numerique, unsigned char type,          void *valeur_numerique, unsigned char type,
         long longueur, long longueur_champ, unsigned char format)          integer8 longueur, integer8 longueur_champ, unsigned char format)
 {  {
     unsigned char               *chaine;      unsigned char               *chaine;
     unsigned char               *construction_chaine;      unsigned char               *construction_chaine;
Line 3799  formateur_fichier_nombre(struct_processu Line 4427  formateur_fichier_nombre(struct_processu
 unsigned char *  unsigned char *
 formateur_fichier_reel(struct_processus *s_etat_processus,  formateur_fichier_reel(struct_processus *s_etat_processus,
         void *valeur_numerique, unsigned char type,          void *valeur_numerique, unsigned char type,
         long longueur, long longueur_champ,          integer8 longueur, integer8 longueur_champ,
         unsigned char format_sortie)          unsigned char format_sortie)
 {  {
     real8                   mantisse;      real8                   mantisse;
     real8                   tampon_reel;      real8                   tampon_reel;
   
       integer8                i;
     integer8                tampon_entier;      integer8                tampon_entier;
   
     long                    correction;      long                    correction;
Line 3817  formateur_fichier_reel(struct_processus Line 4446  formateur_fichier_reel(struct_processus
     unsigned char           mode[3 + 1];      unsigned char           mode[3 + 1];
     unsigned char           tampon[16 + 1];      unsigned char           tampon[16 + 1];
   
     unsigned long           i;  
   
     chaine = (unsigned char *) malloc((32 + 1) * sizeof(unsigned char));      chaine = (unsigned char *) malloc((32 + 1) * sizeof(unsigned char));
   
     if (chaine == NULL)      if (chaine == NULL)
Line 3844  formateur_fichier_reel(struct_processus Line 4471  formateur_fichier_reel(struct_processus
             exposant = 0;              exposant = 0;
         }          }
   
         mantisse = (*((real8 *) valeur_numerique)) / pow(10, exposant);          mantisse = (*((real8 *) valeur_numerique)) / pow(10, (double) exposant);
     }      }
     else      else
     {      {
Line 3852  formateur_fichier_reel(struct_processus Line 4479  formateur_fichier_reel(struct_processus
   
         if (tampon_entier > ((integer8) 0))          if (tampon_entier > ((integer8) 0))
         {          {
             exposant = (long) floor(log10(tampon_entier));              exposant = (long) floor(log10((double) tampon_entier));
         }          }
         else if (tampon_entier < ((integer8) 0))          else if (tampon_entier < ((integer8) 0))
         {          {
             exposant = (long) floor(log10(-tampon_entier));              exposant = (long) floor(log10((double) -tampon_entier));
         }          }
         else          else
         {          {
             exposant = 0;              exposant = 0;
         }          }
   
         mantisse = (*((integer8 *) valeur_numerique)) / pow(10, exposant);          mantisse = ((real8) (*((integer8 *) valeur_numerique))) /
                   pow(10, (double) exposant);
     }      }
   
     longueur_utile = longueur;      longueur_utile = (long) longueur;
     longueur_utile_limite = 15;      longueur_utile_limite = 15;
   
     if (longueur_utile > longueur_utile_limite)      if (longueur_utile > longueur_utile_limite)
Line 3927  formateur_fichier_reel(struct_processus Line 4555  formateur_fichier_reel(struct_processus
   
         sprintf(format, "%%.%luf", longueur_utile);          sprintf(format, "%%.%luf", longueur_utile);
   
         sprintf(tampon, format, (mantisse * pow(10, exposant)));          sprintf(tampon, format, (mantisse * pow(10, (double) exposant)));
         strcpy(chaine, tampon);          strcpy(chaine, tampon);
     }      }
     else if (strcmp(mode, "ENG") == 0)      else if (strcmp(mode, "ENG") == 0)
Line 3950  formateur_fichier_reel(struct_processus Line 4578  formateur_fichier_reel(struct_processus
         longueur_utile -= correction;          longueur_utile -= correction;
         sprintf(format, "%%.%luf", longueur_utile);          sprintf(format, "%%.%luf", longueur_utile);
   
         sprintf(tampon, format, (mantisse * pow(10, correction)));          sprintf(tampon, format, (mantisse * pow(10, (double) correction)));
         strcpy(chaine, tampon);          strcpy(chaine, tampon);
         strcat(chaine, "E");          strcat(chaine, "E");
         sprintf(tampon, "%ld", (exposant - correction));          sprintf(tampon, "%ld", (exposant - correction));
Line 3980  formateur_fichier_reel(struct_processus Line 4608  formateur_fichier_reel(struct_processus
   
             sprintf(tampon, format, *((real8 *) valeur_numerique));              sprintf(tampon, format, *((real8 *) valeur_numerique));
   
             i = strlen(tampon) - 1;              i = (integer8) (strlen(tampon)) - 1;
             while(tampon[i] == '0')              while(tampon[i] == '0')
             {              {
                 tampon[i] = 0;                  tampon[i] = 0;
Line 3989  formateur_fichier_reel(struct_processus Line 4617  formateur_fichier_reel(struct_processus
   
             if (ds_imposition_separateur_decimal == d_faux)              if (ds_imposition_separateur_decimal == d_faux)
             {              {
                 i = strlen(tampon) - 1;                  i = ((integer8) strlen(tampon)) - 1;
                 if (tampon[i] == '.')                  if (tampon[i] == '.')
                 {                  {
                     tampon[i] = 0;                      tampon[i] = 0;
Line 4004  formateur_fichier_reel(struct_processus Line 4632  formateur_fichier_reel(struct_processus
     {      {
         if (strlen(chaine) > (size_t) longueur_champ)          if (strlen(chaine) > (size_t) longueur_champ)
         {          {
             for(i = 0; i < (unsigned long) longueur_champ; i++)              for(i = 0; i < longueur_champ; i++)
             {              {
                 chaine[i] = '*';                  chaine[i] = '*';
             }              }
Line 4026  formateur_fichier_reel(struct_processus Line 4654  formateur_fichier_reel(struct_processus
 unsigned char *  unsigned char *
 formateur_fichier_binaire_nombre(struct_processus *s_etat_processus,  formateur_fichier_binaire_nombre(struct_processus *s_etat_processus,
         void *valeur_numerique, unsigned char type_entree,          void *valeur_numerique, unsigned char type_entree,
         unsigned char type, long longueur, long *longueur_conversion)          unsigned char type, integer8 longueur, integer8 *longueur_conversion)
 {  {
     unsigned char               *chaine;      unsigned char               *chaine;
   
Line 4060  formateur_fichier_binaire_nombre(struct_ Line 4688  formateur_fichier_binaire_nombre(struct_
                     }                      }
   
                     (*longueur_conversion) = 2;                      (*longueur_conversion) = 2;
                     chaine[0] = 0x10;                      chaine[0] = (unsigned char) 0x10;
                     chaine[1] = (*((integer8 *) valeur_numerique)) & 0xFF;                      chaine[1] = (unsigned char) ((*((integer8 *)
                               valeur_numerique)) & 0xFF);
                     break;                      break;
                 }                  }
   
Line 4083  formateur_fichier_binaire_nombre(struct_ Line 4712  formateur_fichier_binaire_nombre(struct_
                     }                      }
   
                     (*longueur_conversion) = 3;                      (*longueur_conversion) = 3;
                     chaine[0] = 0x11;                      chaine[0] = (unsigned char) 0x11;
                     chaine[1] = ((*((integer8 *) valeur_numerique)) >> 8)                      chaine[1] = ((unsigned char) ((*((integer8 *)
                             & 0xFF;                              valeur_numerique)) >> 8) & 0xFF);
                     chaine[2] = (*((integer8 *) valeur_numerique)) & 0xFF;                      chaine[2] = (unsigned char) ((*((integer8 *)
                               valeur_numerique)) & 0xFF);
                     break;                      break;
                 }                  }
   
                 case 4:                  case 4:
                 {                  {
                     if ((*((integer8 *) valeur_numerique)) !=                      if ((*((integer8 *) valeur_numerique)) !=
                             ((integer2) (*((integer8 *) valeur_numerique))))                              ((integer4) (*((integer8 *) valeur_numerique))))
                     {                      {
                         (*s_etat_processus).erreur_execution =                          (*s_etat_processus).erreur_execution =
                                 d_ex_representation;                                  d_ex_representation;
Line 4108  formateur_fichier_binaire_nombre(struct_ Line 4738  formateur_fichier_binaire_nombre(struct_
                     }                      }
   
                     (*longueur_conversion) = 5;                      (*longueur_conversion) = 5;
                     chaine[0] = 0x12;                      chaine[0] = (unsigned char) 0x12;
                     chaine[1] = ((*((integer8 *) valeur_numerique)) >> 24)                      chaine[1] = (unsigned char) (((*((integer8 *)
                             & 0xFF;                              valeur_numerique)) >> 24) & 0xFF);
                     chaine[2] = ((*((integer8 *) valeur_numerique)) >> 16)                      chaine[2] = (unsigned char) (((*((integer8 *)
                             & 0xFF;                              valeur_numerique)) >> 16) & 0xFF);
                     chaine[3] = ((*((integer8 *) valeur_numerique)) >> 8)                      chaine[3] = (unsigned char) (((*((integer8 *)
                             & 0xFF;                              valeur_numerique)) >> 8) & 0xFF);
                     chaine[4] = (*((integer8 *) valeur_numerique)) & 0xFF;                      chaine[4] = (unsigned char) ((*((integer8 *)
                               valeur_numerique)) & 0xFF);
                     break;                      break;
                 }                  }
   
Line 4129  formateur_fichier_binaire_nombre(struct_ Line 4760  formateur_fichier_binaire_nombre(struct_
                     }                      }
   
                     (*longueur_conversion) = 9;                      (*longueur_conversion) = 9;
                     chaine[0] = 0x13;                      chaine[0] = (unsigned char) 0x13;
                     chaine[1] = ((*((integer8 *) valeur_numerique)) >> 56)                      chaine[1] = (unsigned char) (((*((integer8 *)
                             & 0xFF;                              valeur_numerique)) >> 56) & 0xFF);
                     chaine[2] = ((*((integer8 *) valeur_numerique)) >> 48)                      chaine[2] = (unsigned char) (((*((integer8 *)
                             & 0xFF;                              valeur_numerique)) >> 48) & 0xFF);
                     chaine[3] = ((*((integer8 *) valeur_numerique)) >> 40)                      chaine[3] = (unsigned char) (((*((integer8 *)
                             & 0xFF;                              valeur_numerique)) >> 40) & 0xFF);
                     chaine[4] = ((*((integer8 *) valeur_numerique)) >> 32)                      chaine[4] = (unsigned char) (((*((integer8 *)
                             & 0xFF;                              valeur_numerique)) >> 32) & 0xFF);
                     chaine[5] = ((*((integer8 *) valeur_numerique)) >> 24)                      chaine[5] = (unsigned char) (((*((integer8 *)
                             & 0xFF;                              valeur_numerique)) >> 24) & 0xFF);
                     chaine[6] = ((*((integer8 *) valeur_numerique)) >> 16)                      chaine[6] = (unsigned char) (((*((integer8 *)
                             & 0xFF;                              valeur_numerique)) >> 16) & 0xFF);
                     chaine[7] = ((*((integer8 *) valeur_numerique)) >> 8)                      chaine[7] = (unsigned char) (((*((integer8 *)
                             & 0xFF;                              valeur_numerique)) >> 8) & 0xFF);
                     chaine[8] = (*((integer8 *) valeur_numerique)) & 0xFF;                      chaine[8] = (unsigned char) ((*((integer8 *)
                               valeur_numerique)) & 0xFF);
                     break;                      break;
                 }                  }
   
Line 4181  formateur_fichier_binaire_nombre(struct_ Line 4813  formateur_fichier_binaire_nombre(struct_
                     }                      }
                     else if (type_entree == 'I')                      else if (type_entree == 'I')
                     {                      {
                         valeur = (*((integer8 *) valeur_numerique));                          valeur = (real8) (*((integer8 *) valeur_numerique));
                     }                      }
                     else                      else
                     {                      {
Line 4218  formateur_fichier_binaire_nombre(struct_ Line 4850  formateur_fichier_binaire_nombre(struct_
   
                     eq4.r4 = (real4) valeur;                      eq4.r4 = (real4) valeur;
                     (*longueur_conversion) = 5;                      (*longueur_conversion) = 5;
                     chaine[0] = 0x14;                      chaine[0] = (unsigned char) 0x14;
                     chaine[1] = (eq4.i4 >> 24) & 0xFF;                      chaine[1] = (unsigned char) ((eq4.i4 >> 24) & 0xFF);
                     chaine[2] = (eq4.i4 >> 16) & 0xFF;                      chaine[2] = (unsigned char) ((eq4.i4 >> 16) & 0xFF);
                     chaine[3] = (eq4.i4 >> 8) & 0xFF;                      chaine[3] = (unsigned char) ((eq4.i4 >> 8) & 0xFF);
                     chaine[4] = eq4.i4 & 0xFF;                      chaine[4] = (unsigned char) (eq4.i4 & 0xFF);
                     break;                      break;
                 }                  }
   
Line 4243  formateur_fichier_binaire_nombre(struct_ Line 4875  formateur_fichier_binaire_nombre(struct_
   
                     if (type_entree == 'I')                      if (type_entree == 'I')
                     {                      {
                         eq8.r8 = (*((integer8 *) valeur_numerique));                          eq8.r8 = (real8) (*((integer8 *) valeur_numerique));
                     }                      }
                     else if (type_entree == 'R')                      else if (type_entree == 'R')
                     {                      {
Line 4257  formateur_fichier_binaire_nombre(struct_ Line 4889  formateur_fichier_binaire_nombre(struct_
                     }                      }
   
                     (*longueur_conversion) = 9;                      (*longueur_conversion) = 9;
                     chaine[0] = 0x15;                      chaine[0] = (unsigned char) (0x15);
                     chaine[1] = (eq8.i8 >> 56) & 0xFF;                      chaine[1] = (unsigned char) ((eq8.i8 >> 56) & 0xFF);
                     chaine[2] = (eq8.i8 >> 48) & 0xFF;                      chaine[2] = (unsigned char) ((eq8.i8 >> 48) & 0xFF);
                     chaine[3] = (eq8.i8 >> 40) & 0xFF;                      chaine[3] = (unsigned char) ((eq8.i8 >> 40) & 0xFF);
                     chaine[4] = (eq8.i8 >> 32) & 0xFF;                      chaine[4] = (unsigned char) ((eq8.i8 >> 32) & 0xFF);
                     chaine[5] = (eq8.i8 >> 24) & 0xFF;                      chaine[5] = (unsigned char) ((eq8.i8 >> 24) & 0xFF);
                     chaine[6] = (eq8.i8 >> 16) & 0xFF;                      chaine[6] = (unsigned char) ((eq8.i8 >> 16) & 0xFF);
                     chaine[7] = (eq8.i8 >> 8) & 0xFF;                      chaine[7] = (unsigned char) ((eq8.i8 >> 8) & 0xFF);
                     chaine[8] = eq8.i8 & 0xFF;                      chaine[8] = (unsigned char) (eq8.i8 & 0xFF);
                     break;                      break;
                 }                  }
   
Line 4289  formateur_fichier_binaire_nombre(struct_ Line 4921  formateur_fichier_binaire_nombre(struct_
                     unsigned char       *partie_reelle;                      unsigned char       *partie_reelle;
                     unsigned char       *partie_imaginaire;                      unsigned char       *partie_imaginaire;
   
                     long                limag;                      integer8            limag;
                     long                lreel;                      integer8            lreel;
   
                     real8               zero;                      real8               zero;
   
Line 4363  formateur_fichier_binaire_nombre(struct_ Line 4995  formateur_fichier_binaire_nombre(struct_
                         return(NULL);                          return(NULL);
                     }                      }
   
                     if ((chaine = malloc((lreel + limag - 1) *                      if ((chaine = malloc((((size_t) lreel) + ((size_t) limag)
                             sizeof(unsigned char))) == NULL)                              - 1) * sizeof(unsigned char))) == NULL)
                     {                      {
                         free(partie_reelle);                          free(partie_reelle);
                         free(partie_imaginaire);                          free(partie_imaginaire);
Line 4374  formateur_fichier_binaire_nombre(struct_ Line 5006  formateur_fichier_binaire_nombre(struct_
                         return(NULL);                          return(NULL);
                     }                      }
   
                     chaine[0] = 0x18;                      chaine[0] = (unsigned char) 0x18;
                     memcpy(chaine + 1, partie_reelle + 1, lreel - 1);                      memcpy(chaine + 1, partie_reelle + 1,
                     memcpy(chaine + lreel, partie_imaginaire + 1, limag - 1);                              ((size_t) lreel) - 1);
                       memcpy(chaine + lreel, partie_imaginaire + 1,
                               ((size_t) limag) - 1);
                     (*longueur_conversion) = lreel + limag - 1;                      (*longueur_conversion) = lreel + limag - 1;
   
                     free(partie_reelle);                      free(partie_reelle);
Line 4389  formateur_fichier_binaire_nombre(struct_ Line 5023  formateur_fichier_binaire_nombre(struct_
                     unsigned char       *partie_reelle;                      unsigned char       *partie_reelle;
                     unsigned char       *partie_imaginaire;                      unsigned char       *partie_imaginaire;
   
                     long                limag;                      integer8            limag;
                     long                lreel;                      integer8            lreel;
   
                     real8               zero;                      real8               zero;
   
                     if (type_entree == 'I')                      if (type_entree == 'I')
Line 4462  formateur_fichier_binaire_nombre(struct_ Line 5097  formateur_fichier_binaire_nombre(struct_
                         return(NULL);                          return(NULL);
                     }                      }
   
                     if ((chaine = malloc((lreel + limag - 1) *                      if ((chaine = malloc((((size_t) lreel) + ((size_t) limag)
                             sizeof(unsigned char))) == NULL)                              - 1) * sizeof(unsigned char))) == NULL)
                     {                      {
                         free(partie_reelle);                          free(partie_reelle);
                         free(partie_imaginaire);                          free(partie_imaginaire);
Line 4473  formateur_fichier_binaire_nombre(struct_ Line 5108  formateur_fichier_binaire_nombre(struct_
                         return(NULL);                          return(NULL);
                     }                      }
   
                     chaine[0] = 0x19;                      chaine[0] = (unsigned char) 0x19;
                     memcpy(chaine + 1, partie_reelle + 1, lreel - 1);                      memcpy(chaine + 1, partie_reelle + 1,
                     memcpy(chaine + lreel, partie_imaginaire + 1, limag - 1);                              ((size_t) lreel) - 1);
                       memcpy(chaine + lreel, partie_imaginaire + 1,
                               ((size_t) limag) - 1);
                     (*longueur_conversion) = lreel + limag - 1;                      (*longueur_conversion) = lreel + limag - 1;
   
                     free(partie_reelle);                      free(partie_reelle);
Line 4525  lecture_fichier_non_formate(struct_proce Line 5162  lecture_fichier_non_formate(struct_proce
 {  {
     file                        *fichier;      file                        *fichier;
   
       int                         j;
   
     integer8                    i;      integer8                    i;
     integer8                    longueur;      integer8                    longueur;
   
Line 4535  lecture_fichier_non_formate(struct_proce Line 5174  lecture_fichier_non_formate(struct_proce
   
     unsigned char               octets[8];      unsigned char               octets[8];
     unsigned char               *buffer;      unsigned char               *buffer;
       unsigned char               *flux;
     unsigned char               *ptr;      unsigned char               *ptr;
       unsigned char               type_objet;
   
     size_t                      deplacement;      size_t                      deplacement;
   
Line 4547  lecture_fichier_non_formate(struct_proce Line 5188  lecture_fichier_non_formate(struct_proce
     }      }
     else      else
     {      {
         buffer = argument;          buffer = (*((unsigned char **) argument));
         ptr = buffer;          ptr = buffer;
         fichier = NULL;          fichier = NULL;
     }      }
   
   
     if (longueur_buffer < 0)      if (longueur_buffer < 0)
     {      {
         if (fread(octets, (size_t) sizeof(unsigned char),          if (fread(octets, (size_t) sizeof(unsigned char),
                 1, fichier) != 1)                  1, 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);              return(NULL);
         }          }
     }      }
     else      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)                      switch(octets[0] & 0x03)
                     {                      {
                         case 0x00:  // integer*1                          case 0x00:  // integer*1
Line 4612  lecture_fichier_non_formate(struct_proce Line 5351  lecture_fichier_non_formate(struct_proce
                         if (fread(octets, (size_t) sizeof(unsigned char),                          if (fread(octets, (size_t) sizeof(unsigned char),
                                 deplacement, fichier) != deplacement)                                  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);                              return(NULL);
                         }                          }
                     }                      }
                     else                      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);
                         }                          }
                     }                      }
   
                     (*((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;                      break;
Line 4638  lecture_fichier_non_formate(struct_proce Line 5457  lecture_fichier_non_formate(struct_proce
   
                 case 0x04:  // Réel                  case 0x04:  // Réel
                 {                  {
                     if ((s_objet = allocation(s_etat_processus, REL)) == NULL)  
                     {  
                         return(NULL);  
                     }  
   
                     switch(octets[0] & 0x03)                      switch(octets[0] & 0x03)
                     {                      {
                         case 0x00:  // real*4                          case 0x00:  // real*4
Line 4670  lecture_fichier_non_formate(struct_proce Line 5484  lecture_fichier_non_formate(struct_proce
                         if (fread(octets, (size_t) sizeof(unsigned char),                          if (fread(octets, (size_t) sizeof(unsigned char),
                                 deplacement, fichier) != deplacement)                                  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);                              return(NULL);
                         }                          }
                     }                      }
                     else                      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);
                         }                          }
                     }                      }
   
                       if ((s_objet = allocation(s_etat_processus, REL)) == NULL)
                       {
                           return(NULL);
                       }
   
                     if (deplacement == 4)                      if (deplacement == 4)
                     {                      {
                         union                          union
Line 4696  lecture_fichier_non_formate(struct_proce Line 5534  lecture_fichier_non_formate(struct_proce
                         for(i = 0; i < (signed) deplacement; i++)                          for(i = 0; i < (signed) deplacement; i++)
                         {                          {
                             eq4.i4 |= ((integer4) octets[i]) <<                              eq4.i4 |= ((integer4) octets[i]) <<
                                     (8 * ((deplacement - 1) - i));                                      (8 * ((((signed) deplacement) - 1) - i));
                         }                          }
   
                         (*((real8 *) (*s_objet).objet)) = (real8) eq4.r4;                          (*((real8 *) (*s_objet).objet)) = (real8) eq4.r4;
Line 4714  lecture_fichier_non_formate(struct_proce Line 5552  lecture_fichier_non_formate(struct_proce
                         for(i = 0; i < (signed) deplacement; i++)                          for(i = 0; i < (signed) deplacement; i++)
                         {                          {
                             eq8.i8 |= ((integer8) octets[i]) <<                              eq8.i8 |= ((integer8) octets[i]) <<
                                     (8 * ((deplacement - 1) - i));                                      (8 * ((((signed) deplacement) - 1) - i));
                         }                          }
   
                         (*((real8 *) (*s_objet).objet)) = (real8) eq8.r8;                          (*((real8 *) (*s_objet).objet)) = (real8) eq8.r8;
Line 4725  lecture_fichier_non_formate(struct_proce Line 5563  lecture_fichier_non_formate(struct_proce
   
                 case 0x08:  // Complexe                  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)                      if ((s_objet = allocation(s_etat_processus, CPL)) == NULL)
                     {                      {
                         return(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;                      break;
                 }                  }
   
Line 4744  lecture_fichier_non_formate(struct_proce Line 5704  lecture_fichier_non_formate(struct_proce
         }          }
   
         case 0x40:  // Liste          case 0x40:  // Liste
           case 0x60:  // Expression
           case 0x70:  // Expression algébrique
         {          {
             if ((octets[0] & 0x08) == 0)    // Longueur sur 6 bits              if ((octets[0] & 0x08) == 0)    // Longueur sur 6 bits
             {              {
Line 4760  lecture_fichier_non_formate(struct_proce Line 5722  lecture_fichier_non_formate(struct_proce
                             if (fread(octets, (size_t) sizeof(unsigned char),                              if (fread(octets, (size_t) sizeof(unsigned char),
                                     1, fichier) != 1)                                      1, 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);                                  return(NULL);
                             }                              }
                         }                          }
                         else                          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];                          longueur = octets[0];
Line 4781  lecture_fichier_non_formate(struct_proce Line 5761  lecture_fichier_non_formate(struct_proce
                             if (fread(octets, (size_t) sizeof(unsigned char),                              if (fread(octets, (size_t) sizeof(unsigned char),
                                     2, fichier) != 2)                                      2, 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);                                  return(NULL);
                             }                              }
                         }                          }
                         else                          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)                          longueur = (((integer8) (octets[0])) << 8)
Line 4804  lecture_fichier_non_formate(struct_proce Line 5801  lecture_fichier_non_formate(struct_proce
                             if (fread(octets, (size_t) sizeof(unsigned char),                              if (fread(octets, (size_t) sizeof(unsigned char),
                                     4, fichier) != 4)                                      4, 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);                                  return(NULL);
                             }                              }
                         }                          }
                         else                          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)                          longueur = (((integer8) (octets[0])) << 24)
Line 4831  lecture_fichier_non_formate(struct_proce Line 5843  lecture_fichier_non_formate(struct_proce
                             if (fread(octets, (size_t) sizeof(unsigned char),                              if (fread(octets, (size_t) sizeof(unsigned char),
                                     8, fichier) != 8)                                      8, 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);                                  return(NULL);
                             }                              }
                         }                          }
                         else                          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)                          longueur = (((integer8) (octets[0])) << 56)
Line 4867  lecture_fichier_non_formate(struct_proce Line 5890  lecture_fichier_non_formate(struct_proce
                 }                  }
             }              }
   
             if ((s_objet = allocation(s_etat_processus, LST)) == NULL)              if (type_objet == 0x40)
             {              {
                 return(NULL);                  if ((s_objet = allocation(s_etat_processus, LST)) == NULL)
                   {
                       return(NULL);
                   }
               }
               else if (type_objet == 0x60)
               {
                   if ((s_objet = allocation(s_etat_processus, RPN)) == NULL)
                   {
                       return(NULL);
                   }
               }
               else
               {
                   if ((s_objet = allocation(s_etat_processus, ALG)) == NULL)
                   {
                       return(NULL);
                   }
             }              }
   
             l_element_courant = NULL;              l_element_courant = NULL;
Line 4933  lecture_fichier_non_formate(struct_proce Line 5973  lecture_fichier_non_formate(struct_proce
   
         case 0x80:  // Chaîne de caractères          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),
                                       1, fichier) != 1)
                               {
                                   if (feof(fichier))
                                   {
                                       (*s_etat_processus).erreur_execution =
                                               d_ex_syntaxe;
                                   }
                                   else
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_erreur_fichier;
                                   }
   
                                   return(NULL);
                               }
                           }
                           else
                           {
                               if ((longueur_buffer - (ptr - buffer)) >= 1)
                               {
                                   octets[0] = *ptr++;
                               }
                               else
                               {
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_syntaxe;
                                   return(NULL);
                               }
                           }
   
                           longueur = octets[0];
                           break;
                       }
   
                       case 0x01:          // Longueur sur 16 bits
                       {
                           if (longueur_buffer < 0)
                           {
                               if (fread(octets, (size_t) sizeof(unsigned char),
                                       2, fichier) != 2)
                               {
                                   if (feof(fichier))
                                   {
                                       (*s_etat_processus).erreur_execution =
                                               d_ex_syntaxe;
                                   }
                                   else
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_erreur_fichier;
                                   }
   
                                   return(NULL);
                               }
                           }
                           else
                           {
                               if ((longueur_buffer - (ptr - buffer)) >= 2)
                               {
                                   for(j = 0; j < 2; octets[j++] = *ptr++);
                               }
                               else
                               {
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_syntaxe;
                                   return(NULL);
                               }
                           }
   
                           longueur = (((integer8) (octets[0])) << 8)
                                   | ((integer8) (octets[1]));
                           break;
                       }
   
                       case 0x02:          // Longueur sur 32 bits
                       {
                           if (longueur_buffer < 0)
                           {
                               if (fread(octets, (size_t) sizeof(unsigned char),
                                       4, fichier) != 4)
                               {
                                   if (feof(fichier))
                                   {
                                       (*s_etat_processus).erreur_execution =
                                               d_ex_syntaxe;
                                   }
                                   else
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_erreur_fichier;
                                   }
   
                                   return(NULL);
                               }
                           }
                           else
                           {
                               if ((longueur_buffer - (ptr - buffer)) >= 4)
                               {
                                   for(j = 0; j < 4; octets[j++] = *ptr++);
                               }
                               else
                               {
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_syntaxe;
                                   return(NULL);
                               }
                           }
   
                           longueur = (((integer8) (octets[0])) << 24)
                                   | (((integer8) (octets[1])) << 16)
                                   | (((integer8) (octets[2])) << 8)
                                   | ((integer8) (octets[3]));
                           break;
                       }
   
                       case 0x03:          // Longueur sur 64 bits
                       {
                           if (longueur_buffer < 0)
                           {
                               if (fread(octets, (size_t) sizeof(unsigned char),
                                       8, fichier) != 8)
                               {
                                   if (feof(fichier))
                                   {
                                       (*s_etat_processus).erreur_execution =
                                               d_ex_syntaxe;
                                   }
                                   else
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_erreur_fichier;
                                   }
   
                                   return(NULL);
                               }
                           }
                           else
                           {
                               if ((longueur_buffer - (ptr - buffer)) >= 8)
                               {
                                   for(j = 0; j < 8; octets[j++] = *ptr++);
                               }
                               else
                               {
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_syntaxe;
                                   return(NULL);
                               }
                           }
   
                           longueur = (((integer8) (octets[0])) << 56)
                                   | (((integer8) (octets[1])) << 48)
                                   | (((integer8) (octets[2])) << 40)
                                   | (((integer8) (octets[3])) << 32)
                                   | (((integer8) (octets[4])) << 24)
                                   | (((integer8) (octets[5])) << 16)
                                   | (((integer8) (octets[6])) << 8)
                                   | ((integer8) (octets[7]));
                           break;
                       }
   
                       default:
                       {
                           (*s_etat_processus).erreur_execution = d_ex_syntaxe;
                           return(NULL);
                       }
                   }
               }
   
               if (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),
                                       1, fichier) != 1)
                               {
                                   if (feof(fichier))
                                   {
                                       (*s_etat_processus).erreur_execution =
                                               d_ex_syntaxe;
                                   }
                                   else
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_erreur_fichier;
                                   }
   
                                   return(NULL);
                               }
                           }
                           else
                           {
                               if ((longueur_buffer - (ptr - buffer)) >= 1)
                               {
                                   octets[0] = *ptr++;
                               }
                               else
                               {
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_syntaxe;
                                   return(NULL);
                               }
                           }
   
                           longueur = octets[0];
                           break;
                       }
   
                       case 0x01:          // Longueur sur 16 bits
                       {
                           if (longueur_buffer < 0)
                           {
                               if (fread(octets, (size_t) sizeof(unsigned char),
                                       2, fichier) != 2)
                               {
                                   if (feof(fichier))
                                   {
                                       (*s_etat_processus).erreur_execution =
                                               d_ex_syntaxe;
                                   }
                                   else
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_erreur_fichier;
                                   }
   
                                   return(NULL);
                               }
                           }
                           else
                           {
                               if ((longueur_buffer - (ptr - buffer)) >= 2)
                               {
                                   for(j = 0; j < 2; octets[j++] = *ptr++);
                               }
                               else
                               {
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_syntaxe;
                                   return(NULL);
                               }
                           }
   
                           longueur = (((integer8) (octets[0])) << 8)
                                   | ((integer8) (octets[1]));
                           break;
                       }
   
                       case 0x02:          // Longueur sur 32 bits
                       {
                           if (longueur_buffer < 0)
                           {
                               if (fread(octets, (size_t) sizeof(unsigned char),
                                       4, fichier) != 4)
                               {
                                   if (feof(fichier))
                                   {
                                       (*s_etat_processus).erreur_execution =
                                               d_ex_syntaxe;
                                   }
                                   else
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_erreur_fichier;
                                   }
   
                                   return(NULL);
                               }
                           }
                           else
                           {
                               if ((longueur_buffer - (ptr - buffer)) >= 4)
                               {
                                   for(j = 0; j < 4; octets[j++] = *ptr++);
                               }
                               else
                               {
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_syntaxe;
                                   return(NULL);
                               }
                           }
   
                           longueur = (((integer8) (octets[0])) << 24)
                                   | (((integer8) (octets[1])) << 16)
                                   | (((integer8) (octets[2])) << 8)
                                   | ((integer8) (octets[3]));
                           break;
                       }
   
                       case 0x03:          // Longueur sur 64 bits
                       {
                           if (longueur_buffer < 0)
                           {
                               if (fread(octets, (size_t) sizeof(unsigned char),
                                       8, fichier) != 8)
                               {
                                   if (feof(fichier))
                                   {
                                       (*s_etat_processus).erreur_execution =
                                               d_ex_syntaxe;
                                   }
                                   else
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_erreur_fichier;
                                   }
   
                                   return(NULL);
                               }
                           }
                           else
                           {
                               if ((longueur_buffer - (ptr - buffer)) >= 8)
                               {
                                   for(j = 0; j < 8; octets[j++] = *ptr++);
                               }
                               else
                               {
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_syntaxe;
                                   return(NULL);
                               }
                           }
   
                           longueur = (((integer8) (octets[0])) << 56)
                                   | (((integer8) (octets[1])) << 48)
                                   | (((integer8) (octets[2])) << 40)
                                   | (((integer8) (octets[3])) << 32)
                                   | (((integer8) (octets[4])) << 24)
                                   | (((integer8) (octets[5])) << 16)
                                   | (((integer8) (octets[6])) << 8)
                                   | ((integer8) (octets[7]));
                           break;
                       }
   
                       default:
                       {
                           (*s_etat_processus).erreur_execution = d_ex_syntaxe;
                           return(NULL);
                       }
                   }
               }
   
               if ((s_objet = allocation(s_etat_processus, NOM)) == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return(NULL);
               }
   
               if (((*((struct_nom *) (*s_objet).objet)).nom =
                       malloc((((size_t) longueur) + 1) * sizeof(unsigned char)))
                       == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return(NULL);
               }
   
               if (longueur_buffer < 0)
               {
                   if (fread((unsigned char *) (*((struct_nom *) (*s_objet)
                           .objet)).nom, (size_t) sizeof(unsigned char),
                           (size_t) longueur, fichier) != (unsigned) longueur)
                   {
                       if (feof(fichier))
                       {
                           (*s_etat_processus).erreur_execution =
                                   d_ex_syntaxe;
                       }
                       else
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_erreur_fichier;
                       }
   
                       liberation(s_etat_processus, s_objet);
                       return(NULL);
                   }
   
                   if (fread(octets, (size_t) sizeof(unsigned char),
                           1, fichier) != 1)
                   {
                       if (feof(fichier))
                       {
                           (*s_etat_processus).erreur_execution =
                                   d_ex_syntaxe;
                       }
                       else
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_erreur_fichier;
                       }
   
                       liberation(s_etat_processus, s_objet);
                       return(NULL);
                   }
               }
               else
               {
                   if ((longueur_buffer - (ptr - buffer)) >= (longueur + 1))
                   {
                       for(j = 0; j < longueur; (*((struct_nom *)
                               (*s_objet).objet)).nom[j] = *ptr++);
                       octets[0] = *ptr++;
                   }
                   else
                   {
                       liberation(s_etat_processus, s_objet);
                       (*s_etat_processus).erreur_execution = d_ex_syntaxe;
                       return(NULL);
                   }
               }
   
               (*((struct_nom *) (*s_objet).objet)).nom[longueur] =
                       d_code_fin_chaine;
               (*((struct_nom *) (*s_objet).objet)).symbole =
                       (octets[0] == 0xFF) ? d_vrai : d_faux;
               break;
           }
   
           case 0xE0:  // Fonction
           {
               if ((octets[0] & 0x08) == 0)    // Longueur sur 6 bits
               {
                   longueur = (octets[0] & 0x07);
               }
               else
               {
                   switch(octets[0] & 0x07)
                   {
                       case 0x00:          // Longueur sur 8 bits
                       {
                           if (longueur_buffer < 0)
                           {
                               if (fread(octets, (size_t) sizeof(unsigned char),
                                       1, fichier) != 1)
                               {
                                   if (feof(fichier))
                                   {
                                       (*s_etat_processus).erreur_execution =
                                               d_ex_syntaxe;
                                   }
                                   else
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_erreur_fichier;
                                   }
   
                                   return(NULL);
                               }
                           }
                           else
                           {
                               if ((longueur_buffer - (ptr - buffer)) >= 1)
                               {
                                   octets[0] = *ptr++;
                               }
                               else
                               {
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_syntaxe;
                                   return(NULL);
                               }
                           }
   
                           longueur = octets[0];
                           break;
                       }
   
                       case 0x01:          // Longueur sur 16 bits
                       {
                           if (longueur_buffer < 0)
                           {
                               if (fread(octets, (size_t) sizeof(unsigned char),
                                       2, fichier) != 2)
                               {
                                   if (feof(fichier))
                                   {
                                       (*s_etat_processus).erreur_execution =
                                               d_ex_syntaxe;
                                   }
                                   else
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_erreur_fichier;
                                   }
   
                                   return(NULL);
                               }
                           }
                           else
                           {
                               if ((longueur_buffer - (ptr - buffer)) >= 2)
                               {
                                   for(j = 0; j < 2; octets[j++] = *ptr++);
                               }
                               else
                               {
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_syntaxe;
                                   return(NULL);
                               }
                           }
   
                           longueur = (((integer8) (octets[0])) << 8)
                                   | ((integer8) (octets[1]));
                           break;
                       }
   
                       case 0x02:          // Longueur sur 32 bits
                       {
                           if (longueur_buffer < 0)
                           {
                               if (fread(octets, (size_t) sizeof(unsigned char),
                                       4, fichier) != 4)
                               {
                                   if (feof(fichier))
                                   {
                                       (*s_etat_processus).erreur_execution =
                                               d_ex_syntaxe;
                                   }
                                   else
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_erreur_fichier;
                                   }
   
                                   return(NULL);
                               }
                           }
                           else
                           {
                               if ((longueur_buffer - (ptr - buffer)) >= 4)
                               {
                                   for(j = 0; j < 4; octets[j++] = *ptr++);
                               }
                               else
                               {
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_syntaxe;
                                   return(NULL);
                               }
                           }
   
                           longueur = (((integer8) (octets[0])) << 24)
                                   | (((integer8) (octets[1])) << 16)
                                   | (((integer8) (octets[2])) << 8)
                                   | ((integer8) (octets[3]));
                           break;
                       }
   
                       case 0x03:          // Longueur sur 64 bits
                       {
                           if (longueur_buffer < 0)
                           {
                               if (fread(octets, (size_t) sizeof(unsigned char),
                                       8, fichier) != 8)
                               {
                                   if (feof(fichier))
                                   {
                                       (*s_etat_processus).erreur_execution =
                                               d_ex_syntaxe;
                                   }
                                   else
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_erreur_fichier;
                                   }
   
                                   return(NULL);
                               }
                           }
                           else
                           {
                               if ((longueur_buffer - (ptr - buffer)) >= 8)
                               {
                                   for(j = 0; j < 8; octets[j++] = *ptr++);
                               }
                               else
                               {
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_syntaxe;
                                   return(NULL);
                               }
                           }
   
                           longueur = (((integer8) (octets[0])) << 56)
                                   | (((integer8) (octets[1])) << 48)
                                   | (((integer8) (octets[2])) << 40)
                                   | (((integer8) (octets[3])) << 32)
                                   | (((integer8) (octets[4])) << 24)
                                   | (((integer8) (octets[5])) << 16)
                                   | (((integer8) (octets[6])) << 8)
                                   | ((integer8) (octets[7]));
                           break;
                       }
   
                       default:
                       {
                           (*s_etat_processus).erreur_execution = d_ex_syntaxe;
                           return(NULL);
                       }
                   }
               }
   
               if ((s_objet = allocation(s_etat_processus, FCT)) == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return(NULL);
               }
   
               if (((*((struct_fonction *) (*s_objet).objet)).nom_fonction =
                       malloc((((size_t) longueur) + 1) * sizeof(unsigned char)))
                       == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return(NULL);
               }
   
               if (longueur_buffer < 0)
               {
                   if (fread((unsigned char *) (*((struct_fonction *) (*s_objet)
                           .objet)).nom_fonction, (size_t) sizeof(unsigned char),
                           (size_t) longueur, fichier) != (unsigned) longueur)
                   {
                       if (feof(fichier))
                       {
                           (*s_etat_processus).erreur_execution =
                                   d_ex_syntaxe;
                       }
                       else
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_erreur_fichier;
                       }
   
                       liberation(s_etat_processus, s_objet);
                       return(NULL);
                   }
   
                   if (fread(octets, (size_t) sizeof(unsigned char),
                           8, fichier) != 8)
                   {
                       if (feof(fichier))
                       {
                           (*s_etat_processus).erreur_execution =
                                   d_ex_syntaxe;
                       }
                       else
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_erreur_fichier;
                       }
   
                       liberation(s_etat_processus, s_objet);
                       return(NULL);
                   }
               }
               else
               {
                   if ((longueur_buffer - (ptr - buffer)) >= (longueur + 8))
                   {
                       for(j = 0; j < longueur; (*((struct_fonction *)
                               (*s_objet).objet)).nom_fonction[j] = *ptr++);
                       for(j = 0; j < 8; octets[j++] = *ptr++);
                   }
                   else
                   {
                       liberation(s_etat_processus, s_objet);
                       (*s_etat_processus).erreur_execution = d_ex_syntaxe;
                       return(NULL);
                   }
               }
   
               (*((struct_fonction *) (*s_objet).objet)).nom_fonction[longueur] =
                       d_code_fin_chaine;
               (*((struct_fonction *) (*s_objet).objet)).nombre_arguments =
                       (((integer8) (octets[0])) << 56)
                       | (((integer8) (octets[1])) << 48)
                       | (((integer8) (octets[2])) << 40)
                       | (((integer8) (octets[3])) << 32)
                       | (((integer8) (octets[4])) << 24)
                       | (((integer8) (octets[5])) << 16)
                       | (((integer8) (octets[6])) << 8)
                       | ((integer8) (octets[7]));
             break;              break;
         }          }
   
Line 4953  lecture_fichier_non_formate(struct_proce Line 6765  lecture_fichier_non_formate(struct_proce
         {          {
             liberation(s_etat_processus, s_objet);              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);              return(NULL);
         }          }
   
         if ((octets[0] & 0x01) != 0)          if ((octets[0] & 0x01) != 0)
         {          {
             deplacement = ((octets[0] & 0x0F) >> 1) + 1;              deplacement = (size_t) (((octets[0] & 0x0F) >> 1) + 1);
   
             if (fread(octets, (size_t) sizeof(unsigned char), deplacement,              if (fread(octets, (size_t) sizeof(unsigned char), deplacement,
                     fichier) != deplacement)                      fichier) != deplacement)
             {              {
                 liberation(s_etat_processus, s_objet);                  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);                  return(NULL);
             }              }
         }          }
     }      }
   
       if (longueur_buffer >= 0)
       {
           (*((unsigned char **) argument)) = ptr;
       }
   
     return(s_objet);      return(s_objet);
 }  }
   
Removed from v.1.52  
changed lines
  Added in v.1.73

CVSweb interface <joel.bertrand@systella.fr>