[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.67 and 1.72

version 1.67, 2012/12/20 15:32:52 version 1.72, 2013/03/10 17:01:05
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.12    RPL/2 (R) version 4.1.13
   Copyright (C) 1989-2012 Dr. BERTRAND Joël    Copyright (C) 1989-2013 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 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                        i;
     integer8                        id;      integer8                        id;
Line 878  instruction_read(struct_processus *s_eta Line 877  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
     struct sockaddr_in6             adresse_ipv6;      struct sockaddr_in6             adresse_ipv6;
 #   endif  #   endif
   
       struct pollfd                   poll_fd;
   
     struct timespec                 attente;      struct timespec                 attente;
   
     struct_descripteur_fichier      *descripteur;      struct_descripteur_fichier      *descripteur;
Line 893  instruction_read(struct_processus *s_eta Line 892  instruction_read(struct_processus *s_eta
     struct_liste_chainee            *l_element_courant;      struct_liste_chainee            *l_element_courant;
     struct_liste_chainee            *l_element_courant_format;      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;
   
Line 906  instruction_read(struct_processus *s_eta Line 903  instruction_read(struct_processus *s_eta
     unsigned char                   *clef_utf8;      unsigned char                   *clef_utf8;
     unsigned char                   *commande;      unsigned char                   *commande;
     unsigned char                   *format_chaine;      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 1313  instruction_read(struct_processus *s_eta Line 1308  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))                  attente.tv_sec = 0;
                   attente.tv_nsec = GRANULARITE_us * 1000;
   
                   do
                 {                  {
                     case SQLITE_ROW:                      ios = sqlite3_step(ppStmt);
                     {  
                         // Résultat attendu  
                         break;  
                     }  
   
                     case SQLITE_DONE:                      switch(ios)
                     {                      {
                         // Aucun enregistrement                          case SQLITE_ROW:
                         if (sqlite3_finalize(ppStmt) != SQLITE_OK)  
                         {                          {
                             (*s_etat_processus).erreur_systeme =                              // Résultat attendu
                                     d_es_erreur_fichier;                              break;
                             return;  
                         }                          }
   
                         free(commande);                          case SQLITE_DONE:
                           {
                               // Aucun enregistrement
                               if (sqlite3_finalize(ppStmt) != SQLITE_OK)
                               {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_erreur_fichier;
                                   return;
                               }
   
                         liberation(s_etat_processus, s_objet_argument_1);                              free(commande);
                         liberation(s_etat_processus, s_objet_argument_2);  
   
                         (*s_etat_processus).erreur_execution =                              liberation(s_etat_processus, s_objet_argument_1);
                                 d_ex_enregistrement_inexistant;                              liberation(s_etat_processus, s_objet_argument_2);
                         return;  
                     }  
   
                     default:                              (*s_etat_processus).erreur_execution =
                     {                                      d_ex_enregistrement_inexistant;
                         (*s_etat_processus).erreur_systeme =                              return;
                                 d_es_erreur_fichier;                          }
                         return;  
                           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_ROW);
   
                 if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT)                  if (sqlite3_column_type(ppStmt, 0) != SQLITE_TEXT)
                 {                  {
Line 1469  instruction_read(struct_processus *s_eta Line 1480  instruction_read(struct_processus *s_eta
                     return;                      return;
                 }                  }
   
                 if (sqlite3_step(ppStmt) != SQLITE_ROW)                  attente.tv_sec = 0;
                   attente.tv_nsec = GRANULARITE_us * 1000;
   
                   do
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;                      ios = sqlite3_step(ppStmt);
                     return;  
                 }                      if (ios == SQLITE_ROW)
                       {
                           break;
                       }
                       else if ((ios == SQLITE_BUSY) || (ios == SQLITE_LOCKED))
                       {
                           nanosleep(&attente, NULL);
                           INCR_GRANULARITE(attente.tv_nsec);
                       }
                       else
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_erreur_fichier;
                           return;
                       }
                   } while(ios != SQLITE_ROW);
   
                 if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)                  if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
                 {                  {
Line 1525  instruction_read(struct_processus *s_eta Line 1554  instruction_read(struct_processus *s_eta
                     return;                      return;
                 }                  }
   
                 switch(sqlite3_step(ppStmt))                  attente.tv_sec = 0;
                   attente.tv_nsec = GRANULARITE_us * 1000;
   
                   do
                 {                  {
                     case SQLITE_ROW:                      ios = sqlite3_step(ppStmt);
                     {  
                         // Résultat attendu : une clef correspond.  
                         break;  
                     }  
   
                     case SQLITE_DONE:                      switch(ios)
                     {                      {
                         // Aucun enregistrement                          case SQLITE_ROW:
                         if (sqlite3_finalize(ppStmt) != SQLITE_OK)  
                         {                          {
                             (*s_etat_processus).erreur_systeme =                              // Résultat attendu : une clef correspond.
                                     d_es_erreur_fichier;                              break;
                             return;  
                         }                          }
   
                         free(clef_utf8);                          case SQLITE_DONE:
                         free(commande);                          {
                               // Aucun enregistrement
                               if (sqlite3_finalize(ppStmt) != SQLITE_OK)
                               {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_erreur_fichier;
                                   return;
                               }
   
                         liberation(s_etat_processus, s_objet_argument_1);                              free(clef_utf8);
                         liberation(s_etat_processus, s_objet_argument_2);                              free(commande);
   
                         (*s_etat_processus).erreur_execution =                              liberation(s_etat_processus, s_objet_argument_1);
                                 d_ex_enregistrement_inexistant;                              liberation(s_etat_processus, s_objet_argument_2);
                         return;  
                     }  
   
                     default:                              (*s_etat_processus).erreur_execution =
                     {                                      d_ex_enregistrement_inexistant;
                         (*s_etat_processus).erreur_systeme =                              return;
                                 d_es_erreur_fichier;                          }
                         return;  
                           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_ROW);
   
                 if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)                  if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
                 {                  {
Line 1604  instruction_read(struct_processus *s_eta Line 1649  instruction_read(struct_processus *s_eta
   
                 element = 1;                  element = 1;
   
                   attente.tv_sec = 0;
                   attente.tv_nsec = GRANULARITE_us * 1000;
   
                 do                  do
                 {                  {
                     switch(ios = sqlite3_step(ppStmt))                      switch(ios = sqlite3_step(ppStmt))
Line 1782  instruction_read(struct_processus *s_eta Line 1830  instruction_read(struct_processus *s_eta
                             break;                              break;
                         }                          }
   
                           case SQLITE_BUSY:
                           case SQLITE_LOCKED:
                           {
                               nanosleep(&attente, NULL);
                               INCR_GRANULARITE(attente.tv_nsec);
                               break;
                           }
   
                         default:                          default:
                         {                          {
                             (*s_etat_processus).erreur_systeme =                              (*s_etat_processus).erreur_systeme =
Line 1889  instruction_read(struct_processus *s_eta Line 1945  instruction_read(struct_processus *s_eta
   
                 BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n"));                  BUG(((*descripteur).type != 'C'), uprintf("Bad filtype !\n"));
   
                 if (fread(&type_enregistrement, (size_t) sizeof(unsigned char),                  if ((s_objet_resultat = lecture_fichier_non_formate(
                         1, (*descripteur).descripteur_c) != 1)                          s_etat_processus, (*descripteur).descripteur_c, -1,
                 {                          d_faux)) == NULL)
                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;  
                     return;  
                 }  
   
                 if ((type_enregistrement & 0xF0) != 0x40)  
                 {                  {
                     // L'enregistrement trouvé n'est pas une liste.  
                     // Tout porte à croire que le fichier est corrompu.  
                     (*s_etat_processus).erreur_execution =  
                             d_ex_fichier_corrompu;  
                     return;                      return;
                 }                  }
   
                 switch(type_enregistrement)                  if (empilement(s_etat_processus,
                 {                          &((*s_etat_processus).l_base_pile),
                     unsigned char       taille_enregistrement[8];                          s_objet_resultat) == d_erreur)
   
                     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;  
                     }  
                 }  
   
 printf("L=%d\n", longueur_enregistrement);  
                 // La variable longueur_enregistrement contient le nombre  
                 // d'éléments à lire dans le fichier pour générer la liste  
                 // contenant l'enregistrement.  
   
                 if ((s_objet_resultat = allocation(s_etat_processus, LST))  
                         == NULL)  
                 {                  {
                     (*s_etat_processus).erreur_systeme =  
                             d_es_allocation_memoire;  
                     return;                      return;
                 }                  }
   
                 for(i = 0; i < longueur_enregistrement; i++)  
                 {  
                     /* A FAIRE  
                     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          else
Line 2294  printf("L=%d\n", longueur_enregistrement Line 2217  printf("L=%d\n", longueur_enregistrement
   
         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 = 4096;
             longueur_effective = 0;              longueur_effective = 0;
             tampon_lecture = NULL;              tampon_lecture = NULL;
   
Line 2337  printf("L=%d\n", longueur_enregistrement Line 2260  printf("L=%d\n", longueur_enregistrement
                     {                      {
                         ios = recvfrom((*((struct_socket *)                          ios = recvfrom((*((struct_socket *)
                                 (*s_objet_argument_1).objet)).socket,                                  (*s_objet_argument_1).objet)).socket,
                                 tampon_lecture + longueur_effective,                                  tampon_lecture,
                                 longueur_questure,                                  longueur_effective + longueur_questure,
                                 MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)                                  MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
                                 &adresse_unix, &longueur_adresse);                                  &adresse_unix, &longueur_adresse);
                     } while((ios == -1) && (errno == EINTR));                      } while((ios == -1) && (errno == EINTR));
Line 2352  printf("L=%d\n", longueur_enregistrement Line 2275  printf("L=%d\n", longueur_enregistrement
                     {                      {
                         ios = recvfrom((*((struct_socket *)                          ios = recvfrom((*((struct_socket *)
                                 (*s_objet_argument_1).objet)).socket,                                  (*s_objet_argument_1).objet)).socket,
                                 tampon_lecture + longueur_effective,                                  tampon_lecture,
                                 longueur_questure,                                  longueur_effective + longueur_questure,
                                 MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)                                  MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
                                 &adresse_ipv4, &longueur_adresse);                                  &adresse_ipv4, &longueur_adresse);
                     } while((ios == -1) && (errno == EINTR));                      } while((ios == -1) && (errno == EINTR));
Line 2368  printf("L=%d\n", longueur_enregistrement Line 2291  printf("L=%d\n", longueur_enregistrement
                     {                      {
                         ios = recvfrom((*((struct_socket *)                          ios = recvfrom((*((struct_socket *)
                                 (*s_objet_argument_1).objet)).socket,                                  (*s_objet_argument_1).objet)).socket,
                                 tampon_lecture + longueur_effective,                                  tampon_lecture,
                                 longueur_questure,                                  longueur_effective + longueur_questure,
                                 MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)                                  MSG_PEEK | MSG_DONTWAIT, (struct sockaddr *)
                                 &adresse_ipv6, &longueur_adresse);                                  &adresse_ipv6, &longueur_adresse);
                     } while((ios == -1) && (errno == EINTR));                      } while((ios == -1) && (errno == EINTR));
Line 2438  printf("L=%d\n", longueur_enregistrement Line 2361  printf("L=%d\n", longueur_enregistrement
   
                 if (ios >= 0)                  if (ios >= 0)
                 {                  {
                     ancienne_longueur_effective = longueur_effective;  
                     longueur_effective += ios;                      longueur_effective += ios;
                     position_initiale = 0;                      position_initiale = 0;
                     presence_indicateur = d_faux;                      presence_indicateur = d_faux;
Line 2509  printf("L=%d\n", longueur_enregistrement Line 2431  printf("L=%d\n", longueur_enregistrement
                         }                          }
                     }                      }
   
                     // On retire du buffer position_finale -                      // On retire une trame du buffer.
                     // ancienne_longueur_effective octets.  
   
                     if ((*((struct_socket *) (*s_objet_argument_1).objet))  
                             .domaine == PF_UNIX)  
                     {  
                         longueur_adresse = sizeof(adresse_unix);  
   
                         do  
                         {  
                             ios = recvfrom((*((struct_socket *)  
                                     (*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)).domaine == PF_INET)  
                     {  
                         longueur_adresse = sizeof(adresse_ipv4);  
   
                         do                      if (trame_complete == d_vrai)
                         {  
                             ios = recvfrom((*((struct_socket *)  
                                     (*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)) .domaine == PF_INET6)  
                     {                      {
 #                       ifdef IPV6                          if ((*((struct_socket *) (*s_objet_argument_1).objet))
                         longueur_adresse = sizeof(adresse_ipv6);                                  .domaine == PF_UNIX)
   
                         do  
                         {                          {
                             ios = recvfrom((*((struct_socket *)                              do
                                     (*s_objet_argument_1).objet)).socket,                              {
                                     poubelle, position_finale                                  longueur_adresse = sizeof(adresse_unix);
                                     - ancienne_longueur_effective,                                  recvfrom((*((struct_socket *)
                                     MSG_DONTWAIT, (struct sockaddr *)                                          (*s_objet_argument_1).objet)).socket,
                                     &adresse_ipv6, &longueur_adresse);                                          tampon_lecture, longueur_effective,
                         } while((ios == -1) && (errno == EINTR));                                          0, (struct sockaddr *)
 #                       else                                          &adresse_unix, &longueur_adresse);
                         if ((*s_etat_processus).langue == 'F')                              } while((ios == -1) && (errno == EINTR));
                           }
                           else if ((*((struct_socket *) (*s_objet_argument_1)
                                   .objet)).domaine == PF_INET)
                         {                          {
                             printf("+++Attention : Support du protocole"                              do
                                     " IPv6 indisponible\n");                              {
                                   longueur_adresse = sizeof(adresse_ipv4);
                                   recvfrom((*((struct_socket *)
                                           (*s_objet_argument_1).objet)).socket,
                                           tampon_lecture, longueur_effective,
                                           0, (struct sockaddr *)
                                           &adresse_ipv4, &longueur_adresse);
                               } while((ios == -1) && (errno == EINTR));
                         }                          }
                         else                          else if ((*((struct_socket *) (*s_objet_argument_1)
                                   .objet)) .domaine == PF_INET6)
                         {                          {
                             printf("+++Warning : IPv6 support "  #                           ifdef IPV6
                                     "unavailable\n");                              do
                               {
                                   longueur_adresse = sizeof(adresse_ipv6);
                                   recvfrom((*((struct_socket *)
                                           (*s_objet_argument_1).objet)).socket,
                                           tampon_lecture, longueur_effective,
                                           0, (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");
                               }
   
   #                           endif
                         }                          }
   
                         longueur_adresse = 0;                          longueur_effective = ios;
 #                       endif  
                     }                      }
                       else
                     if (presence_indicateur == d_faux)  
                     {                      {
                           // Installation d'un timeout pour sortir de
                           // l'instruction dans le cas où la transmission serait
                           // invalide et que la trame reçue serait erronée.
   
                         poll_fd.fd = (*((struct_socket *)                          poll_fd.fd = (*((struct_socket *)
                                 (*s_objet_argument_1).objet)).socket;                                  (*s_objet_argument_1).objet)).socket;
                         poll_fd.events = POLLIN;                          poll_fd.events = POLLIN;
   
                         while((ios = poll(&poll_fd, 1, 10000)) <= 0)                          while((ios = poll(&poll_fd, 1, 10000)) <= 0)
                         {                          {
                             // La fin de la trame n'est pas atteinte                              // La fin de la trame n'est pas atteinte.
                             // et il reste quelque chose à lire.  
   
                             switch(ios)                              switch(ios)
                             {                              {
Line 2656  printf("L=%d\n", longueur_enregistrement Line 2577  printf("L=%d\n", longueur_enregistrement
   
             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;
             (*s_etat_processus).instruction_courante = &(tampon_lecture              (*s_etat_processus).instruction_courante = tampon_lecture;
                     [position_initiale]);  
   
             indicateur_48 = test_cfsf(s_etat_processus, 48);              indicateur_48 = test_cfsf(s_etat_processus, 48);
             cf(s_etat_processus, 48);              cf(s_etat_processus, 48);
Removed from v.1.67  
changed lines
  Added in v.1.72

CVSweb interface <joel.bertrand@systella.fr>