[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.57 and 1.68

version 1.57, 2012/06/19 10:14:56 version 1.68, 2012/12/21 12:09:50
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.9    RPL/2 (R) version 4.1.12
   Copyright (C) 1989-2012 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 864  instruction_read(struct_processus *s_eta Line 864  instruction_read(struct_processus *s_eta
     integer8                        position_finale;      integer8                        position_finale;
     integer8                        position_initiale;      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;      logical1                        trame_complete;
   
       long                            longueur;
   
     socklen_t                       longueur_adresse;      socklen_t                       longueur_adresse;
   
     sqlite3_stmt                    *ppStmt;      sqlite3_stmt                    *ppStmt;
Line 888  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_liste_chainee            *l_element_suivant;
   
Line 901  instruction_read(struct_processus *s_eta Line 905  instruction_read(struct_processus *s_eta
     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                   poubelle[256];
     unsigned char                   *ptr;      unsigned char                   *ptr;
     unsigned char                   *tampon_lecture;      unsigned char                   *tampon_lecture;
Line 1308  instruction_read(struct_processus *s_eta Line 1313  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;
                               }
   
                               free(commande);
   
                         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);
   
                         (*s_etat_processus).erreur_execution =                              (*s_etat_processus).erreur_execution =
                                 d_ex_enregistrement_inexistant;                                      d_ex_enregistrement_inexistant;
                         return;                              return;
                     }                          }
   
                     default:                          case SQLITE_BUSY:
                     {                          case SQLITE_LOCKED:
                         (*s_etat_processus).erreur_systeme =                          {
                                 d_es_erreur_fichier;                              nanosleep(&attente, NULL);
                         return;                              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 1464  instruction_read(struct_processus *s_eta Line 1485  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 1520  instruction_read(struct_processus *s_eta Line 1559  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 1599  instruction_read(struct_processus *s_eta Line 1654  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 1777  instruction_read(struct_processus *s_eta Line 1835  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 1784  instruction_read(struct_processus *s_eta Line 1850  instruction_read(struct_processus *s_eta
                             return;                              return;
                         }                          }
                     }                      }
   
                 } while(ios != SQLITE_DONE);                  } while(ios != SQLITE_DONE);
   
                 if (sqlite3_finalize(ppStmt) != SQLITE_OK)                  if (sqlite3_finalize(ppStmt) != SQLITE_OK)
Line 2056  printf("L=%d\n", longueur_enregistrement Line 2121  printf("L=%d\n", longueur_enregistrement
                     return;                      return;
                 }                  }
   
                 do                  l_element_courant_format = (struct_liste_chainee *)
                 {                          (*(*((struct_fichier *) (*s_objet_argument_1).objet))
                     c = getc((*descripteur).descripteur_c);                          .format).objet;
                     longueur_enregistrement++;                  l_element_courant = NULL;
                 } while((c != '\n') && (c != EOF));  
   
                 if (fseek((*descripteur).descripteur_c, position_initiale,  
                         SEEK_SET) != 0)  
                 {  
                     liberation(s_etat_processus, s_objet_argument_1);  
   
                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;  
                     return;  
                 }  
   
                 if ((tampon_lecture = malloc((longueur_enregistrement + 1)  
                         * 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 ((s_objet_resultat = allocation(s_etat_processus, LST))                  if ((s_objet_resultat = allocation(s_etat_processus, LST))
                         == NULL)                          == NULL)
Line 2092  printf("L=%d\n", longueur_enregistrement Line 2134  printf("L=%d\n", longueur_enregistrement
                     return;                      return;
                 }                  }
   
                 if (((*s_objet_resultat).objet =                  while(l_element_courant_format != NULL)
                         allocation_maillon(s_etat_processus)) == NULL)  
                 {                  {
                     (*s_etat_processus).erreur_systeme =                      if ((*(*l_element_courant_format).donnee).type != CHN)
                             d_es_allocation_memoire;                      {
                     return;                          liberation(s_etat_processus, s_objet_argument_1);
                 }                          liberation(s_etat_processus, s_objet_resultat);
   
                 (*((struct_liste_chainee *) (*s_objet_resultat).objet))                          (*s_etat_processus).erreur_execution =
                         .suivant = NULL;                                  d_ex_erreur_type_argument;
                           return;
                       }
   
                 if (((*((struct_liste_chainee *) (*s_objet_resultat).objet))                      if ((format_chaine = conversion_majuscule((unsigned char *)
                         .donnee = allocation(s_etat_processus, CHN)) == NULL)                              (*(*l_element_courant_format).donnee).objet))
                 {                              == NULL)
                     (*s_etat_processus).erreur_systeme =                      {
                             d_es_allocation_memoire;                          (*s_etat_processus).erreur_systeme =
                     return;                                  d_es_allocation_memoire;
                 }                          return;
                       }
   
                 longueur_enregistrement = 1;                      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);
   
                 for(i = 0; i < longueur_effective; i++)                          (*s_etat_processus).erreur_execution =
                 {                                  d_ex_erreur_format_fichier;
                     if (isprint(tampon_lecture[i]) != 0)                          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)  
                 {                      if (format_degenere == d_vrai)
                     (*s_etat_processus).erreur_systeme =                      {
                             d_es_allocation_memoire;                          do
                     return;                          {
                 }                              c = getc((*descripteur).descripteur_c);
                               longueur_enregistrement++;
                           } while((c != '\n') && (c != EOF));
   
                 ptr = tampon;                          if (fseek((*descripteur).descripteur_c,
                                   position_initiale, SEEK_SET) != 0)
                           {
                               liberation(s_etat_processus, s_objet_argument_1);
                               liberation(s_etat_processus, s_objet_resultat);
   
                 for(i = 0; i < longueur_effective; i++)                              (*s_etat_processus).erreur_systeme =
                 {                                      d_es_erreur_fichier;
                     if (isprint(tampon_lecture[i]) != 0)                              return;
                           }
                       }
                       else
                     {                      {
                         (*ptr) = tampon_lecture[i];                          longueur_enregistrement = longueur;
                         ptr++;                      }
   
                       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)
                       {
                           // Premier maillon de la liste
                           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 2343  printf("L=%d\n", longueur_enregistrement Line 2487  printf("L=%d\n", longueur_enregistrement
   
                 if ((*s_etat_processus).var_volatile_requete_arret == -1)                  if ((*s_etat_processus).var_volatile_requete_arret == -1)
                 {                  {
                     longueur_effective += ios;                      if (ios >= 0)
                       {
                           longueur_effective += ios;
                       }
   
                     break;                      break;
                 }                  }
   
Line 2380  printf("L=%d\n", longueur_enregistrement Line 2528  printf("L=%d\n", longueur_enregistrement
   
                             if (caractere == '"')                              if (caractere == '"')
                             {                              {
                                 presence_chaine =                                  if (position_finale > 0)
                                         (presence_chaine == d_vrai)                                  {
                                         ? d_faux : d_vrai;                                      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                              else
                             {                              {
Line 2426  printf("L=%d\n", longueur_enregistrement Line 2586  printf("L=%d\n", longueur_enregistrement
                                     - ancienne_longueur_effective,                                      - ancienne_longueur_effective,
                                     MSG_DONTWAIT, (struct sockaddr *)                                      MSG_DONTWAIT, (struct sockaddr *)
                                     &adresse_unix, &longueur_adresse);                                      &adresse_unix, &longueur_adresse);
                         }                          } while((ios == -1) && (errno == EINTR));
                         while((ios == -1) && (errno == EINTR));  
                     }                      }
                     else if ((*((struct_socket *) (*s_objet_argument_1)                      else if ((*((struct_socket *) (*s_objet_argument_1)
                             .objet)).domaine == PF_INET)                              .objet)).domaine == PF_INET)
Line 2442  printf("L=%d\n", longueur_enregistrement Line 2601  printf("L=%d\n", longueur_enregistrement
                                     - ancienne_longueur_effective,                                      - ancienne_longueur_effective,
                                     MSG_DONTWAIT, (struct sockaddr *)                                      MSG_DONTWAIT, (struct sockaddr *)
                                     &adresse_ipv4, &longueur_adresse);                                      &adresse_ipv4, &longueur_adresse);
                         }                          } while((ios == -1) && (errno == EINTR));
                         while((ios == -1) && (errno == EINTR));  
                     }                      }
                     else if ((*((struct_socket *) (*s_objet_argument_1)                      else if ((*((struct_socket *) (*s_objet_argument_1)
                             .objet)) .domaine == PF_INET6)                              .objet)) .domaine == PF_INET6)
Line 2459  printf("L=%d\n", longueur_enregistrement Line 2617  printf("L=%d\n", longueur_enregistrement
                                     - ancienne_longueur_effective,                                      - ancienne_longueur_effective,
                                     MSG_DONTWAIT, (struct sockaddr *)                                      MSG_DONTWAIT, (struct sockaddr *)
                                     &adresse_ipv6, &longueur_adresse);                                      &adresse_ipv6, &longueur_adresse);
                         }                          } while((ios == -1) && (errno == EINTR));
                         while((ios == -1) && (errno == EINTR));  
 #                       else  #                       else
                         if ((*s_etat_processus).langue == 'F')                          if ((*s_etat_processus).langue == 'F')
                         {                          {
Line 2483  printf("L=%d\n", longueur_enregistrement Line 2640  printf("L=%d\n", longueur_enregistrement
                                 (*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, 100)) <= 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.                              // et il reste quelque chose à lire.
Line 2492  printf("L=%d\n", longueur_enregistrement Line 2649  printf("L=%d\n", longueur_enregistrement
                             {                              {
                                 case EINTR:                                  case EINTR:
                                 {                                  {
                                       if ((*s_etat_processus)
                                               .var_volatile_requete_arret == -1)
                                       {
                                           liberation(s_etat_processus,
                                                   s_objet_argument_1);
                                           free(tampon_lecture);
                                           return;
                                       }
   
                                     break;                                      break;
                                 }                                  }
   
Removed from v.1.57  
changed lines
  Added in v.1.68

CVSweb interface <joel.bertrand@systella.fr>