[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.31 and 1.53

version 1.31, 2011/04/21 16:00:58 version 1.53, 2012/05/21 17:25:44
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.0.prerelease.0    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 852  instruction_read(struct_processus *s_eta Line 852  instruction_read(struct_processus *s_eta
     int                             ios;      int                             ios;
   
     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                        indicateur_48;      logical1                        indicateur_48;
     logical1                        presence_chaine;      logical1                        presence_chaine;
     logical1                        presence_indicateur;      logical1                        presence_indicateur;
   
     long                            i;  
     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;
   
     sqlite3_stmt                    *ppStmt;      sqlite3_stmt                    *ppStmt;
Line 886  instruction_read(struct_processus *s_eta Line 886  instruction_read(struct_processus *s_eta
   
     struct_liste_chainee            *l_element_courant;      struct_liste_chainee            *l_element_courant;
     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 900  instruction_read(struct_processus *s_eta Line 902  instruction_read(struct_processus *s_eta
     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 1860  instruction_read(struct_processus *s_eta
             /*              /*
              * Fichiers non formatés               * Fichiers non formatés
              */               */
   
               if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
                       == 'S')
               {
                   /*
                    * 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"));
   
                   if (fread(&type_enregistrement, (size_t) sizeof(unsigned char),
                           1, (*descripteur).descripteur_c) != 1)
                   {
                       (*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;
                   }
   
                   switch(type_enregistrement)
                   {
                       unsigned char       taille_enregistrement[8];
   
                       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;
                   }
   
                   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 2049  instruction_read(struct_processus *s_eta Line 2220  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 2109  instruction_read(struct_processus *s_eta Line 2276  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 2117  instruction_read(struct_processus *s_eta Line 2287  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)                              (*s_etat_processus).erreur_systeme =
                             {                                      d_es_processus;
                                 (*s_etat_processus).erreur_systeme =  
                                         d_es_processus;  
                                 return;  
                             }  
                         }                          }
   
                         (*s_etat_processus).erreur_execution =                          (*s_etat_processus).erreur_execution =
Line 2154  instruction_read(struct_processus *s_eta Line 2320  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)
                     {                      {
                         (*s_etat_processus).erreur_systeme = d_es_processus;                          (*s_etat_processus).erreur_systeme = d_es_processus;
                         return;                          return;
Line 2560  instruction_read(struct_processus *s_eta Line 2726  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 2781  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 2792  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 2827  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.31  
changed lines
  Added in v.1.53

CVSweb interface <joel.bertrand@systella.fr>