[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.16 and 1.49

version 1.16, 2010/08/26 19:07:35 version 1.49, 2013/02/26 19:56:12
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.19    RPL/2 (R) version 4.1.12
   Copyright (C) 1989-2010 Dr. BERTRAND Joël    Copyright (C) 1989-2013 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 30 Line 30
   Entrées : structure sur l'état du processus et objet à afficher    Entrées : structure sur l'état du processus et objet à afficher
   Longueur est la précision requise et longueur_champ, le nombre maximal    Longueur est la précision requise et longueur_champ, le nombre maximal
   de caractères de la chaîne résultat (-1 signifiant une absence de contrainte)    de caractères de la chaîne résultat (-1 signifiant une absence de contrainte)
   Type = 'F/U'    Type = 'F/U' (formaté, non formaté)
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Sorties : chaine de caractères et longueur du tableau de caractères    Sorties : chaine de caractères et longueur du tableau de caractères
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
Line 75  formateur_fichier(struct_processus *s_et Line 75  formateur_fichier(struct_processus *s_et
   
     logical1                    autorisation_parenthese;      logical1                    autorisation_parenthese;
     logical1                    format_degenere;      logical1                    format_degenere;
     logical1                    longueur_3bits;  
     logical1                    longueur_6bits;  
     logical1                    presence_signe;      logical1                    presence_signe;
   
     struct_liste_chainee        *l_atome;      struct_liste_chainee        *l_atome;
Line 97  formateur_fichier(struct_processus *s_et Line 95  formateur_fichier(struct_processus *s_et
     unsigned char               *chaine_tampon;      unsigned char               *chaine_tampon;
     unsigned char               *chaine_sauvegarde;      unsigned char               *chaine_sauvegarde;
     unsigned char               *format_chaine;      unsigned char               *format_chaine;
     unsigned char               longueur_optimale;  
     unsigned char               parametre_longueur;  
     unsigned char               *ptre;      unsigned char               *ptre;
     unsigned char               *ptrl;      unsigned char               *ptrl;
     unsigned char               tampon[64 + 1];      unsigned char               tampon[64 + 1];
   
     unsigned long               i;      unsigned long               i;
     unsigned long               j;      unsigned long               j;
     unsigned long               longueur_binaire;  
     unsigned long               longueur_champ_final;  
     unsigned long               nombre_arguments;      unsigned long               nombre_arguments;
     unsigned long               nombre_arguments_fonction;      unsigned long               nombre_arguments_fonction;
     unsigned long               nombre_colonnes;      unsigned long               nombre_colonnes;
Line 114  formateur_fichier(struct_processus *s_et Line 108  formateur_fichier(struct_processus *s_et
     unsigned long               nombre_lignes;      unsigned long               nombre_lignes;
   
     integer8                    longueur_liste;      integer8                    longueur_liste;
     integer8                    longueur_entete;  
     integer8                    longueur_objet;  
     integer8                    longueur_totale;      integer8                    longueur_totale;
     integer8                    masque_binaire;      integer8                    masque_binaire;
     integer8                    position_1;      integer8                    position_1;
     integer8                    position_2;      integer8                    position_2;
     integer8                    position_3;      integer8                    position_3;
   
     long                        offset;  
   
     (*recursivite)++;      (*recursivite)++;
   
     if (type == 'F')      if (type == 'F')
Line 138  formateur_fichier(struct_processus *s_et Line 128  formateur_fichier(struct_processus *s_et
   
         strcpy(base, " ");          strcpy(base, " ");
   
         longueur_binaire = 0;  
         masque_binaire = 0;          masque_binaire = 0;
   
         if ((*s_objet).type == ALG)          if ((*s_objet).type == ALG)
Line 998  formateur_fichier(struct_processus *s_et Line 987  formateur_fichier(struct_processus *s_et
                 return(NULL);                  return(NULL);
             }              }
   
             longueur_binaire = longueur_entiers_binaires(s_etat_processus);  
             masque_binaire = masque_entiers_binaires(s_etat_processus);              masque_binaire = masque_entiers_binaires(s_etat_processus);
   
             if ((test_cfsf(s_etat_processus, 43) == d_faux) &&              if ((test_cfsf(s_etat_processus, 43) == d_faux) &&
Line 1176  formateur_fichier(struct_processus *s_et Line 1164  formateur_fichier(struct_processus *s_et
                 return(NULL);                  return(NULL);
             }              }
   
             if ((longueur_champ == -1) || (strlen((unsigned char *)              if ((longueur_champ == -1) || (((long) strlen((unsigned char *)
                     (*s_objet).objet) < longueur_champ))                      (*s_objet).objet)) < longueur_champ))
             {              {
                 chaine = (unsigned char *) malloc((strlen((unsigned char *)                  chaine = (unsigned char *) malloc((strlen((unsigned char *)
                         ((*s_objet).objet)) + 1) * sizeof(unsigned char));                          ((*s_objet).objet)) + 1) * sizeof(unsigned char));
Line 1508  formateur_fichier(struct_processus *s_et Line 1496  formateur_fichier(struct_processus *s_et
                         return(NULL);                          return(NULL);
                     }                      }
   
                     position_3 = strlen(format_chaine);                      position_3 = strlen(format_chaine) - 1;
                     format_chaine[--position_3] = d_code_fin_chaine;  
                       if (format_chaine[position_3] != ')')
                       {
                           free(chaine);
                           free(format_chaine);
   
                           (*s_etat_processus).erreur_execution =
                                   d_ex_erreur_format_fichier;
                           return(NULL);
                       }
   
                       format_chaine[position_3] = d_code_fin_chaine;
   
                     position_2 = position_1;                      position_2 = position_1;
   
Line 1728  formateur_fichier(struct_processus *s_et Line 1727  formateur_fichier(struct_processus *s_et
                         (((*(*((struct_tableau *) (*s_format).objet))                          (((*(*((struct_tableau *) (*s_format).objet))
                         .elements[i]).type == TBL) &&                          .elements[i]).type == TBL) &&
                         ((*(*((struct_tableau *) (*s_objet).objet)).elements[i])                          ((*(*((struct_tableau *) (*s_objet).objet)).elements[i])
                         .type == TAB)))                          .type == TBL)))
                 {                  {
                     chaine_sauvegarde = chaine;                      chaine_sauvegarde = chaine;
   
Line 2711  formateur_fichier(struct_processus *s_et Line 2710  formateur_fichier(struct_processus *s_et
          */           */
   
 #define __zone() \  #define __zone() \
         do { int _i; for(_i = 0; _i < longueur_totale; _i++) \          do { int _i; \
             printf("%02X ", chaine[_i]); printf("\b\n"); } while(0)              for(_i = 0; _i < longueur_totale; _i++) \
                   printf("%02X ", chaine[_i]); printf("\b\n"); } while(0)
   
         /*          /*
          * Chaque enregistrement est composé d'une donnée (une liste)           * Chaque enregistrement est composé d'une donnée (une liste)
Line 2730  formateur_fichier(struct_processus *s_et Line 2730  formateur_fichier(struct_processus *s_et
          * Longueur : (pour l'instruction backspace)           * Longueur : (pour l'instruction backspace)
          *           *
          * 00 XXXXXX                longueur sur 6 bits           * 00 XXXXXX                longueur sur 6 bits
          * 01 ------                longueur sur 16 bits           * 01 XXXXXX                longueur sur 16 bits
          * 10 ------                longueur sur 32 bits           * 10 XXXXXX                longueur sur 32 bits
          * 11 ------                longueur sur 64 bits           * 11 XXXXXX                longueur sur 64 bits
            *
            * Exemples :
            * [00 XXXXXX]
            * [01 ----XX][XXXXXXXX][01 XXXXXX]
            * [10 ----XX][XXXXXXXX][XXXXXXXX][XXXXXXXX][10 XXXXXX]
            * [11 ----XX][XXXXXXXX][XXXXXXXX][XXXXXXXX][XXXXXXXX][XXXXXXXX]
            *         [XXXXXXXX][XXXXXXXX][11 XXXXXX]
          *           *
          * Structures des enregistrements :           * Structures des enregistrements :
          * chaque type de donnée est associé à une en-tête binaire comprenant           * chaque type de donnée est associé à une en-tête binaire comprenant
Line 2813  formateur_fichier(struct_processus *s_et Line 2820  formateur_fichier(struct_processus *s_et
          * 1001 10 10               table de longueur integer*4           * 1001 10 10               table de longueur integer*4
          * 1001 10 11               table de longueur integer*8           * 1001 10 11               table de longueur integer*8
          *           *
            * 1010 00 10               vecteur real*4 (dimensions integer*1)
            * 1010 01 10               vecteur real*4 (dimensions integer*2)
            * 1010 10 10               vecteur real*4 (dimensions integer*4)
            * 1010 11 10               vecteur real*4 (dimensions integer*8)
            * 1010 00 11               vecteur real*8 (dimensions integer*1)
            * 1010 01 11               vecteur real*8 (dimensions integer*2)
            * 1010 10 11               vecteur real*8 (dimensions integer*4)
            * 1010 11 11               vecteur real*8 (dimensions integer*8)
            * 1011 00 10               vecteur complex*8 (dimensions integer*1)
            * 1011 01 10               vecteur complex*8 (dimensions integer*2)
            * 1011 10 10               vecteur complex*8 (dimensions integer*4)
            * 1011 11 10               vecteur complex*8 (dimensions integer*8)
            * 1011 00 11               vecteur complex*16 (dimensions integer*1)
            * 1011 01 11               vecteur complex*16 (dimensions integer*2)
            * 1011 10 11               vecteur complex*16 (dimensions integer*4)
            * 1011 11 11               vecteur complex*16 (dimensions integer*8)
            *
            * 1100 00 10               matrice real*4 (dimensions integer*1)
            * 1100 01 10               matrice real*4 (dimensions integer*2)
            * 1100 10 10               matrice real*4 (dimensions integer*4)
            * 1100 11 10               matrice real*4 (dimensions integer*8)
            * 1100 00 11               matrice real*8 (dimensions integer*1)
            * 1100 01 11               matrice real*8 (dimensions integer*2)
            * 1100 10 11               matrice real*8 (dimensions integer*4)
            * 1100 11 11               matrice real*8 (dimensions integer*8)
            * 1101 00 10               matrice complex*8 (dimensions integer*1)
            * 1101 01 10               matrice complex*8 (dimensions integer*2)
            * 1101 10 10               matrice complex*8 (dimensions integer*4)
            * 1101 11 10               matrice complex*8 (dimensions integer*8)
            * 1101 00 11               matrice complex*16 (dimensions integer*1)
            * 1101 01 11               matrice complex*16 (dimensions integer*2)
            * 1101 10 11               matrice complex*16 (dimensions integer*4)
            * 1101 11 11               matrice complex*16 (dimensions integer*8)
            *
          * 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
            *      01 : integer*2
            *      10 : integer*4
            *      11 : integer*8
            *
          * [En-tête][longueur_1][longueur_2][données]           * [En-tête][longueur_1][longueur_2][données]
          * le nombre de champs longueur dépendant des types d'enregistrement.           * le nombre de champs longueur dépendant des types d'enregistrement.
          *           *
Line 2826  formateur_fichier(struct_processus *s_et Line 2872  formateur_fichier(struct_processus *s_et
   
         strcpy(base, " ");          strcpy(base, " ");
   
         longueur_binaire = 0;  
         masque_binaire = 0;          masque_binaire = 0;
   
         if ((*s_objet).type == ALG)          if ((*s_objet).type == ALG)
Line 3686  formateur_fichier(struct_processus *s_et Line 3731  formateur_fichier(struct_processus *s_et
                 return(NULL);                  return(NULL);
             }              }
   
             longueur_binaire = longueur_entiers_binaires(s_etat_processus);  
             masque_binaire = masque_entiers_binaires(s_etat_processus);              masque_binaire = masque_entiers_binaires(s_etat_processus);
   
             if ((test_cfsf(s_etat_processus, 43) == d_faux) &&              if ((test_cfsf(s_etat_processus, 43) == d_faux) &&
Line 3884  formateur_fichier(struct_processus *s_et Line 3928  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
             if ((format_sortie != 'S') && (format_sortie != 'F') &&              if (format_sortie != 'C')
                     (format_sortie != 'I') && (format_sortie != 'E'))  
             {              {
                 (*s_etat_processus).erreur_execution =                  (*s_etat_processus).erreur_execution =
                         d_ex_erreur_format_fichier;                          d_ex_erreur_format_fichier;
                 return(NULL);                  return(NULL);
             }              }
   
             if ((chaine_formatee = formateur_fichier_nombre(s_etat_processus,              if ((chaine = formateur_fichier_binaire_nombre(s_etat_processus,
                     (void *) ((struct_complexe16 *) ((*s_objet).objet)), 'C',                      (*s_objet).objet, 'C', longueur, longueur_effective))
                     longueur, longueur_champ, format_sortie)) == NULL)                      == NULL)
             {  
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
                 return(NULL);  
             }  
   
             chaine = (unsigned char *) malloc((strlen(chaine_formatee)  
                     + 1) * sizeof(unsigned char));  
   
             if (chaine == NULL)  
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
                 return(NULL);                  return(NULL);
             }              }
   
             strcpy(chaine, chaine_formatee);  
             free(chaine_formatee);  
         }          }
         else if ((*s_objet).type == RPN)          else if ((*s_objet).type == RPN)
         {          {
Line 4009  formateur_fichier(struct_processus *s_et Line 4039  formateur_fichier(struct_processus *s_et
                 return(NULL);                  return(NULL);
             }              }
   
             switch(longueur)              if ((chaine = formateur_fichier_binaire_nombre(s_etat_processus,
                       (*s_objet).objet, 'I', longueur, longueur_effective))
                       == NULL)
             {              {
                 case 1:                  return(NULL);
                 {  
                     if ((*((integer8 *) (*s_objet).objet)) !=  
                             ((integer1) (*((integer8 *) (*s_objet).objet))))  
                     {  
                         (*s_etat_processus).erreur_execution =  
                                 d_ex_representation;  
                         return(NULL);  
                     }  
   
                     if ((chaine = malloc(2 * sizeof(unsigned char))) == NULL)  
                     {  
                         (*s_etat_processus).erreur_systeme =  
                                 d_es_allocation_memoire;  
                         return(NULL);  
                     }  
   
                     longueur_totale = 2;  
                     chaine[0] = 0x10;  
                     chaine[1] = (*((integer8 *) (*s_objet).objet)) & 0xFF;  
                     break;  
                 }  
   
                 case 2:  
                 {  
                     if ((*((integer8 *) (*s_objet).objet)) !=  
                             ((integer2) (*((integer8 *) (*s_objet).objet))))  
                     {  
                         (*s_etat_processus).erreur_execution =  
                                 d_ex_representation;  
                         return(NULL);  
                     }  
   
                     if ((chaine = malloc(3 * sizeof(unsigned char))) == NULL)  
                     {  
                         (*s_etat_processus).erreur_systeme =  
                                 d_es_allocation_memoire;  
                         return(NULL);  
                     }  
   
                     longueur_totale = 3;  
                     chaine[0] = 0x11;  
                     chaine[1] = ((*((integer8 *) (*s_objet).objet)) >> 8)  
                             & 0xFF;  
                     chaine[2] = (*((integer8 *) (*s_objet).objet)) & 0xFF;  
                     break;  
                 }  
   
                 case 4:  
                 {  
                     if ((*((integer4 *) (*s_objet).objet)) !=  
                             ((integer2) (*((integer8 *) (*s_objet).objet))))  
                     {  
                         (*s_etat_processus).erreur_execution =  
                                 d_ex_representation;  
                         return(NULL);  
                     }  
   
                     if ((chaine = malloc(5 * sizeof(unsigned char))) == NULL)  
                     {  
                         (*s_etat_processus).erreur_systeme =  
                                 d_es_allocation_memoire;  
                         return(NULL);  
                     }  
   
                     longueur_totale = 5;  
                     chaine[0] = 0x12;  
                     chaine[1] = ((*((integer8 *) (*s_objet).objet)) >> 24)  
                             & 0xFF;  
                     chaine[2] = ((*((integer8 *) (*s_objet).objet)) >> 16)  
                             & 0xFF;  
                     chaine[3] = ((*((integer8 *) (*s_objet).objet)) >> 8)  
                             & 0xFF;  
                     chaine[4] = (*((integer8 *) (*s_objet).objet)) & 0xFF;  
                     break;  
                 }  
   
                 case 8:  
                 {  
                     if ((chaine = malloc(9 * sizeof(unsigned char))) == NULL)  
                     {  
                         (*s_etat_processus).erreur_systeme =  
                                 d_es_allocation_memoire;  
                         return(NULL);  
                     }  
   
                     longueur_totale = 9;  
                     chaine[0] = 0x13;  
                     chaine[1] = ((*((integer8 *) (*s_objet).objet)) >> 56)  
                             & 0xFF;  
                     chaine[2] = ((*((integer8 *) (*s_objet).objet)) >> 48)  
                             & 0xFF;  
                     chaine[3] = ((*((integer8 *) (*s_objet).objet)) >> 40)  
                             & 0xFF;  
                     chaine[4] = ((*((integer8 *) (*s_objet).objet)) >> 32)  
                             & 0xFF;  
                     chaine[5] = ((*((integer8 *) (*s_objet).objet)) >> 24)  
                             & 0xFF;  
                     chaine[6] = ((*((integer8 *) (*s_objet).objet)) >> 16)  
                             & 0xFF;  
                     chaine[7] = ((*((integer8 *) (*s_objet).objet)) >> 8)  
                             & 0xFF;  
                     chaine[8] = (*((integer8 *) (*s_objet).objet)) & 0xFF;  
                     break;  
                 }  
   
                 default :  
                 {  
                     (*s_etat_processus).erreur_execution =  
                             d_ex_erreur_format_fichier;  
                     return(NULL);  
                 }  
             }              }
   
             (*longueur_effective) = longueur_totale;  
         }          }
         else if ((*s_objet).type == FCT)          else if ((*s_objet).type == FCT)
         {          {
Line 4596  formateur_fichier(struct_processus *s_et Line 4515  formateur_fichier(struct_processus *s_et
                         (((*(*((struct_tableau *) (*s_format).objet))                          (((*(*((struct_tableau *) (*s_format).objet))
                         .elements[i]).type == TBL) &&                          .elements[i]).type == TBL) &&
                         ((*(*((struct_tableau *) (*s_objet).objet)).elements[i])                          ((*(*((struct_tableau *) (*s_objet).objet)).elements[i])
                         .type == TAB)))                          .type == TBL)))
                 {                  {
                     chaine_sauvegarde = chaine;                      chaine_sauvegarde = chaine;
   
Line 5306  formateur_fichier(struct_processus *s_et Line 5225  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
             if ((format_sortie != 'S') && (format_sortie != 'F') &&              if (format_sortie != 'R')
                     (format_sortie != 'I') && (format_sortie != 'E'))  
             {              {
                 (*s_etat_processus).erreur_execution =                  (*s_etat_processus).erreur_execution =
                         d_ex_erreur_format_fichier;                          d_ex_erreur_format_fichier;
                 return(NULL);                  return(NULL);
             }              }
   
             if ((chaine_formatee = formateur_fichier_nombre(s_etat_processus,              if ((chaine = formateur_fichier_binaire_nombre(s_etat_processus,
                     (void *) ((real8 *) ((*s_objet).objet)), 'R',                      (*s_objet).objet, 'R', longueur, longueur_effective))
                     longueur, longueur_champ, format_sortie)) == NULL)                      == NULL)
             {  
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
                 return(NULL);  
             }  
   
             chaine = (unsigned char *) malloc((strlen(chaine_formatee) + 1)  
                     * sizeof(unsigned char));  
   
             if (chaine == NULL)  
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
                 return(NULL);                  return(NULL);
             }              }
   
             strcpy(chaine, chaine_formatee);  
             free(chaine_formatee);  
         }          }
         else if ((*s_objet).type == VCX)          else if ((*s_objet).type == VCX)
         {          {
Line 5733  formateur_fichier_nombre(struct_processu Line 5638  formateur_fichier_nombre(struct_processu
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Recherche de la longueur de l'entier minimale pour représenter la donnée  
 --------------------------------------------------------------------------------  
 */  
   
 unsigned char  
 recherche_longueur_optimale(integer8 parametre)  
 {  
     if (parametre == (integer8) ((integer1) parametre))  
     {  
         return(0x0);  
     }  
     else if (parametre == (integer8) ((integer2) parametre))  
     {  
         return(0x1);  
     }  
     else if (parametre == (integer8) ((integer4) parametre))  
     {  
         return(0x2);  
     }  
     else  
     {  
         return(0x3);  
     }  
 }  
   
   
 /*  
 --------------------------------------------------------------------------------  
   Formateur des réels et entiers    Formateur des réels et entiers
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
Line 5983  formateur_fichier_reel(struct_processus Line 5860  formateur_fichier_reel(struct_processus
   
     return(chaine);      return(chaine);
 }  }
   
   
   /*
   --------------------------------------------------------------------------------
     Mêmes fonctions mais pour les fichiers binaires
   --------------------------------------------------------------------------------
   */
   
   unsigned char *
   formateur_fichier_binaire_nombre(struct_processus *s_etat_processus,
           void *valeur_numerique, unsigned char type, long longueur,
           long *longueur_conversion)
   {
       unsigned char               *chaine;
   
       switch(type)
       {
           default :
           case 'I' :
           {
               switch(longueur)
               {
                   case 1:
                   {
                       if ((*((integer8 *) valeur_numerique)) !=
                               ((integer1) (*((integer8 *) valeur_numerique))))
                       {
                           (*s_etat_processus).erreur_execution =
                                   d_ex_representation;
                           return(NULL);
                       }
   
                       if ((chaine = malloc(2 * sizeof(unsigned char))) == NULL)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return(NULL);
                       }
   
                       (*longueur_conversion) = 2;
                       chaine[0] = 0x10;
                       chaine[1] = (*((integer8 *) valeur_numerique)) & 0xFF;
                       break;
                   }
   
                   case 2:
                   {
                       if ((*((integer8 *) valeur_numerique)) !=
                               ((integer2) (*((integer8 *) valeur_numerique))))
                       {
                           (*s_etat_processus).erreur_execution =
                                   d_ex_representation;
                           return(NULL);
                       }
   
                       if ((chaine = malloc(3 * sizeof(unsigned char))) == NULL)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return(NULL);
                       }
   
                       (*longueur_conversion) = 3;
                       chaine[0] = 0x11;
                       chaine[1] = ((*((integer8 *) valeur_numerique)) >> 8)
                               & 0xFF;
                       chaine[2] = (*((integer8 *) valeur_numerique)) & 0xFF;
                       break;
                   }
   
                   case 4:
                   {
                       if ((*((integer8 *) valeur_numerique)) !=
                               ((integer2) (*((integer8 *) valeur_numerique))))
                       {
                           (*s_etat_processus).erreur_execution =
                                   d_ex_representation;
                           return(NULL);
                       }
   
                       if ((chaine = malloc(5 * sizeof(unsigned char))) == NULL)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return(NULL);
                       }
   
                       (*longueur_conversion) = 5;
                       chaine[0] = 0x12;
                       chaine[1] = ((*((integer8 *) valeur_numerique)) >> 24)
                               & 0xFF;
                       chaine[2] = ((*((integer8 *) valeur_numerique)) >> 16)
                               & 0xFF;
                       chaine[3] = ((*((integer8 *) valeur_numerique)) >> 8)
                               & 0xFF;
                       chaine[4] = (*((integer8 *) valeur_numerique)) & 0xFF;
                       break;
                   }
   
                   case 8:
                   {
                       if ((chaine = malloc(9 * sizeof(unsigned char))) == NULL)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return(NULL);
                       }
   
                       (*longueur_conversion) = 9;
                       chaine[0] = 0x13;
                       chaine[1] = ((*((integer8 *) valeur_numerique)) >> 56)
                               & 0xFF;
                       chaine[2] = ((*((integer8 *) valeur_numerique)) >> 48)
                               & 0xFF;
                       chaine[3] = ((*((integer8 *) valeur_numerique)) >> 40)
                               & 0xFF;
                       chaine[4] = ((*((integer8 *) valeur_numerique)) >> 32)
                               & 0xFF;
                       chaine[5] = ((*((integer8 *) valeur_numerique)) >> 24)
                               & 0xFF;
                       chaine[6] = ((*((integer8 *) valeur_numerique)) >> 16)
                               & 0xFF;
                       chaine[7] = ((*((integer8 *) valeur_numerique)) >> 8)
                               & 0xFF;
                       chaine[8] = (*((integer8 *) valeur_numerique)) & 0xFF;
                       break;
                   }
   
                   default :
                   {
                       (*s_etat_processus).erreur_execution =
                               d_ex_erreur_format_fichier;
                       return(NULL);
                   }
               }
   
               break;
           }
   
           case 'R' :
           {
               switch(longueur)
               {
                   case 4:
                   {
                       double          vinf;
                       double          vsup;
   
                       union
                       {
                           real4       r4;
                           integer4    i4;
                       }               eq4;
   
                       if ((*((real8 *) valeur_numerique)) > 0)
                       {
                           vinf = nextafter((*((real8 *) valeur_numerique)), 0);
                           vsup = nextafter((*((real8 *) valeur_numerique)),
                                   (*((real8 *) valeur_numerique)) * 2);
                       }
                       else
                       {
                           vinf = nextafter((*((real8 *) valeur_numerique)),
                                   (*((real8 *) valeur_numerique)) * 2);
                           vsup = nextafter((*((real8 *) valeur_numerique)), 0);
                       }
   
                       if (!((vinf <= ((real4) (*((real8 *) valeur_numerique)))) &&
                               ((real4) ((*((real8 *) valeur_numerique)))
                               <= vsup)))
                       {
                           (*s_etat_processus).erreur_execution =
                                   d_ex_representation;
                           return(NULL);
                       }
   
                       if ((chaine = malloc(5 * sizeof(unsigned char))) == NULL)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return(NULL);
                       }
   
                       eq4.r4 = (real4) (*((real8 *) valeur_numerique));
                       (*longueur_conversion) = 5;
                       chaine[0] = 0x12;
                       chaine[1] = (eq4.i4 >> 24) & 0xFF;
                       chaine[2] = (eq4.i4 >> 16) & 0xFF;
                       chaine[3] = (eq4.i4 >> 8) & 0xFF;
                       chaine[4] = eq4.i4 & 0xFF;
                       break;
                   }
   
                   case 8:
                   {
                       union
                       {
                           real8       r8;
                           integer8    i8;
                       }               eq8;
   
                       if ((chaine = malloc(9 * sizeof(unsigned char))) == NULL)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return(NULL);
                       }
   
                       eq8.r8 = (*((real8 *) valeur_numerique));
   
                       (*longueur_conversion) = 9;
                       chaine[0] = 0x13;
                       chaine[1] = (eq8.i8 >> 56) & 0xFF;
                       chaine[2] = (eq8.i8 >> 48) & 0xFF;
                       chaine[3] = (eq8.i8 >> 40) & 0xFF;
                       chaine[4] = (eq8.i8 >> 32) & 0xFF;
                       chaine[5] = (eq8.i8 >> 24) & 0xFF;
                       chaine[6] = (eq8.i8 >> 16) & 0xFF;
                       chaine[7] = (eq8.i8 >> 8) & 0xFF;
                       chaine[8] = eq8.i8 & 0xFF;
                       break;
                   }
   
                   default :
                   {
                       (*s_etat_processus).erreur_execution =
                               d_ex_erreur_format_fichier;
                       return(NULL);
                   }
               }
   
               break;
           }
   
           case 'C' :
           {
               switch(longueur)
               {
                   case 8:
                   {
                       unsigned char       *partie_reelle;
                       unsigned char       *partie_imaginaire;
   
                       long                limag;
                       long                lreel;
   
                       if ((partie_reelle = formateur_fichier_binaire_nombre(
                               s_etat_processus, &((*((complex16 *)
                               valeur_numerique)).partie_reelle), 'R', 4, &lreel))
                               == NULL)
                       {
                           return(NULL);
                       }
   
                       if ((partie_imaginaire = formateur_fichier_binaire_nombre(
                               s_etat_processus, &((*((complex16 *)
                               valeur_numerique)).partie_imaginaire), 'R', 4,
                               &limag)) == NULL)
                       {
                           free(partie_reelle);
                           return(NULL);
                       }
   
                       if ((chaine = malloc((lreel + limag - 1) *
                               sizeof(unsigned char))) == NULL)
                       {
                           free(partie_reelle);
                           free(partie_imaginaire);
   
                           (*s_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return(NULL);
                       }
   
                       chaine[0] = 0x18;
                       memcpy(chaine + 1, partie_reelle + 1, lreel - 1);
                       memcpy(chaine + lreel, partie_imaginaire + 1, limag - 1);
                       (*longueur_conversion) = lreel + limag - 1;
   
                       free(partie_reelle);
                       free(partie_imaginaire);
                       break;
                   }
   
                   case 16:
                   {
                       unsigned char       *partie_reelle;
                       unsigned char       *partie_imaginaire;
   
                       long                limag;
                       long                lreel;
   
                       if ((partie_reelle = formateur_fichier_binaire_nombre(
                               s_etat_processus, &((*((complex16 *)
                               valeur_numerique)).partie_reelle), 'R', 8, &lreel))
                               == NULL)
                       {
                           return(NULL);
                       }
   
                       if ((partie_imaginaire = formateur_fichier_binaire_nombre(
                               s_etat_processus, &((*((complex16 *)
                               valeur_numerique)).partie_imaginaire), 'R', 8,
                               &limag)) == NULL)
                       {
                           free(partie_reelle);
                           return(NULL);
                       }
   
                       if ((chaine = malloc((lreel + limag - 1) *
                               sizeof(unsigned char))) == NULL)
                       {
                           free(partie_reelle);
                           free(partie_imaginaire);
   
                           (*s_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return(NULL);
                       }
   
                       chaine[0] = 0x19;
                       memcpy(chaine + 1, partie_reelle + 1, lreel - 1);
                       memcpy(chaine + lreel, partie_imaginaire + 1, limag - 1);
                       (*longueur_conversion) = lreel + limag - 1;
   
                       free(partie_reelle);
                       free(partie_imaginaire);
                       break;
                   }
   
                   default :
                   {
                       (*s_etat_processus).erreur_execution =
                               d_ex_erreur_format_fichier;
                       return(NULL);
                   }
               }
   
               break;
           }
       }
   
       return(chaine);
   }
   
   // vim: ts=4
Removed from v.1.16  
changed lines
  Added in v.1.49

CVSweb interface <joel.bertrand@systella.fr>