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

version 1.63, 2012/06/21 16:07:25 version 1.76, 2013/03/11 11:07:25
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.9    RPL/2 (R) version 4.1.13
   Copyright (C) 1989-2012 Dr. BERTRAND Joël    Copyright (C) 1989-2013 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 385  instruction_write(struct_processus *s_et Line 385  instruction_write(struct_processus *s_et
   
     int                                 adresse[16];      int                                 adresse[16];
     int                                 port;      int                                 port;
       int                                 sqlite_status;
   
     integer8                            clef;      integer8                            clef;
     integer8                            compteur;      integer8                            compteur;
     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 422  instruction_write(struct_processus *s_et Line 425  instruction_write(struct_processus *s_et
   
     struct flock                        lock;      struct flock                        lock;
   
       struct timespec                     attente;
   
     uint32_t                            calcul_adresse;      uint32_t                            calcul_adresse;
   
     unsigned char                       *chaine;      unsigned char                       *chaine;
     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 587  instruction_write(struct_processus *s_et Line 592  instruction_write(struct_processus *s_et
                 if ((chaine = formateur_fichier(s_etat_processus,                  if ((chaine = formateur_fichier(s_etat_processus,
                         s_objet_argument_2, (*((struct_fichier *)                          s_objet_argument_2, (*((struct_fichier *)
                         (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'F',                          (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'F',
                         &longueur_effective, &recursivite)) == NULL)                          &longueur_effective, &recursivite, d_vrai)) == NULL)
                 {                  {
                     liberation(s_etat_processus, s_objet_argument_2);                      liberation(s_etat_processus, s_objet_argument_2);
                     liberation(s_etat_processus, s_objet_argument_1);                      liberation(s_etat_processus, s_objet_argument_1);
Line 669  instruction_write(struct_processus *s_et Line 674  instruction_write(struct_processus *s_et
                 if ((chaine = formateur_fichier(s_etat_processus,                  if ((chaine = formateur_fichier(s_etat_processus,
                         s_objet_argument_3, (*((struct_fichier *)                          s_objet_argument_3, (*((struct_fichier *)
                         (*s_objet_argument_1).objet)).format, 0, 0, ' ',                          (*s_objet_argument_1).objet)).format, 0, 0, ' ',
                         'F', &longueur_effective, &recursivite)) == NULL)                          'F', &longueur_effective, &recursivite, d_vrai))
                           == NULL)
                 {                  {
                     liberation(s_etat_processus, s_objet_argument_3);                      liberation(s_etat_processus, s_objet_argument_3);
                     liberation(s_etat_processus, s_objet_argument_2);                      liberation(s_etat_processus, s_objet_argument_2);
Line 758  instruction_write(struct_processus *s_et Line 764  instruction_write(struct_processus *s_et
                     return;                      return;
                 }                  }
   
                 if (sqlite3_step(ppStmt) != SQLITE_ROW)                  attente.tv_sec = 0;
                   attente.tv_nsec = GRANULARITE_us * 1000;
   
                   do
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;                      sqlite_status = sqlite3_step(ppStmt);
                     return;  
                 }                      if (sqlite_status == SQLITE_ROW)
                       {
                           break;
                       }
                       else if ((sqlite_status == SQLITE_BUSY) ||
                               (sqlite_status == SQLITE_LOCKED))
                       {
                           nanosleep(&attente, NULL);
                           INCR_GRANULARITE(attente.tv_nsec);
                       }
                       else
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_erreur_fichier;
                           return;
                       }
                   } while(sqlite_status != SQLITE_ROW);
   
                 if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)                  if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
                 {                  {
Line 873  instruction_write(struct_processus *s_et Line 898  instruction_write(struct_processus *s_et
   
                 if ((chaine = formateur_fichier(s_etat_processus,                  if ((chaine = formateur_fichier(s_etat_processus,
                         s_element, s_format, 0, 0, ' ',                          s_element, s_format, 0, 0, ' ',
                         'F', &longueur_effective, &recursivite)) == NULL)                          'F', &longueur_effective, &recursivite, d_vrai))
                           == NULL)
                 {                  {
                     liberation(s_etat_processus, s_element);                      liberation(s_etat_processus, s_element);
                     liberation(s_etat_processus, s_format);                      liberation(s_etat_processus, s_format);
Line 915  instruction_write(struct_processus *s_et Line 941  instruction_write(struct_processus *s_et
                     return;                      return;
                 }                  }
   
                 switch(sqlite3_step(ppStmt))                  attente.tv_sec = 0;
                   attente.tv_nsec = GRANULARITE_us * 1000;
   
                   do
                 {                  {
                     case SQLITE_ROW:                      switch(sqlite_status = sqlite3_step(ppStmt))
                     {                      {
                         // Une clef existe.                          case SQLITE_ROW:
                           {
                               // Une clef existe.
   
                         mise_a_jour = d_vrai;                              mise_a_jour = d_vrai;
                         break;                              break;
                     }                          }
   
                     case SQLITE_DONE:                          case SQLITE_DONE:
                     {                          {
                         // Aucune clef n'existe.                              // Aucune clef n'existe.
   
                         mise_a_jour = d_faux;                              mise_a_jour = d_faux;
   
                         if (sqlite3_finalize(ppStmt) != SQLITE_OK)                              if (sqlite3_finalize(ppStmt) != SQLITE_OK)
                         {                              {
                             (*s_etat_processus).erreur_systeme =                                  (*s_etat_processus).erreur_systeme =
                                     d_es_erreur_fichier;                                          d_es_erreur_fichier;
                             return;                                  return;
                         }                              }
   
                         free(commande);                              free(commande);
   
                         if (alsprintf(&commande, "insert into key "                              if (alsprintf(&commande, "insert into key "
                                 "(key) values ('%s')", clef_utf8) < 0)                                      "(key) values ('%s')", clef_utf8) < 0)
                         {                              {
                             (*s_etat_processus).erreur_systeme =                                  (*s_etat_processus).erreur_systeme =
                                     d_es_allocation_memoire;                                          d_es_allocation_memoire;
                             return;                                  return;
                         }                              }
   
                         if (sqlite3_prepare_v2((*descripteur)                              if (sqlite3_prepare_v2((*descripteur)
                                 .descripteur_sqlite,                                      .descripteur_sqlite,
                                 commande, strlen(commande), &ppStmt, &queue)                                      commande, strlen(commande), &ppStmt, &queue)
                                 != SQLITE_OK)                                      != SQLITE_OK)
                         {                              {
                             (*s_etat_processus).erreur_systeme =                                  (*s_etat_processus).erreur_systeme =
                                     d_es_erreur_fichier;                                          d_es_erreur_fichier;
                             return;                                  return;
                         }                              }
   
                         if (sqlite3_step(ppStmt) != SQLITE_DONE)                              if (sqlite3_step(ppStmt) != SQLITE_DONE)
                         {                              {
                             (*s_etat_processus).erreur_systeme =                                  (*s_etat_processus).erreur_systeme =
                                     d_es_erreur_fichier;                                          d_es_erreur_fichier;
                             return;                                  return;
                         }                              }
   
                         if (sqlite3_finalize(ppStmt) != SQLITE_OK)                              if (sqlite3_finalize(ppStmt) != SQLITE_OK)
                         {                              {
                             (*s_etat_processus).erreur_systeme =                                  (*s_etat_processus).erreur_systeme =
                                     d_es_erreur_fichier;                                          d_es_erreur_fichier;
                             return;                                  return;
                         }                              }
   
                         free(commande);                              free(commande);
   
                         if (alsprintf(&commande, "select id from key "                              if (alsprintf(&commande, "select id from key "
                                 "where key = '%s'", clef_utf8) < 0)                                      "where key = '%s'", clef_utf8) < 0)
                         {                              {
                             (*s_etat_processus).erreur_systeme =                                  (*s_etat_processus).erreur_systeme =
                                     d_es_allocation_memoire;                                          d_es_allocation_memoire;
                             return;                                  return;
                               }
   
                               if (sqlite3_prepare_v2((*descripteur)
                                       .descripteur_sqlite,
                                       commande, strlen(commande), &ppStmt, &queue)
                                       != SQLITE_OK)
                               {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_erreur_fichier;
                                   return;
                               }
   
                               break;
                         }                          }
   
                         if (sqlite3_prepare_v2((*descripteur)                          case SQLITE_BUSY:
                                 .descripteur_sqlite,                          case SQLITE_LOCKED:
                                 commande, strlen(commande), &ppStmt, &queue)  
                                 != SQLITE_OK)  
                         {                          {
                             (*s_etat_processus).erreur_systeme =                              nanosleep(&attente, NULL);
                                     d_es_erreur_fichier;                              INCR_GRANULARITE(attente.tv_nsec);
                             return;                              break;
                         }                          }
   
                         if (sqlite3_step(ppStmt) != SQLITE_ROW)                          default:
                         {                          {
                             (*s_etat_processus).erreur_systeme =                              (*s_etat_processus).erreur_systeme =
                                     d_es_erreur_fichier;                                      d_es_erreur_fichier;
                             return;                              return;
                         }                          }
   
                         break;  
                     }                      }
                   } while(sqlite_status != SQLITE_ROW);
                     default:  
                     {  
                         (*s_etat_processus).erreur_systeme =  
                                 d_es_erreur_fichier;  
                         return;  
                     }  
                 }  
   
                 if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)                  if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
                 {                  {
Line 1180  instruction_write(struct_processus *s_et Line 1213  instruction_write(struct_processus *s_et
   
                     if ((chaine = formateur_fichier(s_etat_processus,                      if ((chaine = formateur_fichier(s_etat_processus,
                             s_element, s_format, 0, 0, ' ',                              s_element, s_format, 0, 0, ' ',
                             'F', &longueur_effective, &recursivite)) == NULL)                              'F', &longueur_effective, &recursivite, d_vrai))
                               == NULL)
                     {                      {
                         free(clef_utf8);                          free(clef_utf8);
   
Line 1273  instruction_write(struct_processus *s_et Line 1307  instruction_write(struct_processus *s_et
              * Fichiers non formatés               * Fichiers non formatés
              */               */
   
             if ((chaine = formateur_fichier(s_etat_processus,  
                     s_objet_argument_2, (*((struct_fichier *)  
                     (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'U',  
                     &longueur_effective, &recursivite)) == NULL)  
             {  
                 liberation(s_etat_processus, s_objet_argument_2);  
                 liberation(s_etat_processus, s_objet_argument_1);  
   
                 return;  
             }  
   
             if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces              if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
                     == 'S')                      == 'S')
             {              {
                   if ((*s_objet_argument_2).type != LST)
                   {
                       liberation(s_etat_processus, s_objet_argument_2);
                       liberation(s_etat_processus, s_objet_argument_1);
   
                       (*s_etat_processus).erreur_execution =
                               d_ex_erreur_type_argument;
                       return;
                   }
   
                   if ((chaine = formateur_fichier(s_etat_processus,
                           s_objet_argument_2, (*((struct_fichier *)
                           (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'U',
                           &longueur_effective, &recursivite, d_vrai)) == NULL)
                   {
                       liberation(s_etat_processus, s_objet_argument_2);
                       liberation(s_etat_processus, s_objet_argument_1);
   
                       return;
                   }
   
                 BUG(((*descripteur).type != 'C'), uprintf("Bad filetype !\n"));                  BUG(((*descripteur).type != 'C'), uprintf("Bad filetype !\n"));
   
                 if (fseek((*descripteur).descripteur_c, (long) 0, SEEK_END)                  if (fseek((*descripteur).descripteur_c, (long) 0, SEEK_END)
Line 1310  instruction_write(struct_processus *s_et Line 1354  instruction_write(struct_processus *s_et
             else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces              else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
                     == 'D')                      == 'D')
             {              {
                   if ((*s_objet_argument_2).type != INT)
                   {
                       liberation(s_etat_processus, s_objet_argument_2);
                       liberation(s_etat_processus, s_objet_argument_1);
   
                       (*s_etat_processus).erreur_execution =
                               d_ex_erreur_type_argument;
                       return;
                   }
   
                   if (depilement(s_etat_processus, &((*s_etat_processus)
                           .l_base_pile), &s_objet_argument_3) == d_erreur)
                   {
                       (*s_etat_processus).erreur_execution = d_ex_manque_argument;
                       return;
                   }
   
                   if ((*s_objet_argument_3).type != LST)
                   {
                       liberation(s_etat_processus, s_objet_argument_3);
                       liberation(s_etat_processus, s_objet_argument_2);
                       liberation(s_etat_processus, s_objet_argument_1);
   
                       (*s_etat_processus).erreur_execution =
                               d_ex_erreur_type_argument;
                       return;
                   }
   
                   if ((chaine = formateur_fichier(s_etat_processus,
                           s_objet_argument_2, (*((struct_fichier *)
                           (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'U',
                           &longueur_effective, &recursivite, d_faux)) == NULL)
                   {
                       liberation(s_etat_processus, s_objet_argument_2);
                       liberation(s_etat_processus, s_objet_argument_1);
   
                       return;
                   }
             }              }
             else              else // Fichiers indexés
             {              {
                 /* Fichiers indexés : panique totale ! */                  if ((*s_objet_argument_2).type != LST)
                   {
                       liberation(s_etat_processus, s_objet_argument_2);
                       liberation(s_etat_processus, s_objet_argument_1);
   
                       (*s_etat_processus).erreur_execution =
                               d_ex_erreur_type_argument;
                       return;
                   }
   
                   if ((chaine = formateur_fichier(s_etat_processus,
                           s_objet_argument_2, (*((struct_fichier *)
                           (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'U',
                           &longueur_effective, &recursivite, d_faux)) == NULL)
                   {
                       liberation(s_etat_processus, s_objet_argument_2);
                       liberation(s_etat_processus, s_objet_argument_1);
   
                       return;
                   }
             }              }
   
             free(chaine);              free(chaine);
Line 1350  instruction_write(struct_processus *s_et Line 1451  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);
   
                 // Le fichier de type FLOW est à accès séquentiel. Il                      if (format_chaine[longueur - 1] != ')')
                 // convient d'ajouter un retour à la ligne pour l'opération                      {
                 // de lecture.                          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;
                       }
   
                       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);
   
                               (*s_etat_processus).erreur_execution =
                                       d_ex_erreur_format_fichier;
                               return;
                           }
                       }
   
                       free(format_chaine);
   
                       if ((chaine = formateur_flux(s_etat_processus,
                               (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);
   
                 retour = d_code_retour_chariot;                      l_element_courant = (*l_element_courant).suivant;
                       l_element_courant_format = (*l_element_courant_format)
                               .suivant;
                   }
   
                 if (fwrite(&retour, sizeof(unsigned char), 1,                  if ((l_element_courant_format != NULL) ||
                         (*descripteur).descripteur_c) != 1)                          (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;
                 }                  }
             }              }
Line 1430  instruction_write(struct_processus *s_et Line 1630  instruction_write(struct_processus *s_et
             if ((chaine = formateur_fichier(s_etat_processus,              if ((chaine = formateur_fichier(s_etat_processus,
                     s_objet_argument_2, (*((struct_socket *)                      s_objet_argument_2, (*((struct_socket *)
                     (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'F',                      (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'F',
                     &longueur_effective, &recursivite)) == NULL)                      &longueur_effective, &recursivite, d_faux)) == NULL)
             {              {
                 liberation(s_etat_processus, s_objet_argument_2);                  liberation(s_etat_processus, s_objet_argument_2);
                 liberation(s_etat_processus, s_objet_argument_1);                  liberation(s_etat_processus, s_objet_argument_1);
Line 1636  instruction_write(struct_processus *s_et Line 1836  instruction_write(struct_processus *s_et
                         return;                          return;
                     }                      }
   
                       if (ios == EMSGSIZE)
                       {
                           (*s_etat_processus).erreur_execution =
                                   d_ex_taille_message;
                           return;
                       }
   
                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;                      (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                     return;                      return;
Line 1688  instruction_write(struct_processus *s_et Line 1894  instruction_write(struct_processus *s_et
                             longueur_effective, 0, (struct sockaddr *)                              longueur_effective, 0, (struct sockaddr *)
                             &adresse_ipv4, sizeof(adresse_ipv4)) < 0)                              &adresse_ipv4, sizeof(adresse_ipv4)) < 0)
                     {                      {
                           ios = errno;
   
 #                       ifndef SEMAPHORES_NOMMES  #                       ifndef SEMAPHORES_NOMMES
                             while(sem_wait(&((*s_etat_processus)                              while(sem_wait(&((*s_etat_processus)
                                     .semaphore_fork)) != 0)                                      .semaphore_fork)) != 0)
Line 1704  instruction_write(struct_processus *s_et Line 1912  instruction_write(struct_processus *s_et
                             }                              }
                         }                          }
   
                           if ((ios == EPIPE) || (ios == ECONNRESET))
                           {
                               (*s_etat_processus).erreur_execution =
                                       d_ex_erreur_acces_fichier;
                               return;
                           }
   
                           if (ios == EMSGSIZE)
                           {
                               (*s_etat_processus).erreur_execution =
                                       d_ex_taille_message;
                               return;
                           }
   
                         (*s_etat_processus).erreur_systeme =                          (*s_etat_processus).erreur_systeme =
                                 d_es_erreur_fichier;                                  d_es_erreur_fichier;
                         return;                          return;
Line 1771  instruction_write(struct_processus *s_et Line 1993  instruction_write(struct_processus *s_et
                             longueur_effective, 0, (struct sockaddr *)                              longueur_effective, 0, (struct sockaddr *)
                             &adresse_ipv6, sizeof(adresse_ipv6)) < 0)                              &adresse_ipv6, sizeof(adresse_ipv6)) < 0)
                     {                      {
                           ios = errno;
   
 #                       ifndef SEMAPHORES_NOMMES  #                       ifndef SEMAPHORES_NOMMES
                             while(sem_wait(&((*s_etat_processus)                              while(sem_wait(&((*s_etat_processus)
                                     .semaphore_fork)) != 0)                                      .semaphore_fork)) != 0)
Line 1787  instruction_write(struct_processus *s_et Line 2011  instruction_write(struct_processus *s_et
                             }                              }
                         }                          }
   
                           if ((ios == EPIPE) || (ios == ECONNRESET))
                           {
                               (*s_etat_processus).erreur_execution =
                                       d_ex_erreur_acces_fichier;
                               return;
                           }
   
                           if (ios == EMSGSIZE)
                           {
                               (*s_etat_processus).erreur_execution =
                                       d_ex_taille_message;
                               return;
                           }
   
                         (*s_etat_processus).erreur_systeme =                          (*s_etat_processus).erreur_systeme =
                                 d_es_erreur_fichier;                                  d_es_erreur_fichier;
                         return;                          return;
Removed from v.1.63  
changed lines
  Added in v.1.76

CVSweb interface <joel.bertrand@systella.fr>