[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.53

version 1.52, 2013/03/10 17:01:05 version 1.53, 2013/03/10 22:15:48
Line 2744  formateur_fichier(struct_processus *s_et Line 2744  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 3591  formateur_fichier(struct_processus *s_et Line 3591  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 4526  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 4538  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 4556  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)
Line 4575  lecture_fichier_non_formate(struct_proce Line 4594  lecture_fichier_non_formate(struct_proce
             {              {
                 case 0x00:  // Entier                  case 0x00:  // Entier
                 {                  {
                     if ((s_objet = allocation(s_etat_processus, INT)) == NULL)  
                     {  
                         return(NULL);  
                     }  
   
                     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 4626  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++)
Line 4638  lecture_fichier_non_formate(struct_proce Line 4675  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 4702  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 4781  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 4936  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 4975  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 5015  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 5057  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 5170  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 5432  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 5453  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.53

CVSweb interface <joel.bertrand@systella.fr>