[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.20 and 1.44

version 1.20, 2011/06/20 17:54:17 version 1.44, 2012/12/17 21:22:43
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.0.prerelease.1    RPL/2 (R) version 4.1.11
   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 119  instruction_idn(struct_processus *s_etat Line 119  instruction_idn(struct_processus *s_etat
   
         if (s_objet_argument == NULL)          if (s_objet_argument == 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,
                     (*(*s_etat_processus).pointeur_variable_courante).nom,                      (*(*s_etat_processus).pointeur_variable_courante).nom,
                     (*(*s_etat_processus).pointeur_variable_courante)                      (*(*s_etat_processus).pointeur_variable_courante)
                     .variable_partagee, (*(*s_etat_processus)                      .variable_partagee, (*(*s_etat_processus)
                     .pointeur_variable_courante).origine) == d_faux)                      .pointeur_variable_courante).origine) == NULL)
             {              {
                 if (pthread_mutex_unlock(&((*(*s_etat_processus)  
                         .s_liste_variables_partagees).mutex)) != 0)  
                 {  
                     (*s_etat_processus).erreur_systeme = d_es_processus;  
                     return;  
                 }  
   
                 (*s_etat_processus).erreur_systeme = d_es;                  (*s_etat_processus).erreur_systeme = d_es;
                 (*s_etat_processus).erreur_execution =                  (*s_etat_processus).erreur_execution =
                         d_ex_variable_non_definie;                          d_ex_variable_non_definie;
Line 147  instruction_idn(struct_processus *s_etat Line 133  instruction_idn(struct_processus *s_etat
             }              }
   
             s_objet_argument = (*(*s_etat_processus)              s_objet_argument = (*(*s_etat_processus)
                     .s_liste_variables_partagees).table[(*(*s_etat_processus)                      .pointeur_variable_partagee_courante).objet;
                     .s_liste_variables_partagees).position_variable].objet;  
             variable_partagee = d_vrai;              variable_partagee = d_vrai;
         }          }
         else          else
Line 181  instruction_idn(struct_processus *s_etat Line 166  instruction_idn(struct_processus *s_etat
             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;
Line 215  instruction_idn(struct_processus *s_etat Line 200  instruction_idn(struct_processus *s_etat
                 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;
Line 244  instruction_idn(struct_processus *s_etat Line 229  instruction_idn(struct_processus *s_etat
             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;
Line 266  instruction_idn(struct_processus *s_etat Line 251  instruction_idn(struct_processus *s_etat
                 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;
Line 297  instruction_idn(struct_processus *s_etat Line 282  instruction_idn(struct_processus *s_etat
         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;
Line 325  instruction_idn(struct_processus *s_etat Line 310  instruction_idn(struct_processus *s_etat
         if (variable_partagee == d_vrai)          if (variable_partagee == d_vrai)
         {          {
             (*(*s_etat_processus).pointeur_variable_courante).objet = NULL;              (*(*s_etat_processus).pointeur_variable_courante).objet = NULL;
             (*(*s_etat_processus).s_liste_variables_partagees).table              (*(*s_etat_processus).pointeur_variable_partagee_courante).objet =
                     [(*(*s_etat_processus).s_liste_variables_partagees)                      s_objet_resultat;
                     .position_variable].objet = s_objet_resultat;  
   
             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;
Line 782  instruction_input(struct_processus *s_et Line 766  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 848  instruction_input(struct_processus *s_et Line 837  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 1033  instruction_int(struct_processus *s_etat Line 1060  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 1402  instruction_incr(struct_processus *s_eta Line 1517  instruction_incr(struct_processus *s_eta
   
         if ((*(*s_etat_processus).pointeur_variable_courante).objet == NULL)          if ((*(*s_etat_processus).pointeur_variable_courante).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,
                     (*(*s_etat_processus).pointeur_variable_courante).nom,                      (*(*s_etat_processus).pointeur_variable_courante).nom,
                     (*(*s_etat_processus).pointeur_variable_courante)                      (*(*s_etat_processus).pointeur_variable_courante)
                     .variable_partagee, (*(*s_etat_processus)                      .variable_partagee, (*(*s_etat_processus)
                     .pointeur_variable_courante).origine) == d_faux)                      .pointeur_variable_courante).origine) == NULL)
             {              {
                 (*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 1423  instruction_incr(struct_processus *s_eta Line 1531  instruction_incr(struct_processus *s_eta
             }              }
   
             s_objet_argument = (*(*s_etat_processus)              s_objet_argument = (*(*s_etat_processus)
                     .s_liste_variables_partagees).table                      .pointeur_variable_partagee_courante).objet;
                     [(*(*s_etat_processus).s_liste_variables_partagees)  
                     .position_variable].objet;  
             variable_partagee = d_vrai;              variable_partagee = d_vrai;
         }          }
         else          else
Line 1441  instruction_incr(struct_processus *s_eta Line 1547  instruction_incr(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;
Line 1457  instruction_incr(struct_processus *s_eta Line 1563  instruction_incr(struct_processus *s_eta
         if (variable_partagee == d_vrai)          if (variable_partagee == d_vrai)
         {          {
             (*(*s_etat_processus).pointeur_variable_courante).objet = NULL;              (*(*s_etat_processus).pointeur_variable_courante).objet = NULL;
             (*(*s_etat_processus)              (*(*s_etat_processus).pointeur_variable_partagee_courante).objet =
                     .s_liste_variables_partagees).table                      s_copie_argument;
                     [(*(*s_etat_processus).s_liste_variables_partagees)  
                     .position_variable].objet = s_copie_argument;  
         }          }
         else          else
         {          {
Line 1475  instruction_incr(struct_processus *s_eta Line 1579  instruction_incr(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;
Line 1487  instruction_incr(struct_processus *s_eta Line 1591  instruction_incr(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;
Removed from v.1.20  
changed lines
  Added in v.1.44

CVSweb interface <joel.bertrand@systella.fr>