[BACK]Return to instructions_i2.c CVS log [TXT] [DIR] Up to [local] / rpl / src

Diff for /rpl/src/instructions_i2.c between versions 1.8 and 1.41

version 1.8, 2010/05/24 10:58:33 version 1.41, 2012/08/22 10:47:16
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.16    RPL/2 (R) version 4.1.10
   Copyright (C) 1989-2010 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 20 Line 20
 */  */
   
   
 #include "rpl.conv.h"  #include "rpl-conv.h"
   
   
 /*  /*
Line 107  instruction_idn(struct_processus *s_etat Line 107  instruction_idn(struct_processus *s_etat
   
         liberation(s_etat_processus, s_objet_argument);          liberation(s_etat_processus, s_objet_argument);
   
         if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)          if ((*(*s_etat_processus).pointeur_variable_courante)
                 .position_variable_courante].variable_verrouillee == d_vrai)                  .variable_verrouillee == d_vrai)
         {          {
             (*s_etat_processus).erreur_execution = d_ex_variable_verrouillee;              (*s_etat_processus).erreur_execution = d_ex_variable_verrouillee;
             return;              return;
         }          }
   
         s_objet_argument = (*s_etat_processus).s_liste_variables          s_objet_argument = (*(*s_etat_processus).pointeur_variable_courante)
                 [(*s_etat_processus).position_variable_courante].objet;                  .objet;
   
         if (s_objet_argument == NULL)          if (s_objet_argument == NULL)
         {          {
Line 127  instruction_idn(struct_processus *s_etat Line 127  instruction_idn(struct_processus *s_etat
             }              }
   
             if (recherche_variable_partagee(s_etat_processus,              if (recherche_variable_partagee(s_etat_processus,
                     (*s_etat_processus).s_liste_variables                      (*(*s_etat_processus).pointeur_variable_courante).nom,
                     [(*s_etat_processus).position_variable_courante].nom,                      (*(*s_etat_processus).pointeur_variable_courante)
                     (*s_etat_processus).s_liste_variables                      .variable_partagee, (*(*s_etat_processus)
                     [(*s_etat_processus).position_variable_courante]                      .pointeur_variable_courante).origine) == d_faux)
                     .variable_partagee, (*s_etat_processus).s_liste_variables  
                     [(*s_etat_processus).position_variable_courante].origine)  
                     == d_faux)  
             {              {
                 if (pthread_mutex_unlock(&((*(*s_etat_processus)                  if (pthread_mutex_unlock(&((*(*s_etat_processus)
                         .s_liste_variables_partagees).mutex)) != 0)                          .s_liste_variables_partagees).mutex)) != 0)
Line 327  instruction_idn(struct_processus *s_etat Line 324  instruction_idn(struct_processus *s_etat
     {      {
         if (variable_partagee == d_vrai)          if (variable_partagee == d_vrai)
         {          {
             (*s_etat_processus).s_liste_variables[(*s_etat_processus)              (*(*s_etat_processus).pointeur_variable_courante).objet = NULL;
                     .position_variable_courante].objet = NULL;  
             (*(*s_etat_processus).s_liste_variables_partagees).table              (*(*s_etat_processus).s_liste_variables_partagees).table
                     [(*(*s_etat_processus).s_liste_variables_partagees)                      [(*(*s_etat_processus).s_liste_variables_partagees)
                     .position_variable].objet = s_objet_resultat;                      .position_variable].objet = s_objet_resultat;
Line 342  instruction_idn(struct_processus *s_etat Line 338  instruction_idn(struct_processus *s_etat
         }          }
         else          else
         {          {
             (*s_etat_processus).s_liste_variables[(*s_etat_processus)              (*(*s_etat_processus).pointeur_variable_courante).objet =
                     .position_variable_courante].objet = s_objet_resultat;                      s_objet_resultat;
         }          }
     }      }
   
Line 786  instruction_input(struct_processus *s_et Line 782  instruction_input(struct_processus *s_et
 {  {
     struct_objet                *s_objet_resultat;      struct_objet                *s_objet_resultat;
   
       unsigned char               *ptr_e;
       unsigned char               *ptr_l;
     unsigned char               *tampon;      unsigned char               *tampon;
       unsigned char               *tampon2;
   
       unsigned long               i;
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
Line 852  instruction_input(struct_processus *s_et Line 853  instruction_input(struct_processus *s_et
     }      }
   
     free((unsigned char *) (*s_objet_resultat).objet);      free((unsigned char *) (*s_objet_resultat).objet);
     (*s_objet_resultat).objet = tampon;  
       ptr_l = tampon;
       i = 0;
   
       while((*ptr_l) != d_code_fin_chaine)
       {
           if ((*ptr_l) == '\"')
           {
               i++;
           }
   
           ptr_l++;
       }
   
       if ((tampon2 = malloc((strlen(tampon) + 1 + i) *
               sizeof(unsigned char))) == NULL)
       {
           (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
           return;
       }
   
       ptr_l = tampon;
       ptr_e = tampon2;
   
       while((*ptr_l) != d_code_fin_chaine)
       {
           if ((*ptr_l) == '\"')
           {
               (*ptr_e) = '\\';
               ptr_e++;
           }
   
           (*ptr_e) = (*ptr_l);
           ptr_e++;
           ptr_l++;
       }
   
       free(tampon);
       (*s_objet_resultat).objet = tampon2;
   
     add_history((unsigned char *) (*s_objet_resultat).objet);      add_history((unsigned char *) (*s_objet_resultat).objet);
     stifle_history(ds_longueur_historique);      stifle_history(ds_longueur_historique);
Line 1037  instruction_int(struct_processus *s_etat Line 1076  instruction_int(struct_processus *s_etat
   
         if ((*s_etat_processus).langue == 'F')          if ((*s_etat_processus).langue == 'F')
         {          {
             printf("(intégration numérique)\n\n");              printf("(intégration)\n\n");
         }          }
         else          else
         {          {
             printf("(numerical integration)\n\n");              printf("(numerical)\n\n");
         }          }
   
         printf("    3: %s, %s, %s\n", d_NOM, d_ALG, d_RPN);          printf("    3: %s, %s, %s, %s, %s\n", d_INT, d_REL,
                   d_NOM, d_ALG, d_RPN);
         printf("    2: %s\n", d_LST);          printf("    2: %s\n", d_LST);
         printf("    1: %s, %s\n", d_INT, d_REL);          printf("    1: %s, %s\n", d_INT, d_REL);
         printf("->  2: %s, %s\n", d_INT, d_REL);          printf("->  2: %s, %s\n", d_INT, d_REL);
         printf("    1: %s, %s\n", d_INT, d_REL);          printf("    1: %s, %s\n\n", d_INT, d_REL);
   
           printf("    2: %s, %s, %s, %s\n", d_INT, d_REL, d_NOM, d_ALG);
           printf("    1: %s\n", d_NOM);
           printf("->  1: %s, %s, %s, %s\n", d_INT, d_REL, d_NOM, d_ALG);
         return;          return;
     }      }
     else if ((*s_etat_processus).test_instruction == 'Y')      else if ((*s_etat_processus).test_instruction == 'Y')
     {      {
         (*s_etat_processus).nombre_arguments = 3;          (*s_etat_processus).nombre_arguments = -1;
         return;          return;
     }      }
       
     if ((last_valide = test_cfsf(s_etat_processus, 31)) == d_vrai)  
     {  
         if (empilement_pile_last(s_etat_processus, 3) == d_erreur)  
         {  
             return;  
         }  
     }  
   
     if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),      if ((*s_etat_processus).l_base_pile == NULL)
             &s_objet_argument_1) == d_erreur)  
     {      {
         (*s_etat_processus).erreur_execution = d_ex_manque_argument;          (*s_etat_processus).erreur_execution = d_ex_manque_argument;
         return;          return;
     }      }
   
     if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),      if ((*(*(*s_etat_processus).l_base_pile).donnee).type == NOM)
             &s_objet_argument_2) == d_erreur)  
     {      {
         liberation(s_etat_processus, s_objet_argument_1);          // Intégration symbolique
   
         (*s_etat_processus).erreur_execution = d_ex_manque_argument;          if (test_cfsf(s_etat_processus, 31) == d_vrai)
         return;          {
     }              if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
               {
                   return;
               }
           }
   
     if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),          if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
             &s_objet_argument_3) == d_erreur)                  &s_objet_argument_1) == d_erreur)
     {          {
         liberation(s_etat_processus, s_objet_argument_1);              (*s_etat_processus).erreur_execution = d_ex_manque_argument;
         liberation(s_etat_processus, s_objet_argument_2);              return;
           }
   
         (*s_etat_processus).erreur_execution = d_ex_manque_argument;          if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
         return;                  &s_objet_argument_2) == d_erreur)
     }          {
               liberation(s_etat_processus, s_objet_argument_1);
   
     if ((*s_objet_argument_1).type == INT)              (*s_etat_processus).erreur_execution = d_ex_manque_argument;
     {              return;
         precision = (*((integer8 *) (*s_objet_argument_1).objet));          }
     }  
     else if ((*s_objet_argument_1).type == REL)          if (((*s_objet_argument_1).type == NOM) &&
     {                  (((*s_objet_argument_2).type == NOM) ||
         precision = (*((real8 *) (*s_objet_argument_1).objet));                  ((*s_objet_argument_2).type == ALG) ||
                   ((*s_objet_argument_2).type == REL) ||
                   ((*s_objet_argument_2).type == INT)))
           {
               if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
                       s_objet_argument_2) == d_erreur)
               {
                   return;
               }
   
               if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
                       s_objet_argument_1) == d_erreur)
               {
                   return;
               }
   
               interface_cas(s_etat_processus, RPLCAS_INTEGRATION);
           }
           else
           {
               liberation(s_etat_processus, s_objet_argument_1);
               liberation(s_etat_processus, s_objet_argument_2);
   
               (*s_etat_processus).erreur_execution =
                       d_ex_erreur_type_argument;
               return;
           }
     }      }
     else      else
     {      {
         liberation(s_etat_processus, s_objet_argument_1);          // Intégration numérique
         liberation(s_etat_processus, s_objet_argument_2);  
         liberation(s_etat_processus, s_objet_argument_3);  
   
         (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;          if ((last_valide = test_cfsf(s_etat_processus, 31)) == d_vrai)
         return;          {
     }              if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
               {
                   return;
               }
           }
   
     if ((*s_objet_argument_2).type == LST)          if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
     {                  &s_objet_argument_1) == d_erreur)
         l_element_courant = (*s_objet_argument_2).objet;          {
               (*s_etat_processus).erreur_execution = d_ex_manque_argument;
               return;
           }
   
         if ((*(*l_element_courant).donnee).type != NOM)          if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
                   &s_objet_argument_2) == d_erreur)
         {          {
             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_3);  
   
             (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;              (*s_etat_processus).erreur_execution = d_ex_manque_argument;
             return;              return;
         }          }
   
         if ((nom_variable = malloc((strlen((*((struct_nom *)          if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
                 (*(*l_element_courant).donnee).objet)).nom)                  &s_objet_argument_3) == d_erreur)
                 + 1) * sizeof(unsigned char))) == NULL)  
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              liberation(s_etat_processus, s_objet_argument_1);
               liberation(s_etat_processus, s_objet_argument_2);
   
               (*s_etat_processus).erreur_execution = d_ex_manque_argument;
             return;              return;
         }          }
   
         strcpy(nom_variable, (*((struct_nom *) (*(*l_element_courant)          if (((*s_objet_argument_3).type != NOM) &&
                 .donnee).objet)).nom);                  ((*s_objet_argument_3).type != ALG) &&
                   ((*s_objet_argument_3).type != RPN) &&
                   ((*s_objet_argument_3).type != REL) &&
                   ((*s_objet_argument_3).type != INT))
           {
               liberation(s_etat_processus, s_objet_argument_1);
               liberation(s_etat_processus, s_objet_argument_2);
               liberation(s_etat_processus, s_objet_argument_3);
   
         l_element_courant = (*l_element_courant).suivant;              (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
               return;
           }
   
         if ((*(*l_element_courant).donnee).type == INT)          if ((*s_objet_argument_1).type == INT)
         {          {
             borne_minimale = (real8) (*((integer8 *)              precision = (*((integer8 *) (*s_objet_argument_1).objet));
                     (*(*l_element_courant).donnee).objet));  
         }          }
         else if ((*(*l_element_courant).donnee).type == REL)          else if ((*s_objet_argument_1).type == REL)
         {          {
             borne_minimale = (*((real8 *) (*(*l_element_courant)              precision = (*((real8 *) (*s_objet_argument_1).objet));
                     .donnee).objet));  
         }          }
         else          else
         {          {
             if (evaluation(s_etat_processus, (*l_element_courant).donnee,              liberation(s_etat_processus, s_objet_argument_1);
                     'N') == d_erreur)              liberation(s_etat_processus, s_objet_argument_2);
               liberation(s_etat_processus, s_objet_argument_3);
   
               (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
               return;
           }
   
           if ((*s_objet_argument_2).type == LST)
           {
               l_element_courant = (*s_objet_argument_2).objet;
   
               if ((*(*l_element_courant).donnee).type != NOM)
             {              {
                 free(nom_variable);  
                 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);
                 liberation(s_etat_processus, s_objet_argument_3);                  liberation(s_etat_processus, s_objet_argument_3);
   
                   (*s_etat_processus).erreur_execution =
                           d_ex_erreur_type_argument;
                 return;                  return;
             }              }
   
             if (depilement(s_etat_processus, &((*s_etat_processus)              if ((nom_variable = malloc((strlen((*((struct_nom *)
                     .l_base_pile), &s_objet_evalue) == d_erreur)                      (*(*l_element_courant).donnee).objet)).nom)
                       + 1) * sizeof(unsigned char))) == NULL)
             {              {
                 free(nom_variable);                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 liberation(s_etat_processus, s_objet_argument_1);  
                 liberation(s_etat_processus, s_objet_argument_2);  
                 liberation(s_etat_processus, s_objet_argument_3);  
   
                 (*s_etat_processus).erreur_execution =  
                         d_ex_manque_argument;  
                 return;                  return;
             }              }
   
             if ((*s_objet_evalue).type == INT)              strcpy(nom_variable, (*((struct_nom *) (*(*l_element_courant)
                       .donnee).objet)).nom);
   
               l_element_courant = (*l_element_courant).suivant;
   
               if ((*(*l_element_courant).donnee).type == INT)
             {              {
                 borne_minimale = (real8) (*((integer8 *)                  borne_minimale = (real8) (*((integer8 *)
                         (*s_objet_evalue).objet));                          (*(*l_element_courant).donnee).objet));
             }              }
             else if ((*s_objet_evalue).type == REL)              else if ((*(*l_element_courant).donnee).type == REL)
             {              {
                 borne_minimale = (*((real8 *) (*s_objet_evalue).objet));                  borne_minimale = (*((real8 *) (*(*l_element_courant)
                           .donnee).objet));
             }              }
             else              else
             {              {
                 free(nom_variable);                  if (evaluation(s_etat_processus, (*l_element_courant).donnee,
                                           'N') == d_erreur)
                 liberation(s_etat_processus, s_objet_evalue);                  {
                 liberation(s_etat_processus, s_objet_argument_1);                      free(nom_variable);
                 liberation(s_etat_processus, s_objet_argument_2);                      liberation(s_etat_processus, s_objet_argument_1);
                 liberation(s_etat_processus, s_objet_argument_3);                      liberation(s_etat_processus, s_objet_argument_2);
                       liberation(s_etat_processus, s_objet_argument_3);
                 (*s_etat_processus).erreur_execution =  
                         d_ex_erreur_type_argument;  
                 return;  
             }  
   
             liberation(s_etat_processus, s_objet_evalue);                      return;
         }                  }
   
         l_element_courant = (*l_element_courant).suivant;                  if (depilement(s_etat_processus, &((*s_etat_processus)
                           .l_base_pile), &s_objet_evalue) == d_erreur)
                   {
                       free(nom_variable);
                       liberation(s_etat_processus, s_objet_argument_1);
                       liberation(s_etat_processus, s_objet_argument_2);
                       liberation(s_etat_processus, s_objet_argument_3);
   
         if ((*(*l_element_courant).donnee).type == INT)                      (*s_etat_processus).erreur_execution =
         {                              d_ex_manque_argument;
             borne_maximale = (real8) (*((integer8 *)                      return;
                     (*(*l_element_courant).donnee).objet));                  }
         }  
         else if ((*(*l_element_courant).donnee).type == REL)  
         {  
             borne_maximale = (*((real8 *) (*(*l_element_courant)  
                     .donnee).objet));  
         }  
         else  
         {  
             if (evaluation(s_etat_processus, (*l_element_courant).donnee,  
                     'N') == d_erreur)  
             {  
                 free(nom_variable);  
                 liberation(s_etat_processus, s_objet_argument_1);  
                 liberation(s_etat_processus, s_objet_argument_2);  
                 liberation(s_etat_processus, s_objet_argument_3);  
   
                 return;                  if ((*s_objet_evalue).type == INT)
             }                  {
                       borne_minimale = (real8) (*((integer8 *)
                               (*s_objet_evalue).objet));
                   }
                   else if ((*s_objet_evalue).type == REL)
                   {
                       borne_minimale = (*((real8 *) (*s_objet_evalue).objet));
                   }
                   else
                   {
                       free(nom_variable);
                       
                       liberation(s_etat_processus, s_objet_evalue);
                       liberation(s_etat_processus, s_objet_argument_1);
                       liberation(s_etat_processus, s_objet_argument_2);
                       liberation(s_etat_processus, s_objet_argument_3);
   
             if (depilement(s_etat_processus, &((*s_etat_processus)                      (*s_etat_processus).erreur_execution =
                     .l_base_pile), &s_objet_evalue) == d_erreur)                              d_ex_erreur_type_argument;
             {                      return;
                 free(nom_variable);                  }
                 liberation(s_etat_processus, s_objet_argument_1);  
                 liberation(s_etat_processus, s_objet_argument_2);  
                 liberation(s_etat_processus, s_objet_argument_3);  
   
                 (*s_etat_processus).erreur_execution =                  liberation(s_etat_processus, s_objet_evalue);
                         d_ex_manque_argument;  
                 return;  
             }              }
   
             if ((*s_objet_evalue).type == INT)              l_element_courant = (*l_element_courant).suivant;
   
               if ((*(*l_element_courant).donnee).type == INT)
             {              {
                 borne_maximale = (real8) (*((integer8 *)                  borne_maximale = (real8) (*((integer8 *)
                         (*s_objet_evalue).objet));                          (*(*l_element_courant).donnee).objet));
             }              }
             else if ((*s_objet_evalue).type == REL)              else if ((*(*l_element_courant).donnee).type == REL)
             {              {
                 borne_maximale = (*((real8 *) (*s_objet_evalue).objet));                  borne_maximale = (*((real8 *) (*(*l_element_courant)
                           .donnee).objet));
             }              }
             else              else
             {              {
                 free(nom_variable);                  if (evaluation(s_etat_processus, (*l_element_courant).donnee,
                           'N') == d_erreur)
                   {
                       free(nom_variable);
                       liberation(s_etat_processus, s_objet_argument_1);
                       liberation(s_etat_processus, s_objet_argument_2);
                       liberation(s_etat_processus, s_objet_argument_3);
   
                 liberation(s_etat_processus, s_objet_evalue);                      return;
                 liberation(s_etat_processus, s_objet_argument_1);                  }
                 liberation(s_etat_processus, s_objet_argument_2);  
                 liberation(s_etat_processus, s_objet_argument_3);  
   
                 (*s_etat_processus).erreur_execution =                  if (depilement(s_etat_processus, &((*s_etat_processus)
                         d_ex_erreur_type_argument;                          .l_base_pile), &s_objet_evalue) == d_erreur)
                 return;                  {
                       free(nom_variable);
                       liberation(s_etat_processus, s_objet_argument_1);
                       liberation(s_etat_processus, s_objet_argument_2);
                       liberation(s_etat_processus, s_objet_argument_3);
   
                       (*s_etat_processus).erreur_execution =
                               d_ex_manque_argument;
                       return;
                   }
   
                   if ((*s_objet_evalue).type == INT)
                   {
                       borne_maximale = (real8) (*((integer8 *)
                               (*s_objet_evalue).objet));
                   }
                   else if ((*s_objet_evalue).type == REL)
                   {
                       borne_maximale = (*((real8 *) (*s_objet_evalue).objet));
                   }
                   else
                   {
                       free(nom_variable);
   
                       liberation(s_etat_processus, s_objet_evalue);
                       liberation(s_etat_processus, s_objet_argument_1);
                       liberation(s_etat_processus, s_objet_argument_2);
                       liberation(s_etat_processus, s_objet_argument_3);
   
                       (*s_etat_processus).erreur_execution =
                               d_ex_erreur_type_argument;
                       return;
                   }
   
                   liberation(s_etat_processus, s_objet_evalue);
             }              }
   
             liberation(s_etat_processus, s_objet_evalue);              /*
         }               * Le résultat est retourné sur la pile par la routine
                */
   
         /*              if (last_valide == d_vrai)
          * Le résultat est retourné sur la pile par la routine              {
          */                  cf(s_etat_processus, 31);
               }
   
         if (last_valide == d_vrai)              integrale_romberg(s_etat_processus, s_objet_argument_3,
         {                      nom_variable, borne_minimale, borne_maximale, precision);
             cf(s_etat_processus, 31);  
         }  
   
         integrale_romberg(s_etat_processus, s_objet_argument_3, nom_variable,              if (last_valide == d_vrai)
                 borne_minimale, borne_maximale, precision);              {
                   sf(s_etat_processus, 31);
               }
   
         if (last_valide == d_vrai)              free(nom_variable);
           }
           else
         {          {
             sf(s_etat_processus, 31);              liberation(s_etat_processus, s_objet_argument_1);
               liberation(s_etat_processus, s_objet_argument_2);
               liberation(s_etat_processus, s_objet_argument_3);
   
               (*s_etat_processus).erreur_execution =
                       d_ex_erreur_type_argument;
               return;
         }          }
   
         free(nom_variable);  
     }  
     else  
     {  
         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);
         liberation(s_etat_processus, s_objet_argument_3);          liberation(s_etat_processus, s_objet_argument_3);
   
         (*s_etat_processus).erreur_execution =  
                 d_ex_erreur_type_argument;  
         return;  
     }      }
   
     liberation(s_etat_processus, s_objet_argument_1);  
     liberation(s_etat_processus, s_objet_argument_2);  
     liberation(s_etat_processus, s_objet_argument_3);  
   
     return;      return;
 }  }
   
Line 1397  instruction_incr(struct_processus *s_eta Line 1524  instruction_incr(struct_processus *s_eta
   
         liberation(s_etat_processus, s_objet_argument);          liberation(s_etat_processus, s_objet_argument);
   
         if ((*s_etat_processus).s_liste_variables          if ((*(*s_etat_processus).pointeur_variable_courante)
                 [(*s_etat_processus).position_variable_courante]  
                 .variable_verrouillee == d_vrai)                  .variable_verrouillee == d_vrai)
         {          {
             (*s_etat_processus).erreur_execution = d_ex_variable_verrouillee;              (*s_etat_processus).erreur_execution = d_ex_variable_verrouillee;
             return;              return;
         }          }
   
         if ((*s_etat_processus).s_liste_variables          if ((*(*s_etat_processus).pointeur_variable_courante).objet == NULL)
                 [(*s_etat_processus).position_variable_courante].objet  
                 == NULL)  
         {          {
             if (pthread_mutex_lock(&((*(*s_etat_processus)              if (pthread_mutex_lock(&((*(*s_etat_processus)
                     .s_liste_variables_partagees).mutex)) != 0)                      .s_liste_variables_partagees).mutex)) != 0)
Line 1417  instruction_incr(struct_processus *s_eta Line 1541  instruction_incr(struct_processus *s_eta
             }              }
   
             if (recherche_variable_partagee(s_etat_processus,              if (recherche_variable_partagee(s_etat_processus,
                     (*s_etat_processus).s_liste_variables                      (*(*s_etat_processus).pointeur_variable_courante).nom,
                     [(*s_etat_processus).position_variable_courante].nom,                      (*(*s_etat_processus).pointeur_variable_courante)
                     (*s_etat_processus).s_liste_variables                      .variable_partagee, (*(*s_etat_processus)
                     [(*s_etat_processus).position_variable_courante]                      .pointeur_variable_courante).origine) == d_faux)
                     .variable_partagee, (*s_etat_processus).s_liste_variables  
                     [(*s_etat_processus).position_variable_courante]  
                     .origine) == d_faux)  
             {              {
                 (*s_etat_processus).erreur_systeme = d_es;                  (*s_etat_processus).erreur_systeme = d_es;
                 (*s_etat_processus).erreur_execution =                  (*s_etat_processus).erreur_execution =
Line 1440  instruction_incr(struct_processus *s_eta Line 1561  instruction_incr(struct_processus *s_eta
         }          }
         else          else
         {          {
             s_objet_argument = (*s_etat_processus).s_liste_variables              s_objet_argument = (*(*s_etat_processus).pointeur_variable_courante)
                     [(*s_etat_processus).position_variable_courante].objet;                      .objet;
             variable_partagee = d_faux;              variable_partagee = d_faux;
         }          }
   
Line 1466  instruction_incr(struct_processus *s_eta Line 1587  instruction_incr(struct_processus *s_eta
   
         if (variable_partagee == d_vrai)          if (variable_partagee == d_vrai)
         {          {
             (*s_etat_processus).s_liste_variables[(*s_etat_processus)              (*(*s_etat_processus).pointeur_variable_courante).objet = NULL;
                     .position_variable_courante].objet = NULL;  
             (*(*s_etat_processus)              (*(*s_etat_processus)
                     .s_liste_variables_partagees).table                      .s_liste_variables_partagees).table
                     [(*(*s_etat_processus).s_liste_variables_partagees)                      [(*(*s_etat_processus).s_liste_variables_partagees)
Line 1475  instruction_incr(struct_processus *s_eta Line 1595  instruction_incr(struct_processus *s_eta
         }          }
         else          else
         {          {
             (*s_etat_processus).s_liste_variables[(*s_etat_processus)              (*(*s_etat_processus).pointeur_variable_courante).objet =
                     .position_variable_courante].objet = s_copie_argument;                      s_copie_argument;
         }          }
   
         if ((*s_copie_argument).type == INT)          if ((*s_copie_argument).type == INT)
Removed from v.1.8  
changed lines
  Added in v.1.41

CVSweb interface <joel.bertrand@systella.fr>