[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.52 and 1.54

version 1.52, 2013/03/10 17:01:05 version 1.54, 2013/03/11 11:07:24
Line 100  formateur_fichier(struct_processus *s_et Line 100  formateur_fichier(struct_processus *s_et
     unsigned char               *ptre;      unsigned char               *ptre;
     unsigned char               *ptrl;      unsigned char               *ptrl;
     unsigned char               tampon[64 + 1];      unsigned char               tampon[64 + 1];
       unsigned char               type_binaire;
   
     unsigned long               i;      unsigned long               i;
     unsigned long               j;      unsigned long               j;
Line 2744  formateur_fichier(struct_processus *s_et Line 2745  formateur_fichier(struct_processus *s_et
          *           *
          * XXXXXXX0                             longueur sur 7 bits           * XXXXXXX0                             longueur sur 7 bits
          * XXXX0011 XXXXXXXX XXXX0011           longueur sur 16 bits           * XXXX0011 XXXXXXXX XXXX0011           longueur sur 16 bits
          * MSB(1/2) LSB      MSB(2/2)           * LSB(1/2) MSB      LSB(2/2)
          * XXXX0101 XXXXXXXX XXXXXXXX XXXX0101  longueur sur 24 bits           * XXXX0101 XXXXXXXX XXXXXXXX XXXX0101  longueur sur 24 bits
          * XXXX0111 XXXXXXXX XXXXXXXX XXXXXXXX           * XXXX0111 XXXXXXXX XXXXXXXX XXXXXXXX
          *          XXXX0111                    longueur sur 32 bits           *          XXXX0111                    longueur sur 32 bits
Line 2888  formateur_fichier(struct_processus *s_et Line 2889  formateur_fichier(struct_processus *s_et
         chaine_formatee = NULL;          chaine_formatee = NULL;
         chaine_sauvegarde = NULL;          chaine_sauvegarde = NULL;
   
         if ((*s_objet).type == ALG)          if ((*s_objet).type == BIN)
         {          {
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Expression algébrique    Entier binaire en base 2, 8, 10 ou 16
     Poids fort 0000
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
         }              if (format_sortie != 'L')
         else if ((*s_objet).type == BIN)              {
         {                  (*s_etat_processus).erreur_execution =
                           d_ex_erreur_format_fichier;
                   return(NULL);
               }
   
 /*              if (longueur_champ < 8)
 --------------------------------------------------------------------------------              {
   Entier binaire en base 2, 8, 10 ou 16                  if ((*((logical8 *) (*s_objet).objet)) >=
 --------------------------------------------------------------------------------                          ((logical8) 1 << (8 * longueur_champ)))
 */                  {
                       (*s_etat_processus).erreur_execution =
                               d_ex_representation;
                       return(NULL);
                   }
               }
   
               (*longueur_effective) = longueur_champ + 1;
   
               if ((chaine = malloc((*longueur_effective) * sizeof(unsigned char)))
                       == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return(NULL);
               }
   
               chaine[0] = longueur_champ;
   
               for(i = 1; i <= (unsigned) (*longueur_effective); i++)
               {
                   chaine[i] = ((*((logical8 *) (*s_objet).objet)) >>
                           (8 * (longueur_champ - i))) & 0xFF;
               }
         }          }
         else if ((*s_objet).type == CHN)          else if ((*s_objet).type == CHN)
         {          {
Line 3088  formateur_fichier(struct_processus *s_et Line 3114  formateur_fichier(struct_processus *s_et
                 return(NULL);                  return(NULL);
             }              }
         }          }
         else if ((*s_objet).type == RPN)  
         {  
   
 /*  
 --------------------------------------------------------------------------------  
   Définition  
 --------------------------------------------------------------------------------  
 */  
         }  
         else if ((*s_objet).type == INT)          else if ((*s_objet).type == INT)
         {          {
   
Line 3132  formateur_fichier(struct_processus *s_et Line 3149  formateur_fichier(struct_processus *s_et
 */  */
   
         }          }
         else if ((*s_objet).type == LST)          else if (((*s_objet).type == LST) || ((*s_objet).type == ALG)
                   || ((*s_objet).type == RPN))
         {          {
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Liste    Liste
   Poids fort 0100    Poids fort 0100
   
     Expression algébrique
     Poids fort 0111
   
     Définition
     Poids fort 0110
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 3150  formateur_fichier(struct_processus *s_et Line 3174  formateur_fichier(struct_processus *s_et
                 return(NULL);                  return(NULL);
             }              }
   
               if ((*s_objet).type == LST)
               {
                   type_binaire = 0x40;
               }
               else if ((*s_objet).type == RPN)
               {
                   type_binaire = 0x60;
               }
               else // ALG
               {
                   type_binaire = 0x70;
               }
   
             // Calcul de la longueur de la liste.              // Calcul de la longueur de la liste.
   
             longueur_liste = 0;              longueur_liste = 0;
Line 3163  formateur_fichier(struct_processus *s_et Line 3200  formateur_fichier(struct_processus *s_et
   
             if (longueur_liste < (1LL << 3))              if (longueur_liste < (1LL << 3))
             {              {
                 chaine[0] = 0x40 | (longueur_liste & 0x7);                  chaine[0] = type_binaire | (longueur_liste & 0x7);
             }              }
             else if (longueur_liste < (1LL << 8))              else if (longueur_liste < (1LL << 8))
             {              {
                 chaine[0] = 0x48;                  chaine[0] = type_binaire | 0x08;
             }              }
             else if (longueur_liste < (1LL << 16))              else if (longueur_liste < (1LL << 16))
             {              {
                 chaine[0] = 0x49;                  chaine[0] = type_binaire | 0x09;
             }              }
             else if (longueur_liste < (1LL << 32))              else if (longueur_liste < (1LL << 32))
             {              {
                 chaine[0] = 0x4A;                  chaine[0] = type_binaire | 0x0A;
             }              }
             else              else
             {              {
                 chaine[0] = 0x4B;                  chaine[0] = type_binaire | 0x0B;
             }              }
   
             longueur_totale = 1;              longueur_totale = 1;
Line 3591  formateur_fichier(struct_processus *s_et Line 3628  formateur_fichier(struct_processus *s_et
                     if ((longueur_totale < (((integer8) 1) << (8 * (i + 2))))                      if ((longueur_totale < (((integer8) 1) << (8 * (i + 2))))
                             || (i == 6))                              || (i == 6))
                     {                      {
                         // MSB (4 bits de poids fort)                          // LSB (4 bits de poids fort)
                         tampon[0] = ((longueur_totale >> 8) & 0xF0)                          tampon[0] = (longueur_totale & 0xF0)
                                 | 0x1 /* longueur supérieure à 7 bits */                                  | 0x1 /* longueur supérieure à 7 bits */
                                 | ((i + 1) << 1);                                  | ((i + 1) << 1);
   
                         for(j = 0; j <= i; j++)                          for(j = 0; j <= i; j++)
                         {                          {
                             tampon[(i - j) + 1] = (longueur_totale >> (j + 1))                              tampon[(i - j) + 1] =
                                       (longueur_totale >> (8 * (j + 1)))
                                     & 0xFF;                                      & 0xFF;
                         }                          }
   
                         // MSB (4 bits de poids faible)                          // LSB (4 bits de poids faible)
                         tampon[i + 2] = (((longueur_totale >> 8) & 0x0F) << 4)                          tampon[i + 2] = ((longueur_totale & 0x0F) << 4)
                                 | 0x1 /* longueur supérieure à 7 bits */                                  | 0x1 /* longueur supérieure à 7 bits */
                                 | ((i + 1) << 1);                                  | ((i + 1) << 1);
                         break;                          break;
Line 4525  lecture_fichier_non_formate(struct_proce Line 4563  lecture_fichier_non_formate(struct_proce
 {  {
     file                        *fichier;      file                        *fichier;
   
       int                         j;
   
     integer8                    i;      integer8                    i;
     integer8                    longueur;      integer8                    longueur;
   
Line 4535  lecture_fichier_non_formate(struct_proce Line 4575  lecture_fichier_non_formate(struct_proce
   
     unsigned char               octets[8];      unsigned char               octets[8];
     unsigned char               *buffer;      unsigned char               *buffer;
       unsigned char               *flux;
     unsigned char               *ptr;      unsigned char               *ptr;
   
     size_t                      deplacement;      size_t                      deplacement;
Line 4552  lecture_fichier_non_formate(struct_proce Line 4593  lecture_fichier_non_formate(struct_proce
         fichier = NULL;          fichier = NULL;
     }      }
   
   
     if (longueur_buffer < 0)      if (longueur_buffer < 0)
     {      {
         if (fread(octets, (size_t) sizeof(unsigned char),          if (fread(octets, (size_t) sizeof(unsigned char),
                 1, fichier) != 1)                  1, fichier) != 1)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;              if (feof(fichier))
               {
                   (*s_etat_processus).erreur_execution = d_ex_syntaxe;
               }
               else
               {
                   (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
               }
   
             return(NULL);              return(NULL);
         }          }
     }      }
     else      else
     {      {
         octets[0] = *ptr++;          if ((longueur_buffer - (ptr - buffer)) >= 1)
           {
               octets[0] = *ptr++;
           }
           else
           {
               (*s_etat_processus).erreur_execution = d_ex_syntaxe;
               return(NULL);
           }
     }      }
   
     switch(octets[0] & 0xF0)      switch(octets[0] & 0xF0)
     {      {
         case 0x10:  // Scalaire          case 0x00:  // Binaire
         {          {
             switch(octets[0] & 0x0C)              switch(octets[0] & 0x0F)
             {              {
                 case 0x00:  // Entier                  case 0x01:  // logical*1
                 {                  {
                     if ((s_objet = allocation(s_etat_processus, INT)) == NULL)                      deplacement = 1;
                       break;
                   }
   
                   case 0x02:  // logical*2
                   {
                       deplacement = 2;
                       break;
                   }
   
                   case 0x04:  // logical*4
                   {
                       deplacement = 4;
                       break;
                   }
   
                   case 0x08:  // logical*8
                   {
                       deplacement = 8;
                       break;
                   }
   
                   default:
                   {
                       (*s_etat_processus).erreur_execution =
                               d_ex_syntaxe;
                       return(NULL);
                   }
               }
   
               if (longueur_buffer < 0)
               {
                   if (fread(octets, (size_t) sizeof(unsigned char),
                           deplacement, fichier) != deplacement)
                   {
                       if (feof(fichier))
                     {                      {
                         return(NULL);                          (*s_etat_processus).erreur_execution =
                                   d_ex_syntaxe;
                       }
                       else
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_erreur_fichier;
                     }                      }
   
                       return(NULL);
                   }
               }
               else
               {
                   if ((longueur_buffer - (ptr - buffer)) >=
                           (ssize_t) deplacement)
                   {
                       for(i = 0; i < (signed) deplacement; i++)
                       {
                           octets[i] = *ptr++;
                       }
                   }
                   else
                   {
                       (*s_etat_processus).erreur_execution = d_ex_syntaxe;
                       return(NULL);
                   }
               }
   
               if ((s_objet = allocation(s_etat_processus, BIN)) == NULL)
               {
                   return(NULL);
               }
   
               (*((logical8 *) (*s_objet).objet)) = 0;
   
               for(i = 0; i < (signed) deplacement; i++)
               {
                   (*((logical8 *) (*s_objet).objet)) |= ((logical8) octets[i])
                           << (8 * ((deplacement - 1) - i));
               }
   
               break;
           }
   
           case 0x10:  // Scalaire
           {
               switch(octets[0] & 0x0C)
               {
                   case 0x00:  // Entier
                   {
                     switch(octets[0] & 0x03)                      switch(octets[0] & 0x03)
                     {                      {
                         case 0x00:  // integer*1                          case 0x00:  // integer*1
Line 4612  lecture_fichier_non_formate(struct_proce Line 4751  lecture_fichier_non_formate(struct_proce
                         if (fread(octets, (size_t) sizeof(unsigned char),                          if (fread(octets, (size_t) sizeof(unsigned char),
                                 deplacement, fichier) != deplacement)                                  deplacement, fichier) != deplacement)
                         {                          {
                             (*s_etat_processus).erreur_systeme =                              if (feof(fichier))
                                     d_es_erreur_fichier;                              {
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_syntaxe;
                               }
                               else
                               {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_erreur_fichier;
                               }
   
                             return(NULL);                              return(NULL);
                         }                          }
                     }                      }
                     else                      else
                     {                      {
                         for(i = 0; i < (signed) deplacement; i++)                          if ((longueur_buffer - (ptr - buffer)) >=
                                   (ssize_t) deplacement)
                           {
                               for(i = 0; i < (signed) deplacement; i++)
                               {
                                   octets[i] = *ptr++;
                               }
                           }
                           else
                         {                          {
                             octets[i] = *ptr++;                              (*s_etat_processus).erreur_execution = d_ex_syntaxe;
                               return(NULL);
                         }                          }
                     }                      }
   
                       if ((s_objet = allocation(s_etat_processus, INT)) == NULL)
                       {
                           return(NULL);
                       }
   
                     (*((integer8 *) (*s_objet).objet)) = 0;                      (*((integer8 *) (*s_objet).objet)) = 0;
   
                     for(i = 0; i < (signed) deplacement; i++)                      for(i = 0; i < (signed) deplacement; i++)
                     {                      {
                         (*((integer8 *) (*s_objet).objet)) |=                          (*((integer8 *) (*s_objet).objet)) |=
                                 octets[i] << (8 * ((deplacement - 1) - i));                                  ((integer8) octets[i])
                                   << (8 * ((deplacement - 1) - i));
                     }                      }
   
                     break;                      break;
Line 4638  lecture_fichier_non_formate(struct_proce Line 4801  lecture_fichier_non_formate(struct_proce
   
                 case 0x04:  // Réel                  case 0x04:  // Réel
                 {                  {
                     if ((s_objet = allocation(s_etat_processus, REL)) == NULL)  
                     {  
                         return(NULL);  
                     }  
   
                     switch(octets[0] & 0x03)                      switch(octets[0] & 0x03)
                     {                      {
                         case 0x00:  // real*4                          case 0x00:  // real*4
Line 4670  lecture_fichier_non_formate(struct_proce Line 4828  lecture_fichier_non_formate(struct_proce
                         if (fread(octets, (size_t) sizeof(unsigned char),                          if (fread(octets, (size_t) sizeof(unsigned char),
                                 deplacement, fichier) != deplacement)                                  deplacement, fichier) != deplacement)
                         {                          {
                             (*s_etat_processus).erreur_systeme =                              if (feof(fichier))
                                     d_es_erreur_fichier;                              {
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_syntaxe;
                               }
                               else
                               {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_erreur_fichier;
                               }
   
                             return(NULL);                              return(NULL);
                         }                          }
                     }                      }
                     else                      else
                     {                      {
                         for(i = 0; i < (signed) deplacement; i++)                          if ((longueur_buffer - (ptr - buffer)) >=
                                   (ssize_t) deplacement)
                         {                          {
                             octets[i] = *ptr++;                              for(i = 0; i < (signed) deplacement; i++)
                               {
                                   octets[i] = *ptr++;
                               }
                           }
                           else
                           {
                               (*s_etat_processus).erreur_execution =
                                       d_ex_syntaxe;
                               return(NULL);
                         }                          }
                     }                      }
   
                       if ((s_objet = allocation(s_etat_processus, REL)) == NULL)
                       {
                           return(NULL);
                       }
   
                     if (deplacement == 4)                      if (deplacement == 4)
                     {                      {
                         union                          union
Line 4725  lecture_fichier_non_formate(struct_proce Line 4907  lecture_fichier_non_formate(struct_proce
   
                 case 0x08:  // Complexe                  case 0x08:  // Complexe
                 {                  {
                       switch(octets[0] & 0x03)
                       {
                           case 0x00:  // complex*8
                           {
                               deplacement = 4;
                               break;
                           }
   
                           case 0x01:  // complex*16
                           {
                               deplacement = 8;
                               break;
                           }
   
                           default:
                           {
                               (*s_etat_processus).erreur_execution =
                                       d_ex_syntaxe;
                               return(NULL);
                           }
                       }
   
                     if ((s_objet = allocation(s_etat_processus, CPL)) == NULL)                      if ((s_objet = allocation(s_etat_processus, CPL)) == NULL)
                     {                      {
                         return(NULL);                          return(NULL);
                     }                      }
   
                       for(j = 0; j < 2; j++)
                       {
                           if (longueur_buffer < 0)
                           {
                               if (fread(octets, (size_t) sizeof(unsigned char),
                                       deplacement, fichier) != deplacement)
                               {
                                   liberation(s_etat_processus, s_objet);
   
                                   if (feof(fichier))
                                   {
                                       (*s_etat_processus).erreur_execution =
                                               d_ex_syntaxe;
                                   }
                                   else
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_erreur_fichier;
                                   }
   
                                   return(NULL);
                               }
                           }
                           else
                           {
                               if ((longueur_buffer - (ptr - buffer)) >=
                                       (ssize_t) deplacement)
                               {
                                   for(i = 0; i < (signed) deplacement; i++)
                                   {
                                       octets[i] = *ptr++;
                                   }
                               }
                               else
                               {
                                   liberation(s_etat_processus, s_objet);
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_syntaxe;
                                   return(NULL);
                               }
                           }
   
                           if (deplacement == 4)
                           {
                               union
                               {
                                   real4       r4;
                                   integer4    i4;
                               } eq4;
   
                               eq4.i4 = 0;
   
                               for(i = 0; i < (signed) deplacement; i++)
                               {
                                   eq4.i4 |= ((integer4) octets[i]) <<
                                           (8 * ((deplacement - 1) - i));
                               }
   
                               if (j == 0)
                               {
                                   (*((complex16 *) (*s_objet).objet))
                                           .partie_reelle = (real8) eq4.r4;
                               }
                               else
                               {
                                   (*((complex16 *) (*s_objet).objet))
                                           .partie_imaginaire = (real8) eq4.r4;
                               }
                           }
                           else
                           {
                               union
                               {
                                   real8       r8;
                                   integer8    i8;
                               } eq8;
   
                               eq8.i8 = 0;
   
                               for(i = 0; i < (signed) deplacement; i++)
                               {
                                   eq8.i8 |= ((integer8) octets[i]) <<
                                           (8 * ((deplacement - 1) - i));
                               }
   
                               if (j == 0)
                               {
                                   (*((complex16 *) (*s_objet).objet))
                                           .partie_reelle = (real8) eq8.r8;
                               }
                               else
                               {
                                   (*((complex16 *) (*s_objet).objet))
                                           .partie_imaginaire = (real8) eq8.r8;
                               }
                           }
                       }
   
                     break;                      break;
                 }                  }
   
Line 4760  lecture_fichier_non_formate(struct_proce Line 5062  lecture_fichier_non_formate(struct_proce
                             if (fread(octets, (size_t) sizeof(unsigned char),                              if (fread(octets, (size_t) sizeof(unsigned char),
                                     1, fichier) != 1)                                      1, fichier) != 1)
                             {                              {
                                 (*s_etat_processus).erreur_systeme =                                  if (feof(fichier))
                                         d_es_erreur_fichier;                                  {
                                       (*s_etat_processus).erreur_execution =
                                               d_ex_syntaxe;
                                   }
                                   else
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_erreur_fichier;
                                   }
   
                                 return(NULL);                                  return(NULL);
                             }                              }
                         }                          }
                         else                          else
                         {                          {
                             octets[0] = *ptr++;                              if ((longueur_buffer - (ptr - buffer)) >= 1)
                               {
                                   octets[0] = *ptr++;
                               }
                               else
                               {
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_syntaxe;
                                   return(NULL);
                               }
                         }                          }
   
                         longueur = octets[0];                          longueur = octets[0];
Line 4781  lecture_fichier_non_formate(struct_proce Line 5101  lecture_fichier_non_formate(struct_proce
                             if (fread(octets, (size_t) sizeof(unsigned char),                              if (fread(octets, (size_t) sizeof(unsigned char),
                                     2, fichier) != 2)                                      2, fichier) != 2)
                             {                              {
                                 (*s_etat_processus).erreur_systeme =                                  if (feof(fichier))
                                         d_es_erreur_fichier;                                  {
                                       (*s_etat_processus).erreur_execution =
                                               d_ex_syntaxe;
                                   }
                                   else
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_erreur_fichier;
                                   }
   
                                 return(NULL);                                  return(NULL);
                             }                              }
                         }                          }
                         else                          else
                         {                          {
                             octets[0] = *ptr++;                              if ((longueur_buffer - (ptr - buffer)) >= 2)
                             octets[1] = *ptr++;                              {
                                   for(j = 0; j < 2; octets[j++] = *ptr++);
                               }
                               else
                               {
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_syntaxe;
                                   return(NULL);
                               }
                         }                          }
   
                         longueur = (((integer8) (octets[0])) << 8)                          longueur = (((integer8) (octets[0])) << 8)
Line 4804  lecture_fichier_non_formate(struct_proce Line 5141  lecture_fichier_non_formate(struct_proce
                             if (fread(octets, (size_t) sizeof(unsigned char),                              if (fread(octets, (size_t) sizeof(unsigned char),
                                     4, fichier) != 4)                                      4, fichier) != 4)
                             {                              {
                                 (*s_etat_processus).erreur_systeme =                                  if (feof(fichier))
                                         d_es_erreur_fichier;                                  {
                                       (*s_etat_processus).erreur_execution =
                                               d_ex_syntaxe;
                                   }
                                   else
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_erreur_fichier;
                                   }
   
                                 return(NULL);                                  return(NULL);
                             }                              }
                         }                          }
                         else                          else
                         {                          {
                             octets[0] = *ptr++;                              if ((longueur_buffer - (ptr - buffer)) >= 4)
                             octets[1] = *ptr++;                              {
                             octets[2] = *ptr++;                                  for(j = 0; j < 4; octets[j++] = *ptr++);
                             octets[3] = *ptr++;                              }
                               else
                               {
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_syntaxe;
                                   return(NULL);
                               }
                         }                          }
   
                         longueur = (((integer8) (octets[0])) << 24)                          longueur = (((integer8) (octets[0])) << 24)
Line 4831  lecture_fichier_non_formate(struct_proce Line 5183  lecture_fichier_non_formate(struct_proce
                             if (fread(octets, (size_t) sizeof(unsigned char),                              if (fread(octets, (size_t) sizeof(unsigned char),
                                     8, fichier) != 8)                                      8, fichier) != 8)
                             {                              {
                                 (*s_etat_processus).erreur_systeme =                                  if (feof(fichier))
                                         d_es_erreur_fichier;                                  {
                                       (*s_etat_processus).erreur_execution =
                                               d_ex_syntaxe;
                                   }
                                   else
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_erreur_fichier;
                                   }
   
                                 return(NULL);                                  return(NULL);
                             }                              }
                         }                          }
                         else                          else
                         {                          {
                             octets[0] = *ptr++;                              if ((longueur_buffer - (ptr - buffer)) >= 8)
                             octets[1] = *ptr++;                              {
                             octets[2] = *ptr++;                                  for(j = 0; j < 8; octets[j++] = *ptr++);
                             octets[3] = *ptr++;                              }
                             octets[4] = *ptr++;                              else
                             octets[5] = *ptr++;                              {
                             octets[6] = *ptr++;                                  (*s_etat_processus).erreur_execution =
                             octets[7] = *ptr++;                                          d_ex_syntaxe;
                                   return(NULL);
                               }
                         }                          }
   
                         longueur = (((integer8) (octets[0])) << 56)                          longueur = (((integer8) (octets[0])) << 56)
Line 4933  lecture_fichier_non_formate(struct_proce Line 5296  lecture_fichier_non_formate(struct_proce
   
         case 0x80:  // Chaîne de caractères          case 0x80:  // Chaîne de caractères
         {          {
             s_objet = NULL;              if ((octets[0] & 0x08) == 0)    // Longueur sur 6 bits
               {
                   longueur = (octets[0] & 0x07);
               }
               else
               {
                   switch(octets[0] & 0x07)
                   {
                       case 0x00:          // Longueur sur 8 bits
                       {
                           if (longueur_buffer < 0)
                           {
                               if (fread(octets, (size_t) sizeof(unsigned char),
                                       1, fichier) != 1)
                               {
                                   if (feof(fichier))
                                   {
                                       (*s_etat_processus).erreur_execution =
                                               d_ex_syntaxe;
                                   }
                                   else
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_erreur_fichier;
                                   }
   
                                   return(NULL);
                               }
                           }
                           else
                           {
                               if ((longueur_buffer - (ptr - buffer)) >= 1)
                               {
                                   octets[0] = *ptr++;
                               }
                               else
                               {
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_syntaxe;
                                   return(NULL);
                               }
                           }
   
                           longueur = octets[0];
                           break;
                       }
   
                       case 0x01:          // Longueur sur 16 bits
                       {
                           if (longueur_buffer < 0)
                           {
                               if (fread(octets, (size_t) sizeof(unsigned char),
                                       2, fichier) != 2)
                               {
                                   if (feof(fichier))
                                   {
                                       (*s_etat_processus).erreur_execution =
                                               d_ex_syntaxe;
                                   }
                                   else
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_erreur_fichier;
                                   }
   
                                   return(NULL);
                               }
                           }
                           else
                           {
                               if ((longueur_buffer - (ptr - buffer)) >= 2)
                               {
                                   for(j = 0; j < 2; octets[j++] = *ptr++);
                               }
                               else
                               {
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_syntaxe;
                                   return(NULL);
                               }
                           }
   
                           longueur = (((integer8) (octets[0])) << 8)
                                   | ((integer8) (octets[1]));
                           break;
                       }
   
                       case 0x02:          // Longueur sur 32 bits
                       {
                           if (longueur_buffer < 0)
                           {
                               if (fread(octets, (size_t) sizeof(unsigned char),
                                       4, fichier) != 4)
                               {
                                   if (feof(fichier))
                                   {
                                       (*s_etat_processus).erreur_execution =
                                               d_ex_syntaxe;
                                   }
                                   else
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_erreur_fichier;
                                   }
   
                                   return(NULL);
                               }
                           }
                           else
                           {
                               if ((longueur_buffer - (ptr - buffer)) >= 4)
                               {
                                   for(j = 0; j < 4; octets[j++] = *ptr++);
                               }
                               else
                               {
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_syntaxe;
                                   return(NULL);
                               }
                           }
   
                           longueur = (((integer8) (octets[0])) << 24)
                                   | (((integer8) (octets[1])) << 16)
                                   | (((integer8) (octets[2])) << 8)
                                   | ((integer8) (octets[3]));
                           break;
                       }
   
                       case 0x03:          // Longueur sur 64 bits
                       {
                           if (longueur_buffer < 0)
                           {
                               if (fread(octets, (size_t) sizeof(unsigned char),
                                       8, fichier) != 8)
                               {
                                   if (feof(fichier))
                                   {
                                       (*s_etat_processus).erreur_execution =
                                               d_ex_syntaxe;
                                   }
                                   else
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_erreur_fichier;
                                   }
   
                                   return(NULL);
                               }
                           }
                           else
                           {
                               if ((longueur_buffer - (ptr - buffer)) >= 8)
                               {
                                   for(j = 0; j < 8; octets[j++] = *ptr++);
                               }
                               else
                               {
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_syntaxe;
                                   return(NULL);
                               }
                           }
   
                           longueur = (((integer8) (octets[0])) << 56)
                                   | (((integer8) (octets[1])) << 48)
                                   | (((integer8) (octets[2])) << 40)
                                   | (((integer8) (octets[3])) << 32)
                                   | (((integer8) (octets[4])) << 24)
                                   | (((integer8) (octets[5])) << 16)
                                   | (((integer8) (octets[6])) << 8)
                                   | ((integer8) (octets[7]));
                           break;
                       }
   
                       default:
                       {
                           (*s_etat_processus).erreur_execution = d_ex_syntaxe;
                           return(NULL);
                       }
                   }
               }
   
               if (longueur_buffer < 0)
               {
                   if ((flux = malloc(longueur * sizeof(unsigned char))) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   if (fread(flux, (size_t) sizeof(unsigned char),
                           longueur, fichier) != (size_t) longueur)
                   {
                       if (feof(fichier))
                       {
                           (*s_etat_processus).erreur_execution = d_ex_syntaxe;
                       }
                       else
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_erreur_fichier;
                       }
   
                       return(NULL);
                   }
               }
               else
               {
                   if ((longueur_buffer - (ptr - buffer)) < longueur)
                   {
                       (*s_etat_processus).erreur_execution =
                               d_ex_syntaxe;
                       return(NULL);
                   }
   
                   flux = ptr;
                   ptr += longueur;
               }
   
               if ((s_objet = allocation(s_etat_processus, CHN)) == NULL)
               {
                   if (longueur_buffer < 0)
                   {
                       free(flux);
                   }
   
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return(NULL);
               }
   
               if (((*s_objet).objet = analyse_flux(s_etat_processus, flux,
                       longueur)) == NULL)
               {
                   return(NULL);
               }
   
               if (longueur_buffer < 0)
               {
                   free(flux);
               }
   
             break;              break;
         }          }
   
Line 4953  lecture_fichier_non_formate(struct_proce Line 5558  lecture_fichier_non_formate(struct_proce
         {          {
             liberation(s_etat_processus, s_objet);              liberation(s_etat_processus, s_objet);
   
             (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;              if (feof(fichier))
               {
                   (*s_etat_processus).erreur_execution = d_ex_syntaxe;
               }
               else
               {
                   (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
               }
   
             return(NULL);              return(NULL);
         }          }
   
Line 4966  lecture_fichier_non_formate(struct_proce Line 5579  lecture_fichier_non_formate(struct_proce
             {              {
                 liberation(s_etat_processus, s_objet);                  liberation(s_etat_processus, s_objet);
   
                 (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;                  if (feof(fichier))
                   {
                       (*s_etat_processus).erreur_execution = d_ex_syntaxe;
                   }
                   else
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   }
   
                 return(NULL);                  return(NULL);
             }              }
         }          }
Removed from v.1.52  
changed lines
  Added in v.1.54

CVSweb interface <joel.bertrand@systella.fr>