[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.32

version 1.20, 2011/06/20 17:54:17 version 1.32, 2011/09/26 15:57:13
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.0.prerelease.1    RPL/2 (R) version 4.1.4
   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 1033  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");
         }          }
   
         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;
 }  }
   
Removed from v.1.20  
changed lines
  Added in v.1.32

CVSweb interface <joel.bertrand@systella.fr>