rpl/src/instructions_w1.c - diff

Return to instructions_w1.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/instructions_w1.c between versions 1.63 and 1.71

-version 1.63, 2012/06/21 16:07:25
+version 1.71, 2013/02/26 19:56:16
  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-2013 Dr. BERTRAND Joël
    This file is part of RPL/2.
  Line 385  instruction_write(struct_processus *s_et
      int                                 adresse[16];
      int                                 port;
+     int                                 sqlite_status;
      integer8                            clef;
      integer8                            compteur;
      integer8                            id;
      integer8                            ordre;
+     logical1                            format_degenere;
      logical1                            mise_a_jour;
+     long                                longueur;
      long                                longueur_effective;
      long                                recursivite;
- Line 422  instruction_write(struct_processus *s_et
+ Line 425  instruction_write(struct_processus *s_et
      struct flock                        lock;
+     struct timespec                     attente;
      uint32_t                            calcul_adresse;
      unsigned char                       *chaine;
      unsigned char                       *chaine_utf8;
      unsigned char                       *clef_utf8;
      unsigned char                       *commande;
-     unsigned char                       retour;
+     unsigned char                       *format_chaine;
      unsigned long                       i;
- Line 758  instruction_write(struct_processus *s_et
+ Line 763  instruction_write(struct_processus *s_et
                      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;
+                     sqlite_status = sqlite3_step(ppStmt);
-                     return;
-                 }
+                     if (sqlite_status == SQLITE_ROW)
+                     {
+                         break;
+                     }
+                     else if ((sqlite_status == SQLITE_BUSY) ||
+                             (sqlite_status == SQLITE_LOCKED))
+                     {
+                         nanosleep(&attente, NULL);
+                         INCR_GRANULARITE(attente.tv_nsec);
+                     }
+                     else
+                     {
+                         (*s_etat_processus).erreur_systeme =
+                                 d_es_erreur_fichier;
+                         return;
+                     }
+                 } while(sqlite_status != SQLITE_ROW);
                  if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
                  {
- Line 915  instruction_write(struct_processus *s_et
+ Line 939  instruction_write(struct_processus *s_et
                      return;
                  }
-                 switch(sqlite3_step(ppStmt))
+                 attente.tv_sec = 0;
-                 {
+                 attente.tv_nsec = GRANULARITE_us * 1000;
-                     case SQLITE_ROW:
-                     {
-                         // Une clef existe.
-                         mise_a_jour = d_vrai;
-                         break;
-                     }
-                     case SQLITE_DONE:
+                 do
+                 {
+                     switch(sqlite_status = sqlite3_step(ppStmt))
                      {
-                         // Aucune clef n'existe.
+                         case SQLITE_ROW:
-                         mise_a_jour = d_faux;
-                         if (sqlite3_finalize(ppStmt) != SQLITE_OK)
-                         {
-                             (*s_etat_processus).erreur_systeme =
-                                     d_es_erreur_fichier;
-                             return;
-                         }
-                         free(commande);
-                         if (alsprintf(&commande, "insert into key "
-                                 "(key) values ('%s')", clef_utf8) < 0)
                          {
-                             (*s_etat_processus).erreur_systeme =
+                             // Une clef existe.
-                                     d_es_allocation_memoire;
-                             return;
-                         }
-                         if (sqlite3_prepare_v2((*descripteur)
+                             mise_a_jour = d_vrai;
-                                 .descripteur_sqlite,
+                             break;
-                                 commande, strlen(commande), &ppStmt, &queue)
-                                 != SQLITE_OK)
-                         {
-                             (*s_etat_processus).erreur_systeme =
-                                     d_es_erreur_fichier;
-                             return;
                          }
-                         if (sqlite3_step(ppStmt) != SQLITE_DONE)
+                         case SQLITE_DONE:
                          {
-                             (*s_etat_processus).erreur_systeme =
+                             // Aucune clef n'existe.
-                                     d_es_erreur_fichier;
-                             return;
-                         }
-                         if (sqlite3_finalize(ppStmt) != SQLITE_OK)
+                             mise_a_jour = d_faux;
-                         {
-                             (*s_etat_processus).erreur_systeme =
-                                     d_es_erreur_fichier;
-                             return;
-                         }
-                         free(commande);
+                             if (sqlite3_finalize(ppStmt) != SQLITE_OK)
+                             {
+                                 (*s_etat_processus).erreur_systeme =
+                                         d_es_erreur_fichier;
+                                 return;
+                             }
+                             free(commande);
+                             if (alsprintf(&commande, "insert into key "
+                                     "(key) values ('%s')", clef_utf8) < 0)
+                             {
+                                 (*s_etat_processus).erreur_systeme =
+                                         d_es_allocation_memoire;
+                                 return;
+                             }
+                             if (sqlite3_prepare_v2((*descripteur)
+                                     .descripteur_sqlite,
+                                     commande, strlen(commande), &ppStmt, &queue)
+                                     != SQLITE_OK)
+                             {
+                                 (*s_etat_processus).erreur_systeme =
+                                         d_es_erreur_fichier;
+                                 return;
+                             }
+                             if (sqlite3_step(ppStmt) != SQLITE_DONE)
+                             {
+                                 (*s_etat_processus).erreur_systeme =
+                                         d_es_erreur_fichier;
+                                 return;
+                             }
+                             if (sqlite3_finalize(ppStmt) != SQLITE_OK)
+                             {
+                                 (*s_etat_processus).erreur_systeme =
+                                         d_es_erreur_fichier;
+                                 return;
+                             }
+                             free(commande);
+                             if (alsprintf(&commande, "select id from key "
+                                     "where key = '%s'", clef_utf8) < 0)
+                             {
+                                 (*s_etat_processus).erreur_systeme =
+                                         d_es_allocation_memoire;
+                                 return;
+                             }
+                             if (sqlite3_prepare_v2((*descripteur)
+                                     .descripteur_sqlite,
+                                     commande, strlen(commande), &ppStmt, &queue)
+                                     != SQLITE_OK)
+                             {
+                                 (*s_etat_processus).erreur_systeme =
+                                         d_es_erreur_fichier;
+                                 return;
+                             }
-                         if (alsprintf(&commande, "select id from key "
+                             break;
-                                 "where key = '%s'", clef_utf8) < 0)
-                         {
-                             (*s_etat_processus).erreur_systeme =
-                                     d_es_allocation_memoire;
-                             return;
                          }
-                         if (sqlite3_prepare_v2((*descripteur)
+                         case SQLITE_BUSY:
-                                 .descripteur_sqlite,
+                         case SQLITE_LOCKED:
-                                 commande, strlen(commande), &ppStmt, &queue)
-                                 != SQLITE_OK)
                          {
-                             (*s_etat_processus).erreur_systeme =
+                             nanosleep(&attente, NULL);
-                                     d_es_erreur_fichier;
+                             INCR_GRANULARITE(attente.tv_nsec);
-                             return;
+                             break;
                          }
-                         if (sqlite3_step(ppStmt) != SQLITE_ROW)
+                         default:
                          {
                              (*s_etat_processus).erreur_systeme =
                                      d_es_erreur_fichier;
                              return;
                          }
-                         break;
-                     }
-                     default:
-                     {
-                         (*s_etat_processus).erreur_systeme =
-                                 d_es_erreur_fichier;
-                         return;
                      }
-                 }
+                 } while(sqlite_status != SQLITE_ROW);
                  if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
                  {
- Line 1350  instruction_write(struct_processus *s_et
+ Line 1381  instruction_write(struct_processus *s_et
                      return;
                  }
-                 if ((*((*((struct_liste_chainee *) (*s_objet_argument_2).objet))
+                 l_element_courant = (*s_objet_argument_2).objet;
-                         .donnee)).type != CHN)
+                 l_element_courant_format = (struct_liste_chainee *)
+                         (*(*((struct_fichier *) (*s_objet_argument_1).objet))
+                         .format).objet;
+                 while((l_element_courant != NULL) &&
+                         (l_element_courant_format != NULL))
                  {
-                     liberation(s_etat_processus, s_objet_argument_2);
+                     if ((*(*l_element_courant).donnee).type != CHN)
-                     liberation(s_etat_processus, s_objet_argument_1);
+                     {
+                         liberation(s_etat_processus, s_objet_argument_2);
+                         liberation(s_etat_processus, s_objet_argument_1);
-                     (*s_etat_processus).erreur_execution =
+                         (*s_etat_processus).erreur_execution =
-                             d_ex_erreur_type_argument;
+                                 d_ex_erreur_type_argument;
-                     return;
+                         return;
-                 }
+                     }
-                 if ((chaine = formateur_flux(s_etat_processus, (unsigned char *)
+                     if ((*(*l_element_courant_format).donnee).type != CHN)
-                         (*((*((struct_liste_chainee *) (*s_objet_argument_2)
+                     {
-                         .objet)).donnee)).objet, &longueur_effective)) == NULL)
+                         liberation(s_etat_processus, s_objet_argument_2);
-                 {
+                         liberation(s_etat_processus, s_objet_argument_1);
-                     (*s_etat_processus).erreur_systeme =
-                             d_es_allocation_memoire;
-                     return;
-                 }
-                 if (fwrite(chaine, sizeof(unsigned char), longueur_effective,
+                         (*s_etat_processus).erreur_execution =
-                         (*descripteur).descripteur_c) !=
+                                 d_ex_erreur_type_argument;
-                         (size_t) longueur_effective)
+                         return;
-                 {
+                     }
-                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
-                     return;
-                 }
-                 free(chaine);
+                     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)
+                     {
+                         free(format_chaine);
+                         liberation(s_etat_processus, s_objet_argument_2);
+                         liberation(s_etat_processus, s_objet_argument_1);
+                         (*s_etat_processus).erreur_execution =
+                                 d_ex_erreur_format_fichier;
+                         return;
+                     }
+                     longueur = strlen(format_chaine);
+                     if (format_chaine[longueur - 1] != ')')
+                     {
+                         free(format_chaine);
+                         liberation(s_etat_processus, s_objet_argument_2);
+                         liberation(s_etat_processus, s_objet_argument_1);
+                         (*s_etat_processus).erreur_execution =
+                                 d_ex_erreur_format_fichier;
+                         return;
+                     }
+                     format_chaine[longueur] = d_code_fin_chaine;
+                     if (format_chaine[8] == '*')
+                     {
+                         format_degenere = d_vrai;
+                     }
+                     else
+                     {
+                         // Détermination de la longueur
+                         format_degenere = d_faux;
+                         if (sscanf(&(format_chaine[8]), "%ld", &longueur) != 1)
+                         {
+                             free(format_chaine);
-                 // Le fichier de type FLOW est à accès séquentiel. Il
+                             liberation(s_etat_processus, s_objet_argument_2);
-                 // convient d'ajouter un retour à la ligne pour l'opération
+                             liberation(s_etat_processus, s_objet_argument_1);
-                 // de lecture.
-                 retour = d_code_retour_chariot;
+                             (*s_etat_processus).erreur_execution =
+                                     d_ex_erreur_format_fichier;
+                             return;
+                         }
+                     }
-                 if (fwrite(&retour, sizeof(unsigned char), 1,
+                     free(format_chaine);
-                         (*descripteur).descripteur_c) != 1)
+                     if ((chaine = formateur_flux(s_etat_processus,
+                             (unsigned char *) (*(*l_element_courant).donnee)
+                             .objet, &longueur_effective)) == NULL)
+                     {
+                         (*s_etat_processus).erreur_systeme =
+                                 d_es_allocation_memoire;
+                         return;
+                     }
+                     if ((format_degenere == d_vrai) ||
+                             (longueur_effective < longueur))
+                     {
+                         if (fwrite(chaine, sizeof(unsigned char),
+                                 longueur_effective,
+                                 (*descripteur).descripteur_c) !=
+                                 (size_t) longueur_effective)
+                         {
+                             (*s_etat_processus).erreur_systeme =
+                                     d_es_erreur_fichier;
+                             return;
+                         }
+                     }
+                     else
+                     {
+                         if (fwrite(chaine, sizeof(unsigned char),
+                                 longueur_effective,
+                                 (*descripteur).descripteur_c) !=
+                                 (size_t) longueur)
+                         {
+                             (*s_etat_processus).erreur_systeme =
+                                     d_es_erreur_fichier;
+                             return;
+                         }
+                     }
+                     free(chaine);
+                     l_element_courant = (*l_element_courant).suivant;
+                     l_element_courant_format = (*l_element_courant_format)
+                             .suivant;
+                 }
+                 if ((l_element_courant_format != NULL) ||
+                         (l_element_courant != NULL))
                  {
-                     (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
+                     liberation(s_etat_processus, s_objet_argument_2);
+                     liberation(s_etat_processus, s_objet_argument_1);
+                     (*s_etat_processus).erreur_execution =
+                             d_ex_erreur_format_fichier;
                      return;
                  }
              }

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.63
changed lines
	Added in v.1.71