[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.35 and 1.60

version 1.35, 2011/06/22 13:27:02 version 1.60, 2012/07/05 08:05:50
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.0.prerelease.3    RPL/2 (R) version 4.1.9
   Copyright (C) 1989-2011 Dr. BERTRAND Joël    Copyright (C) 1989-2012 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 851  instruction_read(struct_processus *s_eta Line 851  instruction_read(struct_processus *s_eta
     int                             c;      int                             c;
     int                             ios;      int                             ios;
   
       integer8                        ancienne_longueur_effective;
     integer8                        element;      integer8                        element;
       integer8                        i;
     integer8                        id;      integer8                        id;
     integer8                        position_clef;      integer8                        position_clef;
       integer8                        longueur_effective;
       integer8                        longueur_enregistrement;
       integer8                        longueur_questure;
       integer8                        niveau;
       integer8                        pointeur;
       integer8                        position_finale;
       integer8                        position_initiale;
   
       logical1                        format_degenere;
     logical1                        indicateur_48;      logical1                        indicateur_48;
     logical1                        presence_chaine;      logical1                        presence_chaine;
     logical1                        presence_indicateur;      logical1                        presence_indicateur;
       logical1                        trame_complete;
   
     long                            i;      long                            longueur;
     long                            longueur_effective;  
     long                            longueur_enregistrement;  
     long                            longueur_questure;  
     long                            niveau;  
     long                            pointeur;  
     long                            position_finale;  
     long                            position_initiale;  
   
     socklen_t                       longueur_adresse;      socklen_t                       longueur_adresse;
   
Line 874  instruction_read(struct_processus *s_eta Line 878  instruction_read(struct_processus *s_eta
   
     struct flock                    lock;      struct flock                    lock;
   
       struct pollfd                   poll_fd;
   
     struct sockaddr_un              adresse_unix;      struct sockaddr_un              adresse_unix;
     struct sockaddr_in              adresse_ipv4;      struct sockaddr_in              adresse_ipv4;
 #   ifdef IPV6  #   ifdef IPV6
Line 885  instruction_read(struct_processus *s_eta Line 891  instruction_read(struct_processus *s_eta
     struct_descripteur_fichier      *descripteur;      struct_descripteur_fichier      *descripteur;
   
     struct_liste_chainee            *l_element_courant;      struct_liste_chainee            *l_element_courant;
       struct_liste_chainee            *l_element_courant_format;
     struct_liste_chainee            *l_element_inclus;      struct_liste_chainee            *l_element_inclus;
       struct_liste_chainee            *l_element_suivant;
   
     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;
       struct_objet                    *s_objet_element;
     struct_objet                    *s_objet_resultat;      struct_objet                    *s_objet_resultat;
     struct_objet                    *s_objet_type;      struct_objet                    *s_objet_type;
   
     unsigned char                   caractere;      unsigned char                   caractere;
     unsigned char                   *clef_utf8;      unsigned char                   *clef_utf8;
     unsigned char                   *commande;      unsigned char                   *commande;
       unsigned char                   *format_chaine;
       unsigned char                   poubelle[256];
     unsigned char                   *ptr;      unsigned char                   *ptr;
     unsigned char                   *tampon_lecture;      unsigned char                   *tampon_lecture;
     unsigned char                   *tampon;      unsigned char                   *tampon;
     unsigned char                   *tampon2;      unsigned char                   *tampon2;
       unsigned char                   type_enregistrement;
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
Line 1857  instruction_read(struct_processus *s_eta Line 1869  instruction_read(struct_processus *s_eta
             /*              /*
              * Fichiers non formatés               * Fichiers non formatés
              */               */
         }  
         else  
         {  
             /*  
              * Fichiers de type FLOW  
              */  
   
             if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces              if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
                     == 'S')                      == 'S')
             {              {
                 /*                  /*
                  * Fichiers séquentiels                   * Fichiers séquentiels
                    *
                    * Les fichiers séquentiels non formatés contiennent comme
                    * les fichiers séquentiels formatés leurs enregistrements
                    * sous la forme de listes les unes derrières les autres.
                    *
                    * Le quartet de poids fort du premier octet à lire
                    * doit donc être égal à 0100. Si ce n'est pas le cas,
                    * il sera impossible de lire le fichier et on renvoie
                    * immédiatement une erreur. Si on lit dans le fichier
                    * la valeur attendue, on récupère la longueur en octet
                    * de l'enregistrement puis on le lit.
                  */                   */
   
                 BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n"));                  BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n"));
                 longueur_enregistrement = 0;  
   
                 if ((position_initiale = ftell((*descripteur).descripteur_c))                  if (fread(&type_enregistrement, (size_t) sizeof(unsigned char),
                         == -1)                          1, (*descripteur).descripteur_c) != 1)
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;                      (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                     return;                      return;
                 }                  }
   
                 do                  if ((type_enregistrement & 0xF0) != 0x40)
                 {  
                     c = getc((*descripteur).descripteur_c);  
                     longueur_enregistrement++;  
                 } while((c != '\n') && (c != EOF));  
   
                 if (fseek((*descripteur).descripteur_c, position_initiale,  
                         SEEK_SET) != 0)  
                 {                  {
                     liberation(s_etat_processus, s_objet_argument_1);                      // L'enregistrement trouvé n'est pas une liste.
                       // Tout porte à croire que le fichier est corrompu.
                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;                      (*s_etat_processus).erreur_execution =
                               d_ex_fichier_corrompu;
                     return;                      return;
                 }                  }
   
                 if ((tampon_lecture = malloc((longueur_enregistrement + 1)                  switch(type_enregistrement)
                         * sizeof(unsigned char))) == NULL)  
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      unsigned char       taille_enregistrement[8];
                             d_es_allocation_memoire;  
                     return;                      case 0x48:
                       {
                           if (fread(taille_enregistrement,
                                   (size_t) sizeof(unsigned char),
                                   1, (*descripteur).descripteur_c) != 1)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_erreur_fichier;
                               return;
                           }
   
                           longueur_enregistrement = taille_enregistrement[0];
                           break;
                       }
   
                       case 0x49:
                       {
                           if (fread(taille_enregistrement,
                                   (size_t) sizeof(unsigned char),
                                   2, (*descripteur).descripteur_c) != 2)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_erreur_fichier;
                               return;
                           }
   
   // A FAIRE conversion de taille_enregistrement en longueur_enregistrement
                           break;
                       }
   
                       case 0x4A:
                       {
                           if (fread(taille_enregistrement,
                                   (size_t) sizeof(unsigned char),
                                   4, (*descripteur).descripteur_c) != 4)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_erreur_fichier;
                               return;
                           }
   
   // A FAIRE conversion de taille_enregistrement en longueur_enregistrement
                           break;
                       }
   
                       case 0x4B:
                       {
                           if (fread(taille_enregistrement,
                                   (size_t) sizeof(unsigned char),
                                   8, (*descripteur).descripteur_c) != 8)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_erreur_fichier;
                               return;
                           }
   
   // A FAIRE conversion de taille_enregistrement en longueur_enregistrement
                           break;
                       }
   
                       default:
                       {
                           longueur_enregistrement = type_enregistrement & 0x07;
                       }
                 }                  }
   
                 longueur_effective = fread(tampon_lecture,  printf("L=%d\n", longueur_enregistrement);
                         (size_t) sizeof(unsigned char),                  // La variable longueur_enregistrement contient le nombre
                         (size_t) longueur_enregistrement,                  // d'éléments à lire dans le fichier pour générer la liste
                         (*descripteur).descripteur_c);                  // contenant l'enregistrement.
   
                 if ((s_objet_resultat = allocation(s_etat_processus, LST))                  if ((s_objet_resultat = allocation(s_etat_processus, LST))
                         == NULL)                          == NULL)
Line 1917  instruction_read(struct_processus *s_eta Line 1989  instruction_read(struct_processus *s_eta
                     return;                      return;
                 }                  }
   
                 if (((*s_objet_resultat).objet =                  for(i = 0; i < longueur_enregistrement; i++)
                         allocation_maillon(s_etat_processus)) == NULL)  
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      /* A FAIRE
                             d_es_allocation_memoire;                      s_objet_element = decodage_enregistrement(s_etat_processus,
                               (*descripteur).descripteur_c);
                               */
                       s_objet_element = NULL;
   
                       if (s_objet_element == NULL)
                       {
                           liberation(s_etat_processus, s_objet_resultat);
                           return;
                       }
   
                       if ((*s_objet_resultat).objet == NULL)
                       {
                           if (((*s_objet_resultat).objet = allocation_maillon(
                                   s_etat_processus)) == NULL)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_allocation_memoire;
                               return;
                           }
   
                           (*((struct_liste_chainee *) (*s_objet_resultat).objet))
                                   .donnee = s_objet_element;
                           l_element_courant = (*s_objet_resultat).objet;
                       }
                       else
                       {
                           if ((l_element_suivant = allocation_maillon(
                                   s_etat_processus)) == NULL)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_allocation_memoire;
                               return;
                           }
   
                           (*l_element_courant).suivant = l_element_suivant;
                           (*l_element_suivant).donnee = s_objet_element;
                           l_element_courant = l_element_suivant;
                       }
                   }
   
                   // On saute les caractère des gestion de la commande
                   // BACKSPACE.
                   // A FAIRE
               }
           }
           else
           {
               /*
                * Fichiers de type FLOW
                */
   
               if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
                       == 'S')
               {
                   /*
                    * Fichiers séquentiels
                    */
   
                   BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n"));
                   longueur_enregistrement = 0;
   
                   if ((position_initiale = ftell((*descripteur).descripteur_c))
                           == -1)
                   {
                       (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                     return;                      return;
                 }                  }
   
                 (*((struct_liste_chainee *) (*s_objet_resultat).objet))                  l_element_courant_format = (struct_liste_chainee *)
                         .suivant = NULL;                          (*(*((struct_fichier *) (*s_objet_argument_1).objet))
                           .format).objet;
                   l_element_courant = NULL;
   
                 if (((*((struct_liste_chainee *) (*s_objet_resultat).objet))                  if ((s_objet_resultat = allocation(s_etat_processus, LST))
                         .donnee = allocation(s_etat_processus, CHN)) == NULL)                          == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
                             d_es_allocation_memoire;                              d_es_allocation_memoire;
                     return;                      return;
                 }                  }
   
                 longueur_enregistrement = 1;                  while(l_element_courant_format != NULL)
   
                 for(i = 0; i < longueur_effective; i++)  
                 {                  {
                     if (isprint(tampon_lecture[i]) != 0)                      if ((*(*l_element_courant_format).donnee).type != CHN)
                       {
                           liberation(s_etat_processus, s_objet_argument_1);
                           liberation(s_etat_processus, s_objet_resultat);
   
                           (*s_etat_processus).erreur_execution =
                                   d_ex_erreur_type_argument;
                           return;
                       }
   
                       if ((format_chaine = conversion_majuscule((unsigned char *)
                               (*(*l_element_courant_format).donnee).objet))
                               == NULL)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return;
                       }
   
                       if (strncmp("LENGTH*(", format_chaine, 8) != 0)
                       {
                           liberation(s_etat_processus, s_objet_argument_1);
                           liberation(s_etat_processus, s_objet_resultat);
                           free(format_chaine);
   
                           (*s_etat_processus).erreur_execution =
                                   d_ex_erreur_format_fichier;
                           return;
                       }
   
                       longueur = strlen(format_chaine);
   
                       if (format_chaine[longueur - 1] != ')')
                       {
                           liberation(s_etat_processus, s_objet_argument_1);
                           liberation(s_etat_processus, s_objet_resultat);
                           free(format_chaine);
   
                           (*s_etat_processus).erreur_execution =
                                   d_ex_erreur_format_fichier;
                           return;
                       }
   
                       format_chaine[longueur] = d_code_fin_chaine;
   
                       if (format_chaine[8] == '*')
                     {                      {
                         longueur_enregistrement += 4;                          format_degenere = d_vrai;
                     }                      }
                     else                      else
                     {                      {
                         longueur_enregistrement++;                          // Détermination de la longueur
                           format_degenere = d_faux;
   
                           if (sscanf(&(format_chaine[8]), "%ld", &longueur) != 1)
                           {
                               liberation(s_etat_processus, s_objet_argument_1);
                               liberation(s_etat_processus, s_objet_resultat);
                               free(format_chaine);
   
                               (*s_etat_processus).erreur_execution =
                                       d_ex_erreur_format_fichier;
                               return;
                           }
                     }                      }
                 }  
   
                 if ((tampon = malloc(longueur_enregistrement *                      free(format_chaine);
                         sizeof(unsigned char))) == NULL)  
                 {  
                     (*s_etat_processus).erreur_systeme =  
                             d_es_allocation_memoire;  
                     return;  
                 }  
   
                 ptr = tampon;                      if (format_degenere == d_vrai)
                       {
                           do
                           {
                               c = getc((*descripteur).descripteur_c);
                               longueur_enregistrement++;
                           } while((c != '\n') && (c != EOF));
   
                 for(i = 0; i < longueur_effective; i++)                          if (fseek((*descripteur).descripteur_c,
                 {                                  position_initiale, SEEK_SET) != 0)
                     if (isprint(tampon_lecture[i]) != 0)                          {
                               liberation(s_etat_processus, s_objet_argument_1);
                               liberation(s_etat_processus, s_objet_resultat);
   
                               (*s_etat_processus).erreur_systeme =
                                       d_es_erreur_fichier;
                               return;
                           }
                       }
                       else
                       {
                           longueur_enregistrement = longueur;
                       }
   
                       if ((tampon_lecture = malloc((longueur_enregistrement)
                               * sizeof(unsigned char))) == NULL)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return;
                       }
   
                       longueur_effective = fread(tampon_lecture,
                               (size_t) sizeof(unsigned char),
                               (size_t) longueur_enregistrement,
                               (*descripteur).descripteur_c);
   
                       if (l_element_courant == NULL)
                     {                      {
                         (*ptr) = tampon_lecture[i];                          // Premier maillon de la liste
                         ptr++;                          if (((*s_objet_resultat).objet =
                                   allocation_maillon(s_etat_processus)) == NULL)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_allocation_memoire;
                               return;
                           }
   
                           l_element_courant = (*s_objet_resultat).objet;
                     }                      }
                     else                      else
                     {                      {
                         (*ptr) = '\\';                          if (((*l_element_courant).suivant =
                         ptr++;                                  allocation_maillon(s_etat_processus)) == NULL)
                         (*ptr) = 'x';                          {
                         ptr++;                              (*s_etat_processus).erreur_systeme =
                         sprintf(ptr, "%02X", tampon_lecture[i]);                                      d_es_allocation_memoire;
                         ptr += 2;                              return;
                           }
   
                           l_element_courant = (*l_element_courant).suivant;
                     }                      }
                 }  
   
                 (*ptr) = d_code_fin_chaine;                      (*l_element_courant).suivant = NULL;
                 free(tampon_lecture);  
                 ((*(*((struct_liste_chainee *) (*s_objet_resultat).objet))                      if (((*l_element_courant).donnee =
                         .donnee)).objet = tampon;                              allocation(s_etat_processus, CHN)) == NULL)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return;
                       }
   
                       if (format_degenere == d_vrai)
                       {
                           if (((*(*l_element_courant).donnee).objet =
                               analyse_flux(s_etat_processus, tampon_lecture,
                               longueur_enregistrement - 1)) == NULL)
                           {
                               return;
                           }
                       }
                       else
                       {
                           if (((*(*l_element_courant).donnee).objet =
                               analyse_flux(s_etat_processus, tampon_lecture,
                               longueur_enregistrement)) == NULL)
                           {
                               return;
                           }
                       }
   
                       free(tampon_lecture);
   
                       l_element_courant_format =
                               (*l_element_courant_format).suivant;
                   }
   
                 if (empilement(s_etat_processus,                  if (empilement(s_etat_processus,
                         &((*s_etat_processus).l_base_pile),                          &((*s_etat_processus).l_base_pile),
Line 2037  instruction_read(struct_processus *s_eta Line 2296  instruction_read(struct_processus *s_eta
         if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire == 'N')          if ((*((struct_socket *) (*s_objet_argument_1).objet)).binaire == 'N')
         { // Socket formatée          { // Socket formatée
             longueur_questure = 256;              longueur_questure = 256;
               longueur_effective = 0;
               tampon_lecture = NULL;
   
               attente.tv_sec = 0;
               attente.tv_nsec = GRANULARITE_us * 1000;
   
               trame_complete = d_faux;
               position_initiale = 0;
               position_finale = 0;
   
             do              do
             {              {
                 if ((tampon_lecture = malloc((longueur_questure + 1) *                  presence_indicateur = d_faux;
                         sizeof(unsigned char))) == NULL)  
                   if ((tampon_lecture = realloc(tampon_lecture,
                           (longueur_effective + longueur_questure + 1)
                           * sizeof(unsigned char))) == NULL)
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
                             d_es_allocation_memoire;                              d_es_allocation_memoire;
Line 2049  instruction_read(struct_processus *s_eta Line 2320  instruction_read(struct_processus *s_eta
                 }                  }
   
 #               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
                       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;
                 }                  }
 #               else  
                 if (sem_post((*s_etat_processus).semaphore_fork) != 0)                  if ((*((struct_socket *) (*s_objet_argument_1).objet))
                           .domaine == PF_UNIX)
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_processus;                      longueur_adresse = sizeof(adresse_unix);
   
                       do
                       {
                           ios = recvfrom((*((struct_socket *)
                                   (*s_objet_argument_1).objet)).socket,
                                   tampon_lecture + longueur_effective,
                                   longueur_questure,
                                   MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
                                   &adresse_unix, &longueur_adresse);
                       } while((ios == -1) && (errno == EINTR));
                   }
                   else if ((*((struct_socket *) (*s_objet_argument_1).objet))
                           .domaine == PF_INET)
                   {
                       longueur_adresse = sizeof(adresse_ipv4);
   
                       do
                       {
                           ios = recvfrom((*((struct_socket *)
                                   (*s_objet_argument_1).objet)).socket,
                                   tampon_lecture + longueur_effective,
                                   longueur_questure,
                                   MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
                                   &adresse_ipv4, &longueur_adresse);
                       } while((ios == -1) && (errno == EINTR));
                   }
                   else if ((*((struct_socket *) (*s_objet_argument_1).objet))
                           .domaine == PF_INET6)
                   {
   #                   ifdef IPV6
                       longueur_adresse = sizeof(adresse_ipv6);
                       
                       do
                       {
                           ios = recvfrom((*((struct_socket *)
                                   (*s_objet_argument_1).objet)).socket,
                                   tampon_lecture + longueur_effective,
                                   longueur_questure,
                                   MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
                                   &adresse_ipv6, &longueur_adresse);
                       } while((ios == -1) && (errno == EINTR));
   #                   else
                       if ((*s_etat_processus).langue == 'F')
                       {
                           printf("+++Attention : Support du protocole"
                                   " IPv6 indisponible\n");
                       }
                       else
                       {
                           printf("+++Warning : IPv6 support "
                                   "unavailable\n");
                       }
   
                       longueur_adresse = 0;
                       longueur_effective = 0;
                       ios = 0;
   #                   endif
                   }
                   else
                   {
                       free(tampon_lecture);
                       liberation(s_etat_processus, s_objet_argument_1);
   
   #                   ifndef SEMAPHORES_NOMMES
                           while(sem_wait(&((*s_etat_processus)
                                   .semaphore_fork)) != 0)
   #                   else
                           while(sem_wait((*s_etat_processus)
                                   .semaphore_fork) != 0)
   #                   endif
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_processus;
                       }
   
                       (*s_etat_processus).erreur_execution =
                               d_ex_erreur_acces_fichier;
                     return;                      return;
                 }                  }
 #               endif  
   
                 attente.tv_sec = 0;                  if (ios < 0)
                 attente.tv_nsec = GRANULARITE_us * 1000;                  {
                       nanosleep(&attente, NULL);
                       INCR_GRANULARITE(attente.tv_nsec);
                       scrutation_injection(s_etat_processus);
                   }
                   else
                   {
                       attente.tv_sec = 0;
                       attente.tv_nsec = GRANULARITE_us * 1000;
                   }
   
                 for(;;)                  if ((*s_etat_processus).var_volatile_requete_arret == -1)
                 {                  {
                       longueur_effective += ios;
                       break;
                   }
   
                   // Une donnée a été reçue.
   
                   if (ios >= 0)
                   {
                       ancienne_longueur_effective = longueur_effective;
                       longueur_effective += ios;
                       position_initiale = 0;
                       presence_indicateur = d_faux;
   
                       do
                       {
                           if (tampon_lecture[position_initiale] == '{')
                           {
                               presence_indicateur = d_vrai;
                               break;
                           }
   
                           position_initiale++;
                       } while(position_initiale < longueur_effective);
   
                       if (presence_indicateur == d_vrai)
                       {
                           position_finale = position_initiale + 1;
                           presence_chaine = d_faux;
                           presence_indicateur = d_faux;
                           niveau = 1;
   
                           while(position_finale < longueur_effective)
                           {
                               caractere = tampon_lecture[position_finale];
   
                               if (caractere == '"')
                               {
                                   if (position_finale > 0)
                                   {
                                       if (tampon_lecture[position_finale - 1]
                                               != '\\')
                                       {
                                           presence_chaine = (presence_chaine ==
                                                   d_vrai) ? d_faux : d_vrai;
                                       }
                                   }
                                   else
                                   {
                                       presence_chaine =
                                               (presence_chaine == d_vrai)
                                               ? d_faux : d_vrai;
                                   }
                               }
                               else
                               {
                                   if (presence_chaine == d_faux)
                                   {
                                       if (caractere == '{')
                                       {
                                           niveau++;
                                       }
                                       else if (caractere == '}')
                                       {
                                           niveau--;
                                       }
                                   }
                               }
   
                               if (niveau == 0)
                               {
                                   presence_indicateur = d_vrai;
                                   trame_complete = d_vrai;
                                   break;
                               }
   
                               position_finale++;
                           }
                       }
   
                       // On retire du buffer position_finale -
                       // ancienne_longueur_effective octets.
   
                     if ((*((struct_socket *) (*s_objet_argument_1).objet))                      if ((*((struct_socket *) (*s_objet_argument_1).objet))
                             .domaine == PF_UNIX)                              .domaine == PF_UNIX)
                     {                      {
                         longueur_adresse = sizeof(adresse_unix);                          longueur_adresse = sizeof(adresse_unix);
                         longueur_effective = recvfrom((*((struct_socket *)  
                                 (*s_objet_argument_1).objet)).socket,                          do
                                 tampon_lecture, longueur_questure,                          {
                                 MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)                              ios = recvfrom((*((struct_socket *)
                                 &adresse_unix, &longueur_adresse);                                      (*s_objet_argument_1).objet)).socket,
                                       poubelle, position_finale
                                       - ancienne_longueur_effective,
                                       MSG_DONTWAIT, (struct sockaddr *)
                                       &adresse_unix, &longueur_adresse);
                           }
                           while((ios == -1) && (errno == EINTR));
                     }                      }
                     else if ((*((struct_socket *) (*s_objet_argument_1).objet))                      else if ((*((struct_socket *) (*s_objet_argument_1)
                             .domaine == PF_INET)                              .objet)).domaine == PF_INET)
                     {                      {
                         longueur_adresse = sizeof(adresse_ipv4);                          longueur_adresse = sizeof(adresse_ipv4);
                         longueur_effective = recvfrom((*((struct_socket *)  
                                 (*s_objet_argument_1).objet)).socket,                          do
                                 tampon_lecture, longueur_questure,                          {
                                 MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)                              ios = recvfrom((*((struct_socket *)
                                 &adresse_ipv4, &longueur_adresse);                                      (*s_objet_argument_1).objet)).socket,
                                       poubelle, position_finale
                                       - ancienne_longueur_effective,
                                       MSG_DONTWAIT, (struct sockaddr *)
                                       &adresse_ipv4, &longueur_adresse);
                           }
                           while((ios == -1) && (errno == EINTR));
                     }                      }
                     else if ((*((struct_socket *) (*s_objet_argument_1).objet))                      else if ((*((struct_socket *) (*s_objet_argument_1)
                             .domaine == PF_INET6)                              .objet)) .domaine == PF_INET6)
                     {                      {
 #                       ifdef IPV6  #                       ifdef IPV6
                         longueur_adresse = sizeof(adresse_ipv6);                          longueur_adresse = sizeof(adresse_ipv6);
                         longueur_effective = recvfrom((*((struct_socket *)  
                                 (*s_objet_argument_1).objet)).socket,  
                                 tampon_lecture, longueur_questure,  
                                 MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)  
                                 &adresse_ipv6, &longueur_adresse);  
   
                           do
                           {
                               ios = recvfrom((*((struct_socket *)
                                       (*s_objet_argument_1).objet)).socket,
                                       poubelle, position_finale
                                       - ancienne_longueur_effective,
                                       MSG_DONTWAIT, (struct sockaddr *)
                                       &adresse_ipv6, &longueur_adresse);
                           }
                           while((ios == -1) && (errno == EINTR));
 #                       else  #                       else
                         if ((*s_etat_processus).langue == 'F')                          if ((*s_etat_processus).langue == 'F')
                         {                          {
Line 2109  instruction_read(struct_processus *s_eta Line 2568  instruction_read(struct_processus *s_eta
                             printf("+++Warning : IPv6 support "                              printf("+++Warning : IPv6 support "
                                     "unavailable\n");                                      "unavailable\n");
                         }                          }
   
                           longueur_adresse = 0;
 #                       endif  #                       endif
                     }                      }
                     else  
                       if (presence_indicateur == d_faux)
                     {                      {
                         free(tampon_lecture);                          poll_fd.fd = (*((struct_socket *)
                         liberation(s_etat_processus, s_objet_argument_1);                                  (*s_objet_argument_1).objet)).socket;
                           poll_fd.events = POLLIN;
   
 #                       ifndef SEMAPHORES_NOMMES                          while((ios = poll(&poll_fd, 1, 100)) <= 0)
                         while(sem_wait(&((*s_etat_processus)  
                                 .semaphore_fork)) == -1)  
 #                       else  
                         while(sem_wait((*s_etat_processus)  
                                 .semaphore_fork) == -1)  
 #                       endif  
                         {                          {
                             if (errno != EINTR)                              // La fin de la trame n'est pas atteinte
                             {                              // et il reste quelque chose à lire.
                                 (*s_etat_processus).erreur_systeme =  
                                         d_es_processus;  
                                 return;  
                             }  
                         }  
   
                         (*s_etat_processus).erreur_execution =                              switch(ios)
                                 d_ex_erreur_acces_fichier;                              {
                         return;                                  case EINTR:
                     }                                  {
                                       break;
                     if (longueur_effective < 0)                                  }
                     {  
                         nanosleep(&attente, NULL);  
                         INCR_GRANULARITE(attente.tv_nsec);  
                         scrutation_injection(s_etat_processus);  
                     }  
   
                     // Une donnée a été reçue.                                  case 0:
                                   {
                                       liberation(s_etat_processus,
                                               s_objet_argument_1);
                                       free(tampon_lecture);
   
                     if (((*s_etat_processus).var_volatile_requete_arret == -1)                                      (*s_etat_processus).erreur_execution =
                             || (longueur_effective >= 0))                                              d_ex_fin_de_fichier_atteinte;
                     {                                      return;
                         break;                                  }
                               }
                           }
                     }                      }
                 }                  }
   
 #               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)
                     {                      {
                         (*s_etat_processus).erreur_systeme = d_es_processus;                          (*s_etat_processus).erreur_systeme = d_es_processus;
                         return;                          return;
Line 2190  instruction_read(struct_processus *s_eta Line 2643  instruction_read(struct_processus *s_eta
                             d_ex_erreur_acces_fichier;                              d_ex_erreur_acces_fichier;
                     return;                      return;
                 }                  }
               } while(trame_complete == d_faux);
                 position_initiale = 0;  
                 presence_indicateur = d_faux;  
   
                 do  
                 {  
                     if (tampon_lecture[position_initiale] == '{')  
                     {  
                         presence_indicateur = d_vrai;  
                         break;  
                     }  
   
                     position_initiale++;  
                 } while(position_initiale < longueur_effective);  
   
   
                 if (presence_indicateur == d_vrai)  
                 {  
                     position_finale = position_initiale + 1;  
                     presence_chaine = d_faux;  
                     presence_indicateur = d_faux;  
                     niveau = 1;  
   
                     while(position_finale < longueur_effective)  
                     {  
                         caractere = tampon_lecture[position_finale];  
   
                         if (caractere == '"')  
                         {  
                             presence_chaine = (presence_chaine == d_vrai)  
                                     ? d_faux : d_vrai;  
                         }  
                         else  
                         {  
                             if (presence_chaine == d_faux)  
                             {  
                                 if (caractere == '{')  
                                 {  
                                     niveau++;  
                                 }  
                                 else if (caractere == '}')  
                                 {  
                                     niveau--;  
                                 }  
                             }  
                         }  
   
                         if (niveau == 0)  
                         {  
                             presence_indicateur = d_vrai;  
                             break;  
                         }  
   
                         position_finale++;  
                     }  
                 }  
   
                 if (presence_indicateur == d_faux)  
                 {  
                     if (longueur_effective < longueur_questure)  
                     {  
                         liberation(s_etat_processus, s_objet_argument_1);  
                         free(tampon_lecture);  
   
                         (*s_etat_processus).erreur_execution =  
                                 d_ex_fin_de_fichier_atteinte;  
                         return;  
                     }  
   
                     free(tampon_lecture);  
                     longueur_questure *= 2;  
                 }  
             } while(presence_indicateur == d_faux);  
   
             tampon_lecture[++position_finale] = d_code_fin_chaine;              tampon_lecture[++position_finale] = d_code_fin_chaine;
             tampon = (*s_etat_processus).instruction_courante;              tampon = (*s_etat_processus).instruction_courante;
Line 2279  instruction_read(struct_processus *s_eta Line 2660  instruction_read(struct_processus *s_eta
                 (*s_etat_processus).instruction_courante = tampon;                  (*s_etat_processus).instruction_courante = tampon;
                 free(tampon_lecture);                  free(tampon_lecture);
                                   
                   if (indicateur_48 == d_vrai)
                   {
                       sf(s_etat_processus, 48);
                   }
                   else
                   {
                       cf(s_etat_processus, 48);
                   }
   
                   if ((*s_etat_processus).var_volatile_requete_arret == -1)
                   {
                       (*s_etat_processus).erreur_execution = d_ex;
                   }
   
                 liberation(s_etat_processus, s_objet_argument_1);                  liberation(s_etat_processus, s_objet_argument_1);
                 return;                  return;
             }              }
Line 2354  instruction_read(struct_processus *s_eta Line 2749  instruction_read(struct_processus *s_eta
                     (strcmp((*((struct_socket *) (*s_objet_argument_1).objet))                      (strcmp((*((struct_socket *) (*s_objet_argument_1).objet))
                     .type, "SEQUENTIAL DATAGRAM") == 0))                      .type, "SEQUENTIAL DATAGRAM") == 0))
             {              {
                 longueur_adresse = 0;  
                 recvfrom((*((struct_socket *)  
                         (*s_objet_argument_1).objet)).socket, tampon_lecture,  
                         longueur_effective, MSG_DONTWAIT,  
                         NULL, &longueur_adresse);  
   
                 (*s_objet_adresse).objet = NULL;                  (*s_objet_adresse).objet = NULL;
             }              }
             else if ((*((struct_socket *) (*s_objet_argument_1).objet))              else if ((*((struct_socket *) (*s_objet_argument_1).objet))
                     .domaine == PF_INET)                      .domaine == PF_INET)
             {              {
                 longueur_adresse = sizeof(adresse_ipv4);  
                 recvfrom((*((struct_socket *)  
                         (*s_objet_argument_1).objet)).socket, tampon_lecture,  
                         longueur_effective, MSG_DONTWAIT,  
                         (struct sockaddr *) &adresse_ipv4, &longueur_adresse);  
   
                 if (((*s_objet_adresse).objet =                  if (((*s_objet_adresse).objet =
                         allocation_maillon(s_etat_processus)) == NULL)                          allocation_maillon(s_etat_processus)) == NULL)
                 {                  {
Line 2445  instruction_read(struct_processus *s_eta Line 2828  instruction_read(struct_processus *s_eta
                     .domaine == PF_INET6)                      .domaine == PF_INET6)
             {              {
 #               ifdef IPV6  #               ifdef IPV6
                 longueur_adresse = sizeof(adresse_ipv6);  
                 recvfrom((*((struct_socket *)  
                         (*s_objet_argument_1).objet)).socket, tampon_lecture,  
                         longueur_effective, MSG_DONTWAIT,  
                         (struct sockaddr *) &adresse_ipv6, &longueur_adresse);  
   
                 if (((*s_objet_adresse).objet =                  if (((*s_objet_adresse).objet =
                         allocation_maillon(s_etat_processus)) == NULL)                          allocation_maillon(s_etat_processus)) == NULL)
                 {                  {
Line 2560  instruction_read(struct_processus *s_eta Line 2937  instruction_read(struct_processus *s_eta
                 }                  }
   
 #               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  
   
                 attente.tv_sec = 0;                  attente.tv_sec = 0;
                 attente.tv_nsec = GRANULARITE_us * 1000;                  attente.tv_nsec = GRANULARITE_us * 1000;
Line 2619  instruction_read(struct_processus *s_eta Line 2992  instruction_read(struct_processus *s_eta
                             printf("+++Warning : IPv6 support "                              printf("+++Warning : IPv6 support "
                                     "unavailable\n");                                      "unavailable\n");
                         }                          }
   
                           longueur_adresse = 0;
                           longueur_effective = 0;
 #                       endif  #                       endif
                     }                      }
                     else                      else
Line 2627  instruction_read(struct_processus *s_eta Line 3003  instruction_read(struct_processus *s_eta
                         liberation(s_etat_processus, s_objet_argument_1);                          liberation(s_etat_processus, s_objet_argument_1);
   
 #                       ifndef SEMAPHORES_NOMMES  #                       ifndef SEMAPHORES_NOMMES
                         while(sem_wait(&((*s_etat_processus)                              while(sem_wait(&((*s_etat_processus)
                                 .semaphore_fork)) == -1)                                      .semaphore_fork)) != 0)
 #                       else  #                       else
                         while(sem_wait((*s_etat_processus)                              while(sem_wait((*s_etat_processus)
                                 .semaphore_fork) == -1)                                      .semaphore_fork) != 0)
 #                       endif  #                       endif
                         {                          {
                             if (errno != EINTR)                              if (errno != EINTR)
Line 2662  instruction_read(struct_processus *s_eta Line 3038  instruction_read(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)
Removed from v.1.35  
changed lines
  Added in v.1.60

CVSweb interface <joel.bertrand@systella.fr>