[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.2 and 1.7

version 1.2, 2010/01/27 22:22:16 version 1.7, 2010/03/08 08:34:15
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.10    RPL/2 (R) version 4.0.12
   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 374  instruction_wireframe(struct_processus * Line 374  instruction_wireframe(struct_processus *
 void  void
 instruction_write(struct_processus *s_etat_processus)  instruction_write(struct_processus *s_etat_processus)
 {  {
     file                                *descripteur;      const char                          *queue;
   
     int                                 adresse[16];      int                                 adresse[16];
     int                                 port;      int                                 port;
Line 382  instruction_write(struct_processus *s_et Line 382  instruction_write(struct_processus *s_et
     long                                longueur_effective;      long                                longueur_effective;
     long                                recursivite;      long                                recursivite;
   
       sqlite3_stmt                        *ppStmt;
   
     ssize_t                             ios;      ssize_t                             ios;
   
     struct_objet                        *s_objet_argument_2;      struct_descripteur_fichier          *descripteur;
   
     struct_objet                        *s_objet_argument_1;      struct_objet                        *s_objet_argument_1;
       struct_objet                        *s_objet_argument_2;
       struct_objet                        *s_objet_argument_3;
   
     struct sigaction                    action;      struct sigaction                    action;
     struct sigaction                    registre;      struct sigaction                    registre;
Line 399  instruction_write(struct_processus *s_et Line 404  instruction_write(struct_processus *s_et
     uint32_t                            calcul_adresse;      uint32_t                            calcul_adresse;
   
     unsigned char                       *chaine;      unsigned char                       *chaine;
       unsigned char                       *chaine_utf8;
       unsigned char                       *commande;
   
     unsigned long                       i;      unsigned long                       i;
   
Line 418  instruction_write(struct_processus *s_et Line 425  instruction_write(struct_processus *s_et
         }          }
   
         printf("    2: %s\n", d_LST);          printf("    2: %s\n", d_LST);
         printf("    1: %s, %s\n", d_FCH, d_SCK);          printf("    1: %s, %s\n\n", d_FCH, d_SCK);
   
           printf("    3: %s\n", d_LST);
           printf("    2: %s, %s\n", d_INT, d_CHN);
           printf("    1: %s\n", d_FCH);
         return;          return;
     }      }
     else if ((*s_etat_processus).test_instruction == 'Y')      else if ((*s_etat_processus).test_instruction == 'Y')
Line 430  instruction_write(struct_processus *s_et Line 440  instruction_write(struct_processus *s_et
   
     if (test_cfsf(s_etat_processus, 31) == d_vrai)      if (test_cfsf(s_etat_processus, 31) == d_vrai)
     {      {
         if (empilement_pile_last(s_etat_processus, 2) == d_erreur)          if ((*s_etat_processus).l_base_pile == NULL)
         {          {
               (*s_etat_processus).erreur_execution = d_ex_manque_argument;
             return;              return;
         }          }
   
           if ((*(*(*s_etat_processus).l_base_pile).donnee).type == FCH)
           {
               if ((*((struct_fichier *) (*(*(*s_etat_processus).l_base_pile)
                       .donnee).objet)).acces == 'S')
               {
                   if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
                   {
                       return;
                   }
               }
               else
               {
                   if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
                   {
                       return;
                   }
               }
           }
           else
           {
               if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
               {
                   return;
               }
           }
     }      }
   
     if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),      if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
Line 452  instruction_write(struct_processus *s_et Line 489  instruction_write(struct_processus *s_et
         return;          return;
     }      }
           
     if (((*s_objet_argument_2).type == LST) &&      if ((*s_objet_argument_1).type == FCH)
             ((*s_objet_argument_1).type == FCH))  
     {      {
           if ((descripteur = descripteur_fichier(s_etat_processus,
                   (struct_fichier *) (*s_objet_argument_1).objet)) == NULL)
           {
               return;
           }
   
         /*          /*
          * Vérification des verrous           * Vérification des verrous
          */           */
Line 466  instruction_write(struct_processus *s_et Line 508  instruction_write(struct_processus *s_et
         lock.l_pid = getpid();          lock.l_pid = getpid();
         recursivite = 0;          recursivite = 0;
   
         if ((descripteur = descripteur_fichier(s_etat_processus,          if (fcntl(fileno((*descripteur).descripteur_c), F_GETLK, &lock)
                 (struct_fichier *) (*s_objet_argument_1).objet)) == NULL)                  == -1)
         {  
             return;  
         }  
   
         if (fcntl(fileno(descripteur), F_GETLK, &lock) == -1)  
         {          {
             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 511  instruction_write(struct_processus *s_et Line 548  instruction_write(struct_processus *s_et
              * Fichiers formatés               * Fichiers formatés
              */               */
   
             if ((chaine = formateur_fichier(s_etat_processus,  
                     s_objet_argument_2, (*((struct_fichier *)  
                     (*s_objet_argument_1).objet)).format, 0, 0, ' ', 'F',  
                     &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 (fseek(descripteur, (long) 0, SEEK_END) != 0)                  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, ' ', 'F',
                           &longueur_effective, &recursivite)) == 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"));
   
                   if (fseek((*descripteur).descripteur_c, (long) 0, SEEK_END)
                           != 0)
                 {                  {
                     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 534  instruction_write(struct_processus *s_et Line 584  instruction_write(struct_processus *s_et
                     return;                      return;
                 }                  }
   
                 if (fprintf(descripteur, "%s\n", chaine) < 0)                  if ((chaine_utf8 = transliteration(s_etat_processus,
                           chaine, d_locale, "UTF-8")) == NULL)
                 {                  {
                       free(chaine);
   
                       liberation(s_etat_processus, s_objet_argument_2);
                       liberation(s_etat_processus, s_objet_argument_1);
   
                       return;
                   }
   
                   free(chaine);
   
                   if (fprintf((*descripteur).descripteur_c, "%s\n", chaine_utf8)
                           < 0)
                   {
                       free(chaine_utf8);
   
                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;                      (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                     return;                      return;
                 }                  }
   
                   free(chaine_utf8);
             }              }
             else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces              else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
                     == 'D')                      == 'D')
             {              {
                   BUG(((*descripteur).type != 'S'), uprintf("Bad filetype !\n"));
   
                   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 ((*s_objet_argument_3).objet == NULL)
                   {
                       // Effacement d'un enregistrement
   
                       if (alsprintf(&commande, "delete from data where "
                               "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;
                       }
                   }
                   else
                   {
                       // 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)
                       {
                           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)
                       {
                           free(chaine_utf8);
                           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_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              else
             {              {
                 /* Fichiers indexés : panique totale ! */                  /* Fichiers indexés : panique totale ! */
             }              }
   
             free(chaine);  
         }          }
         else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire          else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire
                 == 'Y')                  == 'Y')
Line 572  instruction_write(struct_processus *s_et Line 750  instruction_write(struct_processus *s_et
             if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces              if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
                     == 'S')                      == 'S')
             {              {
                 if (fseek(descripteur, (long) 0, SEEK_END) != 0)                  BUG(((*descripteur).type != 'C'), uprintf("Bad filetype !\n"));
   
                   if (fseek((*descripteur).descripteur_c, (long) 0, SEEK_END)
                           != 0)
                 {                  {
                     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 582  instruction_write(struct_processus *s_et Line 763  instruction_write(struct_processus *s_et
                 }                  }
   
                 if (fwrite(chaine, sizeof(unsigned char), longueur_effective,                  if (fwrite(chaine, sizeof(unsigned char), longueur_effective,
                         descripteur) != (size_t) longueur_effective)                          (*descripteur).descripteur_c) !=
                           (size_t) longueur_effective)
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;                      (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                     return;                      return;
Line 982  instruction_write(struct_processus *s_et Line 1164  instruction_write(struct_processus *s_et
 void  void
 instruction_wflock(struct_processus *s_etat_processus)  instruction_wflock(struct_processus *s_etat_processus)
 {  {
     file                        *descripteur;  
   
     logical1                    drapeau;      logical1                    drapeau;
   
     struct flock                lock;      struct flock                lock;
   
     struct timespec             attente;      struct timespec             attente;
   
       struct_descripteur_fichier  *descripteur;
   
     struct_objet                *s_objet_argument_1;      struct_objet                *s_objet_argument_1;
     struct_objet                *s_objet_argument_2;      struct_objet                *s_objet_argument_2;
   
Line 1100  instruction_wflock(struct_processus *s_e Line 1282  instruction_wflock(struct_processus *s_e
                 return;                  return;
             }              }
   
             if (fcntl(fileno(descripteur), F_GETLK, &lock) == -1)              if (fcntl(fileno((*descripteur).descripteur_c), F_GETLK, &lock)
                       == -1)
             {              {
                 liberation(s_etat_processus, s_objet_argument_1);                  liberation(s_etat_processus, s_objet_argument_1);
                 liberation(s_etat_processus, s_objet_argument_2);                  liberation(s_etat_processus, s_objet_argument_2);
Removed from v.1.2  
changed lines
  Added in v.1.7

CVSweb interface <joel.bertrand@systella.fr>