Diff for /rpl/src/instructions_v1.c between versions 1.20 and 1.72

version 1.20, 2011/06/19 17:48:27 version 1.72, 2017/06/28 09:20:36
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.0.prerelease.0    RPL/2 (R) version 4.1.27
   Copyright (C) 1989-2011 Dr. BERTRAND Joël    Copyright (C) 1989-2017 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 42  instruction_var(struct_processus *s_etat Line 42  instruction_var(struct_processus *s_etat
     struct_objet                        *s_objet_resultat;      struct_objet                        *s_objet_resultat;
     struct_objet                        *s_objet_temporaire;      struct_objet                        *s_objet_temporaire;
   
     unsigned long                       nombre_colonnes;      integer8                            nombre_colonnes;
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
Line 132  instruction_var(struct_processus *s_etat Line 132  instruction_var(struct_processus *s_etat
             return;              return;
         }          }
   
         if (((*s_objet_resultat).objet = variance_statistique((struct_matrice *)          if (((*s_objet_resultat).objet = variance_statistique(s_etat_processus,
                 (*s_objet_statistique).objet, 'E')) == NULL)                  (struct_matrice *) (*s_objet_statistique).objet, 'E')) == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
Line 237  instruction_version(struct_processus *s_ Line 237  instruction_version(struct_processus *s_
     struct_objet                        *s_objet_resultat;      struct_objet                        *s_objet_resultat;
   
     unsigned char                       texte[] = "RPL/2 version ";      unsigned char                       texte[] = "RPL/2 version ";
       unsigned char                       tampon[256 + 1];
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
Line 499  instruction_version(struct_processus *s_ Line 500  instruction_version(struct_processus *s_
         return;          return;
     }      }
   
     if (((*(*l_element_courant).donnee).objet = malloc((strlen(d_date_en_rpl)      if (((*(*l_element_courant).donnee).objet =
             + 1) * sizeof(unsigned char))) == NULL)              date_compilation(s_etat_processus)) == NULL)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;          (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
         return;          return;
     }      }
   
     strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,  
             d_date_en_rpl);  
   
     /*      /*
      * Ajout des options de compilation       * Ajout des options de compilation
      */       */
Line 830  instruction_version(struct_processus *s_ Line 828  instruction_version(struct_processus *s_
         return;          return;
     }      }
   
 #ifdef DEBUG  #ifdef RPLCAS
     if (((*(*l_element_courant).donnee).objet = malloc(6 *      if (((*(*l_element_courant).donnee).objet = malloc(8 *
             sizeof(unsigned char))) == NULL)              sizeof(unsigned char))) == NULL)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;          (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 839  instruction_version(struct_processus *s_ Line 837  instruction_version(struct_processus *s_
     }      }
   
     strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,      strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
             "DEBUG");              "RPL/CAS");
 #else  #else
     if (((*(*l_element_courant).donnee).objet = malloc(15 *      if (((*(*l_element_courant).donnee).objet = malloc(17 *
             sizeof(unsigned char))) == NULL)              sizeof(unsigned char))) == NULL)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;          (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 849  instruction_version(struct_processus *s_ Line 847  instruction_version(struct_processus *s_
     }      }
   
     strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,      strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
             "DEBUG DISABLED");              "RPL/CAS DISABLED");
 #endif  #endif
   
     if (((*l_element_courant).suivant =      if (((*l_element_courant).suivant =
Line 891  instruction_version(struct_processus *s_ Line 889  instruction_version(struct_processus *s_
             "EXPERIMENTAL CODE DISABLED");              "EXPERIMENTAL CODE DISABLED");
 #endif  #endif
   
       if (((*l_element_courant).suivant =
               allocation_maillon(s_etat_processus)) == NULL)
       {
           (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
           return;
       }
   
       l_element_courant = (*l_element_courant).suivant;
       (*l_element_courant).suivant = NULL;
   
       if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
               == NULL)
       {
           (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
           return;
       }
   
       sprintf(tampon, "%zu BITS ABI", sizeof(void *) * 8);
   
       if (((*(*l_element_courant).donnee).objet = malloc((strlen(tampon) + 1 )
               * sizeof(unsigned char))) == NULL)
       {
           (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
           return;
       }
   
       strcpy((unsigned char *) (*(*l_element_courant).donnee).objet, tampon);
   
       if (((*l_element_courant).suivant =
               allocation_maillon(s_etat_processus)) == NULL)
       {
           (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
           return;
       }
   
       l_element_courant = (*l_element_courant).suivant;
       (*l_element_courant).suivant = NULL;
   
       if (((*l_element_courant).donnee = allocation(s_etat_processus, CHN))
               == NULL)
       {
           (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
           return;
       }
   
       if (((*(*l_element_courant).donnee).objet = conversion_majuscule(
               s_etat_processus, HOST)) == NULL)
       {
           (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
           return;
       }
   
     /*      /*
      * Empilement du résultat       * Empilement du résultat
      */       */
Line 920  instruction_version(struct_processus *s_ Line 970  instruction_version(struct_processus *s_
 void  void
 instruction_vars(struct_processus *s_etat_processus)  instruction_vars(struct_processus *s_etat_processus)
 {  {
     int                                 i;      integer8                            i;
     int                                 nb_variables;      integer8                            nb_variables;
   
     logical1                            variable_partagee;      logical1                            variable_partagee;
   
Line 974  instruction_vars(struct_processus *s_eta Line 1024  instruction_vars(struct_processus *s_eta
     (*s_objet_resultat).objet = NULL;      (*s_objet_resultat).objet = NULL;
     l_element_precedent = NULL;      l_element_precedent = NULL;
   
     nb_variables = nombre_variables(s_etat_processus,      nb_variables = nombre_variables(s_etat_processus);
             (*s_etat_processus).s_arbre_variables);  
   
     if ((tableau = malloc(nb_variables * sizeof(struct_tableau_variables)))      if ((tableau = malloc(((size_t) nb_variables) *
             == NULL)              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;          (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
         return;          return;
     }      }
   
     liste_variables(s_etat_processus, tableau, 0,      nb_variables = liste_variables(s_etat_processus, tableau);
             (*s_etat_processus).s_arbre_variables);  
   
     for(i = 0; i < nb_variables; i++)      for(i = 0; i < nb_variables; i++)
     {      {
Line 1039  instruction_vars(struct_processus *s_eta Line 1089  instruction_vars(struct_processus *s_eta
   
         if (tableau[i].objet == NULL)          if (tableau[i].objet == NULL)
         {          {
             if (pthread_mutex_lock(&((*(*s_etat_processus)  
                     .s_liste_variables_partagees).mutex)) != 0)  
             {  
                 (*s_etat_processus).erreur_systeme = d_es_processus;  
                 return;  
             }  
   
             if (recherche_variable_partagee(s_etat_processus,              if (recherche_variable_partagee(s_etat_processus,
                     tableau[i].nom, tableau[i].variable_partagee,                      tableau[i].nom, tableau[i].variable_partagee,
                     tableau[i].origine) == d_faux)                      tableau[i].origine) == NULL)
             {              {
                 // La variable partagée n'existe plus.                  // La variable partagée n'existe plus.
   
                 if (pthread_mutex_unlock(&((*(*s_etat_processus)  
                         .s_liste_variables_partagees).mutex)) != 0)  
                 {  
                     (*s_etat_processus).erreur_systeme = d_es_processus;  
                     return;  
                 }  
   
                 continue;                  continue;
             }              }
   
Line 1080  instruction_vars(struct_processus *s_eta Line 1115  instruction_vars(struct_processus *s_eta
             if (variable_partagee == d_vrai)              if (variable_partagee == d_vrai)
             {              {
                 if (pthread_mutex_unlock(&((*(*s_etat_processus)                  if (pthread_mutex_unlock(&((*(*s_etat_processus)
                         .s_liste_variables_partagees).mutex)) != 0)                          .pointeur_variable_partagee_courante).mutex)) != 0)
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_processus;                      (*s_etat_processus).erreur_systeme = d_es_processus;
                     return;                      return;
                 }                  }
             }              }
   
               if (tableau[i].mutex != NULL)
               {
                   // La variable est une variable partagée. On libère le mutex.
                   pthread_mutex_unlock(tableau[i].mutex);
               }
   
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
         }          }
Line 1103  instruction_vars(struct_processus *s_eta Line 1144  instruction_vars(struct_processus *s_eta
             if (variable_partagee == d_vrai)              if (variable_partagee == d_vrai)
             {              {
                 if (pthread_mutex_unlock(&((*(*s_etat_processus)                  if (pthread_mutex_unlock(&((*(*s_etat_processus)
                         .s_liste_variables_partagees).mutex)) != 0)                          .pointeur_variable_partagee_courante).mutex)) != 0)
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_processus;                      (*s_etat_processus).erreur_systeme = d_es_processus;
                     return;                      return;
                 }                  }
             }              }
   
               if (tableau[i].mutex != NULL)
               {
                   // La variable est une variable partagée. On libère le mutex.
                   pthread_mutex_unlock(tableau[i].mutex);
               }
   
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
         }          }
Line 1129  instruction_vars(struct_processus *s_eta Line 1176  instruction_vars(struct_processus *s_eta
             if (variable_partagee == d_vrai)              if (variable_partagee == d_vrai)
             {              {
                 if (pthread_mutex_unlock(&((*(*s_etat_processus)                  if (pthread_mutex_unlock(&((*(*s_etat_processus)
                         .s_liste_variables_partagees).mutex)) != 0)                          .pointeur_variable_partagee_courante).mutex)) != 0)
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_processus;                      (*s_etat_processus).erreur_systeme = d_es_processus;
                     return;                      return;
                 }                  }
             }              }
   
               if (tableau[i].mutex != NULL)
               {
                   // La variable est une variable partagée. On libère le mutex.
                   pthread_mutex_unlock(tableau[i].mutex);
               }
   
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
         }          }
Line 1147  instruction_vars(struct_processus *s_eta Line 1200  instruction_vars(struct_processus *s_eta
             if (variable_partagee == d_vrai)              if (variable_partagee == d_vrai)
             {              {
                 if (pthread_mutex_unlock(&((*(*s_etat_processus)                  if (pthread_mutex_unlock(&((*(*s_etat_processus)
                         .s_liste_variables_partagees).mutex)) != 0)                          .pointeur_variable_partagee_courante).mutex)) != 0)
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_processus;                      (*s_etat_processus).erreur_systeme = d_es_processus;
                     return;                      return;
                 }                  }
             }              }
   
               if (tableau[i].mutex != NULL)
               {
                   // La variable est une variable partagée. On libère le mutex.
                   pthread_mutex_unlock(tableau[i].mutex);
               }
   
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
         }          }
Line 1173  instruction_vars(struct_processus *s_eta Line 1232  instruction_vars(struct_processus *s_eta
             if (variable_partagee == d_vrai)              if (variable_partagee == d_vrai)
             {              {
                 if (pthread_mutex_unlock(&((*(*s_etat_processus)                  if (pthread_mutex_unlock(&((*(*s_etat_processus)
                         .s_liste_variables_partagees).mutex)) != 0)                          .pointeur_variable_partagee_courante).mutex)) != 0)
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_processus;                      (*s_etat_processus).erreur_systeme = d_es_processus;
                     return;                      return;
                 }                  }
             }              }
   
               if (tableau[i].mutex != NULL)
               {
                   // La variable est une variable partagée. On libère le mutex.
                   pthread_mutex_unlock(tableau[i].mutex);
               }
   
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
         }          }
Line 1191  instruction_vars(struct_processus *s_eta Line 1256  instruction_vars(struct_processus *s_eta
             if (((*(*(*((struct_liste_chainee *) (*((struct_objet *)              if (((*(*(*((struct_liste_chainee *) (*((struct_objet *)
                     (*l_element_courant).donnee)).objet)).suivant).suivant)                      (*l_element_courant).donnee)).objet)).suivant).suivant)
                     .donnee = copie_objet(s_etat_processus,                      .donnee = copie_objet(s_etat_processus,
                     (*(*s_etat_processus)                      (*(*s_etat_processus).pointeur_variable_partagee_courante)
                     .s_liste_variables_partagees).table[(*(*s_etat_processus)                      .objet, 'P')) == NULL)
                     .s_liste_variables_partagees).position_variable].objet,  
                     'P')) == NULL)  
             {              {
                 if (pthread_mutex_unlock(&((*(*s_etat_processus)                  if (pthread_mutex_unlock(&((*(*s_etat_processus)
                         .s_liste_variables_partagees).mutex)) != 0)                          .pointeur_variable_partagee_courante).mutex)) != 0)
                 {                  {
                     (*s_etat_processus).erreur_systeme = d_es_processus;                      (*s_etat_processus).erreur_systeme = d_es_processus;
                     return;                      return;
                 }                  }
   
                   if (tableau[i].mutex != NULL)
                   {
                       // La variable est une variable partagée. On libère
                       // le mutex.
                       pthread_mutex_unlock(tableau[i].mutex);
                   }
   
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return;                  return;
             }              }
   
             if (pthread_mutex_unlock(&((*(*s_etat_processus)              if (pthread_mutex_unlock(&((*(*s_etat_processus)
                     .s_liste_variables_partagees).mutex)) != 0)                      .pointeur_variable_partagee_courante).mutex)) != 0)
             {              {
                   if (tableau[i].mutex != NULL)
                   {
                       // La variable est une variable partagée. On libère
                       // le mutex.
                       pthread_mutex_unlock(tableau[i].mutex);
                   }
   
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
                 return;                  return;
             }              }
Line 1223  instruction_vars(struct_processus *s_eta Line 1300  instruction_vars(struct_processus *s_eta
                     .donnee = copie_objet(s_etat_processus, tableau[i].objet,                      .donnee = copie_objet(s_etat_processus, tableau[i].objet,
                     'P')) == NULL)                      'P')) == NULL)
             {              {
                   if (tableau[i].mutex != NULL)
                   {
                       // La variable est une variable partagée. On libère
                       // le mutex.
                       pthread_mutex_unlock(tableau[i].mutex);
                   }
   
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return;                  return;
             }              }
Line 1236  instruction_vars(struct_processus *s_eta Line 1320  instruction_vars(struct_processus *s_eta
                 (*l_element_courant).donnee)).objet)).suivant).suivant)                  (*l_element_courant).donnee)).objet)).suivant).suivant)
                 .suivant = allocation_maillon(s_etat_processus)) == NULL)                  .suivant = allocation_maillon(s_etat_processus)) == NULL)
         {          {
               if (tableau[i].mutex != NULL)
               {
                   // La variable est une variable partagée. On libère le mutex.
                   pthread_mutex_unlock(tableau[i].mutex);
               }
   
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
         }          }
Line 1244  instruction_vars(struct_processus *s_eta Line 1334  instruction_vars(struct_processus *s_eta
                 (*l_element_courant).donnee)).objet)).suivant).suivant).suivant)                  (*l_element_courant).donnee)).objet)).suivant).suivant).suivant)
                 .donnee = allocation(s_etat_processus, CHN)) == NULL)                  .donnee = allocation(s_etat_processus, CHN)) == NULL)
         {          {
               if (tableau[i].mutex != NULL)
               {
                   // La variable est une variable partagée. On libère le mutex.
                   pthread_mutex_unlock(tableau[i].mutex);
               }
   
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
         }          }
Line 1257  instruction_vars(struct_processus *s_eta Line 1353  instruction_vars(struct_processus *s_eta
                     .suivant).donnee).objet = malloc(7 *                      .suivant).donnee).objet = malloc(7 *
                     sizeof(unsigned char))) == NULL)                      sizeof(unsigned char))) == NULL)
             {              {
                   if (tableau[i].mutex != NULL)
                   {
                       // La variable est une variable partagée. On libère
                       // le mutex.
                       pthread_mutex_unlock(tableau[i].mutex);
                   }
   
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return;                  return;
             }              }
   
             strcpy((unsigned char *) (*(*(*(*(*((struct_liste_chainee *)              if (tableau[i].variable_masquee == d_vrai)
                     (*((struct_objet *) (*l_element_courant).donnee)).objet))              {
                     .suivant).suivant) .suivant).donnee).objet, "STATIC");                  strcpy((unsigned char *) (*(*(*(*(*((struct_liste_chainee *)
                           (*((struct_objet *) (*l_element_courant).donnee))
                           .objet)).suivant).suivant).suivant).donnee).objet,
                           "SHADOW");
               }
               else
               {
                   strcpy((unsigned char *) (*(*(*(*(*((struct_liste_chainee *)
                           (*((struct_objet *) (*l_element_courant).donnee))
                           .objet)).suivant).suivant).suivant).donnee).objet,
                           "STATIC");
               }
         }          }
         else          else
         {          {
Line 1271  instruction_vars(struct_processus *s_eta Line 1385  instruction_vars(struct_processus *s_eta
                     (*l_element_courant).donnee)).objet)).suivant).suivant)                      (*l_element_courant).donnee)).objet)).suivant).suivant)
                     .suivant).donnee).objet = malloc(9 *                      .suivant).donnee).objet = malloc(9 *
                     sizeof(unsigned char))) == NULL)                      sizeof(unsigned char))) == NULL)
             {              { 
                   if (tableau[i].mutex != NULL)
                   {
                       // La variable est une variable partagée. On libère
                       // le mutex.
                       pthread_mutex_unlock(tableau[i].mutex);
                   }
   
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return;                  return;
             }              }
Line 1290  instruction_vars(struct_processus *s_eta Line 1411  instruction_vars(struct_processus *s_eta
                 .suivant).suivant = allocation_maillon(s_etat_processus))                  .suivant).suivant = allocation_maillon(s_etat_processus))
                 == NULL)                  == NULL)
         {          {
               if (tableau[i].mutex != NULL)
               {
                   // La variable est une variable partagée. On libère le mutex.
                   pthread_mutex_unlock(tableau[i].mutex);
               }
   
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
         }          }
Line 1299  instruction_vars(struct_processus *s_eta Line 1426  instruction_vars(struct_processus *s_eta
                 .suivant).donnee = allocation(s_etat_processus, CHN))                  .suivant).donnee = allocation(s_etat_processus, CHN))
                 == NULL)                  == NULL)
         {          {
               if (tableau[i].mutex != NULL)
               {
                   // La variable est une variable partagée. On libère le mutex.
                   pthread_mutex_unlock(tableau[i].mutex);
               }
   
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
         }          }
Line 1310  instruction_vars(struct_processus *s_eta Line 1443  instruction_vars(struct_processus *s_eta
                     .suivant).suivant).donnee).objet = malloc(7 *                      .suivant).suivant).donnee).objet = malloc(7 *
                     sizeof(unsigned char))) == NULL)                      sizeof(unsigned char))) == NULL)
             {              {
                   if (tableau[i].mutex != NULL)
                   {
                       // La variable est une variable partagée. On libère
                       // le mutex.
                       pthread_mutex_unlock(tableau[i].mutex);
                   }
   
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return;                  return;
             }              }
Line 1326  instruction_vars(struct_processus *s_eta Line 1466  instruction_vars(struct_processus *s_eta
                     .suivant).suivant).donnee).objet = malloc(9 *                      .suivant).suivant).donnee).objet = malloc(9 *
                     sizeof(unsigned char))) == NULL)                      sizeof(unsigned char))) == NULL)
             {              {
                   if (tableau[i].mutex != NULL)
                   {
                       // La variable est une variable partagée. On libère
                       // le mutex.
                       pthread_mutex_unlock(tableau[i].mutex);
                   }
   
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return;                  return;
             }              }
Line 1337  instruction_vars(struct_processus *s_eta Line 1484  instruction_vars(struct_processus *s_eta
         }          }
   
         /*          /*
          * Préparation du drapeau PRIVATE/SHARED           * Préparation du drapeau PRIVATE/SHARED/MAPPED
          */           */
   
         if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)          if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
Line 1345  instruction_vars(struct_processus *s_eta Line 1492  instruction_vars(struct_processus *s_eta
                 .suivant).suivant).suivant =                  .suivant).suivant).suivant =
                 allocation_maillon(s_etat_processus)) == NULL)                  allocation_maillon(s_etat_processus)) == NULL)
         {          {
               if (tableau[i].mutex != NULL)
               {
                   // La variable est une variable partagée. On libère le mutex.
                   pthread_mutex_unlock(tableau[i].mutex);
               }
   
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
         }          }
Line 1354  instruction_vars(struct_processus *s_eta Line 1507  instruction_vars(struct_processus *s_eta
                 .suivant).suivant).donnee = allocation(s_etat_processus,                  .suivant).suivant).donnee = allocation(s_etat_processus,
                 CHN)) == NULL)                  CHN)) == NULL)
         {          {
               if (tableau[i].mutex != NULL)
               {
                   // La variable est une variable partagée. On libère le mutex.
                   pthread_mutex_unlock(tableau[i].mutex);
               }
   
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return;              return;
         }          }
Line 1365  instruction_vars(struct_processus *s_eta Line 1524  instruction_vars(struct_processus *s_eta
                     .suivant).suivant).suivant).donnee).objet = malloc(7 *                      .suivant).suivant).suivant).donnee).objet = malloc(7 *
                     sizeof(unsigned char))) == NULL)                      sizeof(unsigned char))) == NULL)
             {              {
                   if (tableau[i].mutex != NULL)
                   {
                       // La variable est une variable partagée. On libère
                       // le mutex.
                       pthread_mutex_unlock(tableau[i].mutex);
                   }
   
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               strcpy((unsigned char *) (*(*(*(*(*(*(*((struct_liste_chainee *)
                       (*((struct_objet *) (*l_element_courant).donnee)).objet))
                       .suivant).suivant).suivant).suivant).suivant).donnee).objet,
                       "MAPPED");
           }
           else if (tableau[i].mutex != NULL)
           {
               if (((*(*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
                       (*l_element_courant).donnee)).objet)).suivant).suivant)
                       .suivant).suivant).suivant).donnee).objet = malloc(7 *
                       sizeof(unsigned char))) == NULL)
               {
                   if (tableau[i].mutex != NULL)
                   {
                       // La variable est une variable partagée. On libère
                       // le mutex.
                       pthread_mutex_unlock(tableau[i].mutex);
                   }
   
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return;                  return;
             }              }
Line 1381  instruction_vars(struct_processus *s_eta Line 1570  instruction_vars(struct_processus *s_eta
                     .suivant).suivant).suivant).donnee).objet = malloc(8 *                      .suivant).suivant).suivant).donnee).objet = malloc(8 *
                     sizeof(unsigned char))) == NULL)                      sizeof(unsigned char))) == NULL)
             {              {
                   if (tableau[i].mutex != NULL)
                   {
                       // La variable est une variable partagée. On libère
                       // le mutex.
                       pthread_mutex_unlock(tableau[i].mutex);
                   }
   
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return;                  return;
             }              }
Line 1400  instruction_vars(struct_processus *s_eta Line 1596  instruction_vars(struct_processus *s_eta
                 .suivant).suivant).suivant).suivant = NULL;                  .suivant).suivant).suivant).suivant = NULL;
   
         l_element_precedent = l_element_courant;          l_element_precedent = l_element_courant;
   
           if (tableau[i].mutex != NULL)
           {
               // La variable est une variable partagée. On libère
               // le mutex.
               pthread_mutex_unlock(tableau[i].mutex);
           }
     }      }
   
     free(tableau);      free(tableau);
Line 1433  instruction_visit(struct_processus *s_et Line 1636  instruction_visit(struct_processus *s_et
   
     struct_objet                        *s_objet;      struct_objet                        *s_objet;
   
     unsigned long                       profondeur_initiale;      integer8                            profondeur_initiale;
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   

Removed from v.1.20  
changed lines
  Added in v.1.72


CVSweb interface <joel.bertrand@systella.fr>