[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.33 and 1.34

version 1.33, 2011/09/26 15:57:10 version 1.34, 2011/11/15 07:01:37
Line 1176  formateur_fichier(struct_processus *s_et Line 1176  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 2711  formateur_fichier(struct_processus *s_et Line 2711  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 2731  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 2821  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 3884  formateur_fichier(struct_processus *s_et Line 3931  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 4042  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 5306  formateur_fichier(struct_processus *s_et Line 5228  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 5641  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 5981  formateur_fichier_reel(struct_processus Line 5861  formateur_fichier_reel(struct_processus
         }          }
     }      }
   
       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);      return(chaine);
 }  }
Removed from v.1.33  
changed lines
  Added in v.1.34

CVSweb interface <joel.bertrand@systella.fr>