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

Diff for /rpl/src/instructions_r4.c between versions 1.6 and 1.19

version 1.6, 2010/03/07 17:03:29 version 1.19, 2010/08/06 15:26:49
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.12    RPL/2 (R) version 4.0.18
   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 20 Line 20
 */  */
   
   
 #include "rpl.conv.h"  #include "rpl-conv.h"
   
   
 /*  /*
Line 848  instruction_read(struct_processus *s_eta Line 848  instruction_read(struct_processus *s_eta
 {  {
     const char                      *queue;      const char                      *queue;
   
       int                             ios;
   
       integer8                        element;
       integer8                        id;
       integer8                        position_clef;
   
     logical1                        indicateur_48;      logical1                        indicateur_48;
     logical1                        presence_chaine;      logical1                        presence_chaine;
     logical1                        presence_indicateur;      logical1                        presence_indicateur;
Line 868  instruction_read(struct_processus *s_eta Line 874  instruction_read(struct_processus *s_eta
   
     struct sockaddr_un              adresse_unix;      struct sockaddr_un              adresse_unix;
     struct sockaddr_in              adresse_ipv4;      struct sockaddr_in              adresse_ipv4;
   #   ifdef IPV6
     struct sockaddr_in6             adresse_ipv6;      struct sockaddr_in6             adresse_ipv6;
   #   endif
   
     struct timespec                 attente;      struct timespec                 attente;
   
     struct_descripteur_fichier      *descripteur;      struct_descripteur_fichier      *descripteur;
   
       struct_liste_chainee            *l_element_courant;
       struct_liste_chainee            *l_element_inclus;
   
     struct_objet                    *s_objet_adresse;      struct_objet                    *s_objet_adresse;
     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 881  instruction_read(struct_processus *s_eta Line 892  instruction_read(struct_processus *s_eta
     struct_objet                    *s_objet_type;      struct_objet                    *s_objet_type;
   
     unsigned char                   caractere;      unsigned char                   caractere;
       unsigned char                   *clef_utf8;
     unsigned char                   *commande;      unsigned char                   *commande;
     unsigned char                   *tampon_lecture;      unsigned char                   *tampon_lecture;
     unsigned char                   *tampon;      unsigned char                   *tampon;
       unsigned char                   *tampon2;
   
     unsigned long                   i;      unsigned long                   i;
   
Line 907  instruction_read(struct_processus *s_eta Line 920  instruction_read(struct_processus *s_eta
   
         printf("    1: %s, %s\n\n", d_FCH, d_SCK);          printf("    1: %s, %s\n\n", d_FCH, d_SCK);
   
         printf("    1: %s, %s\n", d_INT, d_CHN);          printf("    2: %s, %s\n", d_INT, d_CHN);
         printf("    1: %s\n", d_FCH);          printf("    1: %s\n", d_FCH);
         return;          return;
     }      }
Line 1116  instruction_read(struct_processus *s_eta Line 1129  instruction_read(struct_processus *s_eta
                     {                      {
                         if (tampon_lecture[pointeur] == '"')                          if (tampon_lecture[pointeur] == '"')
                         {                          {
                             presence_chaine = (presence_chaine == d_vrai)                              if (pointeur > 0)
                                     ? d_faux : d_vrai;                              {
                                   if (tampon_lecture[pointeur - 1] != '\\')
                                   {
                                       presence_chaine = (presence_chaine ==
                                               d_vrai) ? d_faux : d_vrai;
                                   }
                               }
                               else
                               {
                                   presence_chaine = (presence_chaine == d_vrai)
                                           ? d_faux : d_vrai;
                               }
                         }                          }
                         else                          else
                         {                          {
Line 1279  instruction_read(struct_processus *s_eta Line 1303  instruction_read(struct_processus *s_eta
                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;                      (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                     return;                      return;
                 }                  }
   
                                   
                 switch(sqlite3_step(ppStmt))                  switch(sqlite3_step(ppStmt))
                 {                  {
Line 1360  instruction_read(struct_processus *s_eta Line 1383  instruction_read(struct_processus *s_eta
                         cf(s_etat_processus, 48);                          cf(s_etat_processus, 48);
                     }                      }
   
                     (*s_etat_processus).instruction_courante = tampon;  
                       
                     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);
   
                     free((*s_etat_processus).instruction_courante);                      free((*s_etat_processus).instruction_courante);
                     free(commande);                      free(commande);
   
                       (*s_etat_processus).instruction_courante = tampon;
                     return;                      return;
                 }                  }
   
Line 1399  instruction_read(struct_processus *s_eta Line 1422  instruction_read(struct_processus *s_eta
             }              }
             else              else
             {              {
                   BUG(((*descripteur).type != 'S'), uprintf("Bad filtype !\n"));
   
                   if (depilement(s_etat_processus, &((*s_etat_processus)
                           .l_base_pile), &s_objet_argument_2) == d_erreur)
                   {
                       (*s_etat_processus).erreur_execution = d_ex_manque_argument;
                       return;
                   }
   
                   if ((*s_objet_argument_2).type != CHN)
                   {
                       liberation(s_etat_processus, s_objet_argument_1);
                       liberation(s_etat_processus, s_objet_argument_2);
   
                       (*s_etat_processus).erreur_execution =
                               d_ex_erreur_type_argument;
                       return;
                   }
   
                   // Récupération de la position de la clef
   
                   if (alsprintf(&commande, "select key from control "
                           "where id = 1") < 0)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
                           commande, strlen(commande), &ppStmt, &queue)
                           != SQLITE_OK)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   if (sqlite3_step(ppStmt) != SQLITE_ROW)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   position_clef = sqlite3_column_int64(ppStmt, 0);
   
                   if (sqlite3_step(ppStmt) != SQLITE_DONE)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   if (sqlite3_finalize(ppStmt) != SQLITE_OK)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   free(commande);
   
                   if ((clef_utf8 = transliteration(s_etat_processus,
                           (unsigned char *) (*s_objet_argument_2).objet,
                           d_locale, "UTF-8")) == NULL)
                   {
                       liberation(s_etat_processus, s_objet_argument_1);
                       liberation(s_etat_processus, s_objet_argument_2);
   
                       return;
                   }
   
                   // Récupération de l'identifiant de la clef
   
                   if (alsprintf(&commande, "select id from key where key = "
                           "'{ \"%s\" }'", clef_utf8) < 0)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
                           commande, strlen(commande), &ppStmt, &queue)
                           != SQLITE_OK)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   switch(sqlite3_step(ppStmt))
                   {
                       case SQLITE_ROW:
                       {
                           // Résultat attendu : une clef correspond.
                           break;
                       }
   
                       case SQLITE_DONE:
                       {
                           // Aucun enregistrement
                           if (sqlite3_finalize(ppStmt) != SQLITE_OK)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_erreur_fichier;
                               return;
                           }
   
                           free(clef_utf8);
                           free(commande);
   
                           liberation(s_etat_processus, s_objet_argument_1);
                           liberation(s_etat_processus, s_objet_argument_2);
   
                           (*s_etat_processus).erreur_execution =
                                   d_ex_enregistrement_inexistant;
                           return;
                       }
   
                       default:
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_erreur_fichier;
                           return;
                       }
                   }
   
                   if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
                   {
                       free(clef_utf8);
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   id = sqlite3_column_int64(ppStmt, 0);
   
                   if (sqlite3_step(ppStmt) != SQLITE_DONE)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   if (sqlite3_finalize(ppStmt) != SQLITE_OK)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_erreur_fichier;
                       return;
                   }
   
                   free(commande);
   
                   if (alsprintf(&commande, "select data from data where "
                           "key_id = %lld order by sequence asc", id) < 0)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
                           commande, strlen(commande), &ppStmt, &queue)
                           != SQLITE_OK)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                       return;
                   }
   
                   element = 1;
   
                   do
                   {
                       switch(ios = sqlite3_step(ppStmt))
                       {
                           case SQLITE_ROW:
                           {
                               // Donnée supplémentaire
   
                               if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT)
                               {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_erreur_fichier;
                                   return;
                               }
   
                               tampon = (*s_etat_processus).instruction_courante;
   
                               if ((tampon_lecture = (unsigned char *)
                                       sqlite3_column_text(ppStmt, 0)) == NULL)
                               {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_erreur_fichier;
                                   return;
                               }
   
                               if (((*s_etat_processus).instruction_courante =
                                       transliteration(s_etat_processus,
                                       tampon_lecture,
                                       "UTF-8", d_locale)) == NULL)
                               {
                                   (*s_etat_processus).instruction_courante =
                                           tampon;
   
                                   liberation(s_etat_processus,
                                           s_objet_argument_1);
                                   liberation(s_etat_processus,
                                           s_objet_argument_2);
   
                                   free(commande);
                                   free(clef_utf8);
                                   return;
                               }
   
                               indicateur_48 = test_cfsf(s_etat_processus, 48);
                               cf(s_etat_processus, 48);
   
                               recherche_type(s_etat_processus);
   
                               if ((*s_etat_processus).erreur_execution != d_ex)
                               {
                                   if (indicateur_48 == d_vrai)
                                   {
                                       sf(s_etat_processus, 48);
                                   }
                                   else
                                   {
                                       cf(s_etat_processus, 48);
                                   }
   
                                   liberation(s_etat_processus,
                                           s_objet_argument_1);
                                   liberation(s_etat_processus,
                                           s_objet_argument_2);
   
                                   free((*s_etat_processus).instruction_courante);
                                   free(commande);
                                   free(clef_utf8);
   
                                   (*s_etat_processus).instruction_courante =
                                           tampon;
                                   return;
                               }
   
                               if (indicateur_48 == d_vrai)
                               {
                                   sf(s_etat_processus, 48);
                               }
                               else
                               {
                                   cf(s_etat_processus, 48);
                               }
   
                               free((*s_etat_processus).instruction_courante);
                               (*s_etat_processus).instruction_courante = tampon;
   
                               element++;
   
                               // Inscription de la clef
   
                               if (element == position_clef)
                               {
                                   if (((*s_etat_processus).instruction_courante =
                                           transliteration(s_etat_processus,
                                           clef_utf8, "UTF-8", d_locale)) == NULL)
                                   {
                                       (*s_etat_processus).instruction_courante =
                                               tampon;
   
                                       liberation(s_etat_processus,
                                               s_objet_argument_1);
                                       liberation(s_etat_processus,
                                               s_objet_argument_2);
   
                                       free(commande);
                                       free(clef_utf8);
                                       return;
                                   }
   
                                   if (alsprintf(&tampon2, "{ \"%s\" }",
                                           (*s_etat_processus)
                                           .instruction_courante) < 0)
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_allocation_memoire;
                                       return;
                                   }
   
                                   free((*s_etat_processus).instruction_courante);
                                   (*s_etat_processus).instruction_courante
                                           = tampon2;
   
                                   indicateur_48 = test_cfsf(s_etat_processus, 48);
                                   cf(s_etat_processus, 48);
   
                                   recherche_type(s_etat_processus);
   
                                   if ((*s_etat_processus).erreur_execution
                                           != d_ex)
                                   {
                                       if (indicateur_48 == d_vrai)
                                       {
                                           sf(s_etat_processus, 48);
                                       }
                                       else
                                       {
                                           cf(s_etat_processus, 48);
                                       }
   
                                       liberation(s_etat_processus,
                                               s_objet_argument_1);
                                       liberation(s_etat_processus,
                                               s_objet_argument_2);
   
                                       free((*s_etat_processus)
                                               .instruction_courante);
                                       free(commande);
                                       free(clef_utf8);
   
                                       (*s_etat_processus).instruction_courante =
                                               tampon;
                                       return;
                                   }
   
                                   if (indicateur_48 == d_vrai)
                                   {
                                       sf(s_etat_processus, 48);
                                   }
                                   else
                                   {
                                       cf(s_etat_processus, 48);
                                   }
   
                                   free((*s_etat_processus).instruction_courante);
                                   (*s_etat_processus).instruction_courante =
                                           tampon;
   
                                   element++;
                               }
   
                               break;
                           }
   
                           case SQLITE_DONE:
                           {
                               // Fin de la liste
                               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;
                   }
   
                   free(commande);
                   free(clef_utf8);
   
                   liberation(s_etat_processus, s_objet_argument_2);
   
                   if ((s_objet_resultat = allocation(s_etat_processus, LST))
                           == NULL)
                   {
                       (*s_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   l_element_courant = NULL;
                   l_element_inclus = NULL;
   
                   for(element--; element > 0; element--)
                   {
                       if (depilement(s_etat_processus, &((*s_etat_processus)
                               .l_base_pile), &s_objet_argument_2) == d_erreur)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_erreur_fichier;
                           return;
                       }
   
                       if ((*s_objet_argument_2).type != LST)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_erreur_fichier;
                           return;
                       }
   
                       l_element_inclus = (*s_objet_argument_2).objet;
   
                       if (l_element_inclus != NULL)
                       {
                           while(l_element_inclus != NULL)
                           {
                               if ((*l_element_inclus).suivant == NULL)
                               {
                                   (*l_element_inclus).suivant = l_element_courant;
                                   break;
                               }
   
                               l_element_inclus = (*l_element_inclus).suivant;
                           }
   
                           l_element_courant = (*s_objet_argument_2).objet;
                           (*s_objet_argument_2).objet = NULL;
                       }
   
                       liberation(s_etat_processus, s_objet_argument_2);
                   }
   
                   (*s_objet_resultat).objet = l_element_inclus;
   
                   if (empilement(s_etat_processus,
                           &((*s_etat_processus).l_base_pile),
                           s_objet_resultat) == d_erreur)
                   {
                       return;
                   }
             }              }
         }          }
         else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire          else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).binaire
Line 1463  instruction_read(struct_processus *s_eta Line 1915  instruction_read(struct_processus *s_eta
                     return;                      return;
                 }                  }
   
   #               ifndef SEMAPHORES_NOMMES
                 if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)                  if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_processus;                      (*s_etat_processus).erreur_systeme = d_es_processus;
                     return;                      return;
                 }                  }
   #               else
                   if (sem_post((*s_etat_processus).semaphore_fork) != 0)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_processus;
                       return;
                   }
   #               endif
   
                 for(;;)                  for(;;)
                 {                  {
Line 1494  instruction_read(struct_processus *s_eta Line 1954  instruction_read(struct_processus *s_eta
                     else if ((*((struct_socket *) (*s_objet_argument_1).objet))                      else if ((*((struct_socket *) (*s_objet_argument_1).objet))
                             .domaine == PF_INET6)                              .domaine == PF_INET6)
                     {                      {
   #                       ifdef IPV6
                         longueur_adresse = sizeof(adresse_ipv6);                          longueur_adresse = sizeof(adresse_ipv6);
                         longueur_effective = recvfrom((*((struct_socket *)                          longueur_effective = recvfrom((*((struct_socket *)
                                 (*s_objet_argument_1).objet)).socket,                                  (*s_objet_argument_1).objet)).socket,
                                 tampon_lecture, longueur_questure,                                  tampon_lecture, longueur_questure,
                                 MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)                                  MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
                                 &adresse_ipv6, &longueur_adresse);                                  &adresse_ipv6, &longueur_adresse);
   #                       else
   #                       endif
                     }                      }
                     else                      else
                     {                      {
                         free(tampon_lecture);                          free(tampon_lecture);
                         liberation(s_etat_processus, s_objet_argument_1);                          liberation(s_etat_processus, s_objet_argument_1);
   
   #                       ifndef SEMAPHORES_NOMMES
                         while(sem_wait(&((*s_etat_processus)                          while(sem_wait(&((*s_etat_processus)
                                 .semaphore_fork)) == -1)                                  .semaphore_fork)) == -1)
   #                       else
                           while(sem_wait((*s_etat_processus)
                                   .semaphore_fork) == -1)
   #                       endif
                         {                          {
                             if (errno != EINTR)                              if (errno != EINTR)
                             {                              {
Line 1535  instruction_read(struct_processus *s_eta Line 2003  instruction_read(struct_processus *s_eta
                     }                      }
                 }                  }
   
                 while(sem_wait(&((*s_etat_processus).semaphore_fork))  #               ifndef SEMAPHORES_NOMMES
                         == -1)                  while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
   #               else
                   while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
   #               endif
                 {                  {
                     if (errno != EINTR)                      if (errno != EINTR)
                     {                      {
Line 1823  instruction_read(struct_processus *s_eta Line 2294  instruction_read(struct_processus *s_eta
             else if ((*((struct_socket *) (*s_objet_argument_1).objet))              else if ((*((struct_socket *) (*s_objet_argument_1).objet))
                     .domaine == PF_INET6)                      .domaine == PF_INET6)
             {              {
   #               ifdef IPV6
                 longueur_adresse = sizeof(adresse_ipv6);                  longueur_adresse = sizeof(adresse_ipv6);
                 recvfrom((*((struct_socket *)                  recvfrom((*((struct_socket *)
                         (*s_objet_argument_1).objet)).socket, tampon_lecture,                          (*s_objet_argument_1).objet)).socket, tampon_lecture,
Line 1889  instruction_read(struct_processus *s_eta Line 2361  instruction_read(struct_processus *s_eta
   
                 (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))                  (*(*((struct_liste_chainee *) (*s_objet_adresse).objet))
                         .suivant).suivant = NULL;                          .suivant).suivant = NULL;
   #               else
   #               endif
             }              }
             else              else
             {              {
Removed from v.1.6  
changed lines
  Added in v.1.19

CVSweb interface <joel.bertrand@systella.fr>