Diff for /rpl/src/formateur_fichiers.c between versions 1.57 and 1.58

version 1.57, 2013/03/18 15:53:48 version 1.58, 2013/03/19 11:46:11
Line 78  formateur_fichier(struct_processus *s_et Line 78  formateur_fichier(struct_processus *s_et
     logical1                    format_degenere;      logical1                    format_degenere;
     logical1                    presence_signe;      logical1                    presence_signe;
   
     long                        longueur_chaine_traitee;      unsigned long int           longueur_chaine_traitee;
   
     struct_liste_chainee        *l_atome;      struct_liste_chainee        *l_atome;
     struct_liste_chainee        *l_element_courant;      struct_liste_chainee        *l_element_courant;
Line 111  formateur_fichier(struct_processus *s_et Line 111  formateur_fichier(struct_processus *s_et
     unsigned long               nombre_elements;      unsigned long               nombre_elements;
     unsigned long               nombre_lignes;      unsigned long               nombre_lignes;
   
       integer8                    longueur_fonction;
     integer8                    longueur_liste;      integer8                    longueur_liste;
     integer8                    longueur_reelle_chaine;      integer8                    longueur_reelle_chaine;
     integer8                    longueur_totale;      integer8                    longueur_totale;
Line 3031  formateur_fichier(struct_processus *s_et Line 3032  formateur_fichier(struct_processus *s_et
          * 1101 10 11               matrice complex*16 (dimensions integer*4)           * 1101 10 11               matrice complex*16 (dimensions integer*4)
          * 1101 11 11               matrice complex*16 (dimensions integer*8)           * 1101 11 11               matrice complex*16 (dimensions integer*8)
          *           *
            * 1110 0 XXX               fonction de longueur XXX
            * 1110 10 LL               fonction de longueur integer*LL
            *
          * Les longueurs indiquées par le champ LL suivent l'en-tête :           * Les longueurs indiquées par le champ LL suivent l'en-tête :
          *      00 : integer*1           *      00 : integer*1
          *      01 : integer*2           *      01 : integer*2
Line 3334  formateur_fichier(struct_processus *s_et Line 3338  formateur_fichier(struct_processus *s_et
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Fonction    Fonction
     Poids fort 1110
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie != 'N')
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_format_fichier;
                   return(NULL);
               }
   
               longueur_fonction = strlen((*((struct_fonction *) (*s_objet).objet))
                       .nom_fonction);
   
               if (longueur_fonction < (1LL << 3))
               {
                   if ((chaine = malloc((1 + longueur_fonction + 8)
                           * sizeof(unsigned char)))== NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xE0 | (longueur_fonction & 0x7);
   
                   strcpy(chaine + 1, (*((struct_fonction *) (*s_objet).objet))
                           .nom_fonction);
               }
               else if (longueur_fonction < (1LL << 8))
               {
                   if ((chaine = malloc((2 + longueur_fonction + 8)
                           * sizeof(unsigned char)))== NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xE0 | 0x08;
                   chaine[1] = (unsigned char) (longueur_fonction & 0xFF);
   
                   strcpy(chaine + 2, (*((struct_fonction *) (*s_objet).objet))
                           .nom_fonction);
               }
               else if (longueur_fonction < (1LL << 16))
               {
                   if ((chaine = malloc((3 + longueur_fonction + 8)
                           * sizeof(unsigned char)))== NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xE0 | 0x09;
                   chaine[1] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
                   chaine[2] = (unsigned char) (longueur_fonction & 0xFF);
   
                   strcpy(chaine + 3, (*((struct_fonction *) (*s_objet).objet))
                           .nom_fonction);
               }
               else if (longueur_fonction < (1LL << 32))
               {
                   if ((chaine = malloc((5 + longueur_fonction + 8)
                           * sizeof(unsigned char)))== NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xE0 | 0x0A;
                   chaine[1] = (unsigned char) ((longueur_fonction >> 24) & 0xFF);
                   chaine[2] = (unsigned char) ((longueur_fonction >> 16) & 0xFF);
                   chaine[3] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
                   chaine[4] = (unsigned char) (longueur_fonction & 0xFF);
   
                   strcpy(chaine + 5, (*((struct_fonction *) (*s_objet).objet))
                           .nom_fonction);
               }
               else
               {
                   if ((chaine = malloc((9 + longueur_fonction + 8)
                           * sizeof(unsigned char)))== NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return(NULL);
                   }
   
                   chaine[0] = 0xE0 | 0x0B;
                   chaine[1] = (unsigned char) ((longueur_fonction >> 56) & 0xFF);
                   chaine[2] = (unsigned char) ((longueur_fonction >> 48) & 0xFF);
                   chaine[3] = (unsigned char) ((longueur_fonction >> 40) & 0xFF);
                   chaine[4] = (unsigned char) ((longueur_fonction >> 32) & 0xFF);
                   chaine[5] = (unsigned char) ((longueur_fonction >> 24) & 0xFF);
                   chaine[6] = (unsigned char) ((longueur_fonction >> 16) & 0xFF);
                   chaine[7] = (unsigned char) ((longueur_fonction >> 8) & 0xFF);
                   chaine[8] = (unsigned char) (longueur_fonction & 0xFF);
   
                   strcpy(chaine + 9, (*((struct_fonction *) (*s_objet).objet))
                           .nom_fonction);
               }
   
               for(i = 1; i <= 8; i++)
               {
                   chaine[longueur_fonction + i] = (unsigned char)
                           (((*((struct_fonction *) (*s_objet).objet))
                           .nombre_arguments >> ((8 - i) * 8)) & 0xFF);
               }
   
               (*longueur_effective) = longueur_fonction + 9;
         }          }
         else if (((*s_objet).type == LST) || ((*s_objet).type == ALG)          else if (((*s_objet).type == LST) || ((*s_objet).type == ALG)
                 || ((*s_objet).type == RPN))                  || ((*s_objet).type == RPN))
Line 5743  lecture_fichier_non_formate(struct_proce Line 5857  lecture_fichier_non_formate(struct_proce
             break;              break;
         }          }
   
           case 0xE0:  // Fonction
           {
               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 ((s_objet = allocation(s_etat_processus, FCT)) == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return(NULL);
               }
   
               if (((*((struct_fonction *) (*s_objet).objet)).nom_fonction =
                       malloc((longueur + 1) * sizeof(unsigned char))) == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return(NULL);
               }
   
               if (longueur_buffer < 0)
               {
                   if (fread((unsigned char *) (*((struct_fonction *) (*s_objet)
                           .objet)).nom_fonction, (size_t) sizeof(unsigned char),
                           longueur, fichier) != (unsigned) longueur)
                   {
                       if (feof(fichier))
                       {
                           (*s_etat_processus).erreur_execution =
                                   d_ex_syntaxe;
                       }
                       else
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_erreur_fichier;
                       }
   
                       liberation(s_etat_processus, s_objet);
                       return(NULL);
                   }
   
                   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;
                       }
   
                       liberation(s_etat_processus, s_objet);
                       return(NULL);
                   }
               }
               else
               {
                   if ((longueur_buffer - (ptr - buffer)) >= (longueur + 8))
                   {
                       for(j = 0; j < longueur; (*((struct_fonction *)
                               (*s_objet).objet)).nom_fonction[j] = *ptr++);
                       for(j = 0; j < 8; octets[j++] = *ptr++);
                   }
                   else
                   {
                       liberation(s_etat_processus, s_objet);
                       (*s_etat_processus).erreur_execution = d_ex_syntaxe;
                       return(NULL);
                   }
               }
   
               (*((struct_fonction *) (*s_objet).objet)).nom_fonction[longueur] =
                       d_code_fin_chaine;
               (*((struct_fonction *) (*s_objet).objet)).nombre_arguments =
                       (((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:          default:
         {          {
             (*s_etat_processus).erreur_execution = d_ex_syntaxe;              (*s_etat_processus).erreur_execution = d_ex_syntaxe;

Removed from v.1.57  
changed lines
  Added in v.1.58


CVSweb interface <joel.bertrand@systella.fr>