[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.64 and 1.78

version 1.64, 2012/06/22 10:12:19 version 1.78, 2013/03/20 17:11:45
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                            longueur_effective;
     integer8                            ordre;      integer8                            ordre;
   
     logical1                            format_degenere;      logical1                            format_degenere;
     logical1                            mise_a_jour;      logical1                            mise_a_jour;
   
     long                                longueur;      long                                longueur;
     long                                longueur_effective;  
     long                                recursivite;      long                                recursivite;
   
     sqlite3_stmt                        *ppStmt;      sqlite3_stmt                        *ppStmt;
Line 424  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;
Line 589  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 671  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 760  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 875  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 917  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 1182  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 1275  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 1312  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 1403  instruction_write(struct_processus *s_et Line 1502  instruction_write(struct_processus *s_et
   
                     longueur = strlen(format_chaine);                      longueur = strlen(format_chaine);
   
                     if (format_chaine[longueur] != ')')                      if (format_chaine[longueur - 1] != ')')
                     {                      {
                         free(format_chaine);                          free(format_chaine);
   
Line 1531  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 1546  instruction_write(struct_processus *s_et Line 1645  instruction_write(struct_processus *s_et
              * Sockets non formatées               * Sockets non formatées
              */               */
   
             chaine = NULL;              if ((chaine = formateur_fichier(s_etat_processus,
                       s_objet_argument_2, (*((struct_socket *)
                       (*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
         {          {
Line 1737  instruction_write(struct_processus *s_et Line 1845  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 1789  instruction_write(struct_processus *s_et Line 1903  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 1805  instruction_write(struct_processus *s_et Line 1921  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 1872  instruction_write(struct_processus *s_et Line 2002  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 1888  instruction_write(struct_processus *s_et Line 2020  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.64  
changed lines
  Added in v.1.78

CVSweb interface <joel.bertrand@systella.fr>