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

Diff for /rpl/src/simplification.c between versions 1.49 and 1.50

version 1.49, 2014/07/17 08:07:27 version 1.50, 2014/10/13 07:12:54
Line 25 Line 25
   
 /*  /*
 ================================================================================  ================================================================================
   Fonction 'simplification' (ne libère pas les paramètres)    Fonction de transcription d'un arbre en liste chaînée
 ================================================================================  ================================================================================
   Entrées : pointeur sur une structure struct_processus    Entrées : pointeur sur une structure struct_processus
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
Line 35 Line 35
 ================================================================================  ================================================================================
 */  */
   
 struct_objet *  static struct_liste_chainee *
 simplification(struct_processus *s_etat_processus, struct_objet *s_objet)  transcription_arbre(struct_processus *s_etat_processus, struct_arbre *s_arbre)
 {  {
 #ifdef EXPERIMENTAL_CODE      integer8                i;
     struct_arbre            *s_arbre;  
     struct_arbre            *s_noeud_courant;  
   
     struct_liste_chainee    *l_element_courant;      struct_liste_chainee    *l_element_courant;
 #endif      struct_liste_chainee    *l_liste;
     struct_objet            *s_objet_simplifie;      struct_liste_chainee    *l_nouvelle_pile_locale;
 #ifdef EXPERIMENTAL_CODE      struct_liste_chainee    *l_pile_locale;
     struct_objet            **t_expression;  
   
     unsigned long           i;      l_pile_locale = NULL;
     unsigned long           nombre_elements;  
   
     s_arbre = NULL;      for(i = 0; i < (*s_arbre).nombre_branches; i++)
 #endif  
   
     if ((*s_objet).type == ALG)  
     {      {
 #ifdef EXPERIMENTAL_CODE          if ((l_nouvelle_pile_locale = allocation_maillon(s_etat_processus))
         // Inversion de l'ordre des instructions dans l'expression                  == NULL)
   
         nombre_elements = 0;  
         l_element_courant = (*s_objet).objet;  
   
         while(l_element_courant != NULL)  
         {          {
             nombre_elements++;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             l_element_courant = (*l_element_courant).suivant;              return(NULL);
         }          }
   
         if ((t_expression = malloc(nombre_elements * sizeof(struct_objet *)))          (*l_nouvelle_pile_locale).suivant = l_pile_locale;
                 == NULL)          l_pile_locale = l_nouvelle_pile_locale;
   
           if (((*l_pile_locale).donnee = (void *) transcription_arbre(
                   s_etat_processus, (*s_arbre).branches[i])) == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
             return(NULL);              return(NULL);
         }          }
       }
   
         i = nombre_elements - 1;      if ((l_liste = allocation_maillon(s_etat_processus)) == NULL)
         l_element_courant = (*s_objet).objet;      {
           (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
           return(NULL);
       }
   
         while(l_element_courant != NULL)      // Ajout de la fonction
   
       (*l_liste).suivant = NULL;
       (*l_liste).donnee = (*s_arbre).feuille;
   
       free((*s_arbre).branches);
       free(s_arbre);
   
       // Chaînage des arguments
   
       while(l_pile_locale != NULL)
       {
           l_element_courant = (void *) (*l_pile_locale).donnee;
   
           if (l_element_courant == NULL)
         {          {
             if ((t_expression[i--] = copie_objet(s_etat_processus,              (*s_etat_processus).erreur_systeme = d_es_pile_vide;
                     (*l_element_courant).donnee, 'O')) == NULL)              return(NULL);
             {          }
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
                 return(NULL);  
             }  
   
           while((*l_element_courant).suivant != NULL)
           {
             l_element_courant = (*l_element_courant).suivant;              l_element_courant = (*l_element_courant).suivant;
         }          }
   
         // L'objet est toujours évaluable car il s'agit d'une expression          (*l_element_courant).suivant = l_liste;
         // algébrique (cela revient à dire qu'il n'y a qu'un seul arbre          l_liste = (void *) (*l_pile_locale).donnee;
         // et que celui-ci est terminé).  
   
         s_arbre = creation_arbre(s_etat_processus, t_expression, 0,  
                 nombre_elements - 1);  
   
         for(i = 0; i < nombre_elements; liberation(t_expression[i++]));  
         free(t_expression);  
 #endif  
   
         s_objet_simplifie = copie_objet(s_etat_processus, s_objet, 'P');  
   
         // On essaye déjà de voir si l'arbre est cohérent...          l_nouvelle_pile_locale = (*l_pile_locale).suivant;
     }          liberation_maillon(s_etat_processus, l_pile_locale);
     else          l_pile_locale = l_nouvelle_pile_locale;
     {  
         s_objet_simplifie = copie_objet(s_etat_processus, s_objet, 'P');  
     }      }
   
     return(s_objet_simplifie);      return(l_liste);
 }  }
   
   
 /*  /*
 ================================================================================  ================================================================================
   Fonction créant un noeud dans l'arbre    Fonction 'simplification' (ne libère pas les paramètres)
 ================================================================================  ================================================================================
   Entrées : pointeur sur une structure struct_arbre    Entrées : pointeur sur une structure struct_processus
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Sorties :    Sorties :
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
Line 126  simplification(struct_processus *s_etat_ Line 121  simplification(struct_processus *s_etat_
 ================================================================================  ================================================================================
 */  */
   
 struct_arbre *  struct_objet *
 creation_arbre(struct_processus *s_etat_processus,  simplification(struct_processus *s_etat_processus, struct_objet *s_objet)
         struct_objet **t_objets, integer8 indice, integer8 indice_maximal)  
 {  {
     struct_arbre        *s_noeud;      struct_objet                *s_objet_simplifie;
   
     //unsigned long     i;  #   ifdef   EXPERIMENTAL_CODE 
   
     if ((s_noeud = malloc(sizeof(struct_arbre))) == NULL)      integer8                    i;
     {      integer8                    nombre_arguments;
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
         return(NULL);  
     }  
   
 // indice ne peut jamais être supérieur à indice_maximal      struct_arbre                *s_arbre;
       
 #if 0  
         // Création de la racine de l'arbre  
   
         if ((s_arbre = malloc(sizeof(struct_arbre))) == NULL)      struct_liste_chainee        *l_element_courant;
         {  
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;      // Attention : l_liste_locale et l_ancienne_liste_locale ne contiennent pas
             return(NULL);      // un pointeur sur une struct_objet, mais sur une struct_arbre.
         }  
       struct_liste_chainee        *l_liste_locale;
       struct_liste_chainee        *l_ancienne_liste_locale;
   
         s_noeud_courant = s_arbre;      if ((*s_objet).type == ALG)
       {
           /*
            * Transcription de l'expression algébrique en arbre q-aire
            */
   
         for(i = 0; i < nombre_elements; i++)          l_liste_locale = NULL;
           l_element_courant = (*s_objet).objet;
   
           while(l_element_courant != NULL)
         {          {
             if (strcmp((*t_expression[i]).type, "FCT") == 0)              switch((*(*l_element_courant).donnee).type)
             {              {
                 if ((strcmp((*((struct_fonction *) (*t_expression[i]).objet))                  // Toutes les fonctions (intrinsèques, extrinsèques et
                         .nom_fonction, "<<") != 0) &&                  // utilisateurs).
                         (strcmp((*((struct_fonction *)  
                         (*t_expression[i]).objet)).nom_fonction, ">>") != 0))                  case FCT:
                   {
                       // Il s'agit d'un objet de type ALG. Nous pouvons donc
                       // sauter les délimiteurs d'expression.
   
                       if ((l_element_courant != (*s_objet).objet) &&
                               ((*l_element_courant).suivant != NULL))
                       {
                           nombre_arguments = (*((struct_fonction *)
                                   (*(*l_element_courant).donnee).objet))
                                   .nombre_arguments;
   
                           // Si le nombre d'arguments vaut 0, la fonction
                           // apparaît en notation algébrique comme une fonction
                           // infixe.
   
                           if (nombre_arguments == 0)
                           {
                               nombre_arguments = 2;
                           }
   
                           if ((s_arbre = malloc(sizeof(struct_arbre))) == NULL)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_allocation_memoire;
                               return(NULL);
                           }
   
                           (*s_arbre).inversion = d_faux;
                           (*s_arbre).nombre_branches = nombre_arguments;
   
                           if (((*s_arbre).branches = malloc(((size_t) (*s_arbre)
                                   .nombre_branches) * sizeof(struct_arbre *)))
                                   == NULL)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_allocation_memoire;
                               return(NULL);
                           }
   
                           for(i = 0; i < nombre_arguments; i++)
                           {
                               if (l_liste_locale == NULL)
                               {
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_manque_argument;
                                   return(NULL);
                               }
   
                               if (((*s_arbre).branches[i] = malloc(
                                       sizeof(struct_arbre))) == NULL)
                               {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_allocation_memoire;
                                   return(NULL);
                               }
   
                               (*(*s_arbre).branches[i]).feuille =
                                       (*l_liste_locale).donnee;
                               (*(*s_arbre).branches[i]).inversion = d_faux;
                               (*(*s_arbre).branches[i]).nombre_branches = 0;
                               (*(*s_arbre).branches[i]).branches = NULL;
   
                               l_ancienne_liste_locale = l_liste_locale;
                               l_liste_locale = (*l_liste_locale).suivant;
   
                               liberation_maillon(s_etat_processus,
                                       l_ancienne_liste_locale);
                           }
   
                           // Introduction de l'arbre dans la pile locale
   
                           l_ancienne_liste_locale = l_liste_locale;
   
                           if ((l_liste_locale = allocation_maillon(
                                   s_etat_processus)) == NULL)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_allocation_memoire;
                               return(NULL);
                           }
   
                           (*l_liste_locale).suivant = l_ancienne_liste_locale;
                           (*l_liste_locale).donnee = (void *) s_arbre;
                       }
   
                       break;
                   }
   
                   default:
                 {                  {
                     // Création d'un noeud                      l_ancienne_liste_locale = l_liste_locale;
   
                       if ((l_liste_locale = allocation_maillon(s_etat_processus))
                               == NULL)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return(NULL);
                       }
   
                       (*l_liste_locale).suivant = l_ancienne_liste_locale;
   
                       if ((s_arbre = malloc(sizeof(struct_arbre))) == NULL)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return(NULL);
                       }
   
                       (*s_arbre).feuille = copie_objet(s_etat_processus,
                               (*l_element_courant).donnee, 'P');
                       (*s_arbre).inversion = d_faux;
                       (*s_arbre).nombre_branches = 0;
                       (*s_arbre).branches = NULL;
   
                       (*l_liste_locale).donnee = (void *) s_arbre;
                       break;
                 }                  }
             }              }
   
               l_element_courant = (*l_element_courant).suivant;
         }          }
 #endif  
     return(NULL);  
 }  
   
           // Toute l'expression a été balayée. On ne doit plus avoir qu'un
           // seul niveau dans la pile locale, ce niveau contenant l'arbre
           // à réduire.
   
 /*          if (l_liste_locale == NULL)
 ================================================================================          {
   Fonction simplifiant l'arbre q-aire en arbre q'-aire (q <= q')              (*s_etat_processus).erreur_execution = d_ex_erreur_evaluation;
 ================================================================================              return(NULL);
   Entrées : pointeur sur une structure struct_arbre          }
 --------------------------------------------------------------------------------          else if ((*l_liste_locale).suivant != NULL)
   Sorties :          {
 --------------------------------------------------------------------------------              (*s_etat_processus).erreur_execution = d_ex_erreur_evaluation;
   Effets de bord : néant              return(NULL);
 ================================================================================          }
 */  
   
 void          s_arbre = (void *) (*l_liste_locale).donnee;
 simplification_arbre(struct_processus *s_etat_processus, struct_arbre *s_noeud)  
 {  
     unsigned long               i;  
   
     if ((*s_noeud).feuilles != NULL)          liberation_maillon(s_etat_processus, l_liste_locale);
     {          l_liste_locale = NULL;
         for(i = 0; i < (*s_noeud).nombre_feuilles; i++)  
           /*
            * Simplification de l'arbre
            */
   
   #       if 0
           simplification_arbre();
   #       endif
   
           /*
            * Transcription de l'arbre q-aire simplifié en expression algébrique.
            * Seule une fonction récursive permet de faire cette conversion
            * simplement.
            */
   
           l_liste_locale = transcription_arbre(s_etat_processus, s_arbre);
   
           if ((s_objet_simplifie = allocation(s_etat_processus, ALG))
                   == NULL)
         {          {
             simplification_arbre(s_etat_processus, (*s_noeud).feuilles[i]);              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return(NULL);
           }
   
             /*          // Ajout des délimiteurs '<<' et '>>' à la liste d'instructions
              * Si le noeud est une fonction compatible avec une fonction  
              * présente dans les feuilles, on réunit les deux.  
              */  
   
             if ((*(*((*s_noeud).feuilles[i])).objet).type == FCT)          if (((*s_objet_simplifie).objet = allocation_maillon(s_etat_processus))
             {                  == NULL)
                 if (((strcmp((*((struct_fonction *) (*s_noeud).objet))          {
                         .nom_fonction, "+") == 0) && (strcmp(              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                         (*((struct_fonction *) (*(*((*s_noeud).feuilles[i]))              return(NULL);
                         .objet).objet)).nom_fonction, "+") == 0)) ||  
                         ((strcmp((*((struct_fonction *) (*s_noeud).objet))  
                         .nom_fonction, "*") == 0) && (strcmp(  
                         (*((struct_fonction *) (*(*((*s_noeud).feuilles[i]))  
                         .objet).objet)).nom_fonction, "*") == 0)))  
                 {  
                 }  
             }  
         }          }
     }  
   
     return;          l_element_courant = (*s_objet_simplifie).objet;
 }  
   
           if (((*l_element_courant).donnee = allocation(s_etat_processus,
                   FCT)) == NULL)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return(NULL);
           }
   
 /*          (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
 ================================================================================                  .nombre_arguments = 0;
   Fonction parcourant l'arbre q-aire          (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
 ================================================================================                  .fonction = instruction_vers_niveau_superieur;
   Entrées : pointeur sur une structure struct_arbre  
 --------------------------------------------------------------------------------  
   Sorties :  
 --------------------------------------------------------------------------------  
   Effets de bord : néant  
 ================================================================================  
 */  
   
 void          if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
 parcours_arbre(struct_processus *s_etat_processus, struct_arbre *s_noeud)                  .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
 {          {
     unsigned long               i;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return(NULL);
           }
   
     if ((*s_noeud).feuilles != NULL)          strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
     {                  .nom_fonction, "<<");
         for(i = 0; i < (*s_noeud).nombre_feuilles; i++)  
           (*l_element_courant).suivant = l_liste_locale;
   
           while((*l_element_courant).suivant != NULL)
         {          {
             parcours_arbre(s_etat_processus, (*s_noeud).feuilles[i]);              l_element_courant = (*l_element_courant).suivant;
         }          }
     }  
   
     return;          if (((*l_element_courant).suivant =
 }                  allocation_maillon(s_etat_processus)) == NULL)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return(NULL);
           }
   
           l_element_courant = (*l_element_courant).suivant;
           (*l_element_courant).suivant = NULL;
   
 /*          if (((*l_element_courant).donnee = allocation(s_etat_processus,
 ================================================================================                  FCT)) == NULL)
   Fonction libérant l'arbre q-aire          {
 ================================================================================              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
   Entrées : pointeur sur une structure struct_arbre              return(NULL);
 --------------------------------------------------------------------------------          }
   Sorties :  
 --------------------------------------------------------------------------------  
   Effets de bord : néant  
 ================================================================================  
 */  
   
 void          (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
 liberation_arbre(struct_processus *s_etat_processus, struct_arbre *s_noeud)                  .nombre_arguments = 0;
 {          (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
     unsigned long               i;                  .fonction = instruction_vers_niveau_inferieur;
   
     if ((*s_noeud).feuilles != NULL)          if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
     {                  .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
         for(i = 0; i < (*s_noeud).nombre_feuilles; i++)  
         {          {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return(NULL);
         }          }
   
           strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
                   .nom_fonction, ">>");
       }
       else
   #   endif
       {
           s_objet_simplifie = copie_objet(s_etat_processus, s_objet, 'P');
     }      }
   
     return;      return(s_objet_simplifie);
 }  }
   
 // vim: ts=4  // vim: ts=4
Removed from v.1.49  
changed lines
  Added in v.1.50

CVSweb interface <joel.bertrand@systella.fr>