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

Diff for /rpl/src/instructions_s8.c between versions 1.27 and 1.74

version 1.27, 2011/06/22 13:27:03 version 1.74, 2016/03/08 14:20:31
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.0.prerelease.3    RPL/2 (R) version 4.1.25
   Copyright (C) 1989-2011 Dr. BERTRAND Joël    Copyright (C) 1989-2016 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 102  instruction_splash(struct_processus *s_e Line 102  instruction_splash(struct_processus *s_e
             return;              return;
         }          }
   
         encart(s_etat_processus, (unsigned long) (attente * 1E6));          encart(s_etat_processus, (integer8) (attente * 1E6));
     }      }
     else      else
     {      {
Line 133  instruction_splash(struct_processus *s_e Line 133  instruction_splash(struct_processus *s_e
 void  void
 instruction_send(struct_processus *s_etat_processus)  instruction_send(struct_processus *s_etat_processus)
 {  {
     pid_t                       pid;  
   
     pthread_t                   tid;  
   
     sig_atomic_t                registre;      sig_atomic_t                registre;
   
     ssize_t                     longueur_ecriture;      ssize_t                     longueur_ecriture;
Line 145  instruction_send(struct_processus *s_eta Line 141  instruction_send(struct_processus *s_eta
   
     struct timespec             attente;      struct timespec             attente;
   
       unsigned char               caractere;
     unsigned char               tampon;      unsigned char               tampon;
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
Line 242  instruction_send(struct_processus *s_eta Line 239  instruction_send(struct_processus *s_eta
             }              }
         }          }
   
         pid = -3;  
   
         attente.tv_sec = 0;  
         attente.tv_nsec = GRANULARITE_us * 1000;  
   
 #       ifndef SEMAPHORES_NOMMES  #       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;  
             return;  
         }  
 #       else  #       else
         if (sem_post((*s_etat_processus).semaphore_fork) != 0)              if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #       endif
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
             return;              return;
         }          }
 #       endif  
   
         while((longueur_ecriture = write_atomic(s_etat_processus,  
                 (*s_etat_processus).pipe_nombre_objets_attente,  
                 &pid, sizeof(pid))) != sizeof(pid))  
         {  
 #           ifndef SEMAPHORES_NOMMES  
             while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)  
 #           else  
             while(sem_wait((*s_etat_processus).semaphore_fork) == -1)  
 #           endif  
             {  
                 if (errno != EINTR)  
                 {  
                     (*s_etat_processus).erreur_systeme = d_es_processus;  
                     return;  
                 }  
             }  
   
             if (longueur_ecriture == -1)  
             {  
                 if ((*s_etat_processus).profilage == d_vrai)  
                 {  
                     profilage(s_etat_processus, NULL);  
                 }  
   
                 (*s_etat_processus).erreur_systeme = d_es_processus;  
                 return;  
             }  
   
             nanosleep(&attente, NULL);  
             INCR_GRANULARITE(attente.tv_nsec);  
   
 #           ifndef SEMAPHORES_NOMMES  
             if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)  
             {  
                 (*s_etat_processus).erreur_systeme = d_es_processus;  
                 return;  
             }  
 #           else  
             if (sem_post((*s_etat_processus).semaphore_fork) != 0)  
             {  
                 (*s_etat_processus).erreur_systeme = d_es_processus;  
                 return;  
             }  
 #           endif  
         }  
   
         pid = getpid();          caractere = 1;
   
         attente.tv_sec = 0;          attente.tv_sec = 0;
         attente.tv_nsec = GRANULARITE_us * 1000;          attente.tv_nsec = GRANULARITE_us * 1000;
   
         while((longueur_ecriture = write_atomic(s_etat_processus,          while((longueur_ecriture = write_atomic(s_etat_processus,
                 (*s_etat_processus).pipe_nombre_objets_attente,                  (*s_etat_processus).pipe_nombre_elements_attente,
                 &pid, sizeof(pid))) != sizeof(pid))                  &caractere, sizeof(caractere))) != sizeof(caractere))
         {          {
 #           ifndef SEMAPHORES_NOMMES  #           ifndef SEMAPHORES_NOMMES
             while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                  while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #           else  #           else
             while(sem_wait((*s_etat_processus).semaphore_fork) == -1)                  while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #           endif  #           endif
             {              {
                 if (errno != EINTR)                  if (errno != EINTR)
Line 344  instruction_send(struct_processus *s_eta Line 286  instruction_send(struct_processus *s_eta
             INCR_GRANULARITE(attente.tv_nsec);              INCR_GRANULARITE(attente.tv_nsec);
   
 #           ifndef SEMAPHORES_NOMMES  #           ifndef SEMAPHORES_NOMMES
             if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)                  if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
 #           else  #           else
             if (sem_post((*s_etat_processus).semaphore_fork) != 0)                  if (sem_post((*s_etat_processus).semaphore_fork) != 0)
 #           endif  #           endif
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return;                  return;
             }              }
   
               scrutation_interruptions(s_etat_processus);
         }          }
   
 #       ifndef SEMAPHORES_NOMMES  #       ifndef SEMAPHORES_NOMMES
         while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)              while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #       else  #       else
         while(sem_wait((*s_etat_processus).semaphore_fork) == -1)              while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #       endif  #       endif
         {          {
             if (errno != EINTR)              if (errno != EINTR)
Line 379  instruction_send(struct_processus *s_eta Line 323  instruction_send(struct_processus *s_eta
             }              }
         }          }
   
         tid = -3;  
   
         attente.tv_sec = 0;          attente.tv_sec = 0;
         attente.tv_nsec = GRANULARITE_us * 1000;          attente.tv_nsec = GRANULARITE_us * 1000;
   
 #       ifndef SEMAPHORES_NOMMES  #       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;  
             return;  
         }  
 #       else  #       else
         if (sem_post((*s_etat_processus).semaphore_fork) != 0)              if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #       endif
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
             return;              return;
         }          }
 #       endif  
   
         while((longueur_ecriture = write_atomic(s_etat_processus,  
                 (*s_etat_processus).pipe_nombre_objets_attente,  
                 &tid, sizeof(tid))) != sizeof(tid))  
         {  
 #           ifndef SEMAPHORES_NOMMES  
             while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)  
 #           else  
             while(sem_wait((*s_etat_processus).semaphore_fork) == -1)  
 #           endif  
             {  
                 if (errno != EINTR)  
                 {  
                     (*s_etat_processus).erreur_systeme = d_es_processus;  
                     return;  
                 }  
             }  
   
             if (longueur_ecriture == -1)  
             {  
                 if ((*s_etat_processus).profilage == d_vrai)  
                 {  
                     profilage(s_etat_processus, NULL);  
                 }  
   
                 (*s_etat_processus).erreur_systeme = d_es_processus;          caractere = 1;
                 return;  
             }  
   
             nanosleep(&attente, NULL);  
             INCR_GRANULARITE(attente.tv_nsec);  
   
 #           ifndef SEMAPHORES_NOMMES  
             if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)  
             {  
                 (*s_etat_processus).erreur_systeme = d_es_processus;  
                 return;  
             }  
 #           else  
             if (sem_post((*s_etat_processus).semaphore_fork) != 0)  
             {  
                 (*s_etat_processus).erreur_systeme = d_es_processus;  
                 return;  
             }  
 #           endif  
         }  
   
         tid = pthread_self();  
   
         attente.tv_sec = 0;          attente.tv_sec = 0;
         attente.tv_nsec = GRANULARITE_us * 1000;          attente.tv_nsec = GRANULARITE_us * 1000;
   
         while((longueur_ecriture = write_atomic(s_etat_processus,          while((longueur_ecriture = write_atomic(s_etat_processus,
                 (*s_etat_processus).pipe_nombre_objets_attente,                  (*s_etat_processus).pipe_nombre_elements_attente,
                 &tid, sizeof(tid))) != sizeof(tid))                  &caractere, sizeof(caractere))) != sizeof(caractere))
         {          {
 #           ifndef SEMAPHORES_NOMMES  #           ifndef SEMAPHORES_NOMMES
             while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)                  while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #           else  #           else
             while(sem_wait((*s_etat_processus).semaphore_fork) == -1)                  while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #           endif  #           endif
             {              {
                 if (errno != EINTR)                  if (errno != EINTR)
Line 481  instruction_send(struct_processus *s_eta Line 373  instruction_send(struct_processus *s_eta
             INCR_GRANULARITE(attente.tv_nsec);              INCR_GRANULARITE(attente.tv_nsec);
   
 #           ifndef SEMAPHORES_NOMMES  #           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;  
                 return;  
             }  
 #           else  #           else
             if (sem_post((*s_etat_processus).semaphore_fork) != 0)                  if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #           endif
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return;                  return;
             }              }
 #           endif  
               scrutation_interruptions(s_etat_processus);
         }          }
   
 #       ifndef SEMAPHORES_NOMMES  #       ifndef SEMAPHORES_NOMMES
         while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)              if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
 #       else  #       else
         while(sem_wait((*s_etat_processus).semaphore_fork) == -1)              if (sem_post((*s_etat_processus).semaphore_fork) != 0)
 #       endif  #       endif
         {          {
             if (errno != EINTR)              (*s_etat_processus).erreur_systeme = d_es_processus;
             {              return;
                 (*s_etat_processus).erreur_systeme = d_es_processus;  
                 return;  
             }  
         }          }
     }      }
   
Line 515  instruction_send(struct_processus *s_eta Line 402  instruction_send(struct_processus *s_eta
     attente.tv_nsec = GRANULARITE_us * 1000;      attente.tv_nsec = GRANULARITE_us * 1000;
   
 #   ifndef SEMAPHORES_NOMMES  #   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;  
         return;  
     }  
 #   else  #   else
     if (sem_post((*s_etat_processus).semaphore_fork) != 0)          if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #   endif
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
     }      }
 #   endif  
   
     while(read_atomic(s_etat_processus, (*s_etat_processus).pipe_acquittement,      while(read_atomic(s_etat_processus, (*s_etat_processus).pipe_acquittement,
             &tampon, sizeof(unsigned char)) != sizeof(unsigned char))              &tampon, sizeof(unsigned char)) != sizeof(unsigned char))
     {      {
 #       ifndef SEMAPHORES_NOMMES  #       ifndef SEMAPHORES_NOMMES
         while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)              while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #       else  #       else
         while(sem_wait((*s_etat_processus).semaphore_fork) == -1)              while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #       endif  #       endif
         {          {
             if (errno != EINTR)              if (errno != EINTR)
Line 548  instruction_send(struct_processus *s_eta Line 431  instruction_send(struct_processus *s_eta
         INCR_GRANULARITE(attente.tv_nsec);          INCR_GRANULARITE(attente.tv_nsec);
   
 #       ifndef SEMAPHORES_NOMMES  #       ifndef SEMAPHORES_NOMMES
         if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)              if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
 #       else  #       else
         if (sem_post((*s_etat_processus).semaphore_fork) != 0)              if (sem_post((*s_etat_processus).semaphore_fork) != 0)
 #       endif  #       endif
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
             return;              return;
         }          }
   
           scrutation_interruptions(s_etat_processus);
     }      }
   
 #   ifndef SEMAPHORES_NOMMES  #   ifndef SEMAPHORES_NOMMES
     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)          while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #   else  #   else
     while(sem_wait((*s_etat_processus).semaphore_fork) == -1)          while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #   endif  #   endif
     {      {
         if (errno != EINTR)          if (errno != EINTR)
Line 571  instruction_send(struct_processus *s_eta Line 456  instruction_send(struct_processus *s_eta
         }          }
     }      }
   
     // Envoi d'un PID invalide (-1) pour ne pas bloquer le thread  
     // de surveillance.  
   
     if ((*s_etat_processus).processus_detache == d_vrai)  
     {  
         pid = -1;  
   
         attente.tv_sec = 0;  
         attente.tv_nsec = GRANULARITE_us * 1000;  
   
 #       ifndef SEMAPHORES_NOMMES  
         if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)  
 #       else  
         if (sem_post((*s_etat_processus).semaphore_fork) != 0)  
 #       endif  
         {  
             (*s_etat_processus).erreur_systeme = d_es_processus;  
             return;  
         }  
   
         while((longueur_ecriture = write_atomic(s_etat_processus,  
                 (*s_etat_processus).pipe_nombre_interruptions_attente,  
                 &pid, sizeof(pid))) != sizeof(pid))  
         {  
 #           ifndef SEMAPHORES_NOMMES  
             while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)  
 #           else  
             while(sem_wait((*s_etat_processus).semaphore_fork) == -1)  
 #           endif  
             {  
                 if (errno != EINTR)  
                 {  
                     (*s_etat_processus).erreur_systeme = d_es_processus;  
                     return;  
                 }  
             }  
   
             if (longueur_ecriture == -1)  
             {  
                 if ((*s_etat_processus).profilage == d_vrai)  
                 {  
                     profilage(s_etat_processus, NULL);  
                 }  
   
                 (*s_etat_processus).erreur_systeme = d_es_processus;  
                 return;  
             }  
   
             nanosleep(&attente, NULL);  
             INCR_GRANULARITE(attente.tv_nsec);  
   
 #           ifndef SEMAPHORES_NOMMES  
             if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)  
             {  
                 (*s_etat_processus).erreur_systeme = d_es_processus;  
                 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)  
 #       else  
         while(sem_wait((*s_etat_processus).semaphore_fork) == -1)  
 #       endif  
         {  
             if (errno != EINTR)  
             {  
                 (*s_etat_processus).erreur_systeme = d_es_processus;  
                 return;  
             }  
         }  
     }  
     else  
     {  
         tid = -1;  
   
         attente.tv_sec = 0;  
         attente.tv_nsec = GRANULARITE_us * 1000;  
   
 #       ifndef SEMAPHORES_NOMMES  
         if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)  
 #       else  
         if (sem_post((*s_etat_processus).semaphore_fork) != 0)  
 #       endif  
         {  
             (*s_etat_processus).erreur_systeme = d_es_processus;  
             return;  
         }  
   
         while((longueur_ecriture = write_atomic(s_etat_processus,  
                 (*s_etat_processus).pipe_nombre_interruptions_attente,  
                 &tid, sizeof(tid))) != sizeof(tid))  
         {  
 #           ifndef SEMAPHORES_NOMMES  
             while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)  
 #           else  
             while(sem_wait((*s_etat_processus).semaphore_fork) == -1)  
 #           endif  
             {  
                 if (errno != EINTR)  
                 {  
                     (*s_etat_processus).erreur_systeme = d_es_processus;  
                     return;  
                 }  
             }  
   
             if (longueur_ecriture == -1)  
             {  
                 if ((*s_etat_processus).profilage == d_vrai)  
                 {  
                     profilage(s_etat_processus, NULL);  
                 }  
   
                 (*s_etat_processus).erreur_systeme = d_es_processus;  
                 return;  
             }  
   
             nanosleep(&attente, NULL);  
             INCR_GRANULARITE(attente.tv_nsec);  
   
 #           ifndef SEMAPHORES_NOMMES  
             if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)  
 #           else  
             if (sem_post((*s_etat_processus).semaphore_fork) != 0)  
 #           endif  
             {  
                 (*s_etat_processus).erreur_systeme = d_es_processus;  
                 return;  
             }  
         }  
   
 #       ifndef SEMAPHORES_NOMMES  
         while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)  
 #       else  
         while(sem_wait((*s_etat_processus).semaphore_fork) == -1)  
 #       endif  
         {  
             if (errno != EINTR)  
             {  
                 (*s_etat_processus).erreur_systeme = d_es_processus;  
                 return;  
             }  
         }  
     }  
   
     // ecriture_pipe() ne peut être interrompu par un signal.      // ecriture_pipe() ne peut être interrompu par un signal.
   
 #   ifndef SEMAPHORES_NOMMES  #   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;  
         return;  
     }  
 #   else  #   else
     if (sem_post((*s_etat_processus).semaphore_fork) != 0)          if (sem_post((*s_etat_processus).semaphore_fork) != 0)
   #   endif
     {      {
         (*s_etat_processus).erreur_systeme = d_es_processus;          (*s_etat_processus).erreur_systeme = d_es_processus;
         return;          return;
     }      }
 #   endif  
   
     if (ecriture_pipe(s_etat_processus, (*s_etat_processus).pipe_donnees,      if (ecriture_pipe(s_etat_processus, (*s_etat_processus).pipe_donnees,
             s_objet) == d_erreur)              s_objet) == d_erreur)
     {      {
 #       ifndef SEMAPHORES_NOMMES  #       ifndef SEMAPHORES_NOMMES
         while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)              while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #       else  #       else
         while(sem_wait((*s_etat_processus).semaphore_fork) == -1)              while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #       endif  #       endif
         {          {
             if (errno != EINTR)              if (errno != EINTR)
Line 765  instruction_send(struct_processus *s_eta Line 494  instruction_send(struct_processus *s_eta
     }      }
   
 #   ifndef SEMAPHORES_NOMMES  #   ifndef SEMAPHORES_NOMMES
     while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)          while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #   else  #   else
     while(sem_wait((*s_etat_processus).semaphore_fork) == -1)          while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #   endif  #   endif
     {      {
         if (errno != EINTR)          if (errno != EINTR)
Line 812  instruction_send(struct_processus *s_eta Line 541  instruction_send(struct_processus *s_eta
 void  void
 instruction_sqlquery(struct_processus *s_etat_processus)  instruction_sqlquery(struct_processus *s_etat_processus)
 {  {
 #   define                          d_LONGUEUR  1024  
   
     logical1                        connexion_permanente;      logical1                        connexion_permanente;
     logical1                        presence_resultat;  
   
     struct_objet                    *s_copie_1;      struct_objet                    *s_copie_1;
     struct_objet                    *s_objet_1;      struct_objet                    *s_objet_1;
     struct_objet                    *s_copie_2;      struct_objet                    *s_copie_2;
     struct_objet                    *s_objet_2;      struct_objet                    *s_objet_2;
     struct_objet                    *s_objet_resultat;  
   
     struct_liste_chainee            *l_element_courant;  
     struct_liste_chainee            *l_element_courant_ligne;  
   
     unsigned char                   *tampon;      unsigned char                   *tampon;
   
     unsigned int                    i;  
     unsigned int                    j;  
     unsigned int                    nombre_colonnes;  
     unsigned int                    nombre_lignes;  
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
     if ((*s_etat_processus).affichage_arguments == 'Y')      if ((*s_etat_processus).affichage_arguments == 'Y')
Line 872  instruction_sqlquery(struct_processus *s Line 589  instruction_sqlquery(struct_processus *s
         printf("          { \"postgresql:iso-8859-1\" \"server\" "          printf("          { \"postgresql:iso-8859-1\" \"server\" "
                 "\"database\" \"user\" \"password\" port }\n");                  "\"database\" \"user\" \"password\" port }\n");
         printf("          SQLQUERY\n");          printf("          SQLQUERY\n");
           printf("    \"select * from table\"\n");
           printf("          { \"sqlite\" \"file\" } SQLQUERY\n");
   
         return;          return;
     }      }
Line 918  instruction_sqlquery(struct_processus *s Line 637  instruction_sqlquery(struct_processus *s
             return;              return;
         }          }
   
           if ((*s_etat_processus).erreur_execution ==
                   d_ex_instruction_indisponible)
           {
               liberation(s_etat_processus, s_objet_1);
               liberation(s_etat_processus, s_objet_2);
               liberation(s_etat_processus, s_copie_1);
   
               return;
           }
   
         liberation(s_etat_processus, s_copie_1);          liberation(s_etat_processus, s_copie_1);
     }      }
     else      else
Line 979  instruction_sqlquery(struct_processus *s Line 708  instruction_sqlquery(struct_processus *s
         {          {
 #           ifdef MYSQL_SUPPORT  #           ifdef MYSQL_SUPPORT
   
             MYSQL_RES       *resultat_mysql;              unsigned int                i;
             MYSQL_ROW       ligne;              unsigned int                nombre_colonnes;
   
               logical1                    presence_resultat;
   
               MYSQL_RES                   *resultat_mysql;
               MYSQL_ROW                   ligne;
   
               struct_objet                *s_objet_resultat;
   
               struct_liste_chainee        *l_element_courant;
               struct_liste_chainee        *l_element_courant_ligne;
   
             if (mysql_real_query((*((struct_connecteur_sql *) (*s_objet_1)              if (mysql_real_query((*((struct_connecteur_sql *) (*s_objet_1)
                     .objet)).descripteur.mysql, (unsigned char *) (*s_objet_2)                      .objet)).descripteur.mysql, (unsigned char *) (*s_objet_2)
Line 1148  instruction_sqlquery(struct_processus *s Line 887  instruction_sqlquery(struct_processus *s
                         .descripteur.mysql);                          .descripteur.mysql);
             }              }
   
             if (presence_resultat == d_vrai)              if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
                       s_objet_resultat) == d_erreur)
             {              {
                 if (empilement(s_etat_processus,                  return;
                         &((*s_etat_processus).l_base_pile),  
                         s_objet_resultat) == d_erreur)  
                 {  
                     return;  
                 }  
             }              }
   
 #           else  #           else
Line 1182  instruction_sqlquery(struct_processus *s Line 917  instruction_sqlquery(struct_processus *s
         {          {
 #           ifdef POSTGRESQL_SUPPORT  #           ifdef POSTGRESQL_SUPPORT
   
             PGresult        *resultat_postgresql;              int                         i;
               int                         j;
               int                         nombre_colonnes;
               int                         nombre_lignes;
   
               logical1                    presence_resultat;
   
               PGresult                    *resultat_postgresql;
   
               struct_objet                *s_objet_resultat;
   
               struct_liste_chainee        *l_element_courant;
               struct_liste_chainee        *l_element_courant_ligne;
   
             if (PQstatus((*((struct_connecteur_sql *) (*s_objet_1).objet))              if (PQstatus((*((struct_connecteur_sql *) (*s_objet_1).objet))
                     .descripteur.postgresql) != CONNECTION_OK)                      .descripteur.postgresql) != CONNECTION_OK)
Line 1348  instruction_sqlquery(struct_processus *s Line 1095  instruction_sqlquery(struct_processus *s
                             else                              else
                             {                              {
                                 if (((*(*l_element_courant_ligne).donnee).objet                                  if (((*(*l_element_courant_ligne).donnee).objet
                                         = malloc((PQgetlength(                                          = malloc(((size_t) (PQgetlength(
                                         resultat_postgresql, i, j) + 1) *                                          resultat_postgresql, i, j) + 1)) *
                                         sizeof(unsigned char))) == NULL)                                          sizeof(unsigned char))) == NULL)
                                 {                                  {
                                     (*s_etat_processus).erreur_systeme =                                      (*s_etat_processus).erreur_systeme =
Line 1426  instruction_sqlquery(struct_processus *s Line 1173  instruction_sqlquery(struct_processus *s
             fflush(stdout);              fflush(stdout);
 #           endif  #           endif
         }          }
           else if (strcmp((*((struct_connecteur_sql *) (*s_objet_1).objet)).type,
                   "SQLITE") == 0)
           {
               const char                  *queue;
               const unsigned char         *resultat;
   
               int                         i;
               int                         ios;
               int                         nombre_colonnes;
   
               logical1                    presence_resultat;
   
               sqlite3_stmt                *ppStmt;
   
               struct_liste_chainee        *l_element_courant;
               struct_liste_chainee        *l_element_courant_ligne;
   
               struct_objet                *s_objet_resultat;
   
               struct timespec             attente;
   
               if (sqlite3_prepare_v2((*((struct_connecteur_sql *)
                       (*s_objet_1).objet)).descripteur.sqlite,
                       (unsigned char *) (*s_objet_2).objet,
                       (int) strlen((unsigned char *) (*s_objet_2).objet),
                       &ppStmt, &queue) != SQLITE_OK)
               {
                   if (connexion_permanente == d_faux)
                   {
                       sqlite3_close((*((struct_connecteur_sql *)
                               (*s_objet_1).objet)).descripteur.sqlite);
                   }
   
                   liberation(s_etat_processus, s_objet_1);
                   liberation(s_etat_processus, s_objet_2);
   
                   (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
                   return;
               }
   
               presence_resultat = d_faux;
               s_objet_resultat = NULL;
               l_element_courant = NULL;
   
               attente.tv_sec = 0;
               attente.tv_nsec = GRANULARITE_us * 1000;
   
               if ((s_objet_resultat =
                       allocation(s_etat_processus, LST)) == NULL)
               {
                   (*s_etat_processus).erreur_systeme =
                           d_es_allocation_memoire;
                   return;
               }
   
               // Création d'une liste vide
   
               (*s_objet_resultat).objet = NULL;
               l_element_courant = (*s_objet_resultat).objet;
   
               do
               {
                   switch(ios = sqlite3_step(ppStmt))
                   {
                       case SQLITE_ROW:
                       {
                           // Ajout d'une liste au bout de la liste
                           // contenant les lignes
   
                           if (l_element_courant == NULL)
                           {
                               if (((*s_objet_resultat).objet =
                                       allocation_maillon(s_etat_processus))
                                       == NULL)
                               {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_allocation_memoire;
                               }
   
                               l_element_courant = (struct_liste_chainee *)
                                       (*s_objet_resultat).objet;
                           }
                           else
                           {
                               if (((*l_element_courant).suivant =
                                       allocation_maillon(s_etat_processus))
                                       == NULL)
                               {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_allocation_memoire;
                                   return;
                               }
   
                               l_element_courant = (*l_element_courant).suivant;
                           }
   
                           (*l_element_courant).suivant = NULL;
   
                           // Création de la liste fille
   
                           if (((*l_element_courant).donnee =
                                   allocation(s_etat_processus, LST)) == NULL)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_allocation_memoire;
                               return;
                           }
   
                           (*(*l_element_courant).donnee).objet = NULL;
   
                           // Lecture de la ligne
   
                           nombre_colonnes = sqlite3_data_count(ppStmt);
                           l_element_courant_ligne = NULL;
   
                           for(i = 0; i < nombre_colonnes; i++)
                           {
                               if (l_element_courant_ligne == NULL)
                               {
                                   if (((*(*l_element_courant).donnee).objet =
                                           allocation_maillon(s_etat_processus))
                                           == NULL)
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_allocation_memoire;
                                       return;
                                   }
   
                                   l_element_courant_ligne =
                                           (struct_liste_chainee *)
                                           (*(*l_element_courant).donnee).objet;
                               }
                               else
                               {
                                   if (((*l_element_courant_ligne).suivant =
                                           allocation_maillon(s_etat_processus))
                                           == NULL)
                                   {
                                       l_element_courant_ligne =
                                               (*l_element_courant_ligne).suivant;
                                   }
   
                                   l_element_courant_ligne =
                                           (*l_element_courant_ligne).suivant;
                               }
   
                               (*l_element_courant_ligne).suivant = NULL;
   
                               if (((*l_element_courant_ligne).donnee =
                                       allocation(s_etat_processus, CHN))
                                       == NULL)
                               {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_allocation_memoire;
                                   return;
                               }
   
                               if (sqlite3_column_type(ppStmt, i) == SQLITE_NULL)
                               {
                                   if (((*(*l_element_courant_ligne).donnee).objet
                                           = malloc(5 * sizeof(unsigned char)))
                                           == NULL)
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_allocation_memoire;
                                       return;
                                   }
   
                                   strcpy((unsigned char *)
                                           (*(*l_element_courant_ligne).donnee)
                                           .objet, "NULL");
                               }
                               else
                               {
                                   if ((resultat = sqlite3_column_text(ppStmt, i))
                                           == NULL)
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_allocation_memoire;
                                       return;
                                   }
   
                                   if (((*(*l_element_courant_ligne).donnee).objet
                                           = malloc((strlen(resultat) + 1 ) *
                                           sizeof(unsigned char))) == NULL)
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_allocation_memoire;
                                       return;
                                   }
   
                                   strcpy((unsigned char *)
                                           (*(*l_element_courant_ligne).donnee)
                                           .objet, resultat);
                               }
                           }
   
                           break;
                       }
   
                       case SQLITE_DONE:
                       {
                           // Fin de la lecture des données
                           break;
                       }
   
                       case SQLITE_BUSY:
                       case SQLITE_LOCKED:
                       {
                           nanosleep(&attente, NULL);
                           INCR_GRANULARITE(attente.tv_nsec);
                           break;
                       }
   
                       default:
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_erreur_fichier;
                           return;
                       }
                   }
               } while(ios != SQLITE_DONE);
   
               if (sqlite3_finalize(ppStmt) != SQLITE_OK)
               {
                   (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   return;
               }
   
               if (connexion_permanente == d_faux)
               {
                   sqlite3_close((*((struct_connecteur_sql *) (*s_objet_1).objet))
                           .descripteur.sqlite);
               }
   
               if (empilement(s_etat_processus, &((*s_etat_processus)
                       .l_base_pile), s_objet_resultat) == d_erreur)
               {
                   return;
               }
           }
         else          else
         {          {
             liberation(s_etat_processus, s_objet_1);              liberation(s_etat_processus, s_objet_1);
Line 1470  instruction_stop(struct_processus *s_eta Line 1458  instruction_stop(struct_processus *s_eta
   
     struct_objet                *s_objet;      struct_objet                *s_objet;
   
     struct timespec             attente;  
   
     attente.tv_sec = 0;  
     attente.tv_nsec = GRANULARITE_us * 1000;  
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
     if ((*s_etat_processus).affichage_arguments == 'Y')      if ((*s_etat_processus).affichage_arguments == 'Y')
Line 1520  instruction_stop(struct_processus *s_eta Line 1503  instruction_stop(struct_processus *s_eta
         if ((*(*((struct_processus_fils *) (*s_objet).objet)).thread)          if ((*(*((struct_processus_fils *) (*s_objet).objet)).thread)
                 .processus_detache == d_vrai)                  .processus_detache == d_vrai)
         {          {
             kill((*(*((struct_processus_fils *) (*s_objet).objet)).thread).pid,              envoi_signal_processus((*(*((struct_processus_fils *)
                     SIGFSTOP);                      (*s_objet).objet)).thread).pid, rpl_sigstop);
         }          }
         else          else
         {          {
             if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)              if (pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus))
                       != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return;                  return;
Line 1567  instruction_stop(struct_processus *s_eta Line 1551  instruction_stop(struct_processus *s_eta
                     if (pthread_mutex_lock(&((*(*((struct_processus_fils *)                      if (pthread_mutex_lock(&((*(*((struct_processus_fils *)
                             (*s_objet).objet)).thread).mutex)) != 0)                              (*s_objet).objet)).thread).mutex)) != 0)
                     {                      {
                         if (pthread_mutex_unlock(&((*s_etat_processus).mutex))                          if (pthread_mutex_unlock(&((*s_etat_processus)
                                 != 0)                                  .mutex_pile_processus)) != 0)
                         {                          {
                             (*s_etat_processus).erreur_systeme = d_es_processus;                              (*s_etat_processus).erreur_systeme = d_es_processus;
                             return;                              return;
Line 1581  instruction_stop(struct_processus *s_eta Line 1565  instruction_stop(struct_processus *s_eta
                     if ((*(*((struct_processus_fils *)                      if ((*(*((struct_processus_fils *)
                             (*s_objet).objet)).thread).thread_actif == d_vrai)                              (*s_objet).objet)).thread).thread_actif == d_vrai)
                     {                      {
                         pthread_kill((*(*((struct_processus_fils *)                          envoi_signal_thread((*(*((struct_processus_fils *)
                                 (*s_objet).objet)).thread).tid, SIGFSTOP);                                  (*s_objet).objet)).thread).tid, rpl_sigstop);
                     }                      }
   
                     if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)                      if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
                             (*s_objet).objet)).thread).mutex)) != 0)                              (*s_objet).objet)).thread).mutex)) != 0)
                     {                      {
                         if (pthread_mutex_unlock(&((*s_etat_processus).mutex))                          if (pthread_mutex_unlock(&((*s_etat_processus)
                                 != 0)                                  .mutex_pile_processus)) != 0)
                         {                          {
                             (*s_etat_processus).erreur_systeme = d_es_processus;                              (*s_etat_processus).erreur_systeme = d_es_processus;
                             return;                              return;
Line 1601  instruction_stop(struct_processus *s_eta Line 1585  instruction_stop(struct_processus *s_eta
                 }                  }
             }              }
   
             if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)              if (pthread_mutex_unlock(&((*s_etat_processus)
                       .mutex_pile_processus)) != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return;                  return;
Removed from v.1.27  
changed lines
  Added in v.1.74

CVSweb interface <joel.bertrand@systella.fr>