Diff for /rpl/src/instructions_m4.c between versions 1.19 and 1.52

version 1.19, 2011/04/21 16:00:58 version 1.52, 2013/02/26 19:56:15
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.0.prerelease.0    RPL/2 (R) version 4.1.12
   Copyright (C) 1989-2011 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 38 Line 38
 void  void
 instruction_mem(struct_processus *s_etat_processus)  instruction_mem(struct_processus *s_etat_processus)
 {  {
     struct_liste_chainee    *l_element_courant;      int                         j;
       int                         nb_variables;
   
     struct_objet            *s_objet_resultat;      struct_liste_chainee        *l_element_courant;
   
       struct_objet                *s_objet_resultat;
   
     unsigned long           i;      struct_tableau_variables    *tableau;
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
Line 139  instruction_mem(struct_processus *s_etat Line 142  instruction_mem(struct_processus *s_etat
     (*((integer8 *) (*((*((*((struct_liste_chainee *)      (*((integer8 *) (*((*((*((struct_liste_chainee *)
             (*s_objet_resultat).objet)).suivant)).donnee)).objet)) = 0;              (*s_objet_resultat).objet)).suivant)).donnee)).objet)) = 0;
   
     for(i = 0; i < (*s_etat_processus).nombre_variables; i++)      nb_variables = nombre_variables(s_etat_processus);
   
       if ((tableau = malloc(nb_variables * sizeof(struct_tableau_variables)))
               == NULL)
       {
           liberation_mutexes_arbre_variables_partagees(s_etat_processus,
                   (*(*s_etat_processus).s_arbre_variables_partagees));
           (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
           return;
       }
   
       liste_variables(s_etat_processus, tableau);
   
       for(j = 0; j < nb_variables; j++)
     {      {
         (*((integer8 *) (*((*((*((struct_liste_chainee *) (*s_objet_resultat)          (*((integer8 *) (*((*((*((struct_liste_chainee *) (*s_objet_resultat)
                 .objet)).suivant)).donnee)).objet)) += sizeof(unsigned char) *                  .objet)).suivant)).donnee)).objet)) += sizeof(unsigned char) *
                 strlen((*s_etat_processus).s_liste_variables[i].nom);                  strlen(tableau[j].nom);
         (*((integer8 *) (*((*((*((struct_liste_chainee *) (*s_objet_resultat)          (*((integer8 *) (*((*((*((struct_liste_chainee *) (*s_objet_resultat)
                 .objet)).suivant)).donnee)).objet)) += occupation_memoire(                  .objet)).suivant)).donnee)).objet)) += occupation_memoire(
                 (*s_etat_processus).s_liste_variables[i].objet);                  tableau[j].objet);
     }      }
   
     for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++)      free(tableau);
     {  
         // Comptabilisation des empreintes mémoire des variables  
         // statiques qui ne sont pas accessibles, les variables statiques  
         // accessibles étant déjà comptabilitées par la boucle précédente.  
   
         if ((*s_etat_processus).s_liste_variables_statiques[i].objet != NULL)  
         {  
             (*((integer8 *) (*((*((*((struct_liste_chainee *)  
                     (*s_objet_resultat).objet)).suivant)).donnee)).objet)) +=  
                     sizeof(unsigned char) * strlen((*s_etat_processus)  
                     .s_liste_variables_statiques[i].nom);  
             (*((integer8 *) (*((*((*((struct_liste_chainee *)  
                     (*s_objet_resultat).objet)).suivant)).donnee)).objet)) +=  
                     occupation_memoire((*s_etat_processus)  
                     .s_liste_variables_statiques[i].objet);  
         }  
     }  
   
     for(i = 0; i < (*(*s_etat_processus).s_liste_variables_partagees)  
             .nombre_variables; i++)  
     {  
         (*((integer8 *) (*((*((*((struct_liste_chainee *)  
                 (*s_objet_resultat).objet)).suivant)).donnee)).objet)) +=  
                 sizeof(unsigned char) * strlen((*(*s_etat_processus)  
                 .s_liste_variables_partagees).table[i].nom);  
         (*((integer8 *) (*((*((*((struct_liste_chainee *)  
                 (*s_objet_resultat).objet)).suivant)).donnee)).objet)) +=  
                 occupation_memoire((*(*s_etat_processus)  
                 .s_liste_variables_partagees).table[i].objet);  
     }  
   
     /*      /*
      * Empilement du résultat       * Empilement du résultat
Line 397  instruction_mtxlock(struct_processus *s_ Line 383  instruction_mtxlock(struct_processus *s_
         }          }
   
 #       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  
   
         if (pthread_mutex_lock(&((*((struct_mutex *) (*s_objet_argument).objet))          if (pthread_mutex_lock(&((*((struct_mutex *) (*s_objet_argument).objet))
                 .mutex)) != 0)                  .mutex)) != 0)
         {          {
 #           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 ((*s_etat_processus).profilage == d_vrai)  
                 {  
                     profilage(s_etat_processus, NULL);  
                 }  
   
                 if (errno != EINTR)                  if (errno != EINTR)
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_processus;                      (*s_etat_processus).erreur_systeme = d_es_processus;
Line 442  instruction_mtxlock(struct_processus *s_ Line 419  instruction_mtxlock(struct_processus *s_
             return;              return;
         }          }
   
           (*((struct_mutex *) (*s_objet_argument).objet)).tid = pthread_self();
   
 #       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)
Line 597  instruction_mtxtrylock(struct_processus Line 576  instruction_mtxtrylock(struct_processus
                 return;                  return;
             }              }
         }          }
           else
           {
               (*((struct_mutex *) (*s_objet_argument).objet)).tid =
                       pthread_self();
           }
   
         if ((*s_etat_processus).profilage == d_vrai)          if ((*s_etat_processus).profilage == d_vrai)
         {          {
Line 620  instruction_mtxtrylock(struct_processus Line 604  instruction_mtxtrylock(struct_processus
         return;          return;
     }      }
   
     (*((integer8 *) (*s_objet_resultat).objet)) = (ios == 0) ? 0 : -1;      (*((integer8 *) (*s_objet_resultat).objet)) = (ios == 0) ? -1 : 0;
   
     if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),      if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
             s_objet_resultat) == d_erreur)              s_objet_resultat) == d_erreur)
Line 631  instruction_mtxtrylock(struct_processus Line 615  instruction_mtxtrylock(struct_processus
     return;      return;
 }  }
   
   
 /*  /*
 ================================================================================  ================================================================================
   Fonction 'mtxstatus'    Fonction 'mtxstatus'
Line 755  instruction_mtxstatus(struct_processus * Line 740  instruction_mtxstatus(struct_processus *
             }              }
         }          }
   
         if (pthread_mutex_unlock(&((*((struct_mutex *)          if (ios == 0)
                 (*s_objet_argument).objet)).mutex)) != 0)  
         {          {
             liberation(s_etat_processus, s_objet_argument);              // Le mutex a été verrouillé par le trylock précédent.
   
             if ((*s_etat_processus).profilage == d_vrai)              if (pthread_mutex_unlock(&((*((struct_mutex *)
                       (*s_objet_argument).objet)).mutex)) != 0)
             {              {
                 profilage(s_etat_processus, NULL);                  liberation(s_etat_processus, s_objet_argument);
             }  
   
             (*s_etat_processus).erreur_systeme = d_es_processus;                  if ((*s_etat_processus).profilage == d_vrai)
             return;                  {
                       profilage(s_etat_processus, NULL);
                   }
   
                   (*s_etat_processus).erreur_systeme = d_es_processus;
                   return;
               }
         }          }
   
         if ((*s_etat_processus).profilage == d_vrai)          if ((*s_etat_processus).profilage == d_vrai)
Line 880  instruction_mtxunlock(struct_processus * Line 870  instruction_mtxunlock(struct_processus *
   
         if (l_element_courant == NULL)          if (l_element_courant == NULL)
         {          {
               liberation(s_etat_processus, s_objet_argument);
   
             (*s_etat_processus).erreur_execution = d_ex_mutex;              (*s_etat_processus).erreur_execution = d_ex_mutex;
               return;
           }
   
           if (pthread_equal(pthread_self(), (*((struct_mutex *)
                   (*s_objet_argument).objet)).tid) == 0)
           {
             liberation(s_etat_processus, s_objet_argument);              liberation(s_etat_processus, s_objet_argument);
   
               (*s_etat_processus).erreur_execution =
                       d_ex_mutex_acquis_autre_thread;
             return;              return;
         }          }
   

Removed from v.1.19  
changed lines
  Added in v.1.52


CVSweb interface <joel.bertrand@systella.fr>