[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.63 and 1.86

version 1.63, 2013/03/21 16:31:58 version 1.86, 2015/04/14 11:26:18
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.13    RPL/2 (R) version 4.1.21
   Copyright (C) 1989-2013 Dr. BERTRAND Joël    Copyright (C) 1989-2015 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 80  formateur_fichier(struct_processus *s_et Line 80  formateur_fichier(struct_processus *s_et
     logical1                    presence_signe;      logical1                    presence_signe;
   
     struct_liste_chainee        *l_atome;      struct_liste_chainee        *l_atome;
       struct_liste_chainee        *l_compteur;
     struct_liste_chainee        *l_element_courant;      struct_liste_chainee        *l_element_courant;
     struct_liste_chainee        *l_element_courant_format;      struct_liste_chainee        *l_element_courant_format;
     struct_liste_chainee        *l_liste1;      struct_liste_chainee        *l_liste1;
     struct_liste_chainee        *l_liste2;      struct_liste_chainee        *l_liste2;
       struct_liste_chainee        *l_tmp;
   
       struct_objet                *s_format_tmp;
     struct_objet                *s_sous_objet;      struct_objet                *s_sous_objet;
     struct_objet                *s_sous_objet_1;      struct_objet                *s_sous_objet_1;
     struct_objet                *s_sous_objet_2;      struct_objet                *s_sous_objet_2;
Line 94  formateur_fichier(struct_processus *s_et Line 97  formateur_fichier(struct_processus *s_et
     unsigned char               *chaine;      unsigned char               *chaine;
     unsigned char               *chaine_fonction;      unsigned char               *chaine_fonction;
     unsigned char               *chaine_formatee;      unsigned char               *chaine_formatee;
       unsigned char               *chaine_offset;
     unsigned char               *chaine_tampon;      unsigned char               *chaine_tampon;
     unsigned char               *chaine_sauvegarde;      unsigned char               *chaine_sauvegarde;
     unsigned char               *format_chaine;      unsigned char               *format_chaine;
Line 111  formateur_fichier(struct_processus *s_et Line 115  formateur_fichier(struct_processus *s_et
     integer8                    nombre_lignes;      integer8                    nombre_lignes;
   
     integer8                    longueur_chaine_traitee;      integer8                    longueur_chaine_traitee;
       integer8                    longueur_element;
     integer8                    longueur_fonction;      integer8                    longueur_fonction;
     integer8                    longueur_liste;      integer8                    longueur_liste;
       integer8                    longueur_objet;
     integer8                    longueur_reelle_chaine;      integer8                    longueur_reelle_chaine;
     integer8                    longueur_totale;      integer8                    longueur_totale;
     integer8                    position_1;      integer8                    position_1;
Line 233  formateur_fichier(struct_processus *s_et Line 239  formateur_fichier(struct_processus *s_et
                                     .instruction_courante[1]                                      .instruction_courante[1]
                                     == '-')) ? d_vrai : d_faux;                                      == '-')) ? d_vrai : d_faux;
   
                               (*s_etat_processus).type_en_cours = NON;
                             recherche_type(s_etat_processus);                              recherche_type(s_etat_processus);
   
                             if ((*s_etat_processus).erreur_execution != d_ex)                              if ((*s_etat_processus).erreur_execution != d_ex)
Line 292  formateur_fichier(struct_processus *s_et Line 299  formateur_fichier(struct_processus *s_et
                                     if ((strcmp(chaine_fonction, "AND") == 0) ||                                      if ((strcmp(chaine_fonction, "AND") == 0) ||
                                             (strcmp(chaine_fonction, "XOR") ==                                              (strcmp(chaine_fonction, "XOR") ==
                                             0) || (strcmp(chaine_fonction, "OR")                                              0) || (strcmp(chaine_fonction, "OR")
                                             == 0))                                              == 0) || (strcmp(chaine_fonction,
                                               "EQV") == 0))
                                     {                                      {
                                         autorisation_parenthese = d_vrai;                                          autorisation_parenthese = d_vrai;
                                     }                                      }
Line 319  formateur_fichier(struct_processus *s_et Line 327  formateur_fichier(struct_processus *s_et
                                             || (strcmp(chaine_fonction, "AND")                                              || (strcmp(chaine_fonction, "AND")
                                             == 0) || (strcmp(chaine_fonction,                                              == 0) || (strcmp(chaine_fonction,
                                             "XOR") == 0) || (strcmp(                                              "XOR") == 0) || (strcmp(
                                             chaine_fonction, "OR") == 0))                                              chaine_fonction, "OR") == 0) ||
                                               (strcmp(chaine_fonction, "EQV")
                                               == 0))
                                     {                                      {
                                         autorisation_parenthese = d_vrai;                                          autorisation_parenthese = d_vrai;
                                     }                                      }
Line 400  formateur_fichier(struct_processus *s_et Line 410  formateur_fichier(struct_processus *s_et
                                     "'%s'", (unsigned char *)                                      "'%s'", (unsigned char *)
                                     (*s_sous_objet_1).objet);                                      (*s_sous_objet_1).objet);
   
                               (*s_etat_processus).type_en_cours = NON;
                             recherche_type(s_etat_processus);                              recherche_type(s_etat_processus);
   
                             if ((*s_etat_processus).erreur_execution != d_ex)                              if ((*s_etat_processus).erreur_execution != d_ex)
Line 457  formateur_fichier(struct_processus *s_et Line 468  formateur_fichier(struct_processus *s_et
                                     if ((strcmp(chaine_fonction, "AND") == 0) ||                                      if ((strcmp(chaine_fonction, "AND") == 0) ||
                                             (strcmp(chaine_fonction, "XOR") ==                                              (strcmp(chaine_fonction, "XOR") ==
                                             0) || (strcmp(chaine_fonction, "OR")                                              0) || (strcmp(chaine_fonction, "OR")
                                             == 0))                                              == 0) || (strcmp(chaine_fonction,
                                               "EQV") == 0))
                                     {                                      {
                                         autorisation_parenthese = d_vrai;                                          autorisation_parenthese = d_vrai;
                                     }                                      }
Line 474  formateur_fichier(struct_processus *s_et Line 486  formateur_fichier(struct_processus *s_et
                                             || (strcmp(chaine_fonction, "AND")                                              || (strcmp(chaine_fonction, "AND")
                                             == 0) || (strcmp(chaine_fonction,                                              == 0) || (strcmp(chaine_fonction,
                                             "XOR") == 0) || (strcmp(                                              "XOR") == 0) || (strcmp(
                                             chaine_fonction, "OR") == 0))                                              chaine_fonction, "OR") == 0) ||
                                               (strcmp(chaine_fonction, "EQV")
                                               == 0))
                                     {                                      {
                                         autorisation_parenthese = d_vrai;                                          autorisation_parenthese = d_vrai;
                                     }                                      }
Line 715  formateur_fichier(struct_processus *s_et Line 729  formateur_fichier(struct_processus *s_et
                                 "XOR") == 0) || (strcmp((*((struct_fonction *)                                  "XOR") == 0) || (strcmp((*((struct_fonction *)
                                 (*(*l_element_courant).donnee).objet))                                  (*(*l_element_courant).donnee).objet))
                                 .nom_fonction,                                  .nom_fonction,
                                 "AND") == 0))                                  "AND") == 0) || (strcmp((*((struct_fonction *)
                                   (*(*l_element_courant).donnee).objet))
                                   .nom_fonction, "EQV") == 0))
                         {                          {
                             if (depilement(s_etat_processus,                              if (depilement(s_etat_processus,
                                     &((*s_etat_processus)                                      &((*s_etat_processus)
Line 1000  formateur_fichier(struct_processus *s_et Line 1016  formateur_fichier(struct_processus *s_et
   
             if (format_sortie == 'N')              if (format_sortie == 'N')
             {              {
                 sprintf(tampon, "%llX", (*((logical8 *)                  sprintf(tampon, "%llX", (unsigned long long) (*((logical8 *)
                         ((*s_objet).objet))));                          ((*s_objet).objet))));
                 strcpy(base, "h");                  strcpy(base, "h");
             }              }
Line 1010  formateur_fichier(struct_processus *s_et Line 1026  formateur_fichier(struct_processus *s_et
                 {                  {
                     case 2:                      case 2:
                     {                      {
                         sprintf(tampon, "%llX", (*((logical8 *)                          sprintf(tampon, "%llX", (unsigned long long)
                                 ((*s_objet).objet))));                                  (*((logical8 *) ((*s_objet).objet))));
   
                         chaine = (unsigned char *) malloc((strlen(tampon) + 1)                          chaine = (unsigned char *) malloc((strlen(tampon) + 1)
                                 * sizeof(unsigned char));                                  * sizeof(unsigned char));
Line 1120  formateur_fichier(struct_processus *s_et Line 1136  formateur_fichier(struct_processus *s_et
   
                     case 8:                      case 8:
                     {                      {
                         sprintf(tampon, "%llo", (*((logical8 *)                          sprintf(tampon, "%llo", (*((unsigned long long *)
                                 ((*s_objet).objet))));                                  ((*s_objet).objet))));
                         strcpy(base, "o");                          strcpy(base, "o");
                         break;                          break;
Line 1128  formateur_fichier(struct_processus *s_et Line 1144  formateur_fichier(struct_processus *s_et
   
                     case 10:                      case 10:
                     {                      {
                         sprintf(tampon, "%llu", (*((logical8 *)                          sprintf(tampon, "%llu", (*((unsigned long long *)
                                 ((*s_objet).objet))));                                  ((*s_objet).objet))));
                         strcpy(base, "d");                          strcpy(base, "d");
                         break;                          break;
Line 1136  formateur_fichier(struct_processus *s_et Line 1152  formateur_fichier(struct_processus *s_et
   
                     case 16:                      case 16:
                     {                      {
                         sprintf(tampon, "%llX", (*((logical8 *)                          sprintf(tampon, "%llX", (unsigned long long)
                                 ((*s_objet).objet))));                                  (*((logical8 *) ((*s_objet).objet))));
                         strcpy(base, "h");                          strcpy(base, "h");
                         break;                          break;
                     }                      }
Line 1530  formateur_fichier(struct_processus *s_et Line 1546  formateur_fichier(struct_processus *s_et
                 }                  }
                 else                  else
                 {                  {
                     if ((format_chaine = conversion_majuscule((unsigned char *)                      if ((format_chaine = conversion_majuscule(
                               s_etat_processus, (unsigned char *)
                             (*(*l_element_courant_format).donnee).objet))                              (*(*l_element_courant_format).donnee).objet))
                             == NULL)                              == NULL)
                     {                      {
Line 1673  formateur_fichier(struct_processus *s_et Line 1690  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 1878  formateur_fichier(struct_processus *s_et Line 1949  formateur_fichier(struct_processus *s_et
                     else                      else
                     {                      {
                         if ((format_chaine = conversion_majuscule(                          if ((format_chaine = conversion_majuscule(
                                   s_etat_processus,
                                 (unsigned char *) (*(*((struct_tableau *)                                  (unsigned char *) (*(*((struct_tableau *)
                                 (*s_format).objet)).elements[i]).objet))                                  (*s_format).objet)).elements[i]).objet))
                                 == NULL)                                  == NULL)
Line 3036  formateur_fichier(struct_processus *s_et Line 3108  formateur_fichier(struct_processus *s_et
          * 1110 0 XXX               fonction de longueur XXX           * 1110 0 XXX               fonction de longueur XXX
          * 1110 10 LL               fonction de longueur integer*LL           * 1110 10 LL               fonction de longueur integer*LL
          *           *
            * 1111 XXXXX               page 2
            * 1111 XXXXX 000000001     entier long
            * 1111 XXXXX 000000010     réel long
            * 1111 XXXXX 000000011     complexe long
            *
          * Les longueurs indiquées par le champ LL suivent l'en-tête :           * Les longueurs indiquées par le champ LL suivent l'en-tête :
          *      00 : integer*1           *      00 : integer*1
          *      01 : integer*2           *      01 : integer*2
Line 3662  formateur_fichier(struct_processus *s_et Line 3739  formateur_fichier(struct_processus *s_et
                                 0, 0, ' ', 'U', longueur_effective, recursivite,                                  0, 0, ' ', 'U', longueur_effective, recursivite,
                                 export_fichier)) == NULL)                                  export_fichier)) == NULL)
                         {                          {
                               free(chaine);
                             return(NULL);                              return(NULL);
                         }                          }
                     }                      }
Line 3674  formateur_fichier(struct_processus *s_et Line 3752  formateur_fichier(struct_processus *s_et
                                 0, 0, 'N', 'U', longueur_effective, recursivite,                                  0, 0, 'N', 'U', longueur_effective, recursivite,
                                 export_fichier)) == NULL)                                  export_fichier)) == NULL)
                         {                          {
                               free(chaine);
                             return(NULL);                              return(NULL);
                         }                          }
                     }                      }
Line 3702  formateur_fichier(struct_processus *s_et Line 3781  formateur_fichier(struct_processus *s_et
                 }                  }
                 else                  else
                 {                  {
                     if ((format_chaine = conversion_majuscule((unsigned char *)                      format_degenere = d_faux;
   
                       if ((format_chaine = conversion_majuscule(
                               s_etat_processus, (unsigned char *)
                             (*(*l_element_courant_format).donnee).objet))                              (*(*l_element_courant_format).donnee).objet))
                             == NULL)                              == NULL)
                     {                      {
Line 3785  formateur_fichier(struct_processus *s_et Line 3867  formateur_fichier(struct_processus *s_et
                     }                      }
   
                     free(format_chaine);                      free(format_chaine);
                   
                       // Construction d'une liste de format
   
                       if ((s_format_tmp = allocation(s_etat_processus, LST))
                               == NULL)
                       {
                           return(NULL);
                       }
   
                       if ((*(*l_element_courant).donnee).type == LST)
                       {
                           l_compteur = (struct_liste_chainee *)
                                   (*(*l_element_courant).donnee).objet;
   
                           while(l_compteur != NULL)
                           {
                               l_tmp = (*s_format_tmp).objet;
   
                               if (((*s_format_tmp).objet = allocation_maillon(
                                       s_etat_processus)) == NULL)
                               {
                                   return(NULL);
                               }
   
                               if (((*((struct_liste_chainee *)
                                       (*s_format_tmp).objet))
                                       .donnee = copie_objet(s_etat_processus,
                                       (*l_element_courant_format).donnee, 'P'))
                                       == NULL)
                               {
                                   return(NULL);
                               }
   
                               (*((struct_liste_chainee *) (*s_format_tmp).objet))
                                       .suivant = l_tmp;
                               l_compteur = (*l_compteur).suivant;
                           }
                       }
                       else
                       {
                           if (((*s_format_tmp).objet = allocation_maillon(
                                   s_etat_processus)) == NULL)
                           {
                               return(NULL);
                           }
   
                           if (((*((struct_liste_chainee *) (*s_format_tmp).objet))
                                   .donnee = copie_objet(s_etat_processus,
                                   (*l_element_courant_format).donnee, 'P'))
                                   == NULL)
                           {
                               return(NULL);
                           }
   
                           (*((struct_liste_chainee *) (*s_format_tmp).objet))
                                   .suivant = NULL;
                       }
   
                     if ((chaine_formatee = formateur_fichier(s_etat_processus,                      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,
                             ((size_t) (longueur_totale + (*longueur_effective)))                              ((size_t) (longueur_totale + (*longueur_effective)))
                             * sizeof(unsigned char))) == NULL)                              * sizeof(unsigned char))) == NULL)
Line 3811  formateur_fichier(struct_processus *s_et Line 3953  formateur_fichier(struct_processus *s_et
                     free(chaine_formatee);                      free(chaine_formatee);
                 }                  }
   
                   l_element_courant_format = (*l_element_courant_format).suivant;
                 nombre_elements++;                  nombre_elements++;
                 l_element_courant = (*l_element_courant).suivant;                  l_element_courant = (*l_element_courant).suivant;
   
                 if (format_sortie != 'N')  
                 {  
                     l_element_courant_format =  
                             (*l_element_courant_format).suivant;  
                 }  
             }              }
   
             if (format_sortie != 'N')              if ((l_element_courant != NULL) ||
                       (l_element_courant_format != NULL))
             {              {
                 if ((l_element_courant != NULL) ||                  free(chaine);
                         (l_element_courant_format != NULL))  
                 {  
                     free(chaine);  
   
                     (*s_etat_processus).erreur_execution =                  (*s_etat_processus).erreur_execution =
                             d_ex_erreur_format_fichier;                          d_ex_erreur_format_fichier;
                     return(NULL);                  return(NULL);
                 }  
             }              }
   
             (*longueur_effective) = longueur_totale;              (*longueur_effective) = longueur_totale;
Line 3842  formateur_fichier(struct_processus *s_et Line 3976  formateur_fichier(struct_processus *s_et
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Table    Table
     Bits de poids fort : 1001
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               chaine = malloc(sizeof(unsigned char));
   
               if (chaine == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return(NULL);
               }
   
               type_binaire = 0x90;
               longueur_liste = (*((struct_tableau *) (*s_objet).objet))
                       .nombre_elements;
   
               if (longueur_liste < (1LL << 3))
               {
                   chaine[0] = (unsigned char) (type_binaire |
                           (longueur_liste & 0x7));
               }
               else if (longueur_liste < (1LL << 8))
               {
                   chaine[0] = (unsigned char) (type_binaire | 0x08);
               }
               else if (longueur_liste < (1LL << 16))
               {
                   chaine[0] = (unsigned char ) (type_binaire | 0x09);
               }
               else if (longueur_liste < (1LL << 32))
               {
                   chaine[0] = (unsigned char) (type_binaire | 0x0A);
               }
               else
               {
                   chaine[0] = (unsigned char) (type_binaire | 0x0B);
               }
   
               longueur_totale = 1;
   
               if ((chaine[0] & 0x8) != 0)
               { // Longueur sur un entier distinct de l'en-tête
                   switch(chaine[0] & 0x03)
                   {
                       case 0x00 :
                       {
                           longueur_totale += 1;
   
                           if ((chaine = realloc(chaine,
                                   ((size_t) longueur_totale) *
                                   sizeof(unsigned char))) == NULL)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_allocation_memoire;
                               return(NULL);
                           }
   
                           chaine[longueur_totale - 1] =
                                   (unsigned char) (longueur_liste & 0xFF);
                           break;
                       }
   
                       case 0x01 :
                       {
                           longueur_totale += 2;
   
                           if ((chaine = realloc(chaine,
                                   ((size_t) longueur_totale) *
                                   sizeof(unsigned char))) == NULL)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_allocation_memoire;
                               return(NULL);
                           }
   
                           chaine[longueur_totale - 2] =
                                   (unsigned char) ((longueur_liste >> 8) & 0xFF);
                           chaine[longueur_totale - 1] =
                                   (unsigned char) (longueur_liste & 0xFF);
                           break;
                       }
   
                       case 0x02 :
                       {
                           longueur_totale += 4;
   
                           if ((chaine = realloc(chaine,
                                   ((size_t) longueur_totale) *
                                   sizeof(unsigned char))) == NULL)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_allocation_memoire;
                               return(NULL);
                           }
   
                           chaine[longueur_totale - 4] =
                                   (unsigned char) ((longueur_liste >> 24) & 0xFF);
                           chaine[longueur_totale - 3] =
                                   (unsigned char) ((longueur_liste >> 16) & 0xFF);
                           chaine[longueur_totale - 2] =
                                   (unsigned char) ((longueur_liste >> 8) & 0xFF);
                           chaine[longueur_totale - 1] =
                                   (unsigned char) (longueur_liste & 0xFF);
                           break;
                       }
   
                       case 0x03 :
                       {
                           longueur_totale += 8;
   
                           if ((chaine = realloc(chaine,
                                   ((size_t) longueur_totale) *
                                   sizeof(unsigned char))) == NULL)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_allocation_memoire;
                               return(NULL);
                           }
   
                           chaine[longueur_totale - 8] =
                                   (unsigned char) ((longueur_liste >> 56) & 0xFF);
                           chaine[longueur_totale - 7] =
                                   (unsigned char) ((longueur_liste >> 48) & 0xFF);
                           chaine[longueur_totale - 6] =
                                   (unsigned char) ((longueur_liste >> 40) & 0xFF);
                           chaine[longueur_totale - 5] =
                                   (unsigned char) ((longueur_liste >> 32) & 0xFF);
                           chaine[longueur_totale - 4] =
                                   (unsigned char) ((longueur_liste >> 24) & 0xFF);
                           chaine[longueur_totale - 3] =
                                   (unsigned char) ((longueur_liste >> 16) & 0xFF);
                           chaine[longueur_totale - 2] =
                                   (unsigned char) ((longueur_liste >> 8) & 0xFF);
                           chaine[longueur_totale - 1] =
                                   (unsigned char) (longueur_liste & 0xFF);
                           break;
                       }
   
                       default :
                       {
                           BUG(1, printf("Internal format error\n"));
                       }
                   }
               }
   
   uprintf("F=%s\n", formateur(s_etat_processus, 0, s_format));
   uprintf("D=%s\n", formateur(s_etat_processus, 0, s_objet));
               if ((*s_format).type == CHN)
               {
   uprintf("<1>\n");
                   if ((format_chaine = conversion_majuscule(
                           s_etat_processus, (unsigned char *)
                           (*s_format).objet)) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   if (strncmp("INTEGER*", format_chaine, 8) == 0)
                   {
                       format_sortie = 'I';
                       position_1 = 8;
                   }
                   else if (strncmp("LOGICAL*", format_chaine, 8) == 0)
                   {
                       format_sortie = 'L';
                       position_1 = 8;
                   }
                   else if (strncmp("REAL*", format_chaine, 5) == 0)
                   {
                       format_sortie = 'R';
                       position_1 = 5;
                   }
                   else if (strncmp("COMPLEX*", format_chaine, 8) == 0)
                   {
                       format_sortie = 'C';
                       position_1 = 8;
                   }
                   else if (strncmp("CHARACTER*", format_chaine, 10) == 0)
                   {
                       format_sortie = 'S';
                       position_1 = 10;
                       format_degenere = d_vrai;
                   }
                   else if (strcmp("NATIVE*(*)", format_chaine) == 0)
                   {
                       format_sortie = 'N';
                       position_1 = 7;
                       format_degenere = d_vrai;
                   }
                   else
                   {
                       free(chaine);
                       free(format_chaine);
   
                       (*s_etat_processus).erreur_execution =
                               d_ex_erreur_format_fichier;
                       return(NULL);
                   }
   
                   if (format_chaine[position_1] == d_code_fin_chaine)
                   {
                       free(chaine);
                       free(format_chaine);
   
                       (*s_etat_processus).erreur_execution =
                               d_ex_erreur_format_fichier;
                       return(NULL);
                   }
   
                   if (strcmp(&(format_chaine[position_1]), "(*)") != 0)
                   {
                       if (sscanf(&(format_chaine[position_1]), "%lld",
                               &longueur) != 1)
                       {
                           free(chaine);
                           free(format_chaine);
   
                           (*s_etat_processus).erreur_execution =
                                   d_ex_erreur_format_fichier;
                           return(NULL);
                       }
   
                       longueur_champ = longueur;
                   }
                   else
                   {
                       longueur_champ = -1;
                       longueur = -1;
                   }
   
                   free(format_chaine);
   
                   if ((s_format_tmp = allocation(s_etat_processus, TBL))
                           == NULL)
                   {
                       return(NULL);
                   }
   
                   (*((struct_tableau *) (*s_format_tmp).objet))
                           .nombre_elements = (*((struct_tableau *)
                           (*s_objet).objet)).nombre_elements;
   
                   for(i = 0; i < (*((struct_tableau *) (*s_format_tmp).objet))
                           .nombre_elements; i++)
                   {
                       if (((*((struct_tableau *) (*s_format_tmp).objet))
                               .elements[i] = copie_objet(s_etat_processus,
                               s_format, 'P')) == NULL)
                       {
                           return(NULL);
                       }
                   }
   
   uprintf("%s\n", formateur(s_etat_processus, 0, s_format));
                   if ((chaine_formatee = formateur_fichier(s_etat_processus,
                           s_objet, s_format_tmp,
                           longueur, longueur_champ,
                           format_sortie, type, longueur_effective,
                           recursivite, export_fichier)) == NULL)
                   {
                       liberation(s_etat_processus, s_format_tmp);
                       free(chaine);
                       return(NULL);
                   }
   
                   liberation(s_etat_processus, s_format_tmp);
               }
               else if ((*s_format).type == TBL)
               {
   uprintf("<2>\n");
                   free(chaine);
                   // A FIXER
               }
               else
               {
   uprintf("<3>\n");
                   free(chaine);
   
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_format_fichier;
                   return(NULL);
               }
   
               (*longueur_effective) = longueur_totale;
         }          }
         else if ((*s_objet).type == MCX)          else if ((*s_objet).type == MCX)
         {          {
Line 3853  formateur_fichier(struct_processus *s_et Line 4271  formateur_fichier(struct_processus *s_et
   Matrice complexe    Matrice complexe
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'C';
                   longueur = 16;
               }
   
               if (format_sortie != 'C')
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_format_fichier;
                   return(NULL);
               }
   
               longueur_objet = (*((struct_matrice *) (*s_objet).objet))
                       .nombre_lignes * (*((struct_matrice *) (*s_objet).objet))
                       .nombre_colonnes;
   
               if (((*((struct_matrice *) (*s_objet).objet)).nombre_lignes
                       < (1LL << 8)) && ((*((struct_matrice *) (*s_objet).objet))
                       .nombre_colonnes < (1LL << 8)))
               {
                   // Taille sur un octet
                   if ((chaine = malloc((size_t) ((*longueur_effective) =
                           (3 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xD2;
                   chaine[1] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes & 0xFF);
                   chaine[2] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes & 0xFF);
                   chaine_offset = chaine + 3;
               }
               else if (((*((struct_matrice *) (*s_objet).objet)).nombre_lignes
                       < (1LL << 16)) && ((*((struct_matrice *) (*s_objet).objet))
                       .nombre_colonnes < (1LL << 16)))
               {
                   // Taille sur deux octets
                   if ((chaine = malloc((size_t) ((*longueur_effective) =
                           (5 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xD6;
                   chaine[1] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 8) & 0xFF);
                   chaine[2] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes & 0xFF);
                   chaine[3] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 8) & 0xFF);
                   chaine[4] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes & 0xFF);
                   chaine_offset = chaine + 5;
               }
               else if (((*((struct_matrice *) (*s_objet).objet)).nombre_lignes
                       < (1LL << 32)) && ((*((struct_matrice *) (*s_objet).objet))
                       .nombre_colonnes < (1LL << 32)))
               {
                   // Taille sur quatre octets
                   if ((chaine = malloc((size_t) (((*longueur_effective) =
                           9 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xDA;
                   chaine[1] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 24) & 0xFF);
                   chaine[2] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 16) & 0xFF);
                   chaine[3] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 8) & 0xFF);
                   chaine[4] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes & 0xFF);
                   chaine[5] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 24) & 0xFF);
                   chaine[6] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 16) & 0xFF);
                   chaine[7] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 8) & 0xFF);
                   chaine[8] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes & 0xFF);
                   chaine_offset = chaine + 9;
               }
               else
               {
                   // Taille sur huit octets
                   if ((chaine = malloc((size_t) ((*longueur_effective) =
                           (17 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xDE;
                   chaine[1] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 56) & 0xFF);
                   chaine[2] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 48) & 0xFF);
                   chaine[3] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 40) & 0xFF);
                   chaine[4] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 32) & 0xFF);
                   chaine[5] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 24) & 0xFF);
                   chaine[6] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 16) & 0xFF);
                   chaine[7] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 8) & 0xFF);
                   chaine[8] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes & 0xFF);
                   chaine[9] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 56) & 0xFF);
                   chaine[10] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 48) & 0xFF);
                   chaine[11] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 40) & 0xFF);
                   chaine[12] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 32) & 0xFF);
                   chaine[13] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 24) & 0xFF);
                   chaine[14] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 16) & 0xFF);
                   chaine[15] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 8) & 0xFF);
                   chaine[16] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes & 0xFF);
                   chaine_offset = chaine + 17;
               }
   
               switch(longueur)
               {
                   case 8:
                   {
                       break;
                   }
   
                   default:
                   case 16:
                   {
                       chaine[0] |= 0x01;
                       break;
                   }
               }
   
               for(i = 0; i < (*((struct_matrice *) (*s_objet).objet))
                       .nombre_lignes; i++)
               {
                   for(j = 0; j < (*((struct_matrice *) (*s_objet).objet))
                           .nombre_colonnes; j++)
                   {
                       if ((chaine_tampon = formateur_fichier_binaire_nombre(
                               s_etat_processus, &(((complex16 **)
                               (*((struct_matrice *) (*s_objet).objet)).tableau)
                               [i][j]), 'R', format_sortie,
                               longueur, &longueur_element)) == NULL)
                       {
                           free(chaine);
                           return(NULL);
                       }
   
                       memcpy(chaine_offset + (((i * (*((struct_matrice *)
                               (*s_objet).objet)).nombre_colonnes) + j) *
                               longueur), chaine_tampon + 1, (size_t) longueur);
                       free(chaine_tampon);
                   }
               }
         }          }
         else if ((*s_objet).type == MIN)          else if ((*s_objet).type == MIN)
         {          {
Line 3862  formateur_fichier(struct_processus *s_et Line 4462  formateur_fichier(struct_processus *s_et
   Matrice entière    Matrice entière
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'I';
                   longueur = 8;
               }
   
               if ((format_sortie != 'I') && (format_sortie != 'R')
                       && (format_sortie != 'C'))
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_format_fichier;
                   return(NULL);
               }
   
               longueur_objet = (*((struct_matrice *) (*s_objet).objet))
                       .nombre_lignes * (*((struct_matrice *) (*s_objet).objet))
                       .nombre_colonnes;
   
               if (((*((struct_matrice *) (*s_objet).objet)).nombre_lignes
                       < (1LL << 8)) && ((*((struct_matrice *) (*s_objet).objet))
                       .nombre_colonnes < (1LL << 8)))
               {
                   // Taille sur un octet
                   if ((chaine = malloc((size_t) ((*longueur_effective) =
                           (3 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0x00;
                   chaine[1] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes & 0xFF);
                   chaine[2] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes & 0xFF);
                   chaine_offset = chaine + 3;
               }
               else if (((*((struct_matrice *) (*s_objet).objet)).nombre_lignes
                       < (1LL << 16)) && ((*((struct_matrice *) (*s_objet).objet))
                       .nombre_colonnes < (1LL << 16)))
               {
                   // Taille sur deux octets
                   if ((chaine = malloc((size_t) ((*longueur_effective) =
                           (5 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0x04;
                   chaine[1] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 8) & 0xFF);
                   chaine[2] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes & 0xFF);
                   chaine[3] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 8) & 0xFF);
                   chaine[4] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes & 0xFF);
                   chaine_offset = chaine + 5;
               }
               else if (((*((struct_matrice *) (*s_objet).objet)).nombre_lignes
                       < (1LL << 32)) && ((*((struct_matrice *) (*s_objet).objet))
                       .nombre_colonnes < (1LL << 32)))
               {
                   // Taille sur quatre octets
                   if ((chaine = malloc((size_t) (((*longueur_effective) =
                           9 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0x08;
                   chaine[1] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 24) & 0xFF);
                   chaine[2] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 16) & 0xFF);
                   chaine[3] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 8) & 0xFF);
                   chaine[4] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes & 0xFF);
                   chaine[5] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 24) & 0xFF);
                   chaine[6] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 16) & 0xFF);
                   chaine[7] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 8) & 0xFF);
                   chaine[8] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes & 0xFF);
                   chaine_offset = chaine + 9;
               }
               else
               {
                   // Taille sur huit octets
                   if ((chaine = malloc((size_t) ((*longueur_effective) =
                           (17 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0x0C;
                   chaine[1] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 56) & 0xFF);
                   chaine[2] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 48) & 0xFF);
                   chaine[3] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 40) & 0xFF);
                   chaine[4] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 32) & 0xFF);
                   chaine[5] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 24) & 0xFF);
                   chaine[6] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 16) & 0xFF);
                   chaine[7] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 8) & 0xFF);
                   chaine[8] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes & 0xFF);
                   chaine[9] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 56) & 0xFF);
                   chaine[10] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 48) & 0xFF);
                   chaine[11] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 40) & 0xFF);
                   chaine[12] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 32) & 0xFF);
                   chaine[13] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 24) & 0xFF);
                   chaine[14] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 16) & 0xFF);
                   chaine[15] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 8) & 0xFF);
                   chaine[16] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes & 0xFF);
                   chaine_offset = chaine + 17;
               }
   
               switch(format_sortie)
               {
                   default:
                   case 'I':
                   {
                       switch(longueur)
                       {
                           case 1:
                           {
                               break;
                           }
   
                           case 2:
                           {
                               chaine[0] |= 0x01;
                               break;
                           }
   
                           case 4:
                           {
                               chaine[0] |= 0x02;
                               break;
                           }
   
                           default:
                           case 8:
                           {
                               chaine[0] |= 0x03;
                               break;
                           }
                       }
   
                       chaine[0] |= 0x30;
                       break;
                   }
   
                   case 'R':
                   {
                       switch(longueur)
                       {
                           case 4:
                           {
                               break;
                           }
   
                           default:
                           case 8:
                           {
                               chaine[0] |= 0x01;
                               break;
                           }
                       }
   
                       chaine[0] |= 0xC0;
                       break;
                   }
   
                   case 'C':
                   {
                       switch(longueur)
                       {
                           case 8:
                           {
                               break;
                           }
   
                           default:
                           case 16:
                           {
                               chaine[0] |= 0x01;
                               break;
                           }
                       }
   
                       chaine[0] |= 0xD0;
                       break;
                   }
               }
   
               for(i = 0; i < (*((struct_matrice *) (*s_objet).objet))
                       .nombre_lignes; i++)
               {
                   for(j = 0; j < (*((struct_matrice *) (*s_objet).objet))
                           .nombre_colonnes; j++)
                   {
                       if ((chaine_tampon = formateur_fichier_binaire_nombre(
                               s_etat_processus, &(((integer8 **)
                               (*((struct_matrice *) (*s_objet).objet)).tableau)
                               [i][j]), 'I', format_sortie,
                               longueur, &longueur_element)) == NULL)
                       {
                           free(chaine);
                           return(NULL);
                       }
   
                       memcpy(chaine_offset + (((i * (*((struct_matrice *)
                               (*s_objet).objet)).nombre_colonnes) + j) *
                               longueur), chaine_tampon + 1, (size_t) longueur);
                       free(chaine_tampon);
                   }
               }
         }          }
         else if ((*s_objet).type == MRL)          else if ((*s_objet).type == MRL)
         {          {
Line 3871  formateur_fichier(struct_processus *s_et Line 4718  formateur_fichier(struct_processus *s_et
   Matrice réelle    Matrice réelle
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
               if (format_sortie == 'N')
               {
                   format_sortie = 'R';
                   longueur = 8;
               }
   
               if ((format_sortie != 'R') && (format_sortie != 'C'))
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_format_fichier;
                   return(NULL);
               }
   
               longueur_objet = (*((struct_matrice *) (*s_objet).objet))
                       .nombre_lignes * (*((struct_matrice *) (*s_objet).objet))
                       .nombre_colonnes;
   
               if (((*((struct_matrice *) (*s_objet).objet)).nombre_lignes
                       < (1LL << 8)) && ((*((struct_matrice *) (*s_objet).objet))
                       .nombre_colonnes < (1LL << 8)))
               {
                   // Taille sur un octet
                   if ((chaine = malloc((size_t) ((*longueur_effective) =
                           (3 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xC2;
                   chaine[1] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes & 0xFF);
                   chaine[2] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes & 0xFF);
                   chaine_offset = chaine + 3;
               }
               else if (((*((struct_matrice *) (*s_objet).objet)).nombre_lignes
                       < (1LL << 16)) && ((*((struct_matrice *) (*s_objet).objet))
                       .nombre_colonnes < (1LL << 16)))
               {
                   // Taille sur deux octets
                   if ((chaine = malloc((size_t) ((*longueur_effective) =
                           (5 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xC6;
                   chaine[1] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 8) & 0xFF);
                   chaine[2] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes & 0xFF);
                   chaine[3] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 8) & 0xFF);
                   chaine[4] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes & 0xFF);
                   chaine_offset = chaine + 5;
               }
               else if (((*((struct_matrice *) (*s_objet).objet)).nombre_lignes
                       < (1LL << 32)) && ((*((struct_matrice *) (*s_objet).objet))
                       .nombre_colonnes < (1LL << 32)))
               {
                   // Taille sur quatre octets
                   if ((chaine = malloc((size_t) (((*longueur_effective) =
                           9 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xCA;
                   chaine[1] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 24) & 0xFF);
                   chaine[2] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 16) & 0xFF);
                   chaine[3] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 8) & 0xFF);
                   chaine[4] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes & 0xFF);
                   chaine[5] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 24) & 0xFF);
                   chaine[6] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 16) & 0xFF);
                   chaine[7] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 8) & 0xFF);
                   chaine[8] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes & 0xFF);
                   chaine_offset = chaine + 9;
               }
               else
               {
                   // Taille sur huit octets
                   if ((chaine = malloc((size_t) ((*longueur_effective) =
                           (17 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xCE;
                   chaine[1] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 56) & 0xFF);
                   chaine[2] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 48) & 0xFF);
                   chaine[3] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 40) & 0xFF);
                   chaine[4] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 32) & 0xFF);
                   chaine[5] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 24) & 0xFF);
                   chaine[6] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 16) & 0xFF);
                   chaine[7] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes >> 8) & 0xFF);
                   chaine[8] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_lignes & 0xFF);
                   chaine[9] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 56) & 0xFF);
                   chaine[10] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 48) & 0xFF);
                   chaine[11] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 40) & 0xFF);
                   chaine[12] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 32) & 0xFF);
                   chaine[13] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 24) & 0xFF);
                   chaine[14] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 16) & 0xFF);
                   chaine[15] = (unsigned char) (((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes >> 8) & 0xFF);
                   chaine[16] = (unsigned char) ((*((struct_matrice *)
                           (*s_objet).objet)).nombre_colonnes & 0xFF);
                   chaine_offset = chaine + 17;
               }
   
               switch(format_sortie)
               {
                   default:
                   case 'R':
                   {
                       switch(longueur)
                       {
                           case 4:
                           {
                               break;
                           }
   
                           default:
                           case 8:
                           {
                               chaine[0] |= 0x01;
                               break;
                           }
                       }
   
                       break;
                   }
   
                   case 'C':
                   {
                       switch(longueur)
                       {
                           case 8:
                           {
                               break;
                           }
   
                           default:
                           case 16:
                           {
                               chaine[0] |= 0x01;
                               break;
                           }
                       }
   
                       chaine[0] |= 0x10;
                       break;
                   }
               }
   
               for(i = 0; i < (*((struct_matrice *) (*s_objet).objet))
                       .nombre_lignes; i++)
               {
                   for(j = 0; j < (*((struct_matrice *) (*s_objet).objet))
                           .nombre_colonnes; j++)
                   {
                       if ((chaine_tampon = formateur_fichier_binaire_nombre(
                               s_etat_processus, &(((real8 **)
                               (*((struct_matrice *) (*s_objet).objet)).tableau)
                               [i][j]), 'R', format_sortie,
                               longueur, &longueur_element)) == NULL)
                       {
                           free(chaine);
                           return(NULL);
                       }
   
                       memcpy(chaine_offset + (((i * (*((struct_matrice *)
                               (*s_objet).objet)).nombre_colonnes) + j) *
                               longueur), chaine_tampon + 1, (size_t) longueur);
                       free(chaine_tampon);
                   }
               }
         }          }
         else if ((*s_objet).type == NOM)          else if ((*s_objet).type == NOM)
         {          {
Line 4023  formateur_fichier(struct_processus *s_et Line 5081  formateur_fichier(struct_processus *s_et
   Vecteur complexe    Vecteur complexe
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'C';
                   longueur = 16;
               }
   
               if (format_sortie != 'C')
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_format_fichier;
                   return(NULL);
               }
   
               longueur_objet = (*((struct_vecteur *) (*s_objet).objet)).taille;
   
               if (longueur_objet < (1LL << 8))
               {
                   // Taille sur un octet
                   if ((chaine = malloc((size_t) ((*longueur_effective) =
                           (2 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xB2;
                   chaine[1] = (unsigned char) (longueur_objet & 0xFF);
                   chaine_offset = chaine + 2;
               }
               else if (longueur_objet < (1LL << 16))
               {
                   // Taille sur deux octets
                   if ((chaine = malloc((size_t) ((*longueur_effective) =
                           (3 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xB6;
                   chaine[1] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
                   chaine[2] = (unsigned char) (longueur_objet & 0xFF);
                   chaine_offset = chaine + 3;
               }
               else if (longueur_objet < (1LL << 32))
               {
                   // Taille sur quatre octets
                   if ((chaine = malloc((size_t) (((*longueur_effective) =
                           5 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xBA;
                   chaine[1] = (unsigned char) ((longueur_objet >> 24) & 0xFF);
                   chaine[2] = (unsigned char) ((longueur_objet >> 16) & 0xFF);
                   chaine[3] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
                   chaine[4] = (unsigned char) (longueur_objet & 0xFF);
                   chaine_offset = chaine + 5;
               }
               else
               {
                   // Taille sur huit octets
                   if ((chaine = malloc((size_t) ((*longueur_effective) =
                           (9 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xBE;
                   chaine[1] = (unsigned char) ((longueur_objet >> 56) & 0xFF);
                   chaine[2] = (unsigned char) ((longueur_objet >> 48) & 0xFF);
                   chaine[3] = (unsigned char) ((longueur_objet >> 40) & 0xFF);
                   chaine[4] = (unsigned char) ((longueur_objet >> 32) & 0xFF);
                   chaine[5] = (unsigned char) ((longueur_objet >> 24) & 0xFF);
                   chaine[6] = (unsigned char) ((longueur_objet >> 16) & 0xFF);
                   chaine[7] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
                   chaine[8] = (unsigned char) (longueur_objet & 0xFF);
                   chaine_offset = chaine + 9;
               }
   
               switch(longueur)
               {
                   case 8:
                   {
                       break;
                   }
   
                   default:
                   case 16:
                   {
                       chaine[0] |= 0x01;
                       break;
                   }
               }
   
               for(i = 0; i < longueur_objet; i++)
               {
                   if ((chaine_tampon = formateur_fichier_binaire_nombre(
                           s_etat_processus, &(((complex16 *) (*((struct_vecteur *)
                           (*s_objet).objet)).tableau)[i]), 'C', format_sortie,
                           longueur, &longueur_element)) == NULL)
                   {
                       free(chaine);
                       return(NULL);
                   }
   
                   memcpy(chaine_offset + (i * longueur), chaine_tampon + 1,
                           (size_t) longueur);
                   free(chaine_tampon);
               }
         }          }
         else if ((*s_objet).type == VIN)          else if ((*s_objet).type == VIN)
         {          {
Line 4032  formateur_fichier(struct_processus *s_et Line 5212  formateur_fichier(struct_processus *s_et
   Vecteur entier    Vecteur entier
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'I';
                   longueur = 8;
               }
   
               if ((format_sortie != 'I') && (format_sortie != 'R')
                       && (format_sortie != 'C'))
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_format_fichier;
                   return(NULL);
               }
   
               longueur_objet = (*((struct_vecteur *) (*s_objet).objet)).taille;
   
               if (longueur_objet < (1LL << 8))
               {
                   // Taille sur un octet
                   if ((chaine = malloc((size_t) ((*longueur_effective) =
                           (2 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0x20;
                   chaine[1] = (unsigned char) (longueur_objet & 0xFF);
                   chaine_offset = chaine + 2;
               }
               else if (longueur_objet < (1LL << 16))
               {
                   // Taille sur deux octets
                   if ((chaine = malloc((size_t) ((*longueur_effective) =
                           (3 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0x24;
                   chaine[1] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
                   chaine[2] = (unsigned char) (longueur_objet & 0xFF);
                   chaine_offset = chaine + 3;
               }
               else if (longueur_objet < (1LL << 32))
               {
                   // Taille sur quatre octets
                   if ((chaine = malloc((size_t) (((*longueur_effective) =
                           5 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0x28;
                   chaine[1] = (unsigned char) ((longueur_objet >> 24) & 0xFF);
                   chaine[2] = (unsigned char) ((longueur_objet >> 16) & 0xFF);
                   chaine[3] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
                   chaine[4] = (unsigned char) (longueur_objet & 0xFF);
                   chaine_offset = chaine + 5;
               }
               else
               {
                   // Taille sur huit octets
                   if ((chaine = malloc((size_t) ((*longueur_effective) =
                           (9 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0x2C;
                   chaine[1] = (unsigned char) ((longueur_objet >> 56) & 0xFF);
                   chaine[2] = (unsigned char) ((longueur_objet >> 48) & 0xFF);
                   chaine[3] = (unsigned char) ((longueur_objet >> 40) & 0xFF);
                   chaine[4] = (unsigned char) ((longueur_objet >> 32) & 0xFF);
                   chaine[5] = (unsigned char) ((longueur_objet >> 24) & 0xFF);
                   chaine[6] = (unsigned char) ((longueur_objet >> 16) & 0xFF);
                   chaine[7] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
                   chaine[8] = (unsigned char) (longueur_objet & 0xFF);
                   chaine_offset = chaine + 9;
               }
   
               switch(format_sortie)
               {
                   default:
                   case 'I':
                   {
                       switch(longueur)
                       {
                           case 1:
                           {
                               break;
                           }
   
                           case 2:
                           {
                               chaine[0] |= 0x01;
                               break;
                           }
   
                           case 4:
                           {
                               chaine[0] |= 0x02;
                               break;
                           }
   
                           default:
                           case 8:
                           {
                               chaine[0] |= 0x03;
                               break;
                           }
                       }
   
                       break;
                   }
   
                   case 'R':
                   {
                       switch(longueur)
                       {
                           case 4:
                           {
                               break;
                           }
   
                           default:
                           case 8:
                           {
                               chaine[0] |= 0x01;
                               break;
                           }
                       }
   
                       chaine[0] |= 0x80;
                       break;
                   }
   
                   case 'C':
                   {
                       switch(longueur)
                       {
                           case 8:
                           {
                               break;
                           }
   
                           default:
                           case 16:
                           {
                               chaine[0] |= 0x01;
                               break;
                           }
                       }
   
                       chaine[0] |= 0x90;
                       break;
                   }
               }
   
               for(i = 0; i < longueur_objet; i++)
               {
                   if ((chaine_tampon = formateur_fichier_binaire_nombre(
                           s_etat_processus, &(((integer8 *) (*((struct_vecteur *)
                           (*s_objet).objet)).tableau)[i]), 'I', format_sortie,
                           longueur, &longueur_element)) == NULL)
                   {
                       free(chaine);
                       return(NULL);
                   }
   
                   memcpy(chaine_offset + (i * longueur), chaine_tampon + 1,
                           (size_t) longueur);
                   free(chaine_tampon);
               }
         }          }
         else if ((*s_objet).type == VRL)          else if ((*s_objet).type == VRL)
         {          {
Line 4041  formateur_fichier(struct_processus *s_et Line 5407  formateur_fichier(struct_processus *s_et
   Vecteur réel    Vecteur réel
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'R';
                   longueur = 8;
               }
   
               if ((format_sortie != 'R') && (format_sortie != 'C'))
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_format_fichier;
                   return(NULL);
               }
   
               longueur_objet = (*((struct_vecteur *) (*s_objet).objet)).taille;
   
               if (longueur_objet < (1LL << 8))
               {
                   // Taille sur un octet
                   if ((chaine = malloc((size_t) ((*longueur_effective) =
                           (2 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xA2;
                   chaine[1] = (unsigned char) (longueur_objet & 0xFF);
                   chaine_offset = chaine + 2;
               }
               else if (longueur_objet < (1LL << 16))
               {
                   // Taille sur deux octets
                   if ((chaine = malloc((size_t) ((*longueur_effective) =
                           (3 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xA6;
                   chaine[1] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
                   chaine[2] = (unsigned char) (longueur_objet & 0xFF);
                   chaine_offset = chaine + 3;
               }
               else if (longueur_objet < (1LL << 32))
               {
                   // Taille sur quatre octets
                   if ((chaine = malloc((size_t) (((*longueur_effective) =
                           5 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xAA;
                   chaine[1] = (unsigned char) ((longueur_objet >> 24) & 0xFF);
                   chaine[2] = (unsigned char) ((longueur_objet >> 16) & 0xFF);
                   chaine[3] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
                   chaine[4] = (unsigned char) (longueur_objet & 0xFF);
                   chaine_offset = chaine + 5;
               }
               else
               {
                   // Taille sur huit octets
                   if ((chaine = malloc((size_t) ((*longueur_effective) =
                           (9 + (longueur_objet * longueur)))
                           * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xAE;
                   chaine[1] = (unsigned char) ((longueur_objet >> 56) & 0xFF);
                   chaine[2] = (unsigned char) ((longueur_objet >> 48) & 0xFF);
                   chaine[3] = (unsigned char) ((longueur_objet >> 40) & 0xFF);
                   chaine[4] = (unsigned char) ((longueur_objet >> 32) & 0xFF);
                   chaine[5] = (unsigned char) ((longueur_objet >> 24) & 0xFF);
                   chaine[6] = (unsigned char) ((longueur_objet >> 16) & 0xFF);
                   chaine[7] = (unsigned char) ((longueur_objet >> 8) & 0xFF);
                   chaine[8] = (unsigned char) (longueur_objet & 0xFF);
                   chaine_offset = chaine + 9;
               }
   
               switch(format_sortie)
               {
                   default:
                   case 'R':
                   {
                       break;
                   }
   
                   case 'C':
                   {
                       chaine[0] |= 0x10;
                       break;
                   }
               }
   
               switch(longueur)
               {
                   case 4:
                   {
                       break;
                   }
   
                   default:
                   case 8:
                   {
                       chaine[0] |= 0x01;
                       break;
                   }
               }
   
               for(i = 0; i < longueur_objet; i++)
               {
                   if ((chaine_tampon = formateur_fichier_binaire_nombre(
                           s_etat_processus, &(((real8 *) (*((struct_vecteur *)
                           (*s_objet).objet)).tableau)[i]), 'R', format_sortie,
                           longueur, &longueur_element)) == NULL)
                   {
                       free(chaine);
                       return(NULL);
                   }
   
                   memcpy(chaine_offset + (i * longueur), chaine_tampon + 1,
                           (size_t) longueur);
                   free(chaine_tampon);
               }
         }          }
         else          else
         {          {
Line 4078  formateur_fichier(struct_processus *s_et Line 5581  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))
Line 4106  formateur_fichier(struct_processus *s_et Line 5613  formateur_fichier(struct_processus *s_et
                                 | ((i + 1) << 1));                                  | ((i + 1) << 1));
                         break;                          break;
                     }                      }
   
                       switch(i)
                       {
                           case 0 :
                           {
                               i = 2;
                               break;
                           }
   
                           case 2 :
                           {
                               i = 6;
                               break;
                           }
                       }
                 }                  }
   
                 if ((chaine = realloc(chaine, (((size_t) 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 4119  formateur_fichier(struct_processus *s_et Line 5646  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 4697  formateur_fichier_binaire_nombre(struct_ Line 6221  formateur_fichier_binaire_nombre(struct_
                         vinf = nextafter(valeur, 0);                          vinf = nextafter(valeur, 0);
                         vsup = nextafter(valeur, valeur * 2);                          vsup = nextafter(valeur, valeur * 2);
                     }                      }
                     else                      else if (valeur < 0)
                     {                      {
                         vinf = nextafter(valeur, valeur * 2);                          vinf = nextafter(valeur, valeur * 2);
                         vsup = nextafter(valeur, 0);                          vsup = nextafter(valeur, 0);
                     }                      }
                       else
                       {
                           vinf = valeur;
                           vsup = valeur;
                       }
   
                     if (!((vinf <= ((real4) valeur)) &&                      if (!((((real4) vinf) <= ((real4) valeur)) &&
                             (((real4) valeur) <= vsup)))                              (((real4) valeur) <= ((real4) vsup))))
                     {                      {
                         (*s_etat_processus).erreur_execution =                          (*s_etat_processus).erreur_execution =
                                 d_ex_representation;                                  d_ex_representation;
Line 5257  lecture_fichier_non_formate(struct_proce Line 6786  lecture_fichier_non_formate(struct_proce
                         return(NULL);                          return(NULL);
                     }                      }
   
                     (*((integer8 *) (*s_objet).objet)) = 0;                      // Récupération des données avec extension de signe.
   
                     for(i = 0; i < (signed) deplacement; i++)  
                     {                      {
                         (*((integer8 *) (*s_objet).objet)) |=                          integer1        i1;
                                 ((integer8) octets[i])                          integer2        i2;
                                 << (8 * ((((signed) deplacement) - 1) - i));                          integer4        i4;
                           integer8        i8;
   
                           i1 = 0;
                           i2 = 0;
                           i4 = 0;
                           i8 = 0;
   
                           for(i = 0; i < (signed) deplacement; i++)
                           {
                               switch(deplacement)
                               {
                                   case 1:
                                       i1 = (integer1) octets[0];
                                   break;
   
                                   case 2:
                                       i2 |= (integer2) (((integer8) octets[i]) <<
                                               (8 * ((((signed) deplacement) - 1)
                                               - i)));
                                   break;
   
                                   case 4:
                                       i4 |= (integer4) (((integer8) octets[i]) <<
                                               (8 * ((((signed) deplacement) - 1)
                                               - i)));
                                   break;
   
                                   case 8:
                                       i8 |= (integer8) (((integer8) octets[i]) <<
                                               (8 * ((((signed) deplacement) - 1)
                                               - i)));
                                   break;
                               }
                           }
   
                           switch(deplacement)
                           {
                               case 1:
                                   (*((integer8 *) (*s_objet).objet)) =
                                           (integer8) i1;
                               break;
   
                               case 2:
                                   (*((integer8 *) (*s_objet).objet)) =
                                           (integer8) i2;
                               break;
   
                               case 4:
                                   (*((integer8 *) (*s_objet).objet)) =
                                           (integer8) i4;
                               break;
   
                               case 8:
                                   (*((integer8 *) (*s_objet).objet)) =
                                           (integer8) i8;
                               break;
                           }
                     }                      }
   
                     break;                      break;
Removed from v.1.63  
changed lines
  Added in v.1.86

CVSweb interface <joel.bertrand@systella.fr>