[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.85 and 1.91

version 1.85, 2015/03/26 16:12:31 version 1.91, 2016/09/27 15:29:33
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.21    RPL/2 (R) version 4.1.26
   Copyright (C) 1989-2015 Dr. BERTRAND Joël    Copyright (C) 1989-2016 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 20 Line 20
 */  */
   
   
   #define DEBUG_ERREURS
 #include "rpl-conv.h"  #include "rpl-conv.h"
   
   
Line 80  formateur_fichier(struct_processus *s_et Line 81  formateur_fichier(struct_processus *s_et
     logical1                    presence_signe;      logical1                    presence_signe;
   
     struct_liste_chainee        *l_atome;      struct_liste_chainee        *l_atome;
       struct_liste_chainee        *l_compteur;
     struct_liste_chainee        *l_element_courant;      struct_liste_chainee        *l_element_courant;
     struct_liste_chainee        *l_element_courant_format;      struct_liste_chainee        *l_element_courant_format;
     struct_liste_chainee        *l_liste1;      struct_liste_chainee        *l_liste1;
     struct_liste_chainee        *l_liste2;      struct_liste_chainee        *l_liste2;
       struct_liste_chainee        *l_tmp;
   
     struct_objet                *s_format_tmp;      struct_objet                *s_format_tmp;
     struct_objet                *s_sous_objet;      struct_objet                *s_sous_objet;
Line 3866  formateur_fichier(struct_processus *s_et Line 3869  formateur_fichier(struct_processus *s_et
   
                     free(format_chaine);                      free(format_chaine);
   
                     // Si le format_sortie vaut 'N', on remplace le format par                      // Construction d'une liste de format
                     // { "native*(*)" }. L'intérêt est de pouvoir traiter une  
                     // liste par un format "native*(*)".  
   
                     if ((format_sortie == 'N') && ((*(*l_element_courant)                      if ((s_format_tmp = allocation(s_etat_processus, LST))
                             .donnee).type == LST))                              == NULL)
                     {                      {
                         if ((s_format_tmp = allocation(s_etat_processus, LST))                          return(NULL);
                                 == NULL)                      }
   
                       if ((*(*l_element_courant).donnee).type == LST)
                       {
                           l_compteur = (struct_liste_chainee *)
                                   (*(*l_element_courant).donnee).objet;
   
                           while(l_compteur != NULL)
                         {                          {
                             return(NULL);                              l_tmp = (*s_format_tmp).objet;
                         }  
                               if (((*s_format_tmp).objet = allocation_maillon(
                                       s_etat_processus)) == NULL)
                               {
                                   return(NULL);
                               }
   
                               if (((*((struct_liste_chainee *)
                                       (*s_format_tmp).objet))
                                       .donnee = copie_objet(s_etat_processus,
                                       (*l_element_courant_format).donnee, 'P'))
                                       == NULL)
                               {
                                   return(NULL);
                               }
   
                               (*((struct_liste_chainee *) (*s_format_tmp).objet))
                                       .suivant = l_tmp;
                               l_compteur = (*l_compteur).suivant;
                           }
                       }
                       else
                       {
                         if (((*s_format_tmp).objet = allocation_maillon(                          if (((*s_format_tmp).objet = allocation_maillon(
                                 s_etat_processus)) == NULL)                                  s_etat_processus)) == NULL)
                         {                          {
                             return(NULL);                              return(NULL);
                         }                          }
   
                         (*((struct_liste_chainee *) (*s_format_tmp).objet))  
                                 .suivant = NULL;  
   
                         if (((*((struct_liste_chainee *) (*s_format_tmp).objet))                          if (((*((struct_liste_chainee *) (*s_format_tmp).objet))
                                 .donnee = allocation(s_etat_processus, CHN))                                  .donnee = copie_objet(s_etat_processus,
                                   (*l_element_courant_format).donnee, 'P'))
                                 == NULL)                                  == NULL)
                         {                          {
                             return(NULL);                              return(NULL);
                         }                          }
   
                         if (((*(*((struct_liste_chainee *) (*s_format_tmp)                          (*((struct_liste_chainee *) (*s_format_tmp).objet))
                                 .objet)).donnee).objet = malloc(11 *                                  .suivant = NULL;
                                 sizeof(unsigned char))) == NULL)  
                         {  
                             (*s_etat_processus).erreur_systeme =  
                                     d_es_allocation_memoire;  
                             return(NULL);  
                         }  
   
                         strcpy((unsigned char *) (*(*((struct_liste_chainee *)  
                                 (*s_format_tmp).objet)).donnee).objet,  
                                 "native*(*)");  
                     }  
                     else  
                     {  
                         if ((s_format_tmp = copie_objet(s_etat_processus,  
                                 s_format, 'P')) == NULL)  
                         {  
                             return(NULL);  
                         }  
                     }                      }
   
                     if ((chaine_formatee = formateur_fichier(s_etat_processus,                      if ((chaine_formatee = formateur_fichier(s_etat_processus,
Line 3945  formateur_fichier(struct_processus *s_et Line 3954  formateur_fichier(struct_processus *s_et
                     free(chaine_formatee);                      free(chaine_formatee);
                 }                  }
   
                 if (format_sortie != 'N')                  l_element_courant_format = (*l_element_courant_format).suivant;
                 {  
                     l_element_courant_format =  
                             (*l_element_courant_format).suivant;  
                 }  
   
                 nombre_elements++;                  nombre_elements++;
                 l_element_courant = (*l_element_courant).suivant;                  l_element_courant = (*l_element_courant).suivant;
             }              }
   
             if (format_sortie != 'N')              if ((l_element_courant != NULL) ||
                       (l_element_courant_format != NULL))
             {              {
                 if ((l_element_courant != NULL) ||                  free(chaine);
                         (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);
                 }  
             }              }
   
             (*longueur_effective) = longueur_totale;              (*longueur_effective) = longueur_totale;
Line 4121  formateur_fichier(struct_processus *s_et Line 4122  formateur_fichier(struct_processus *s_et
                 }                  }
             }              }
   
   uprintf("F=%s\n", formateur(s_etat_processus, 0, s_format));
   uprintf("D=%s\n", formateur(s_etat_processus, 0, s_objet));
             if ((*s_format).type == CHN)              if ((*s_format).type == CHN)
             {              {
   uprintf("<1>\n");
                 if ((format_chaine = conversion_majuscule(                  if ((format_chaine = conversion_majuscule(
                         s_etat_processus, (unsigned char *)                          s_etat_processus, (unsigned char *)
                         (*s_format).objet)) == NULL)                          (*s_format).objet)) == NULL)
Line 4207  formateur_fichier(struct_processus *s_et Line 4211  formateur_fichier(struct_processus *s_et
   
                 free(format_chaine);                  free(format_chaine);
   
                 for(i = 0; i < longueur_liste; i++)                  if ((s_format_tmp = allocation(s_etat_processus, TBL))
                           == NULL)
                 {                  {
                     if ((chaine_formatee = formateur_fichier(s_etat_processus,                      return(NULL);
                             (*((struct_tableau *) (*s_objet).objet))  
                             .elements[i], (*s_format).objet,  
                             longueur, longueur_champ,  
                             format_sortie, type, longueur_effective,  
                             recursivite, export_fichier)) == NULL)  
                     {  
                         free(chaine);  
                         return(NULL);  
                     }  
                 }                  }
             }  
             else if ((*s_format).type == TBL)  
             {  
             }  
             else  
             {  
                 free(chaine);  
   
                 (*s_etat_processus).erreur_execution =                  (*((struct_tableau *) (*s_format_tmp).objet))
                         d_ex_erreur_format_fichier;                          .nombre_elements = (*((struct_tableau *)
                 return(NULL);                          (*s_objet).objet)).nombre_elements;
             }  
   
             // A FIXER  
   
                   for(i = 0; i < (*((struct_tableau *) (*s_format_tmp).objet))
             /*                          .nombre_elements; i++)
             while((l_element_courant != NULL) &&  
                     (l_element_courant_format != NULL))  
             {  
                 if ((((*(*l_element_courant_format).donnee).type == LST)  
                         && ((*(*l_element_courant).donnee).type == LST)) ||  
                         (((*(*l_element_courant_format).donnee).type == TBL)  
                         && ((*(*l_element_courant).donnee).type == TBL)))  
                 {                  {
                     if (format_sortie != 'N')                      if (((*((struct_tableau *) (*s_format_tmp).objet))
                     {                              .elements[i] = copie_objet(s_etat_processus,
                         if ((chaine_formatee = formateur_fichier(                              s_format, 'P')) == NULL)
                                 s_etat_processus,  
                                 (*l_element_courant).donnee,  
                                 (*l_element_courant_format).donnee,  
                                 0, 0, ' ', 'U', 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', 'U', longueur_effective, recursivite,  
                                 export_fichier)) == NULL)  
                         {  
                             return(NULL);  
                         }  
                     }  
   
                     if ((chaine = realloc(chaine, ((size_t) (longueur_totale +  
                             (*longueur_effective))) * sizeof(unsigned char)))  
                             == NULL)  
                     {                      {
                         (*s_etat_processus).erreur_systeme =  
                                 d_es_allocation_memoire;  
                         return(NULL);                          return(NULL);
                     }                      }
   
                     memcpy(&(chaine[longueur_totale]), chaine_formatee,  
                             (size_t) (*longueur_effective));  
                     longueur_totale += (*longueur_effective);  
                     free(chaine_formatee);  
                 }                  }
                 else if ((*(*l_element_courant_format).donnee).type != CHN)  
                 {  
                     free(chaine);  
   
                     (*s_etat_processus).erreur_execution =  uprintf("%s\n", formateur(s_etat_processus, 0, s_format));
                             d_ex_erreur_format_fichier;                  if ((chaine_formatee = formateur_fichier(s_etat_processus,
                     return(NULL);                          s_objet, s_format_tmp,
                 }                          longueur, longueur_champ,
                 else                          format_sortie, type, longueur_effective,
                           recursivite, export_fichier)) == NULL)
                 {                  {
                     if ((format_chaine = conversion_majuscule(  
                             s_etat_processus, (unsigned char *)  
                             (*(*l_element_courant_format).donnee).objet))  
                             == NULL)  
                     {  
                         (*s_etat_processus).erreur_systeme =  
                                 d_es_allocation_memoire;  
                         return(NULL);  
                     }  
   
                     if (strncmp("INTEGER*", format_chaine, 8) == 0)  
                     {  
                         format_sortie = 'I';  
                         position_1 = 8;  
                     }  
                     else if (strncmp("LOGICAL*", format_chaine, 8) == 0)  
                     {  
                         format_sortie = 'L';  
                         position_1 = 8;  
                     }  
                     else if (strncmp("REAL*", format_chaine, 5) == 0)  
                     {  
                         format_sortie = 'R';  
                         position_1 = 5;  
                     }  
                     else if (strncmp("COMPLEX*", format_chaine, 8) == 0)  
                     {  
                         format_sortie = 'C';  
                         position_1 = 8;  
                     }  
                     else if (strncmp("CHARACTER*", format_chaine, 10) == 0)  
                     {  
                         format_sortie = 'S';  
                         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(format_chaine);  
   
                         (*s_etat_processus).erreur_execution =  
                                 d_ex_erreur_format_fichier;  
                         return(NULL);  
                     }  
   
                     if (format_chaine[position_1] == d_code_fin_chaine)  
                     {  
                         free(chaine);  
                         free(format_chaine);  
   
                         (*s_etat_processus).erreur_execution =  
                                 d_ex_erreur_format_fichier;  
                         return(NULL);  
                     }  
   
                     if (strcmp(&(format_chaine[position_1]), "(*)") != 0)  
                     {  
                         if (sscanf(&(format_chaine[position_1]), "%lld",  
                                 &longueur) != 1)  
                         {  
                             free(chaine);  
                             free(format_chaine);  
   
                             (*s_etat_processus).erreur_execution =  
                                     d_ex_erreur_format_fichier;  
                             return(NULL);  
                         }  
   
                         longueur_champ = longueur;  
                     }  
                     else  
                     {  
                         longueur_champ = -1;  
                         longueur = -1;  
                     }  
   
                     free(format_chaine);  
   
                     // Si le format_sortie vaut 'N', on remplace le format par  
                     // { "native*(*)" }. L'intérêt est de pouvoir traiter une  
                     // liste par un format "native*(*)".  
   
                     if ((format_sortie == 'N') && ((*(*l_element_courant)  
                             .donnee).type == LST))  
                     {  
                         if ((s_format_tmp = allocation(s_etat_processus, LST))  
                                 == NULL)  
                         {  
                             return(NULL);  
                         }  
   
                         if (((*s_format_tmp).objet = allocation_maillon(  
                                 s_etat_processus)) == NULL)  
                         {  
                             return(NULL);  
                         }  
   
                         (*((struct_liste_chainee *) (*s_format_tmp).objet))  
                                 .suivant = NULL;  
   
                         if (((*((struct_liste_chainee *) (*s_format_tmp).objet))  
                                 .donnee = allocation(s_etat_processus, CHN))  
                                 == NULL)  
                         {  
                             return(NULL);  
                         }  
   
                         if (((*(*((struct_liste_chainee *) (*s_format_tmp)  
                                 .objet)).donnee).objet = malloc(11 *  
                                 sizeof(unsigned char))) == NULL)  
                         {  
                             (*s_etat_processus).erreur_systeme =  
                                     d_es_allocation_memoire;  
                             return(NULL);  
                         }  
   
                         strcpy((unsigned char *) (*(*((struct_liste_chainee *)  
                                 (*s_format_tmp).objet)).donnee).objet,  
                                 "native*(*)");  
                     }  
                     else  
                     {  
                         if ((s_format_tmp = copie_objet(s_etat_processus,  
                                 s_format, 'P')) == NULL)  
                         {  
                             return(NULL);  
                         }  
                     }  
   
                     if ((chaine_formatee = formateur_fichier(s_etat_processus,  
                             (*l_element_courant).donnee, s_format_tmp,  
                             longueur, longueur_champ, format_sortie, type,  
                             longueur_effective, recursivite, export_fichier))  
                             == NULL)  
                     {  
                         liberation(s_etat_processus, s_format_tmp);  
                         free(chaine);  
                         return(NULL);  
                     }  
   
                     liberation(s_etat_processus, s_format_tmp);                      liberation(s_etat_processus, s_format_tmp);
                       free(chaine);
                     if ((chaine = realloc(chaine,                      return(NULL);
                             ((size_t) (longueur_totale + (*longueur_effective)))  
                             * sizeof(unsigned char))) == NULL)  
                     {  
                         (*s_etat_processus).erreur_systeme =  
                                 d_es_allocation_memoire;  
                         return(NULL);  
                     }  
   
                     memcpy(&(chaine[longueur_totale]), chaine_formatee,  
                             (size_t) (*longueur_effective));  
                     longueur_totale += (*longueur_effective);  
                     free(chaine_formatee);  
                 }  
   
                 if (format_sortie != 'N')  
                 {  
                     l_element_courant_format =  
                             (*l_element_courant_format).suivant;  
                 }                  }
   
                 nombre_elements++;                  liberation(s_etat_processus, s_format_tmp);
                 l_element_courant = (*l_element_courant).suivant;  
             }              }
               else if ((*s_format).type == TBL)
             if (format_sortie != 'N')  
             {              {
                 if ((l_element_courant != NULL) ||  uprintf("<2>\n");
                         (l_element_courant_format != NULL))                  free(chaine);
                 {                  // A FIXER
                     free(chaine);              }
               else
               {
   uprintf("<3>\n");
                   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);
                 }  
             }              }
         */  
   
             (*longueur_effective) = longueur_totale;              (*longueur_effective) = longueur_totale;
         }          }
Removed from v.1.85  
changed lines
  Added in v.1.91

CVSweb interface <joel.bertrand@systella.fr>