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

version 1.82, 2015/01/27 14:18:06 version 1.84, 2015/03/26 11:10:46
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.20    RPL/2 (R) version 4.1.21
   Copyright (C) 1989-2015 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 95  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 112  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 4145  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 4154  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 4163  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 4840  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;
Removed from v.1.82  
changed lines
  Added in v.1.84

CVSweb interface <joel.bertrand@systella.fr>