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

Diff for /rpl/src/simplification.c between versions 1.5 and 1.65

version 1.5, 2010/03/17 14:14:37 version 1.65, 2018/12/24 15:56:41
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.13    RPL/2 (R) version 4.1.30
   Copyright (C) 1989-2010 Dr. BERTRAND Joël    Copyright (C) 1989-2018 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 20 Line 20
 */  */
   
   
 #include "rpl.conv.h"  #include "rpl-conv.h"
   
   
 /*  /*
 ================================================================================  ================================================================================
   Fonction 'simplication' (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)
 {  {
       integer8                i;
     struct_arbre            *s_arbre;  
     struct_arbre            *s_noeud_courant;  
   
     struct_liste_chainee    *l_element_courant;      struct_liste_chainee    *l_element_courant;
       struct_liste_chainee    *l_liste;
       struct_liste_chainee    *l_nouvelle_pile_locale;
       struct_liste_chainee    *l_pile_locale;
   
     struct_objet            *s_objet_simplifie;      l_pile_locale = NULL;
     struct_objet            **t_expression;  
   
     unsigned long           i;      for(i = 0; i < (*s_arbre).nombre_branches; i++)
     unsigned long           nombre_elements;  
   
     s_arbre = NULL;  
   
     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;      // Ajout des fonctions
         l_element_courant = (*s_objet).objet;  
   
         while(l_element_courant != NULL)      l_liste = (*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 de simplification d'un arbre
 ================================================================================  ================================================================================
   Entrées : pointeur sur une structure struct_arbre    Entrées : pointeur sur une structure struct_processus
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Sorties :    Sorties :
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
Line 124  simplification(struct_processus *s_etat_ Line 114  simplification(struct_processus *s_etat_
 ================================================================================  ================================================================================
 */  */
   
 struct_arbre *  static void
 creation_arbre(struct_processus *s_etat_processus,  inversion_fonctions_arbre(struct_arbre *s_arbre)
         struct_objet **t_objets, unsigned long indice,  
         unsigned long indice_maximal)  
 {  {
     struct_arbre        *s_noeud;      return;
   }
   
     unsigned long       i;  
   
     if ((s_noeud = malloc(sizeof(struct_arbre))) == NULL)  static void
   simplification_arbre(struct_processus *s_etat_processus,
           struct_arbre *s_arbre)
   {
       integer8                i;
   
       if ((*(*(*s_arbre).feuille).donnee).type != FCT)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;          // L'objet formant le noeud n'est pas une fonction. Il n'y a aucune
         return(NULL);          // simplification possible.
     }  
   
 // indice ne peut jamais être supérieur à indice_maximal          return;
           }
 #if 0  
         // Création de la racine de l'arbre  
   
         if ((s_arbre = malloc(sizeof(struct_arbre))) == NULL)      if ((strcmp((*((struct_fonction *) (*(*(*s_arbre).feuille).donnee).objet))
               .nom_fonction, "+") == 0) || (strcmp((*((struct_fonction *)
               (*(*(*s_arbre).feuille).donnee).objet)).nom_fonction, "-") == 0))
       {
           for(i = 0; i < (*s_arbre).nombre_branches; i++)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
             return(NULL);  
         }          }
       }
         s_noeud_courant = s_arbre;      else if ((strcmp((*((struct_fonction *) (*(*(*s_arbre).feuille).donnee)
               .objet)).nom_fonction, "*") == 0) || (strcmp((*((struct_fonction *)
         for(i = 0; i < nombre_elements; i++)              (*(*(*s_arbre).feuille).donnee).objet)).nom_fonction, "/") == 0))
       {
           for(i = 0; i < (*s_arbre).nombre_branches; i++)
         {          {
             if (strcmp((*t_expression[i]).type, "FCT") == 0)  
             {  
                 if ((strcmp((*((struct_fonction *) (*t_expression[i]).objet))  
                         .nom_fonction, "<<") != 0) &&  
                         (strcmp((*((struct_fonction *)  
                         (*t_expression[i]).objet)).nom_fonction, ">>") != 0))  
                 {  
                     // Création d'un noeud  
                 }  
             }  
         }          }
 #endif      }
     return(NULL);  
       return;
 }  }
   
   
 /*  /*
 ================================================================================  ================================================================================
   Fonction simplifiant l'arbre q-aire en arbre q'-aire (q <= q')    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 182  creation_arbre(struct_processus *s_etat_ Line 168  creation_arbre(struct_processus *s_etat_
 ================================================================================  ================================================================================
 */  */
   
 void  struct_objet *
 simplification_arbre(struct_processus *s_etat_processus, struct_arbre *s_noeud)  simplification(struct_processus *s_etat_processus, struct_objet *s_objet)
 {  {
     unsigned long               i;      struct_objet                *s_objet_simplifie;
   
       integer8                    i;
       integer8                    nombre_arguments;
   
       struct_arbre                *s_arbre;
   
     if ((*s_noeud).feuilles != NULL)      struct_liste_chainee        *l_element_courant;
   
       // Attention : l_liste_locale et l_ancienne_liste_locale ne contiennent pas
       // un pointeur sur une struct_objet, mais sur une struct_arbre.
   
       struct_liste_chainee        *l_liste_locale;
       struct_liste_chainee        *l_ancienne_liste_locale;
   
       if ((*s_objet).type == ALG)
     {      {
         for(i = 0; i < (*s_noeud).nombre_feuilles; i++)          /*
         {           * Transcription de l'expression algébrique en arbre q-aire
             simplification_arbre(s_etat_processus, (*s_noeud).feuilles[i]);           */
   
             /*          l_liste_locale = NULL;
              * Si le noeud est une fonction compatible avec une fonction          l_element_courant = (*s_objet).objet;
              * présente dans les feuilles, on réunit les deux.  
              */  
   
             if ((*(*((*s_noeud).feuilles[i])).objet).type == FCT)          while(l_element_courant != NULL)
           {
               switch((*(*l_element_courant).donnee).type)
             {              {
                 if (((strcmp((*((struct_fonction *) (*s_noeud).objet))                  // Toutes les fonctions (intrinsèques, extrinsèques et
                         .nom_fonction, "+") == 0) && (strcmp(                  // utilisateurs).
                         (*((struct_fonction *) (*(*((*s_noeud).feuilles[i]))  
                         .objet).objet)).nom_fonction, "+") == 0)) ||                  case FCT:
                         ((strcmp((*((struct_fonction *) (*s_noeud).objet))  
                         .nom_fonction, "*") == 0) && (strcmp(  
                         (*((struct_fonction *) (*(*((*s_noeud).feuilles[i]))  
                         .objet).objet)).nom_fonction, "*") == 0)))  
                 {                  {
                       // 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).nombre_branches = nombre_arguments;
   
                           if (((*s_arbre).feuille = allocation_maillon(
                                   s_etat_processus)) == NULL)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_allocation_memoire;
                               return(NULL);
                           }
   
                           (*(*s_arbre).feuille).donnee = copie_objet(
                                   s_etat_processus, (*l_element_courant).donnee,
                                   'P');
                           (*(*s_arbre).feuille).suivant = NULL;
   
                           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 = nombre_arguments - 1; i >= 0; i--)
                           {
                               if (l_liste_locale == NULL)
                               {
                                   (*s_etat_processus).erreur_execution =
                                           d_ex_manque_argument;
                                   return(NULL);
                               }
   
                               (*s_arbre).branches[i] = (struct_arbre *)
                                       (*l_liste_locale).donnee;
   
                               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:
                   {
                       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);
                       }
   
                       if (((*s_arbre).feuille = allocation_maillon(
                               s_etat_processus)) == NULL)
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return(NULL);
                       }
   
                       (*(*s_arbre).feuille).donnee = copie_objet(
                               s_etat_processus, (*l_element_courant).donnee, 'P');
                       (*(*s_arbre).feuille).suivant = NULL;
                       (*s_arbre).nombre_branches = 0;
                       (*s_arbre).branches = NULL;
   
                       (*l_liste_locale).donnee = (void *) s_arbre;
                       break;
                 }                  }
             }              }
   
               l_element_courant = (*l_element_courant).suivant;
         }          }
     }  
   
     return;          // 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)
           {
               (*s_etat_processus).erreur_execution = d_ex_erreur_evaluation;
               return(NULL);
           }
           else if ((*l_liste_locale).suivant != NULL)
           {
               (*s_etat_processus).erreur_execution = d_ex_erreur_evaluation;
               return(NULL);
           }
   
 /*          s_arbre = (void *) (*l_liste_locale).donnee;
 ================================================================================  
   Fonction parcourant l'arbre q-aire  
 ================================================================================  
   Entrées : pointeur sur une structure struct_arbre  
 --------------------------------------------------------------------------------  
   Sorties :  
 --------------------------------------------------------------------------------  
   Effets de bord : néant  
 ================================================================================  
 */  
   
 void          liberation_maillon(s_etat_processus, l_liste_locale);
 parcours_arbre(struct_processus *s_etat_processus, struct_arbre *s_noeud)          l_liste_locale = NULL;
 {  
     unsigned long               i;  
   
     if ((*s_noeud).feuilles != NULL)          /*
     {           * Simplification de l'arbre
         for(i = 0; i < (*s_noeud).nombre_feuilles; i++)           */
   
   #       ifdef   EXPERIMENTAL_CODE 
           simplification_arbre(s_etat_processus, s_arbre);
   
           if ((*s_etat_processus).erreur_systeme != d_es)
         {          {
             parcours_arbre(s_etat_processus, (*s_noeud).feuilles[i]);              return(NULL);
         }          }
     }  #       endif
   
     return;          /*
 }           * 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)
   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          // Ajout des délimiteurs '<<' et '>>' à la liste d'instructions
 liberation_arbre(struct_processus *s_etat_processus, struct_arbre *s_noeud)  
 {  
     unsigned long               i;  
   
     if ((*s_noeud).feuilles != NULL)          if (((*s_objet_simplifie).objet = allocation_maillon(s_etat_processus))
     {                  == NULL)
         for(i = 0; i < (*s_noeud).nombre_feuilles; i++)          {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return(NULL);
           }
   
           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;
           (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
                   .fonction = instruction_vers_niveau_superieur;
   
           if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
                   .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return(NULL);
           }
   
           strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
                   .nom_fonction, "<<");
   
           (*l_element_courant).suivant = l_liste_locale;
   
           while((*l_element_courant).suivant != NULL)
           {
               l_element_courant = (*l_element_courant).suivant;
           }
   
           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)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return(NULL);
           }
   
           (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
                   .nombre_arguments = 0;
           (*((struct_fonction *) (*(*l_element_courant).donnee).objet))
                   .fonction = instruction_vers_niveau_inferieur;
   
           if (((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
                   .nom_fonction = malloc(3 * sizeof(unsigned char))) == NULL)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return(NULL);
           }
   
           strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet))
                   .nom_fonction, ">>");
       }
       else
       {
           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.5  
changed lines
  Added in v.1.65

CVSweb interface <joel.bertrand@systella.fr>