[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.61 and 1.84

version 1.61, 2013/03/20 17:11:43 version 1.84, 2015/03/26 11:10:46
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.13    RPL/2 (R) version 4.1.21
   Copyright (C) 1989-2013 Dr. BERTRAND Joël    Copyright (C) 1989-2015 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 19 Line 19
 ================================================================================  ================================================================================
 */  */
   
 #define DEBUG_ERREURS  
 #include "rpl-conv.h"  #include "rpl-conv.h"
   
   
Line 85  formateur_fichier(struct_processus *s_et Line 85  formateur_fichier(struct_processus *s_et
     struct_liste_chainee        *l_liste1;      struct_liste_chainee        *l_liste1;
     struct_liste_chainee        *l_liste2;      struct_liste_chainee        *l_liste2;
   
       struct_objet                *s_format_tmp;
     struct_objet                *s_sous_objet;      struct_objet                *s_sous_objet;
     struct_objet                *s_sous_objet_1;      struct_objet                *s_sous_objet_1;
     struct_objet                *s_sous_objet_2;      struct_objet                *s_sous_objet_2;
Line 94  formateur_fichier(struct_processus *s_et Line 95  formateur_fichier(struct_processus *s_et
     unsigned char               *chaine;      unsigned char               *chaine;
     unsigned char               *chaine_fonction;      unsigned char               *chaine_fonction;
     unsigned char               *chaine_formatee;      unsigned char               *chaine_formatee;
       unsigned char               *chaine_offset;
     unsigned char               *chaine_tampon;      unsigned char               *chaine_tampon;
     unsigned char               *chaine_sauvegarde;      unsigned char               *chaine_sauvegarde;
     unsigned char               *format_chaine;      unsigned char               *format_chaine;
Line 111  formateur_fichier(struct_processus *s_et Line 113  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 237  formateur_fichier(struct_processus *s_et
                                     .instruction_courante[1]                                      .instruction_courante[1]
                                     == '-')) ? d_vrai : d_faux;                                      == '-')) ? d_vrai : d_faux;
   
                               (*s_etat_processus).type_en_cours = NON;
                             recherche_type(s_etat_processus);                              recherche_type(s_etat_processus);
   
                             if ((*s_etat_processus).erreur_execution != d_ex)                              if ((*s_etat_processus).erreur_execution != d_ex)
Line 292  formateur_fichier(struct_processus *s_et Line 297  formateur_fichier(struct_processus *s_et
                                     if ((strcmp(chaine_fonction, "AND") == 0) ||                                      if ((strcmp(chaine_fonction, "AND") == 0) ||
                                             (strcmp(chaine_fonction, "XOR") ==                                              (strcmp(chaine_fonction, "XOR") ==
                                             0) || (strcmp(chaine_fonction, "OR")                                              0) || (strcmp(chaine_fonction, "OR")
                                             == 0))                                              == 0) || (strcmp(chaine_fonction,
                                               "EQV") == 0))
                                     {                                      {
                                         autorisation_parenthese = d_vrai;                                          autorisation_parenthese = d_vrai;
                                     }                                      }
Line 319  formateur_fichier(struct_processus *s_et Line 325  formateur_fichier(struct_processus *s_et
                                             || (strcmp(chaine_fonction, "AND")                                              || (strcmp(chaine_fonction, "AND")
                                             == 0) || (strcmp(chaine_fonction,                                              == 0) || (strcmp(chaine_fonction,
                                             "XOR") == 0) || (strcmp(                                              "XOR") == 0) || (strcmp(
                                             chaine_fonction, "OR") == 0))                                              chaine_fonction, "OR") == 0) ||
                                               (strcmp(chaine_fonction, "EQV")
                                               == 0))
                                     {                                      {
                                         autorisation_parenthese = d_vrai;                                          autorisation_parenthese = d_vrai;
                                     }                                      }
Line 400  formateur_fichier(struct_processus *s_et Line 408  formateur_fichier(struct_processus *s_et
                                     "'%s'", (unsigned char *)                                      "'%s'", (unsigned char *)
                                     (*s_sous_objet_1).objet);                                      (*s_sous_objet_1).objet);
   
                               (*s_etat_processus).type_en_cours = NON;
                             recherche_type(s_etat_processus);                              recherche_type(s_etat_processus);
   
                             if ((*s_etat_processus).erreur_execution != d_ex)                              if ((*s_etat_processus).erreur_execution != d_ex)
Line 457  formateur_fichier(struct_processus *s_et Line 466  formateur_fichier(struct_processus *s_et
                                     if ((strcmp(chaine_fonction, "AND") == 0) ||                                      if ((strcmp(chaine_fonction, "AND") == 0) ||
                                             (strcmp(chaine_fonction, "XOR") ==                                              (strcmp(chaine_fonction, "XOR") ==
                                             0) || (strcmp(chaine_fonction, "OR")                                              0) || (strcmp(chaine_fonction, "OR")
                                             == 0))                                              == 0) || (strcmp(chaine_fonction,
                                               "EQV") == 0))
                                     {                                      {
                                         autorisation_parenthese = d_vrai;                                          autorisation_parenthese = d_vrai;
                                     }                                      }
Line 474  formateur_fichier(struct_processus *s_et Line 484  formateur_fichier(struct_processus *s_et
                                             || (strcmp(chaine_fonction, "AND")                                              || (strcmp(chaine_fonction, "AND")
                                             == 0) || (strcmp(chaine_fonction,                                              == 0) || (strcmp(chaine_fonction,
                                             "XOR") == 0) || (strcmp(                                              "XOR") == 0) || (strcmp(
                                             chaine_fonction, "OR") == 0))                                              chaine_fonction, "OR") == 0) ||
                                               (strcmp(chaine_fonction, "EQV")
                                               == 0))
                                     {                                      {
                                         autorisation_parenthese = d_vrai;                                          autorisation_parenthese = d_vrai;
                                     }                                      }
Line 715  formateur_fichier(struct_processus *s_et Line 727  formateur_fichier(struct_processus *s_et
                                 "XOR") == 0) || (strcmp((*((struct_fonction *)                                  "XOR") == 0) || (strcmp((*((struct_fonction *)
                                 (*(*l_element_courant).donnee).objet))                                  (*(*l_element_courant).donnee).objet))
                                 .nom_fonction,                                  .nom_fonction,
                                 "AND") == 0))                                  "AND") == 0) || (strcmp((*((struct_fonction *)
                                   (*(*l_element_courant).donnee).objet))
                                   .nom_fonction, "EQV") == 0))
                         {                          {
                             if (depilement(s_etat_processus,                              if (depilement(s_etat_processus,
                                     &((*s_etat_processus)                                      &((*s_etat_processus)
Line 1000  formateur_fichier(struct_processus *s_et Line 1014  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 1024  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 1134  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 1142  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 1150  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 1544  formateur_fichier(struct_processus *s_et
                 }                  }
                 else                  else
                 {                  {
                     if ((format_chaine = conversion_majuscule((unsigned char *)                      if ((format_chaine = conversion_majuscule(
                               s_etat_processus, (unsigned char *)
                             (*(*l_element_courant_format).donnee).objet))                              (*(*l_element_courant_format).donnee).objet))
                             == NULL)                              == NULL)
                     {                      {
Line 1673  formateur_fichier(struct_processus *s_et Line 1688  formateur_fichier(struct_processus *s_et
                                   
                     chaine_sauvegarde = chaine;                      chaine_sauvegarde = chaine;
   
                       // Si le format_sortie vaut 'N', on remplace le format par
                       // { "native*(*)" }. L'intérêt est de pouvoir traiter une
                       // liste par un format "native*(*)".
   
                       if ((format_sortie == 'N') && ((*(*l_element_courant)
                               .donnee).type == LST))
                       {
                           if ((s_format_tmp = allocation(s_etat_processus, LST))
                                   == NULL)
                           {
                               return(NULL);
                           }
   
                           if (((*s_format_tmp).objet = allocation_maillon(
                                   s_etat_processus)) == NULL)
                           {
                               return(NULL);
                           }
   
                           (*((struct_liste_chainee *) (*s_format_tmp).objet))
                                   .suivant = NULL;
   
                           if (((*((struct_liste_chainee *) (*s_format_tmp).objet))
                                   .donnee = allocation(s_etat_processus, CHN))
                                   == NULL)
                           {
                               return(NULL);
                           }
   
                           if (((*(*((struct_liste_chainee *) (*s_format_tmp)
                                   .objet)).donnee).objet = malloc(11 *
                                   sizeof(unsigned char))) == NULL)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_allocation_memoire;
                               return(NULL);
                           }
   
                           strcpy((unsigned char *) (*(*((struct_liste_chainee *)
                                   (*s_format_tmp).objet)).donnee).objet,
                                   "native*(*)");
                       }
                       else
                       {
                           if ((s_format_tmp = copie_objet(s_etat_processus,
                                   s_format, 'P')) == NULL)
                           {
                               return(NULL);
                           }
                       }
   
                     if ((chaine_formatee = formateur_fichier(s_etat_processus,                      if ((chaine_formatee = formateur_fichier(s_etat_processus,
                             (*l_element_courant).donnee, s_format,                              (*l_element_courant).donnee, s_format,
                             longueur, longueur_champ, format_sortie, type,                              longueur, longueur_champ, format_sortie, type,
                             longueur_effective, recursivite, export_fichier))                              longueur_effective, recursivite, export_fichier))
                             == NULL)                              == NULL)
                     {                      {
                           liberation(s_etat_processus, s_format_tmp);
                         free(chaine);                          free(chaine);
                         return(NULL);                          return(NULL);
                     }                      }
   
                       liberation(s_etat_processus, s_format_tmp);
   
                     if ((*(*l_element_courant).donnee).type == CHN)                      if ((*(*l_element_courant).donnee).type == CHN)
                     {                      {
                         chaine = (unsigned char *)                          chaine = (unsigned char *)
Line 1878  formateur_fichier(struct_processus *s_et Line 1947  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 3702  formateur_fichier(struct_processus *s_et Line 3772  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 3785  formateur_fichier(struct_processus *s_et Line 3856  formateur_fichier(struct_processus *s_et
                     }                      }
   
                     free(format_chaine);                      free(format_chaine);
                   
                       // Si le format_sortie vaut 'N', on remplace le format par
                       // { "native*(*)" }. L'intérêt est de pouvoir traiter une
                       // liste par un format "native*(*)".
   
                       if ((format_sortie == 'N') && ((*(*l_element_courant)
                               .donnee).type == LST))
                       {
                           if ((s_format_tmp = allocation(s_etat_processus, LST))
                                   == NULL)
                           {
                               return(NULL);
                           }
   
                           if (((*s_format_tmp).objet = allocation_maillon(
                                   s_etat_processus)) == NULL)
                           {
                               return(NULL);
                           }
   
                           (*((struct_liste_chainee *) (*s_format_tmp).objet))
                                   .suivant = NULL;
   
                           if (((*((struct_liste_chainee *) (*s_format_tmp).objet))
                                   .donnee = allocation(s_etat_processus, CHN))
                                   == NULL)
                           {
                               return(NULL);
                           }
   
                           if (((*(*((struct_liste_chainee *) (*s_format_tmp)
                                   .objet)).donnee).objet = malloc(11 *
                                   sizeof(unsigned char))) == NULL)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_allocation_memoire;
                               return(NULL);
                           }
   
                           strcpy((unsigned char *) (*(*((struct_liste_chainee *)
                                   (*s_format_tmp).objet)).donnee).objet,
                                   "native*(*)");
                       }
                       else
                       {
                           if ((s_format_tmp = copie_objet(s_etat_processus,
                                   s_format, 'P')) == NULL)
                           {
                               return(NULL);
                           }
                       }
   
                     if ((chaine_formatee = formateur_fichier(s_etat_processus,                      if ((chaine_formatee = formateur_fichier(s_etat_processus,
                             (*l_element_courant).donnee, s_format,                              (*l_element_courant).donnee, s_format_tmp,
                             longueur, longueur_champ, format_sortie, type,                              longueur, longueur_champ, format_sortie, type,
                             longueur_effective, recursivite, export_fichier))                              longueur_effective, recursivite, export_fichier))
                             == NULL)                              == NULL)
                     {                      {
                           liberation(s_etat_processus, s_format_tmp);
                         free(chaine);                          free(chaine);
                         return(NULL);                          return(NULL);
                     }                      }
   
                       liberation(s_etat_processus, s_format_tmp);
   
                     if ((chaine = realloc(chaine,                      if ((chaine = realloc(chaine,
                             ((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 3936  formateur_fichier(struct_processus *s_et
                     free(chaine_formatee);                      free(chaine_formatee);
                 }                  }
   
                 nombre_elements++;  
                 l_element_courant = (*l_element_courant).suivant;  
   
                 if (format_sortie != 'N')                  if (format_sortie != 'N')
                 {                  {
                     l_element_courant_format =                      l_element_courant_format =
                             (*l_element_courant_format).suivant;                              (*l_element_courant_format).suivant;
                 }                  }
   
                   nombre_elements++;
                   l_element_courant = (*l_element_courant).suivant;
             }              }
   
             if (format_sortie != 'N')              if (format_sortie != 'N')
Line 4023  formateur_fichier(struct_processus *s_et Line 4148  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);
               }
         }          }
         else if ((*s_objet).type == VIN)          else if ((*s_objet).type == VIN)
         {          {
Line 4032  formateur_fichier(struct_processus *s_et Line 4278  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':
                   {
                       break;
                   }
   
                   case 'R':
                   {
                       chaine[0] |= 0x80;
                       break;
                   }
   
                   case 'C':
                   {
                       chaine[0] |= 0x90;
                       break;
                   }
               }
   
               switch(longueur)
               {
                   case 1:
                   {
                       break;
                   }
   
                   case 2:
                   {
                       chaine[0] |= 0x01;
                       break;
                   }
   
                   case 4:
                   {
                       chaine[0] |= 0x02;
                       break;
                   }
   
                   default:
                   case 8:
                   {
                       chaine[0] |= 0x03;
                       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);
               }
         }          }
         else if ((*s_objet).type == VRL)          else if ((*s_objet).type == VRL)
         {          {
Line 4041  formateur_fichier(struct_processus *s_et Line 4442  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);
               }
         }          }
         else          else
         {          {
Line 4078  formateur_fichier(struct_processus *s_et Line 4615  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 4647  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 4680  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 4303  formateur_fichier_reel(struct_processus Line 4861  formateur_fichier_reel(struct_processus
     real8                   mantisse;      real8                   mantisse;
     real8                   tampon_reel;      real8                   tampon_reel;
   
       integer8                i;
     integer8                tampon_entier;      integer8                tampon_entier;
   
     long                    correction;      long                    correction;
Line 4315  formateur_fichier_reel(struct_processus Line 4874  formateur_fichier_reel(struct_processus
     unsigned char           mode[3 + 1];      unsigned char           mode[3 + 1];
     unsigned char           tampon[16 + 1];      unsigned char           tampon[16 + 1];
   
     unsigned long           i;  
   
     chaine = (unsigned char *) malloc((32 + 1) * sizeof(unsigned char));      chaine = (unsigned char *) malloc((32 + 1) * sizeof(unsigned char));
   
     if (chaine == NULL)      if (chaine == NULL)
Line 4365  formateur_fichier_reel(struct_processus Line 4922  formateur_fichier_reel(struct_processus
                 pow(10, (double) exposant);                  pow(10, (double) exposant);
     }      }
   
     longueur_utile = longueur;      longueur_utile = (long) longueur;
     longueur_utile_limite = 15;      longueur_utile_limite = 15;
   
     if (longueur_utile > longueur_utile_limite)      if (longueur_utile > longueur_utile_limite)
Line 4479  formateur_fichier_reel(struct_processus Line 5036  formateur_fichier_reel(struct_processus
   
             sprintf(tampon, format, *((real8 *) valeur_numerique));              sprintf(tampon, format, *((real8 *) valeur_numerique));
   
             i = strlen(tampon) - 1;              i = (integer8) (strlen(tampon)) - 1;
             while(tampon[i] == '0')              while(tampon[i] == '0')
             {              {
                 tampon[i] = 0;                  tampon[i] = 0;
Line 4488  formateur_fichier_reel(struct_processus Line 5045  formateur_fichier_reel(struct_processus
   
             if (ds_imposition_separateur_decimal == d_faux)              if (ds_imposition_separateur_decimal == d_faux)
             {              {
                 i = strlen(tampon) - 1;                  i = ((integer8) strlen(tampon)) - 1;
                 if (tampon[i] == '.')                  if (tampon[i] == '.')
                 {                  {
                     tampon[i] = 0;                      tampon[i] = 0;
Line 4503  formateur_fichier_reel(struct_processus Line 5060  formateur_fichier_reel(struct_processus
     {      {
         if (strlen(chaine) > (size_t) longueur_champ)          if (strlen(chaine) > (size_t) longueur_champ)
         {          {
             for(i = 0; i < (unsigned long) longueur_champ; i++)              for(i = 0; i < longueur_champ; i++)
             {              {
                 chaine[i] = '*';                  chaine[i] = '*';
             }              }
Line 4698  formateur_fichier_binaire_nombre(struct_ Line 5255  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 5258  lecture_fichier_non_formate(struct_proce Line 5820  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.61  
changed lines
  Added in v.1.84

CVSweb interface <joel.bertrand@systella.fr>