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

version 1.53, 2013/03/10 22:15:48 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 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 4588  lecture_fichier_non_formate(struct_proce Line 4625  lecture_fichier_non_formate(struct_proce
   
     switch(octets[0] & 0xF0)      switch(octets[0] & 0xF0)
     {      {
           case 0x00:  // Binaire
           {
               switch(octets[0] & 0x0F)
               {
                   case 0x01:  // logical*1
                   {
                       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))
                       {
                           (*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          case 0x10:  // Scalaire
         {          {
             switch(octets[0] & 0x0C)              switch(octets[0] & 0x0C)
Line 4667  lecture_fichier_non_formate(struct_proce Line 4792  lecture_fichier_non_formate(struct_proce
                     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;
Removed from v.1.53  
changed lines
  Added in v.1.54

CVSweb interface <joel.bertrand@systella.fr>