[BACK]Return to instructions_w1.c CVS log [TXT] [DIR] Up to [local] / rpl / src

Diff for /rpl/src/instructions_w1.c between versions 1.63 and 1.64

version 1.63, 2012/06/21 16:07:25 version 1.64, 2012/06/22 10:12:19
Line 391  instruction_write(struct_processus *s_et Line 391  instruction_write(struct_processus *s_et
     integer8                            id;      integer8                            id;
     integer8                            ordre;      integer8                            ordre;
   
       logical1                            format_degenere;
     logical1                            mise_a_jour;      logical1                            mise_a_jour;
   
       long                                longueur;
     long                                longueur_effective;      long                                longueur_effective;
     long                                recursivite;      long                                recursivite;
   
Line 428  instruction_write(struct_processus *s_et Line 430  instruction_write(struct_processus *s_et
     unsigned char                       *chaine_utf8;      unsigned char                       *chaine_utf8;
     unsigned char                       *clef_utf8;      unsigned char                       *clef_utf8;
     unsigned char                       *commande;      unsigned char                       *commande;
     unsigned char                       retour;      unsigned char                       *format_chaine;
   
     unsigned long                       i;      unsigned long                       i;
   
Line 1350  instruction_write(struct_processus *s_et Line 1352  instruction_write(struct_processus *s_et
                     return;                      return;
                 }                  }
   
                 if ((*((*((struct_liste_chainee *) (*s_objet_argument_2).objet))                  l_element_courant = (*s_objet_argument_2).objet;
                         .donnee)).type != CHN)                  l_element_courant_format = (struct_liste_chainee *)
                           (*(*((struct_fichier *) (*s_objet_argument_1).objet))
                           .format).objet;
   
                   while((l_element_courant != NULL) &&
                           (l_element_courant_format != NULL))
                 {                  {
                     liberation(s_etat_processus, s_objet_argument_2);                      if ((*(*l_element_courant).donnee).type != CHN)
                     liberation(s_etat_processus, s_objet_argument_1);                      {
                           liberation(s_etat_processus, s_objet_argument_2);
                           liberation(s_etat_processus, s_objet_argument_1);
   
                     (*s_etat_processus).erreur_execution =                          (*s_etat_processus).erreur_execution =
                             d_ex_erreur_type_argument;                                  d_ex_erreur_type_argument;
                     return;                          return;
                 }                      }
   
                 if ((chaine = formateur_flux(s_etat_processus, (unsigned char *)                      if ((*(*l_element_courant_format).donnee).type != CHN)
                         (*((*((struct_liste_chainee *) (*s_objet_argument_2)                      {
                         .objet)).donnee)).objet, &longueur_effective)) == NULL)                          liberation(s_etat_processus, s_objet_argument_2);
                 {                          liberation(s_etat_processus, s_objet_argument_1);
                     (*s_etat_processus).erreur_systeme =  
                             d_es_allocation_memoire;  
                     return;  
                 }  
   
                 if (fwrite(chaine, sizeof(unsigned char), longueur_effective,                          (*s_etat_processus).erreur_execution =
                         (*descripteur).descripteur_c) !=                                  d_ex_erreur_type_argument;
                         (size_t) longueur_effective)                          return;
                 {                      }
                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;  
                     return;  
                 }  
   
                 free(chaine);                      if ((format_chaine = conversion_majuscule((unsigned char *)
                               (*(*l_element_courant_format).donnee).objet))
                               == NULL)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return;
                       }
   
                       if (strncmp("LENGTH*(", format_chaine, 8) != 0)
                       {
                           free(format_chaine);
   
                           liberation(s_etat_processus, s_objet_argument_2);
                           liberation(s_etat_processus, s_objet_argument_1);
   
                           (*s_etat_processus).erreur_execution =
                                   d_ex_erreur_format_fichier;
                           return;
                       }
   
                       longueur = strlen(format_chaine);
   
                       if (format_chaine[longueur] != ')')
                       {
                           free(format_chaine);
   
                 // Le fichier de type FLOW est à accès séquentiel. Il                          liberation(s_etat_processus, s_objet_argument_2);
                 // convient d'ajouter un retour à la ligne pour l'opération                          liberation(s_etat_processus, s_objet_argument_1);
                 // de lecture.  
                           (*s_etat_processus).erreur_execution =
                                   d_ex_erreur_format_fichier;
                           return;
                       }
   
                       format_chaine[longueur] = d_code_fin_chaine;
   
                       if (format_chaine[8] == '*')
                       {
                           format_degenere = d_vrai;
                       }
                       else
                       {
                           // Détermination de la longueur
                           format_degenere = d_faux;
   
                           if (sscanf(&(format_chaine[8]), "%ld", &longueur) != 1)
                           {
                               free(format_chaine);
   
                               liberation(s_etat_processus, s_objet_argument_2);
                               liberation(s_etat_processus, s_objet_argument_1);
   
                 retour = d_code_retour_chariot;                              (*s_etat_processus).erreur_execution =
                                       d_ex_erreur_format_fichier;
                               return;
                           }
                       }
   
                       free(format_chaine);
   
                 if (fwrite(&retour, sizeof(unsigned char), 1,                      if ((chaine = formateur_flux(s_etat_processus,
                         (*descripteur).descripteur_c) != 1)                              (unsigned char *) (*(*l_element_courant).donnee)
                               .objet, &longueur_effective)) == NULL)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return;
                       }
   
                       if ((format_degenere == d_vrai) ||
                               (longueur_effective < longueur))
                       {
                           if (fwrite(chaine, sizeof(unsigned char),
                                   longueur_effective,
                                   (*descripteur).descripteur_c) !=
                                   (size_t) longueur_effective)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_erreur_fichier;
                               return;
                           }
                       }
                       else
                       {
                           if (fwrite(chaine, sizeof(unsigned char),
                                   longueur_effective,
                                   (*descripteur).descripteur_c) !=
                                   (size_t) longueur)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_erreur_fichier;
                               return;
                           }
                       }
   
                       free(chaine);
   
                       l_element_courant = (*l_element_courant).suivant;
                       l_element_courant_format = (*l_element_courant_format)
                               .suivant;
                   }
   
                   if ((l_element_courant_format != NULL) ||
                           (l_element_courant != NULL))
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;                      liberation(s_etat_processus, s_objet_argument_2);
                       liberation(s_etat_processus, s_objet_argument_1);
   
                       (*s_etat_processus).erreur_execution =
                               d_ex_erreur_format_fichier;
                     return;                      return;
                 }                  }
             }              }
Removed from v.1.63  
changed lines
  Added in v.1.64

CVSweb interface <joel.bertrand@systella.fr>