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

version 1.52, 2013/03/10 17:01:05 version 1.56, 2013/03/16 20:11:29
Line 62  formateur_fichier(struct_processus *s_et Line 62  formateur_fichier(struct_processus *s_et
      *   "binary*X(*)"       *   "binary*X(*)"
      *   "binary*X(Y)"  (X est la base : 2, 8, 10, 16)       *   "binary*X(Y)"  (X est la base : 2, 8, 10, 16)
      *   "character*(*)"       *   "character*(*)"
      *   "character*(Y)" }       *   "character*(Y)"
        *   "native*(*)" }
      *       *
      * Traitement du format des fichiers non formatés :       * Traitement du format des fichiers non formatés :
      *       *
Line 70  formateur_fichier(struct_processus *s_et Line 71  formateur_fichier(struct_processus *s_et
      *   "real*4", "real*8", ["real*16",]       *   "real*4", "real*8", ["real*16",]
      *   "complex*8", "complex*16", ["complex*32",]       *   "complex*8", "complex*16", ["complex*32",]
      *   "logical*1", "logical*2", "logical*4", logical*8",       *   "logical*1", "logical*2", "logical*4", logical*8",
      *   "character*n" "character*(*)" }       *   "character*n" "character*(*)" "native*(*)" }
      */       */
   
     logical1                    autorisation_parenthese;      logical1                    autorisation_parenthese;
Line 100  formateur_fichier(struct_processus *s_et Line 101  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 112  formateur_fichier(struct_processus *s_et Line 114  formateur_fichier(struct_processus *s_et
     integer8                    longueur_liste;      integer8                    longueur_liste;
     integer8                    longueur_reelle_chaine;      integer8                    longueur_reelle_chaine;
     integer8                    longueur_totale;      integer8                    longueur_totale;
     integer8                    masque_binaire;  
     integer8                    position_1;      integer8                    position_1;
     integer8                    position_2;      integer8                    position_2;
     integer8                    position_3;      integer8                    position_3;
Line 131  formateur_fichier(struct_processus *s_et Line 132  formateur_fichier(struct_processus *s_et
   
         strcpy(base, " ");          strcpy(base, " ");
   
         masque_binaire = 0;  
   
         if ((*s_objet).type == ALG)          if ((*s_objet).type == ALG)
         {          {
   
Line 142  formateur_fichier(struct_processus *s_et Line 141  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie != 'N')
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_format_fichier;
                   return(NULL);
               }
   
             l_element_courant = (struct_liste_chainee *) (*s_objet).objet;              l_element_courant = (struct_liste_chainee *) (*s_objet).objet;
   
             while(l_element_courant != NULL)              while(l_element_courant != NULL)
Line 984  formateur_fichier(struct_processus *s_et Line 990  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
             if (format_sortie != 'B')              if ((format_sortie != 'B') && (format_sortie != 'U'))
             {              {
                 (*s_etat_processus).erreur_execution =                  (*s_etat_processus).erreur_execution =
                         d_ex_erreur_format_fichier;                          d_ex_erreur_format_fichier;
                 return(NULL);                  return(NULL);
             }              }
   
             masque_binaire = masque_entiers_binaires(s_etat_processus);              if (format_sortie == 'N')
   
             if ((test_cfsf(s_etat_processus, 43) == d_faux) &&  
                     (test_cfsf(s_etat_processus, 44) == d_faux))  
             {              {
                   sprintf(tampon, "%llX", (*((logical8 *)
 /*                          ((*s_objet).objet))));
 -- Base décimale ---------------------------------------------------------------                  strcpy(base, "h");
 */  
   
                 sprintf(tampon, "%llu", (*((logical8 *)  
                         ((*s_objet).objet))) & masque_binaire);  
                 strcpy(base, "d");  
             }              }
             else if ((test_cfsf(s_etat_processus, 43) == d_vrai) &&              else
                     (test_cfsf(s_etat_processus, 44) == d_faux))  
             {              {
                   switch(longueur)
                   {
                       case 2:
                       {
                           sprintf(tampon, "%llX", (*((logical8 *)
                                   ((*s_objet).objet))));
   
 /*                          chaine = (unsigned char *) malloc((strlen(tampon) + 1)
 -- Base octale -----------------------------------------------------------------                                  * sizeof(unsigned char));
 */  
   
                 sprintf(tampon, "%llo", (*((logical8 *)                          if (chaine == NULL)
                         ((*s_objet).objet))) & masque_binaire);                          {
                 strcpy(base, "o");                              (*s_etat_processus).erreur_systeme =
             }                                      d_es_allocation_memoire;
             else if (test_cfsf(s_etat_processus, 44) == d_vrai)                              return(NULL);
             {                          }
   
 /*                          strcpy(chaine, tampon);
 -- Bases hexadécimale et binaire -----------------------------------------------                          tampon[0] = 0;
 */  
   
                 sprintf(tampon, "%llX", (*((logical8 *)                          for(i = 0; i < strlen(chaine); i++)
                         ((*s_objet).objet))) & masque_binaire);                          {
                               switch(chaine[i])
                               {
                                   case '0' :
                                   {
                                       strcat(tampon, (i != 0) ? "0000" : "0");
                                       break;
                                   }
                                   case '1' :
                                   {
                                       strcat(tampon, (i != 0) ? "0001" : "1");
                                       break;
                                   }
                                   case '2' :
                                   {
                                       strcat(tampon, (i != 0) ? "0010" : "10");
                                       break;
                                   }
                                   case '3' :
                                   {
                                       strcat(tampon, (i != 0) ? "0011" : "11");
                                   break;
                                   }
                                   case '4' :
                                   {
                                       strcat(tampon, (i != 0) ? "0100" : "100");
                                       break;
                                   }
                                   case '5' :
                                   {
                                       strcat(tampon, (i != 0) ? "0101" : "101");
                                       break;
                                   }
                                   case '6' :
                                   {
                                       strcat(tampon, (i != 0) ? "0110" : "110");
                                       break;
                                   }
                                   case '7' :
                                   {
                                       strcat(tampon, (i != 0) ? "0111" : "111");
                                       break;
                                   }
                                   case '8' :
                                   {
                                       strcat(tampon, "1000");
                                       break;
                                   }
                                   case '9' :
                                   {
                                       strcat(tampon, "1001");
                                       break;
                                   }
                                   case 'A' :
                                   {
                                       strcat(tampon, "1010");
                                       break;
                                   }
                                   case 'B' :
                                   {
                                       strcat(tampon, "1011");
                                       break;
                                   }
                                   case 'C' :
                                   {
                                       strcat(tampon, "1100");
                                       break;
                                   }
                                   case 'D' :
                                   {
                                       strcat(tampon, "1101");
                                       break;
                                   }
                                   case 'E' :
                                   {
                                       strcat(tampon, "1110");
                                       break;
                                   }
                                   case 'F' :
                                   {
                                       strcat(tampon, "1111");
                                       break;
                                   }
                               }
                           }
   
                 if (test_cfsf(s_etat_processus, 43) == d_vrai)                          free(chaine);
                 {                          strcpy(base, "b");
                     strcpy(base, "h");                          break;
                 }                      }
                 else  
                 {  
                     chaine = (unsigned char *) malloc((strlen(tampon) + 1)  
                             * sizeof(unsigned char));  
   
                     if (chaine == NULL)                      case 8:
                     {                      {
                         (*s_etat_processus).erreur_systeme =                          sprintf(tampon, "%llo", (*((logical8 *)
                                 d_es_allocation_memoire;                                  ((*s_objet).objet))));
                         return(NULL);                          strcpy(base, "o");
                           break;
                     }                      }
   
                     strcpy(chaine, tampon);                      case 10:
                     tampon[0] = 0;                      {
                           sprintf(tampon, "%llu", (*((logical8 *)
                                   ((*s_objet).objet))));
                           strcpy(base, "d");
                           break;
                       }
   
                     for(i = 0; i < strlen(chaine); i++)                      case 16:
                     {                      {
                         switch(chaine[i])                          sprintf(tampon, "%llX", (*((logical8 *)
                         {                                  ((*s_objet).objet))));
                             case '0' :                          strcpy(base, "h");
                             {                          break;
                                 strcat(tampon, (i != 0) ? "0000" : "0");  
                                 break;  
                             }  
                             case '1' :  
                             {  
                                     strcat(tampon, (i != 0) ? "0001" : "1");  
                                 break;  
                             }  
                             case '2' :  
                             {  
                                 strcat(tampon, (i != 0) ? "0010" : "10");  
                                 break;  
                             }  
                             case '3' :  
                             {  
                                 strcat(tampon, (i != 0) ? "0011" : "11");  
                                 break;  
                             }  
                             case '4' :  
                             {  
                                 strcat(tampon, (i != 0) ? "0100" : "100");  
                                 break;  
                             }  
                             case '5' :  
                             {  
                                 strcat(tampon, (i != 0) ? "0101" : "101");  
                                 break;  
                             }  
                             case '6' :  
                             {  
                                 strcat(tampon, (i != 0) ? "0110" : "110");  
                                 break;  
                             }  
                             case '7' :  
                             {  
                                 strcat(tampon, (i != 0) ? "0111" : "111");  
                                 break;  
                             }  
                             case '8' :  
                             {  
                                 strcat(tampon, "1000");  
                                 break;  
                             }  
                             case '9' :  
                             {  
                                 strcat(tampon, "1001");  
                                 break;  
                             }  
                             case 'A' :  
                             {  
                                 strcat(tampon, "1010");  
                                 break;  
                             }  
                             case 'B' :  
                             {  
                                 strcat(tampon, "1011");  
                                 break;  
                             }  
                             case 'C' :  
                             {  
                                 strcat(tampon, "1100");  
                                 break;  
                             }  
                             case 'D' :  
                             {  
                                 strcat(tampon, "1101");  
                                 break;  
                             }  
                             case 'E' :  
                             {  
                                 strcat(tampon, "1110");  
                                 break;  
                             }  
                             case 'F' :  
                             {  
                                 strcat(tampon, "1111");  
                                 break;  
                             }  
                         }  
                     }                      }
   
                     free(chaine);                      default:
                     strcpy(base, "b");                      {
                           (*s_etat_processus).erreur_execution =
                                   d_ex_erreur_format_fichier;
                           return(NULL);
                       }
                   }
               }
   
               if (format_sortie == 'B')
               {
                   if ((longueur_champ > 0) && (longueur_champ
                           < (signed) strlen(tampon)))
                   {
                       ptrl = &(tampon[strlen(tampon) - longueur_champ]);
                       ptre = tampon;
   
                       do
                       {
                           *ptre++ = *ptrl++;
                       } while((*ptrl) != d_code_fin_chaine);
   
                       (*ptre) = d_code_fin_chaine;
                 }                  }
             }              }
   
Line 1161  formateur_fichier(struct_processus *s_et Line 1190  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
             if (format_sortie != 'C')              if ((format_sortie != 'C') && (format_sortie != 'U'))
             {              {
                 (*s_etat_processus).erreur_execution =                  (*s_etat_processus).erreur_execution =
                         d_ex_erreur_format_fichier;                          d_ex_erreur_format_fichier;
Line 1171  formateur_fichier(struct_processus *s_et Line 1200  formateur_fichier(struct_processus *s_et
             longueur_reelle_chaine = longueur_chaine(s_etat_processus,              longueur_reelle_chaine = longueur_chaine(s_etat_processus,
                     (unsigned char *) (*s_objet).objet);                      (unsigned char *) (*s_objet).objet);
   
               if (format_sortie == 'N')
               {
                   longueur_champ = -1;
               }
   
             if ((longueur_champ == -1) || (longueur_reelle_chaine <              if ((longueur_champ == -1) || (longueur_reelle_chaine <
                     longueur_champ))                      longueur_champ))
             {              {
Line 1215  formateur_fichier(struct_processus *s_et Line 1249  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'S';
               }
   
             if ((format_sortie != 'S') && (format_sortie != 'F') &&              if ((format_sortie != 'S') && (format_sortie != 'F') &&
                     (format_sortie != 'I') && (format_sortie != 'E'))                      (format_sortie != 'I') && (format_sortie != 'E'))
             {              {
Line 1252  formateur_fichier(struct_processus *s_et Line 1291  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie != 'N')
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_format_fichier;
                   return(NULL);
               }
   
             l_element_courant = (struct_liste_chainee *) ((*s_objet).objet);              l_element_courant = (struct_liste_chainee *) ((*s_objet).objet);
             chaine_sauvegarde = chaine;              chaine_sauvegarde = chaine;
   
Line 1334  formateur_fichier(struct_processus *s_et Line 1380  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'S';
               }
   
             if ((format_sortie != 'S') && (format_sortie != 'F') &&              if ((format_sortie != 'S') && (format_sortie != 'F') &&
                     (format_sortie != 'I') && (format_sortie != 'E'))                      (format_sortie != 'I') && (format_sortie != 'E'))
             {              {
Line 1371  formateur_fichier(struct_processus *s_et Line 1422  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie != 'N')
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_format_fichier;
                   return(NULL);
               }
   
             chaine = (unsigned char *) malloc((strlen((*((struct_fonction *)              chaine = (unsigned char *) malloc((strlen((*((struct_fonction *)
                     ((*s_objet).objet))).nom_fonction) + 1) *                      ((*s_objet).objet))).nom_fonction) + 1) *
                     sizeof(unsigned char));                      sizeof(unsigned char));
Line 1418  formateur_fichier(struct_processus *s_et Line 1476  formateur_fichier(struct_processus *s_et
                 {                  {
                     chaine_sauvegarde = chaine;                      chaine_sauvegarde = chaine;
   
                     if ((chaine_formatee = formateur_fichier(s_etat_processus,                      if (format_sortie != 'N')
                             (*l_element_courant).donnee,  
                             (*l_element_courant_format).donnee,  
                             0, 0, ' ', 'F', longueur_effective, recursivite,  
                             export_fichier)) == NULL)  
                     {                      {
                         return(NULL);                          if ((chaine_formatee =
                                   formateur_fichier(s_etat_processus,
                                   (*l_element_courant).donnee,
                                   (*l_element_courant_format).donnee,
                                   0, 0, ' ', 'F', longueur_effective, recursivite,
                                   export_fichier)) == NULL)
                           {
                               return(NULL);
                           }
                       }
                       else
                       {
                           if ((chaine_formatee =
                                   formateur_fichier(s_etat_processus,
                                   (*l_element_courant).donnee,
                                   (*l_element_courant_format).donnee,
                                   0, 0, 'N', 'F', longueur_effective, recursivite,
                                   export_fichier)) == NULL)
                           {
                               return(NULL);
                           }
                     }                      }
   
                     chaine = (unsigned char *) malloc((strlen(chaine_formatee)                      chaine = (unsigned char *) malloc((strlen(chaine_formatee)
Line 1497  formateur_fichier(struct_processus *s_et Line 1571  formateur_fichier(struct_processus *s_et
                         position_1 = 10;                          position_1 = 10;
                         format_degenere = d_vrai;                          format_degenere = d_vrai;
                     }                      }
                       else if (strcmp("NATIVE*(*)", format_chaine) == 0)
                       {
                           format_sortie = 'N';
                           position_1 = 7;
                           format_degenere = d_vrai;
                       }
                     else                      else
                     {                      {
                         free(chaine);                          free(chaine);
Line 1577  formateur_fichier(struct_processus *s_et Line 1657  formateur_fichier(struct_processus *s_et
                     }                      }
   
                     if ((longueur >= 0) && (longueur_champ >= 0) && (longueur >                      if ((longueur >= 0) && (longueur_champ >= 0) && (longueur >
                             longueur_champ))                              longueur_champ) && (format_sortie != 'B'))
                     {                      {
                         free(chaine);                          free(chaine);
                         free(format_chaine);                          free(format_chaine);
Line 1664  formateur_fichier(struct_processus *s_et Line 1744  formateur_fichier(struct_processus *s_et
   
                 nombre_elements++;                  nombre_elements++;
                 l_element_courant = (*l_element_courant).suivant;                  l_element_courant = (*l_element_courant).suivant;
                 l_element_courant_format = (*l_element_courant_format).suivant;  
                   if (format_sortie != 'N')
                   {
                       l_element_courant_format =
                               (*l_element_courant_format).suivant;
                   }
             }              }
   
             if ((l_element_courant != NULL) ||              // Dans le cas où le format de sortie n'est pas du type
                     (l_element_courant_format != NULL))              // NATIVE*(*), on vérifie que tous les éléments du format et
               // de la liste d'arguments ont été consommés.
   
               if (format_sortie != 'N')
             {              {
                 free(chaine);                  if ((l_element_courant != NULL) ||
                           (l_element_courant_format != NULL))
                   {
                       free(chaine);
   
                 (*s_etat_processus).erreur_execution =                      (*s_etat_processus).erreur_execution =
                         d_ex_erreur_format_fichier;                              d_ex_erreur_format_fichier;
                 return(NULL);                      return(NULL);
                   }
             }              }
   
             chaine_sauvegarde = chaine;              chaine_sauvegarde = chaine;
Line 1700  formateur_fichier(struct_processus *s_et Line 1792  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
             if ((*s_format).type != TBL)              if (((*s_format).type != TBL) && (format_sortie != 'N'))
             {              {
                 (*s_etat_processus).erreur_execution =                  (*s_etat_processus).erreur_execution =
                         d_ex_erreur_format_fichier;                          d_ex_erreur_format_fichier;
                 return(NULL);                  return(NULL);
             }              }
   
             l_element_courant = (struct_liste_chainee *) (*s_objet).objet;              if (format_sortie != 'N')
             l_element_courant_format = (struct_liste_chainee *)  
                     (*s_format).objet;  
   
             if ((*((struct_tableau *) (*s_objet).objet)).nombre_elements !=  
                     (*((struct_tableau *) (*s_format).objet)).nombre_elements)  
             {              {
                 (*s_etat_processus).erreur_execution =                  if ((*((struct_tableau *) (*s_objet).objet)).nombre_elements !=
                         d_ex_erreur_format_fichier;                          (*((struct_tableau *) (*s_format).objet))
                 return(NULL);                          .nombre_elements)
                   {
                       (*s_etat_processus).erreur_execution =
                               d_ex_erreur_format_fichier;
                       return(NULL);
                   }
             }              }
   
             chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));              chaine = (unsigned char *) malloc(3 * sizeof(unsigned char));
Line 1732  formateur_fichier(struct_processus *s_et Line 1824  formateur_fichier(struct_processus *s_et
             for(i = 0; i < (*((struct_tableau *) (*s_objet).objet))              for(i = 0; i < (*((struct_tableau *) (*s_objet).objet))
                     .nombre_elements; i++)                      .nombre_elements; i++)
             {              {
                 if ((((*(*((struct_tableau *) (*s_format).objet))                  if (format_sortie != 'N')
                         .elements[i]).type == LST) &&  
                         ((*(*((struct_tableau *) (*s_objet).objet)).elements[i])  
                         .type == LST)) ||  
                         (((*(*((struct_tableau *) (*s_format).objet))  
                         .elements[i]).type == TBL) &&  
                         ((*(*((struct_tableau *) (*s_objet).objet)).elements[i])  
                         .type == TBL)))  
                 {                  {
                     chaine_sauvegarde = chaine;                      if ((((*(*((struct_tableau *) (*s_format).objet))
                               .elements[i]).type == LST) &&
                     if ((chaine_formatee = formateur_fichier(s_etat_processus,                              ((*(*((struct_tableau *) (*s_objet).objet))
                             (*l_element_courant).donnee,                              .elements[i]).type == LST)) ||
                             (*l_element_courant_format).donnee,                              (((*(*((struct_tableau *) (*s_format).objet))
                             0, 0, ' ', 'F', longueur_effective, recursivite,                              .elements[i]).type == TBL) &&
                             export_fichier)) == NULL)                              ((*(*((struct_tableau *) (*s_objet).objet))
                     {                              .elements[i]).type == TBL)))
                         return(NULL);  
                     }  
   
                     chaine = (unsigned char *) malloc((strlen(chaine_formatee)  
                             + strlen(chaine_sauvegarde) + 2)  
                             * sizeof(unsigned char));  
   
                     if (chaine == NULL)  
                     {                      {
                         (*s_etat_processus).erreur_systeme =                          chaine_sauvegarde = chaine;
                                 d_es_allocation_memoire;  
                         return(NULL);  
                     }  
   
                     strcpy(chaine, chaine_sauvegarde);  
                     free(chaine_sauvegarde);  
                     strcat(chaine, " ");  
                     strcat(chaine, chaine_formatee);  
                     free(chaine_formatee);  
                 }  
                 else if ((*(*((struct_tableau *) (*s_format).objet))  
                         .elements[i]).type != CHN)  
                 {  
                     free(chaine);  
   
                     (*s_etat_processus).erreur_execution =                          if ((chaine_formatee = formateur_fichier(
                             d_ex_erreur_format_fichier;                                  s_etat_processus,
                     return(NULL);                                  (*(*((struct_tableau *) (*s_objet).objet))
                 }                                  .elements[i]).objet,
                 else                                  (*(*((struct_tableau *) (*s_format).objet))
                 {                                  .elements[i]).objet,
                     if ((format_chaine = conversion_majuscule((unsigned char *)                                  0, 0, ' ', 'F', longueur_effective, recursivite,
                             (*(*((struct_tableau *) (*s_format).objet))                                  export_fichier)) == NULL)
                             .elements[i]).objet)) == NULL)                          {
                     {                              return(NULL);
                         (*s_etat_processus).erreur_systeme =                          }
                                 d_es_allocation_memoire;  
                         return(NULL);  
                     }  
   
                     format_degenere = d_faux;                          if ((chaine = (unsigned char *) malloc((strlen(
                                   chaine_formatee) + strlen(chaine_sauvegarde)
                                   + 2) * sizeof(unsigned char))) == NULL)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_allocation_memoire;
                               return(NULL);
                           }
   
                     if (strncmp("STANDARD*", format_chaine, 9) == 0)                          strcpy(chaine, chaine_sauvegarde);
                     {                          free(chaine_sauvegarde);
                         format_sortie = 'S';                          strcat(chaine, " ");
                         position_1 = 9;                          strcat(chaine, chaine_formatee);
                         format_degenere = d_vrai;                          free(chaine_formatee);
                     }  
                     else if (strncmp("BINARY*", format_chaine, 7) == 0)  
                     {  
                         format_sortie = 'B';  
                         position_1 = 7;  
                     }  
                     else if (strncmp("FIXED*", format_chaine, 6) == 0)  
                     {  
                         format_sortie = 'F';  
                         position_1 = 6;  
                     }  
                     else if (strncmp("SCIENTIFIC*", format_chaine, 11) == 0)  
                     {  
                         format_sortie = 'I';  
                         position_1 = 11;  
                     }  
                     else if (strncmp("ENGINEER*", format_chaine, 9) == 0)  
                     {  
                         format_sortie = 'E';  
                         position_1 = 9;  
                     }  
                     else if (strncmp("CHARACTER*", format_chaine, 10) == 0)  
                     {  
                         format_sortie = 'C';  
                         position_1 = 10;  
                         format_degenere = d_vrai;  
                     }                      }
                     else                      else if ((*(*((struct_tableau *) (*s_format).objet))
                               .elements[i]).type != CHN)
                     {                      {
                         free(chaine);                          free(chaine);
                         free(format_chaine);  
   
                         (*s_etat_processus).erreur_execution =                          (*s_etat_processus).erreur_execution =
                                 d_ex_erreur_format_fichier;                                  d_ex_erreur_format_fichier;
                         return(NULL);                          return(NULL);
                     }                      }
                       else
                       {
                           if ((format_chaine = conversion_majuscule(
                                   (unsigned char *) (*(*((struct_tableau *)
                                   (*s_format).objet)).elements[i]).objet))
                                   == NULL)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_allocation_memoire;
                               return(NULL);
                           }
   
                     position_3 = strlen(format_chaine);                          format_degenere = d_faux;
                     format_chaine[--position_3] = d_code_fin_chaine;  
   
                     position_2 = position_1;  
   
                     while(format_chaine[position_2] != '(')                          if (strncmp("STANDARD*", format_chaine, 9) == 0)
                     {                          {
                         if (format_chaine[position_2] == d_code_fin_chaine)                              format_sortie = 'S';
                               position_1 = 9;
                               format_degenere = d_vrai;
                           }
                           else if (strncmp("BINARY*", format_chaine, 7) == 0)
                           {
                               format_sortie = 'B';
                               position_1 = 7;
                           }
                           else if (strncmp("FIXED*", format_chaine, 6) == 0)
                           {
                               format_sortie = 'F';
                               position_1 = 6;
                           }
                           else if (strncmp("SCIENTIFIC*", format_chaine, 11) == 0)
                           {
                               format_sortie = 'I';
                               position_1 = 11;
                           }
                           else if (strncmp("ENGINEER*", format_chaine, 9) == 0)
                           {
                               format_sortie = 'E';
                               position_1 = 9;
                           }
                           else if (strncmp("CHARACTER*", format_chaine, 10) == 0)
                           {
                               format_sortie = 'C';
                               position_1 = 10;
                               format_degenere = d_vrai;
                           }
                           else if (strcmp("NATIVE*(*)", format_chaine) == 0)
                           {
                               format_sortie = 'N';
                               position_1 = 7;
                               format_degenere = d_vrai;
                           }
                           else
                         {                          {
                             free(chaine);                              free(chaine);
                             free(format_chaine);                              free(format_chaine);
Line 1850  formateur_fichier(struct_processus *s_et Line 1935  formateur_fichier(struct_processus *s_et
                             return(NULL);                              return(NULL);
                         }                          }
   
                         position_2++;                          position_3 = strlen(format_chaine);
                     }                          format_chaine[--position_3] = d_code_fin_chaine;
   
                     format_chaine[position_2++] = d_code_fin_chaine;                          position_2 = position_1;
   
                     if (format_degenere == d_faux)                          while(format_chaine[position_2] != '(')
                     {  
                         if (sscanf(&(format_chaine[position_1]), "%ld",  
                                 &longueur) != 1)  
                         {                          {
                             free(chaine);                              if (format_chaine[position_2] == d_code_fin_chaine)
                             free(format_chaine);                              {
                                   free(chaine);
                                   free(format_chaine);
   
                             (*s_etat_processus).erreur_execution =                                  (*s_etat_processus).erreur_execution =
                                     d_ex_erreur_format_fichier;                                          d_ex_erreur_format_fichier;
                             return(NULL);                                  return(NULL);
                               }
   
                               position_2++;
                         }                          }
                     }  
                     else  
                     {  
                         longueur = -1;  
                     }  
   
                     if (strcmp(&(format_chaine[position_2]), "*") != 0)                          format_chaine[position_2++] = d_code_fin_chaine;
                     {  
                         if (sscanf(&(format_chaine[position_2]), "%ld",                          if (format_degenere == d_faux)
                                 &longueur_champ) != 1)                          {
                               if (sscanf(&(format_chaine[position_1]), "%ld",
                                       &longueur) != 1)
                               {
                                   free(chaine);
                                   free(format_chaine);
   
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_erreur_format_fichier;
                                   return(NULL);
                               }
                           }
                           else
                           {
                               longueur = -1;
                           }
   
                           if (strcmp(&(format_chaine[position_2]), "*") != 0)
                           {
                               if (sscanf(&(format_chaine[position_2]), "%ld",
                                       &longueur_champ) != 1)
                               {
                                   free(chaine);
                                   free(format_chaine);
   
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_erreur_format_fichier;
                                   return(NULL);
                               }
                           }
                           else
                           {
                               longueur_champ = -1;
                           }
   
                           if ((longueur >= 0) && (longueur_champ >= 0) &&
                                   (longueur > longueur_champ))
                         {                          {
                             free(chaine);                              free(chaine);
                             free(format_chaine);                              free(format_chaine);
Line 1885  formateur_fichier(struct_processus *s_et Line 2003  formateur_fichier(struct_processus *s_et
                                     d_ex_erreur_format_fichier;                                      d_ex_erreur_format_fichier;
                             return(NULL);                              return(NULL);
                         }                          }
                     }  
                     else  
                     {  
                         longueur_champ = -1;  
                     }  
   
                     if ((longueur >= 0) && (longueur_champ >= 0) && (longueur >  
                             longueur_champ))  
                     {  
                         free(chaine);  
                         free(format_chaine);                          free(format_chaine);
                       
                           chaine_sauvegarde = chaine;
   
                         (*s_etat_processus).erreur_execution =                          if ((chaine_formatee = formateur_fichier(
                                 d_ex_erreur_format_fichier;                                  s_etat_processus, (*((struct_tableau *)
                         return(NULL);                                  (*s_objet).objet)).elements[i], s_format,
                                   longueur, longueur_champ, format_sortie, type,
                                   longueur_effective, recursivite,
                                   export_fichier)) == NULL)
                           {
                               return(NULL);
                           }
                     }                      }
                   }
                     free(format_chaine);                  else // NATIVE*(*)
                                   {
                     chaine_sauvegarde = chaine;                      chaine_sauvegarde = chaine;
   
                     if ((chaine_formatee = formateur_fichier(s_etat_processus,                      if ((chaine_formatee = formateur_fichier(
                             (*((struct_tableau *) (*s_objet).objet))                              s_etat_processus, (*((struct_tableau *)
                             .elements[i], s_format,                              (*s_objet).objet)).elements[i], s_format,
                             longueur, longueur_champ, format_sortie, type,                              longueur, longueur_champ, format_sortie, type,
                             longueur_effective, recursivite, export_fichier))                              longueur_effective, recursivite,
                             == NULL)                              export_fichier)) == NULL)
                     {                      {
                         return(NULL);                          return(NULL);
                     }                      }
                   }
   
                     if ((*(*((struct_tableau *) (*s_objet).objet))                  if ((*(*((struct_tableau *) (*s_objet).objet))
                             .elements[i]).type == CHN)                          .elements[i]).type == CHN)
                     {                  {
                         chaine = (unsigned char *)                      chaine = (unsigned char *)
                                 malloc((strlen(chaine_formatee)                              malloc((strlen(chaine_formatee)
                                 + strlen(chaine_sauvegarde) + 4)                              + strlen(chaine_sauvegarde) + 4)
                                 * sizeof(unsigned char));                              * sizeof(unsigned char));
   
                         if (chaine == NULL)  
                         {  
                             (*s_etat_processus).erreur_systeme =  
                                     d_es_allocation_memoire;  
                             return(NULL);  
                         }  
   
                         strcpy(chaine, chaine_sauvegarde);                      if (chaine == NULL)
                         free(chaine_sauvegarde);  
                         strcat(chaine, " \"");  
                         strcat(chaine, chaine_formatee);  
                         free(chaine_formatee);  
                         strcat(chaine, "\"");  
                     }  
                     else if ((*(*((struct_tableau *) (*s_objet).objet))  
                             .elements[i]).type == NOM)  
                     {                      {
                         chaine = (unsigned char *)                          (*s_etat_processus).erreur_systeme =
                                 malloc((strlen(chaine_formatee)                                  d_es_allocation_memoire;
                                 + strlen(chaine_sauvegarde) + 2)                          return(NULL);
                                 * sizeof(unsigned char));                      }
   
                         if (chaine == NULL)                      strcpy(chaine, chaine_sauvegarde);
                         {                      free(chaine_sauvegarde);
                             (*s_etat_processus).erreur_systeme =                      strcat(chaine, " \"");
                                     d_es_allocation_memoire;                      strcat(chaine, chaine_formatee);
                             return(NULL);                      free(chaine_formatee);
                         }                      strcat(chaine, "\"");
                   }
                   else if ((*(*((struct_tableau *) (*s_objet).objet))
                           .elements[i]).type == NOM)
                   {
                       chaine = (unsigned char *)
                               malloc((strlen(chaine_formatee)
                               + strlen(chaine_sauvegarde) + 2)
                               * sizeof(unsigned char));
   
                         sprintf(chaine, "%s %s", chaine_sauvegarde,                      if (chaine == NULL)
                                 chaine_formatee);  
                         free(chaine_formatee);  
                     }  
                     else  
                     {                      {
                         chaine = (unsigned char *)                          (*s_etat_processus).erreur_systeme =
                                 malloc((strlen(chaine_formatee)                                  d_es_allocation_memoire;
                                 + strlen(chaine_sauvegarde) + 2)                          return(NULL);
                                 * sizeof(unsigned char));                      }
   
                         if (chaine == NULL)                      sprintf(chaine, "%s %s", chaine_sauvegarde,
                         {                              chaine_formatee);
                             (*s_etat_processus).erreur_systeme =                      free(chaine_formatee);
                                     d_es_allocation_memoire;                  }
                             return(NULL);                  else
                         }                  {
                       chaine = (unsigned char *)
                               malloc((strlen(chaine_formatee)
                               + strlen(chaine_sauvegarde) + 2)
                               * sizeof(unsigned char));
   
                         strcpy(chaine, chaine_sauvegarde);                      if (chaine == NULL)
                         free(chaine_sauvegarde);                      {
                         strcat(chaine, " ");                          (*s_etat_processus).erreur_systeme =
                         strcat(chaine, chaine_formatee);                                  d_es_allocation_memoire;
                         free(chaine_formatee);                          return(NULL);
                     }                      }
   
                       strcpy(chaine, chaine_sauvegarde);
                       free(chaine_sauvegarde);
                       strcat(chaine, " ");
                       strcat(chaine, chaine_formatee);
                       free(chaine_formatee);
                 }                  }
             }              }
   
Line 2003  formateur_fichier(struct_processus *s_et Line 2120  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'S';
               }
   
             if ((format_sortie != 'S') && (format_sortie != 'F') &&              if ((format_sortie != 'S') && (format_sortie != 'F') &&
                     (format_sortie != 'I') && (format_sortie != 'E'))                      (format_sortie != 'I') && (format_sortie != 'E'))
             {              {
Line 2146  formateur_fichier(struct_processus *s_et Line 2268  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'S';
               }
   
             if ((format_sortie != 'S') && (format_sortie != 'F') &&              if ((format_sortie != 'S') && (format_sortie != 'F') &&
                     (format_sortie != 'I') && (format_sortie != 'E'))                      (format_sortie != 'I') && (format_sortie != 'E'))
             {              {
Line 2288  formateur_fichier(struct_processus *s_et Line 2415  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'S';
               }
   
             if ((format_sortie != 'S') && (format_sortie != 'F') &&              if ((format_sortie != 'S') && (format_sortie != 'F') &&
                     (format_sortie != 'I') && (format_sortie != 'E'))                      (format_sortie != 'I') && (format_sortie != 'E'))
             {              {
Line 2430  formateur_fichier(struct_processus *s_et Line 2562  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie != 'N')
               {
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_format_fichier;
                   return(NULL);
               }
   
             chaine = (unsigned char *) malloc((strlen((*((struct_nom *)              chaine = (unsigned char *) malloc((strlen((*((struct_nom *)
                     (*s_objet).objet)).nom) + 3) * sizeof(unsigned char));                      (*s_objet).objet)).nom) + 3) * sizeof(unsigned char));
   
Line 2450  formateur_fichier(struct_processus *s_et Line 2589  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'S';
               }
   
             if ((format_sortie != 'S') && (format_sortie != 'F') &&              if ((format_sortie != 'S') && (format_sortie != 'F') &&
                     (format_sortie != 'I') && (format_sortie != 'E'))                      (format_sortie != 'I') && (format_sortie != 'E'))
             {              {
Line 2487  formateur_fichier(struct_processus *s_et Line 2631  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'S';
               }
   
             if ((format_sortie != 'S') && (format_sortie != 'F') &&              if ((format_sortie != 'S') && (format_sortie != 'F') &&
                     (format_sortie != 'I') && (format_sortie != 'E'))                      (format_sortie != 'I') && (format_sortie != 'E'))
             {              {
Line 2563  formateur_fichier(struct_processus *s_et Line 2712  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'S';
               }
   
             if ((format_sortie != 'S') && (format_sortie != 'F') &&              if ((format_sortie != 'S') && (format_sortie != 'F') &&
                     (format_sortie != 'I') && (format_sortie != 'E'))                      (format_sortie != 'I') && (format_sortie != 'E'))
             {              {
Line 2638  formateur_fichier(struct_processus *s_et Line 2792  formateur_fichier(struct_processus *s_et
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
               if (format_sortie == 'N')
               {
                   format_sortie = 'S';
               }
   
             if ((format_sortie != 'S') && (format_sortie != 'F') &&              if ((format_sortie != 'S') && (format_sortie != 'F') &&
                     (format_sortie != 'I') && (format_sortie != 'E'))                      (format_sortie != 'I') && (format_sortie != 'E'))
             {              {
Line 2744  formateur_fichier(struct_processus *s_et Line 2903  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 3047  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 3272  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 3307  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 3332  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 3358  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 3786  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 4093  formateur_fichier_binaire_nombre(struct_ Line 4289  formateur_fichier_binaire_nombre(struct_
                 case 4:                  case 4:
                 {                  {
                     if ((*((integer8 *) valeur_numerique)) !=                      if ((*((integer8 *) valeur_numerique)) !=
                             ((integer2) (*((integer8 *) valeur_numerique))))                              ((integer4) (*((integer8 *) valeur_numerique))))
                     {                      {
                         (*s_etat_processus).erreur_execution =                          (*s_etat_processus).erreur_execution =
                                 d_ex_representation;                                  d_ex_representation;
Line 4525  lecture_fichier_non_formate(struct_proce Line 4721  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 4733  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 4547  lecture_fichier_non_formate(struct_proce Line 4746  lecture_fichier_non_formate(struct_proce
     }      }
     else      else
     {      {
         buffer = argument;          buffer = (*((unsigned char **) argument));
         ptr = buffer;          ptr = buffer;
         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 4909  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, 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 4959  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 4986  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 5065  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 5220  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 5259  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 5299  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 5341  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 5454  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 5716  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 5737  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);
             }              }
         }          }
     }      }
   
       if (longueur_buffer >= 0)
       {
           (*((unsigned char **) argument)) = ptr;
       }
   
     return(s_objet);      return(s_objet);
 }  }
   
Removed from v.1.52  
changed lines
  Added in v.1.56

CVSweb interface <joel.bertrand@systella.fr>