[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.7 and 1.15

version 1.7, 2010/03/08 08:34:15 version 1.15, 2010/06/09 12:19:13
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.12    RPL/2 (R) version 4.0.16
   Copyright (C) 1989-2010 Dr. BERTRAND Joël    Copyright (C) 1989-2010 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
Line 262  instruction_wait(struct_processus *s_eta Line 262  instruction_wait(struct_processus *s_eta
   
         do          do
         {          {
   #           ifndef SEMAPHORES_NOMMES
             if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)              if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return;                  return;
             }              }
   #           else
               if (sem_post((*s_etat_processus).semaphore_fork) != 0)
               {
                   (*s_etat_processus).erreur_systeme = d_es_processus;
                   return;
               }
   #           endif
   
             code_retour = nanosleep(&temporisation, &temporisation);              code_retour = nanosleep(&temporisation, &temporisation);
             erreur = errno;              erreur = errno;
   
   #           ifndef SEMAPHORES_NOMMES
             while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)              while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
   #           else
               while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
   #           endif
             {              {
                 if (errno != EINTR)                  if (errno != EINTR)
                 {                  {
Line 379  instruction_write(struct_processus *s_et Line 391  instruction_write(struct_processus *s_et
     int                                 adresse[16];      int                                 adresse[16];
     int                                 port;      int                                 port;
   
       integer8                            clef;
       integer8                            compteur;
       integer8                            id;
       integer8                            ordre;
   
       logical1                            mise_a_jour;
   
     long                                longueur_effective;      long                                longueur_effective;
     long                                recursivite;      long                                recursivite;
   
Line 388  instruction_write(struct_processus *s_et Line 407  instruction_write(struct_processus *s_et
   
     struct_descripteur_fichier          *descripteur;      struct_descripteur_fichier          *descripteur;
   
       struct_liste_chainee                *l_element_courant;
       struct_liste_chainee                *l_element_courant_format;
   
       struct_objet                        *s_format;
       struct_objet                        *s_element;
     struct_objet                        *s_objet_argument_1;      struct_objet                        *s_objet_argument_1;
     struct_objet                        *s_objet_argument_2;      struct_objet                        *s_objet_argument_2;
     struct_objet                        *s_objet_argument_3;      struct_objet                        *s_objet_argument_3;
Line 405  instruction_write(struct_processus *s_et Line 429  instruction_write(struct_processus *s_et
   
     unsigned char                       *chaine;      unsigned char                       *chaine;
     unsigned char                       *chaine_utf8;      unsigned char                       *chaine_utf8;
       unsigned char                       *clef_utf8;
     unsigned char                       *commande;      unsigned char                       *commande;
   
     unsigned long                       i;      unsigned long                       i;
Line 428  instruction_write(struct_processus *s_et Line 453  instruction_write(struct_processus *s_et
         printf("    1: %s, %s\n\n", d_FCH, d_SCK);          printf("    1: %s, %s\n\n", d_FCH, d_SCK);
   
         printf("    3: %s\n", d_LST);          printf("    3: %s\n", d_LST);
         printf("    2: %s, %s\n", d_INT, d_CHN);          printf("    2: %s\n", d_INT);
         printf("    1: %s\n", d_FCH);          printf("    1: %s\n", d_FCH);
         return;          return;
     }      }
Line 449  instruction_write(struct_processus *s_et Line 474  instruction_write(struct_processus *s_et
         if ((*(*(*s_etat_processus).l_base_pile).donnee).type == FCH)          if ((*(*(*s_etat_processus).l_base_pile).donnee).type == FCH)
         {          {
             if ((*((struct_fichier *) (*(*(*s_etat_processus).l_base_pile)              if ((*((struct_fichier *) (*(*(*s_etat_processus).l_base_pile)
                     .donnee).objet)).acces == 'S')                      .donnee).objet)).acces == 'D')
             {              {
                 if (empilement_pile_last(s_etat_processus, 2) == d_erreur)                  if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
                 {                  {
                     return;                      return;
                 }                  }
             }              }
             else              else
             {              {
                 if (empilement_pile_last(s_etat_processus, 3) == d_erreur)                  if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
                 {                  {
                     return;                      return;
                 }                  }
Line 641  instruction_write(struct_processus *s_et Line 666  instruction_write(struct_processus *s_et
                     return;                      return;
                 }                  }
   
                 if ((*s_objet_argument_3).objet == NULL)                  // Modification ou création d'un nouvel enregistrement
   
                   if ((chaine = formateur_fichier(s_etat_processus,
                           s_objet_argument_3, (*((struct_fichier *)
                           (*s_objet_argument_1).objet)).format, 0, 0, ' ',
                           'F', &longueur_effective, &recursivite)) == NULL)
                 {                  {
                     // Effacement d'un enregistrement                      liberation(s_etat_processus, s_objet_argument_3);
                       liberation(s_etat_processus, s_objet_argument_2);
                       liberation(s_etat_processus, s_objet_argument_1);
   
                     if (alsprintf(&commande, "delete from data where "                      return;
                             "id = %lld", (*((integer8 *)                  }
                             (*s_objet_argument_2).objet))) < 0)  
                     {  
                         liberation(s_etat_processus, s_objet_argument_3);  
                         liberation(s_etat_processus, s_objet_argument_2);  
                         liberation(s_etat_processus, s_objet_argument_1);  
   
                         return;                  if ((chaine_utf8 = transliteration(s_etat_processus,
                           chaine, d_locale, "UTF-8")) == NULL)
                   {
                       free(chaine);
   
                       liberation(s_etat_processus, s_objet_argument_3);
                       liberation(s_etat_processus, s_objet_argument_2);
                       liberation(s_etat_processus, s_objet_argument_1);
   
                       return;
                   }
   
                   free(chaine);
   
                   if (alsprintf(&commande, "insert or replace into data "
                           "(id, data) values (%lld, '%s')", (*((integer8 *)
                           (*s_objet_argument_2).objet)), chaine_utf8) < 0)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   free(chaine_utf8);
   
                   if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
                           commande, strlen(commande), &ppStmt, &queue)
                           != SQLITE_OK)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   if (sqlite3_step(ppStmt) != SQLITE_DONE)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   if (sqlite3_finalize(ppStmt) != SQLITE_OK)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   liberation(s_etat_processus, s_objet_argument_3);
                   free(commande);
               }
               else // Fichiers indexés
               {
                   BUG(((*descripteur).type != 'S'), uprintf("Bad filetype !\n"));
   
                   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;
                   }
   
                   // Récupération de la position de la clef
   
                   if (alsprintf(&commande, "select key from control "
                           "where id = 1") < 0)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       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;
                   }
   
                   if (sqlite3_step(ppStmt) != SQLITE_ROW)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   clef = sqlite3_column_int64(ppStmt, 0);
   
                   if (sqlite3_step(ppStmt) != SQLITE_DONE)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   if (sqlite3_finalize(ppStmt) != SQLITE_OK)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   free(commande);
   
                   l_element_courant = (struct_liste_chainee *)
                           (*s_objet_argument_2).objet;
                   l_element_courant_format = (struct_liste_chainee *)
                           (*(*((struct_fichier *) (*s_objet_argument_1).objet))
                           .format).objet;
                   compteur = 1;
   
                   while((l_element_courant != NULL) &&
                           (l_element_courant_format != NULL))
                   {
                       if (compteur == clef)
                       {
                           break;
                     }                      }
   
                       l_element_courant = (*l_element_courant).suivant;
                       l_element_courant_format = (*l_element_courant_format)
                               .suivant;
                       compteur++;
                 }                  }
                 else  
                   if ((l_element_courant == NULL) ||
                           (l_element_courant_format == NULL))
                 {                  {
                     // Modification ou création d'un nouvel enregistrement                      (*s_etat_processus).erreur_execution =
                               d_ex_clef_inexistante;
                           
                       liberation(s_etat_processus, s_objet_argument_2);
                       liberation(s_etat_processus, s_objet_argument_1);
   
                     if ((chaine = formateur_fichier(s_etat_processus,                      return;
                             s_objet_argument_3, (*((struct_fichier *)                  }
                             (*s_objet_argument_1).objet)).format, 0, 0, ' ',  
                             'F', &longueur_effective, &recursivite)) == NULL)                  if ((s_element = allocation(s_etat_processus, LST)) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   if (((*s_element).objet = allocation_maillon(s_etat_processus))
                           == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   (*((struct_liste_chainee *) (*s_element).objet)).suivant = NULL;
   
                   if (((*((struct_liste_chainee *) (*s_element).objet))
                           .donnee = copie_objet(s_etat_processus,
                           (*l_element_courant).donnee, 'N')) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   if ((s_format = allocation(s_etat_processus, LST)) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   if (((*s_format).objet = allocation_maillon(s_etat_processus))
                           == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   (*((struct_liste_chainee *) (*s_format).objet)).suivant = NULL;
   
                   if (((*((struct_liste_chainee *) (*s_format).objet))
                           .donnee = copie_objet(s_etat_processus,
                           (*l_element_courant_format).donnee, 'N')) == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   if ((chaine = formateur_fichier(s_etat_processus,
                           s_element, s_format, 0, 0, ' ',
                           'F', &longueur_effective, &recursivite)) == NULL)
                   {
                       liberation(s_etat_processus, s_element);
                       liberation(s_etat_processus, s_format);
                       liberation(s_etat_processus, s_objet_argument_2);
                       liberation(s_etat_processus, s_objet_argument_1);
   
                       return;
                   }
   
                   liberation(s_etat_processus, s_element);
                   liberation(s_etat_processus, s_format);
   
                   if ((clef_utf8 = transliteration(s_etat_processus,
                           chaine, d_locale, "UTF-8")) == NULL)
                   {
                       liberation(s_etat_processus, s_objet_argument_2);
                       liberation(s_etat_processus, s_objet_argument_1);
   
                       return;
                   }
   
                   free(chaine);
   
                   // Récupération de l'identifiant de la clef
   
                   if (alsprintf(&commande, "select id from key where key = "
                           "'%s'", clef_utf8) < 0)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       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;
                   }
   
                   switch(sqlite3_step(ppStmt))
                   {
                       case SQLITE_ROW:
                     {                      {
                         liberation(s_etat_processus, s_objet_argument_3);                          // Une clef existe.
                         liberation(s_etat_processus, s_objet_argument_2);  
                         liberation(s_etat_processus, s_objet_argument_1);  
   
                         return;                          mise_a_jour = d_vrai;
                           break;
                     }                      }
   
                     if ((chaine_utf8 = transliteration(s_etat_processus,                      case SQLITE_DONE:
                             chaine, d_locale, "UTF-8")) == NULL)  
                     {                      {
                         free(chaine);                          // Aucune clef n'existe.
   
                         liberation(s_etat_processus, s_objet_argument_3);                          mise_a_jour = d_faux;
                         liberation(s_etat_processus, s_objet_argument_2);  
                         liberation(s_etat_processus, s_objet_argument_1);                          if (sqlite3_finalize(ppStmt) != SQLITE_OK)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_erreur_fichier;
                               return;
                           }
   
                           free(commande);
   
                           if (alsprintf(&commande, "insert into key "
                                   "(key) values ('%s')", clef_utf8) < 0)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_allocation_memoire;
                               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;
                           }
   
                           if (sqlite3_step(ppStmt) != SQLITE_DONE)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_erreur_fichier;
                               return;
                           }
   
                           if (sqlite3_finalize(ppStmt) != SQLITE_OK)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_erreur_fichier;
                               return;
                           }
   
                           free(commande);
   
                           if (alsprintf(&commande, "select id from key "
                                   "where key = '%s'", clef_utf8) < 0)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_allocation_memoire;
                               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;
                           }
   
                           if (sqlite3_step(ppStmt) != SQLITE_ROW)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_erreur_fichier;
                               return;
                           }
   
                           break;
                       }
   
                       default:
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_erreur_fichier;
                         return;                          return;
                     }                      }
                   }
   
                     free(chaine);                  if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   id = sqlite3_column_int64(ppStmt, 0);
   
                   if (sqlite3_step(ppStmt) != SQLITE_DONE)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                     if (alsprintf(&commande, "insert or replace into data "                  if (sqlite3_finalize(ppStmt) != SQLITE_OK)
                             "(id, data) values (%lld, '%s')", (*((integer8 *)                  {
                             (*s_objet_argument_2).objet)), chaine_utf8) < 0)                      (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   free(commande);
   
                   // Modification de la clef
   
                   if (mise_a_jour == d_vrai)
                   {
                       if (alsprintf(&commande, "update key set key = '%s' where "
                               "id = %lld", clef_utf8, id) < 0)
                     {                      {
                         free(chaine_utf8);                          (*s_etat_processus).erreur_systeme =
                         liberation(s_etat_processus, s_objet_argument_3);                                  d_es_allocation_memoire;
                         liberation(s_etat_processus, s_objet_argument_2);                          return;
                         liberation(s_etat_processus, s_objet_argument_1);                      }
   
                       if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
                               commande, strlen(commande), &ppStmt, &queue)
                               != SQLITE_OK)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_erreur_fichier;
                         return;                          return;
                     }                      }
   
                     free(chaine_utf8);                      if (sqlite3_step(ppStmt) != SQLITE_DONE)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_erreur_fichier;
                           return;
                       }
   
                       if (sqlite3_finalize(ppStmt) != SQLITE_OK)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_erreur_fichier;
                           return;
                       }
   
                       free(commande);
                   }
   
                   // Effacement de l'enregistrement existant
   
                   if (alsprintf(&commande, "delete from data where "
                           "key_id = %lld", id) < 0)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                 }                  }
   
                 if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,                  if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
Line 721  instruction_write(struct_processus *s_et Line 1102  instruction_write(struct_processus *s_et
                     return;                      return;
                 }                  }
   
                 liberation(s_etat_processus, s_objet_argument_3);  
                 free(commande);                  free(commande);
             }  
             else                  // Modification ou création d'un nouvel enregistrement
             {  
                 /* Fichiers indexés : panique totale ! */                  l_element_courant = (struct_liste_chainee *)
                           (*s_objet_argument_2).objet;
                   l_element_courant_format = (struct_liste_chainee *)
                           (*(*((struct_fichier *) (*s_objet_argument_1).objet))
                           .format).objet;
                   compteur = 1;
                   ordre = 1;
   
                   while((l_element_courant != NULL) &&
                           (l_element_courant_format != NULL))
                   {
                       if (compteur == clef)
                       {
                           l_element_courant = (*l_element_courant).suivant;
                           l_element_courant_format = (*l_element_courant_format)
                                   .suivant;
                           compteur++;
                           continue;
                       }
   
                       if ((s_element = allocation(s_etat_processus, LST)) == NULL)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return;
                       }
   
                       if (((*s_element).objet =
                               allocation_maillon(s_etat_processus)) == NULL)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return;
                       }
   
                       (*((struct_liste_chainee *) (*s_element).objet)).suivant
                               = NULL;
   
                       if ((s_format = allocation(s_etat_processus, LST)) == NULL)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return;
                       }
   
                       if (((*s_format).objet =
                               allocation_maillon(s_etat_processus)) == NULL)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return;
                       }
   
                       (*((struct_liste_chainee *) (*s_format).objet)).suivant
                               = NULL;
   
                       if (((*((struct_liste_chainee *) (*s_element).objet))
                               .donnee = copie_objet(s_etat_processus,
                               (*l_element_courant).donnee, 'N')) == NULL)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return;
                       }
   
                       if (((*((struct_liste_chainee *) (*s_format).objet))
                               .donnee = copie_objet(s_etat_processus,
                               (*l_element_courant_format).donnee, 'N')) == NULL)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return;
                       }
   
                       if ((chaine = formateur_fichier(s_etat_processus,
                               s_element, s_format, 0, 0, ' ',
                               'F', &longueur_effective, &recursivite)) == NULL)
                       {
                           free(clef_utf8);
   
                           liberation(s_etat_processus, s_element);
                           liberation(s_etat_processus, s_format);
                           liberation(s_etat_processus, s_objet_argument_2);
                           liberation(s_etat_processus, s_objet_argument_1);
   
                           return;
                       }
   
                       if ((chaine_utf8 = transliteration(s_etat_processus,
                               chaine, d_locale, "UTF-8")) == NULL)
                       {
                           free(clef_utf8);
                           free(chaine);
   
                           liberation(s_etat_processus, s_objet_argument_2);
                           liberation(s_etat_processus, s_objet_argument_1);
   
                           return;
                       }
   
                       free(chaine);
   
                       if (alsprintf(&commande, "insert into data "
                               "(data, key_id, sequence) values "
                               "('%s', %lld, %lld)", chaine_utf8, id, ordre) < 0)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           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;
                       }
   
                       if (sqlite3_step(ppStmt) != SQLITE_DONE)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_erreur_fichier;
                           return;
                       }
   
                       if (sqlite3_finalize(ppStmt) != SQLITE_OK)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_erreur_fichier;
                           return;
                       }
   
                       free(commande);
                       free(chaine_utf8);
   
                       liberation(s_etat_processus, s_element);
                       liberation(s_etat_processus, s_format);
   
                       l_element_courant = (*l_element_courant).suivant;
                       l_element_courant_format = (*l_element_courant_format)
                               .suivant;
   
                       compteur++;
                       ordre++;
                   }
   
                   free(clef_utf8);
   
                   if ((l_element_courant != NULL) ||
                           (l_element_courant_format != NULL))
                   {
                       liberation(s_etat_processus, s_objet_argument_1);
                       liberation(s_etat_processus, s_objet_argument_2);
   
                       (*s_etat_processus).erreur_execution =
                               d_ex_erreur_format_fichier;
                       return;
                   }
             }              }
         }          }
         else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire          else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire
Line 837  instruction_write(struct_processus *s_et Line 1376  instruction_write(struct_processus *s_et
                     return;                      return;
                 }                  }
   
                 if (sem_post(&((*s_etat_processus).semaphore_fork))  #               ifndef SEMAPHORES_NOMMES
                         != 0)                  if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
   #               else
                   if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #               endif
                 {                  {
                     if (sigaction(SIGPIPE, &registre, NULL) != 0)                      if (sigaction(SIGPIPE, &registre, NULL) != 0)
                     {                      {
Line 861  instruction_write(struct_processus *s_et Line 1403  instruction_write(struct_processus *s_et
                         return;                          return;
                     }                      }
   
   #                   ifndef SEMAPHORES_NOMMES
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                      while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
   #                   else
                       while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
   #                   endif
                     {                      {
                         if (errno != EINTR)                          if (errno != EINTR)
                         {                          {
Line 881  instruction_write(struct_processus *s_et Line 1427  instruction_write(struct_processus *s_et
                     return;                      return;
                 }                  }
   
   #               ifndef SEMAPHORES_NOMMES
                 while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                  while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
   #               else
                   while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
   #               endif
                 {                  {
                     if (errno != EINTR)                      if (errno != EINTR)
                     {                      {
Line 933  instruction_write(struct_processus *s_et Line 1483  instruction_write(struct_processus *s_et
                             108);                              108);
                     adresse_unix.sun_path[108 - 1] = d_code_fin_chaine;                      adresse_unix.sun_path[108 - 1] = d_code_fin_chaine;
   
   #                   ifndef SEMAPHORES_NOMMES
                     if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)                      if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
                     {                      {
                         (*s_etat_processus).erreur_systeme = d_es_processus;                          (*s_etat_processus).erreur_systeme = d_es_processus;
                         return;                          return;
                     }                      }
   #                   else
                       if (sem_post((*s_etat_processus).semaphore_fork) != 0)
                       {
                           (*s_etat_processus).erreur_systeme = d_es_processus;
                           return;
                       }
   #                   endif
   
                     if (sendto((*((struct_socket *)                      if (sendto((*((struct_socket *)
                             (*s_objet_argument_1).objet)).socket, chaine,                              (*s_objet_argument_1).objet)).socket, chaine,
                             strlen(chaine), 0, (struct sockaddr *)                              strlen(chaine), 0, (struct sockaddr *)
                             &adresse_unix, sizeof(adresse_unix)) < 0)                              &adresse_unix, sizeof(adresse_unix)) < 0)
                     {                      {
   #                       ifndef SEMAPHORES_NOMMES
                         while(sem_wait(&((*s_etat_processus)                          while(sem_wait(&((*s_etat_processus)
                                 .semaphore_fork)) == -1)                                  .semaphore_fork)) == -1)
   #                       else
                           while(sem_wait((*s_etat_processus)
                                   .semaphore_fork) == -1)
   #                       endif
                         {                          {
                             if (errno != EINTR)                              if (errno != EINTR)
                             {                              {
Line 960  instruction_write(struct_processus *s_et Line 1523  instruction_write(struct_processus *s_et
                         return;                          return;
                     }                      }
   
   #                   ifndef SEMAPHORES_NOMMES
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                      while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
   #                   else
                       while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
   #                   endif
                     {                      {
                         if (errno != EINTR)                          if (errno != EINTR)
                         {                          {
Line 987  instruction_write(struct_processus *s_et Line 1554  instruction_write(struct_processus *s_et
                         adresse_ipv4.sin_port = htons(port);                          adresse_ipv4.sin_port = htons(port);
                         adresse_ipv4.sin_addr.s_addr = htonl(calcul_adresse);                          adresse_ipv4.sin_addr.s_addr = htonl(calcul_adresse);
   
   #                       ifndef SEMAPHORES_NOMMES
                         if (sem_post(&((*s_etat_processus)                          if (sem_post(&((*s_etat_processus)
                                 .semaphore_fork)) != 0)                                  .semaphore_fork)) != 0)
                         {                          {
                             (*s_etat_processus).erreur_systeme = d_es_processus;                              (*s_etat_processus).erreur_systeme = d_es_processus;
                             return;                              return;
                         }                          }
   #                       else
                           if (sem_post((*s_etat_processus) .semaphore_fork) != 0)
                           {
                               (*s_etat_processus).erreur_systeme = d_es_processus;
                               return;
                           }
   #                       endif
   
                         if (sendto((*((struct_socket *)                          if (sendto((*((struct_socket *)
                                 (*s_objet_argument_1).objet)).socket, chaine,                                  (*s_objet_argument_1).objet)).socket, chaine,
                                 strlen(chaine), 0, (struct sockaddr *)                                  strlen(chaine), 0, (struct sockaddr *)
                                 &adresse_ipv4, sizeof(adresse_ipv4)) < 0)                                  &adresse_ipv4, sizeof(adresse_ipv4)) < 0)
                         {                          {
   #                           ifndef SEMAPHORES_NOMMES
                             while(sem_wait(&((*s_etat_processus)                              while(sem_wait(&((*s_etat_processus)
                                     .semaphore_fork)) == -1)                                      .semaphore_fork)) == -1)
   #                           else
                               while(sem_wait((*s_etat_processus)
                                       .semaphore_fork) == -1)
   #                           endif
                             {                              {
                                 if (errno != EINTR)                                  if (errno != EINTR)
                                 {                                  {
Line 1015  instruction_write(struct_processus *s_et Line 1595  instruction_write(struct_processus *s_et
                             return;                              return;
                         }                          }
   
   #                       ifndef SEMAPHORES_NOMMES
                         while(sem_wait(&((*s_etat_processus)                          while(sem_wait(&((*s_etat_processus)
                                 .semaphore_fork)) == -1)                                  .semaphore_fork)) == -1)
   #                       else
                           while(sem_wait((*s_etat_processus)
                                   .semaphore_fork) == -1)
   #                       endif
                         {                          {
                             if (errno != EINTR)                              if (errno != EINTR)
                             {                              {
Line 1057  instruction_write(struct_processus *s_et Line 1642  instruction_write(struct_processus *s_et
                                 adresse_ipv6.sin6_addr.s6_addr[i] =                                  adresse_ipv6.sin6_addr.s6_addr[i] =
                                 adresse[i], i++);                                  adresse[i], i++);
   
   #                       ifndef SEMAPHORES_NOMMES
                         if (sem_post(&((*s_etat_processus)                          if (sem_post(&((*s_etat_processus)
                                 .semaphore_fork)) != 0)                                  .semaphore_fork)) != 0)
                         {                          {
                             (*s_etat_processus).erreur_systeme = d_es_processus;                              (*s_etat_processus).erreur_systeme = d_es_processus;
                             return;                              return;
                         }                          }
   #                       else
                           if (sem_post((*s_etat_processus) .semaphore_fork) != 0)
                           {
                               (*s_etat_processus).erreur_systeme = d_es_processus;
                               return;
                           }
   #                       endif
   
                         if (sendto((*((struct_socket *)                          if (sendto((*((struct_socket *)
                                 (*s_objet_argument_1).objet)).socket, chaine,                                  (*s_objet_argument_1).objet)).socket, chaine,
                                 strlen(chaine), 0, (struct sockaddr *)                                  strlen(chaine), 0, (struct sockaddr *)
                                 &adresse_ipv6, sizeof(adresse_ipv6)) < 0)                                  &adresse_ipv6, sizeof(adresse_ipv6)) < 0)
                         {                          {
   #                           ifndef SEMAPHORES_NOMMES
                             while(sem_wait(&((*s_etat_processus)                              while(sem_wait(&((*s_etat_processus)
                                     .semaphore_fork)) == -1)                                      .semaphore_fork)) == -1)
   #                           else
                               while(sem_wait((*s_etat_processus)
                                       .semaphore_fork) == -1)
   #                           endif
                             {                              {
                                 if (errno != EINTR)                                  if (errno != EINTR)
                                 {                                  {
Line 1085  instruction_write(struct_processus *s_et Line 1683  instruction_write(struct_processus *s_et
                             return;                              return;
                         }                          }
   
   #                       ifndef SEMAPHORES_NOMMES
                         while(sem_wait(&((*s_etat_processus)                          while(sem_wait(&((*s_etat_processus)
                                 .semaphore_fork)) == -1)                                  .semaphore_fork)) == -1)
   #                       else
                           while(sem_wait((*s_etat_processus)
                                   .semaphore_fork) == -1)
   #                       endif
                         {                          {
                             if (errno != EINTR)                              if (errno != EINTR)
                             {                              {
Line 1292  instruction_wflock(struct_processus *s_e Line 1895  instruction_wflock(struct_processus *s_e
                 return;                  return;
             }              }
   
   #           ifndef SEMAPHORES_NOMMES
             if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)              if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return;                  return;
             }              }
   #           else
               if (sem_post((*s_etat_processus).semaphore_fork) != 0)
               {
                   (*s_etat_processus).erreur_systeme = d_es_processus;
                   return;
               }
   #           endif
   
   #           ifndef SEMAPHORES_NOMMES
             while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)              while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
   #           else
               while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
   #           endif
             {              {
                 if (errno != EINTR)                  if (errno != EINTR)
                 {                  {
Line 1607  instruction_wfproc(struct_processus *s_e Line 2222  instruction_wfproc(struct_processus *s_e
                                 registre_instruction_valide;                                  registre_instruction_valide;
                     }                      }
   
   #                   ifndef SEMAPHORES_NOMMES
                     if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)                      if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
                     {                      {
                         (*s_etat_processus).erreur_systeme = d_es_processus;                          (*s_etat_processus).erreur_systeme = d_es_processus;
                         return;                          return;
                     }                      }
   #                   else
                       if (sem_post((*s_etat_processus).semaphore_fork) != 0)
                       {
                           (*s_etat_processus).erreur_systeme = d_es_processus;
                           return;
                       }
   #                   endif
   
                     nanosleep(&attente, NULL);                      nanosleep(&attente, NULL);
   
   #                   ifndef SEMAPHORES_NOMMES
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                      while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
   #                   else
                       while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
   #                   endif
                     {                      {
                         if (errno != EINTR)                          if (errno != EINTR)
                         {                          {
Line 1866  instruction_wfdata(struct_processus *s_e Line 2493  instruction_wfdata(struct_processus *s_e
                         return;                          return;
                     }                      }
   
   #                   ifndef SEMAPHORES_NOMMES
                     if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)                      if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
                     {                      {
                         (*s_etat_processus).erreur_systeme = d_es_processus;                          (*s_etat_processus).erreur_systeme = d_es_processus;
                         return;                          return;
                     }                      }
   #                   else
                       if (sem_post((*s_etat_processus).semaphore_fork) != 0)
                       {
                           (*s_etat_processus).erreur_systeme = d_es_processus;
                           return;
                       }
   #                   endif
   
                     nanosleep(&attente, NULL);                      nanosleep(&attente, NULL);
   
   #                   ifndef SEMAPHORES_NOMMES
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                      while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
   #                   else
                       while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
   #                   endif
                     {                      {
                         if (errno != EINTR)                          if (errno != EINTR)
                         {                          {
Line 2058  instruction_wfsock(struct_processus *s_e Line 2697  instruction_wfsock(struct_processus *s_e
             {              {
                 drapeau = d_vrai;                  drapeau = d_vrai;
   
   #               ifndef SEMAPHORES_NOMMES
                 if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)                  if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_processus;                      (*s_etat_processus).erreur_systeme = d_es_processus;
                     return;                      return;
                 }                  }
   #               else
                   if (sem_post((*s_etat_processus).semaphore_fork) != 0)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_processus;
                       return;
                   }
   #               endif
   
                 if (((*((struct_socket *) (*s_objet_resultat).objet)).socket =                  if (((*((struct_socket *) (*s_objet_resultat).objet)).socket =
                         accept((*((struct_socket *) (*s_objet_argument).objet))                          accept((*((struct_socket *) (*s_objet_argument).objet))
Line 2071  instruction_wfsock(struct_processus *s_e Line 2718  instruction_wfsock(struct_processus *s_e
                 {                  {
                     erreur = errno;                      erreur = errno;
   
   #                   ifndef SEMAPHORES_NOMMES
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                      while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
   #                   else
                       while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
   #                   endif
                     {                      {
                         if (errno != EINTR)                          if (errno != EINTR)
                         {                          {
Line 2103  instruction_wfsock(struct_processus *s_e Line 2754  instruction_wfsock(struct_processus *s_e
                 }                  }
                 else                  else
                 {                  {
   #                   ifndef SEMAPHORES_NOMMES
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                      while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
   #                   else
                       while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
   #                   endif
                     {                      {
                         if (errno != EINTR)                          if (errno != EINTR)
                         {                          {
Line 2140  instruction_wfsock(struct_processus *s_e Line 2795  instruction_wfsock(struct_processus *s_e
             {              {
                 drapeau = d_vrai;                  drapeau = d_vrai;
   
   #               ifndef SEMAPHORES_NOMMES
                 if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)                  if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_processus;                      (*s_etat_processus).erreur_systeme = d_es_processus;
                     return;                      return;
                 }                  }
   #               else
                   if (sem_post((*s_etat_processus).semaphore_fork) != 0)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_processus;
                       return;
                   }
   #               endif
   
                 if (((*((struct_socket *) (*s_objet_resultat).objet)).socket =                  if (((*((struct_socket *) (*s_objet_resultat).objet)).socket =
                         accept((*((struct_socket *) (*s_objet_argument).objet))                          accept((*((struct_socket *) (*s_objet_argument).objet))
Line 2153  instruction_wfsock(struct_processus *s_e Line 2816  instruction_wfsock(struct_processus *s_e
                 {                  {
                     erreur = errno;                      erreur = errno;
   
   #                   ifndef SEMAPHORES_NOMMES
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                      while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
   #                   else
                       while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
   #                   endif
                     {                      {
                         if (errno != EINTR)                          if (errno != EINTR)
                         {                          {
Line 2185  instruction_wfsock(struct_processus *s_e Line 2852  instruction_wfsock(struct_processus *s_e
                 }                  }
                 else                  else
                 {                  {
   #                   ifndef SEMAPHORES_NOMMES
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                      while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
   #                   else
                       while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
   #                   endif
                     {                      {
                         if (errno != EINTR)                          if (errno != EINTR)
                         {                          {
Line 2230  instruction_wfsock(struct_processus *s_e Line 2901  instruction_wfsock(struct_processus *s_e
             {              {
                 drapeau = d_vrai;                  drapeau = d_vrai;
   
   #               ifndef SEMAPHORES_NOMMES
                 if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)                  if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_processus;                      (*s_etat_processus).erreur_systeme = d_es_processus;
                     return;                      return;
                 }                  }
   #               else
                   if (sem_post((*s_etat_processus).semaphore_fork) != 0)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_processus;
                       return;
                   }
   #               endif
   
                 if (((*((struct_socket *) (*s_objet_resultat).objet)).socket =                  if (((*((struct_socket *) (*s_objet_resultat).objet)).socket =
                         accept((*((struct_socket *) (*s_objet_argument).objet))                          accept((*((struct_socket *) (*s_objet_argument).objet))
Line 2242  instruction_wfsock(struct_processus *s_e Line 2921  instruction_wfsock(struct_processus *s_e
                 {                  {
                     erreur = errno;                      erreur = errno;
   
   #                   ifndef SEMAPHORES_NOMMES
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                      while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
   #                   else
                       while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
   #                   endif
                     {                      {
                         if (errno != EINTR)                          if (errno != EINTR)
                         {                          {
Line 2274  instruction_wfsock(struct_processus *s_e Line 2957  instruction_wfsock(struct_processus *s_e
                 }                  }
                 else                  else
                 {                  {
   #                   ifndef SEMAPHORES_NOMMES
                     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                      while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
   #                   else
                       while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
   #                   endif
                     {                      {
                         if (errno != EINTR)                          if (errno != EINTR)
                         {                          {
Line 2560  instruction_wfpoke(struct_processus *s_e Line 3247  instruction_wfpoke(struct_processus *s_e
   
     do      do
     {      {
   #       ifndef SEMAPHORES_NOMMES
         if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)          if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
             return;              return;
         }          }
   #       else
           if (sem_post((*s_etat_processus).semaphore_fork) != 0)
           {
               (*s_etat_processus).erreur_systeme = d_es_processus;
               return;
           }
   #       endif
   
         nanosleep(&attente, NULL);          nanosleep(&attente, NULL);
   
   #       ifndef SEMAPHORES_NOMMES
         while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)          while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
   #       else
           while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
   #       endif
         {          {
             if (errno != EINTR)              if (errno != EINTR)
             {              {
Line 2710  instruction_wfack(struct_processus *s_et Line 3409  instruction_wfack(struct_processus *s_et
             return;              return;
         }          }
   
   #       ifndef SEMAPHORES_NOMMES
         if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)          if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
             return;              return;
         }          }
   #       else
           if (sem_post((*s_etat_processus).semaphore_fork) != 0)
           {
               (*s_etat_processus).erreur_systeme = d_es_processus;
               return;
           }
   #       endif
   
         nanosleep(&attente, NULL);          nanosleep(&attente, NULL);
         INCR_GRANULARITE(attente.tv_nsec);          INCR_GRANULARITE(attente.tv_nsec);
   
   #       ifndef SEMAPHORES_NOMMES
         while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)          while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
   #       else
           while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
   #       endif
         {          {
             if (errno != EINTR)              if (errno != EINTR)
             {              {
Removed from v.1.7  
changed lines
  Added in v.1.15

CVSweb interface <joel.bertrand@systella.fr>