[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.17 and 1.24

version 1.17, 2011/04/11 12:10:08 version 1.24, 2011/06/24 15:59:07
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.0.prerelease.0    RPL/2 (R) version 4.1.0.prerelease.3
   Copyright (C) 1989-2011 Dr. BERTRAND Joël    Copyright (C) 1989-2011 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
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 1037  instruction_int(struct_processus *s_etat Line 1033  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");
         }          }
   
           // Entier et réel
         printf("    3: %s, %s, %s\n", d_NOM, d_ALG, d_RPN);          printf("    3: %s, %s, %s\n", 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\n", d_ALG, d_NOM);
           printf("    1: %s\n", d_NOM);
           printf("->  1: %s\n", 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, 3) == 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)  
     {  
         precision = (*((real8 *) (*s_objet_argument_1).objet));  
     }  
     else  
     {  
         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;          if (((*s_objet_argument_1).type == NOM) &&
         return;                  (((*s_objet_argument_2).type == NOM) ||
     }                  ((*s_objet_argument_2).type == ALG)))
           {
               if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
                       s_objet_argument_2) == d_erreur)
               {
                   return;
               }
   
     if ((*s_objet_argument_2).type == LST)              if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
     {                      s_objet_argument_1) == d_erreur)
         l_element_courant = (*s_objet_argument_2).objet;              {
                   return;
               }
   
         if ((*(*l_element_courant).donnee).type != NOM)              interface_cas(s_etat_processus, RPLCAS_INTEGRATION);
           }
           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);  
   
             (*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;              (*s_etat_processus).erreur_execution =
                       d_ex_erreur_type_argument;
             return;              return;
         }          }
       }
       else
       {
           // Intégration numérique
   
         if ((nom_variable = malloc((strlen((*((struct_nom *)          if ((last_valide = test_cfsf(s_etat_processus, 31)) == d_vrai)
                 (*(*l_element_courant).donnee).objet)).nom)  
                 + 1) * sizeof(unsigned char))) == NULL)  
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
               {
                   return;
               }
           }
   
           if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
                   &s_objet_argument_1) == d_erreur)
           {
               (*s_etat_processus).erreur_execution = d_ex_manque_argument;
             return;              return;
         }          }
   
         strcpy(nom_variable, (*((struct_nom *) (*(*l_element_courant)          if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
                 .donnee).objet)).nom);                  &s_objet_argument_2) == d_erreur)
           {
               liberation(s_etat_processus, s_objet_argument_1);
   
         l_element_courant = (*l_element_courant).suivant;              (*s_etat_processus).erreur_execution = d_ex_manque_argument;
               return;
           }
   
         if ((*(*l_element_courant).donnee).type == INT)          if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
                   &s_objet_argument_3) == d_erreur)
         {          {
             borne_minimale = (real8) (*((integer8 *)              liberation(s_etat_processus, s_objet_argument_1);
                     (*(*l_element_courant).donnee).objet));              liberation(s_etat_processus, s_objet_argument_2);
   
               (*s_etat_processus).erreur_execution = d_ex_manque_argument;
               return;
         }          }
         else if ((*(*l_element_courant).donnee).type == REL)  
           if ((*s_objet_argument_1).type == INT)
           {
               precision = (*((integer8 *) (*s_objet_argument_1).objet));
           }
           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 1465  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 1482  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 1502  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 1528  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 1536  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.17  
changed lines
  Added in v.1.24

CVSweb interface <joel.bertrand@systella.fr>