--- rpl/src/simplification.c 2011/06/21 07:45:28 1.21 +++ rpl/src/simplification.c 2017/06/28 09:20:39 1.62 @@ -1,7 +1,7 @@ /* ================================================================================ - RPL/2 (R) version 4.1.0.prerelease.1 - Copyright (C) 1989-2011 Dr. BERTRAND Joël + RPL/2 (R) version 4.1.27 + Copyright (C) 1989-2017 Dr. BERTRAND Joël This file is part of RPL/2. @@ -25,7 +25,7 @@ /* ================================================================================ - 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 -------------------------------------------------------------------------------- @@ -35,88 +35,78 @@ ================================================================================ */ -struct_objet * -simplification(struct_processus *s_etat_processus, struct_objet *s_objet) +static struct_liste_chainee * +transcription_arbre(struct_processus *s_etat_processus, struct_arbre *s_arbre) { - - struct_arbre *s_arbre; - struct_arbre *s_noeud_courant; + integer8 i; 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; - struct_objet **t_expression; - - unsigned long i; - unsigned long nombre_elements; - - s_arbre = NULL; + l_pile_locale = NULL; - if ((*s_objet).type == ALG) + for(i = 0; i < (*s_arbre).nombre_branches; i++) { -#ifdef EXPERIMENTAL_CODE - // Inversion de l'ordre des instructions dans l'expression - - nombre_elements = 0; - l_element_courant = (*s_objet).objet; - - while(l_element_courant != NULL) + if ((l_nouvelle_pile_locale = allocation_maillon(s_etat_processus)) + == NULL) { - nombre_elements++; - l_element_courant = (*l_element_courant).suivant; + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return(NULL); } - if ((t_expression = malloc(nombre_elements * sizeof(struct_objet *))) - == NULL) + (*l_nouvelle_pile_locale).suivant = l_pile_locale; + 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); } + } - i = nombre_elements - 1; - l_element_courant = (*s_objet).objet; + // Ajout des fonctions - 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, - (*l_element_courant).donnee, 'O')) == NULL) - { - (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; - return(NULL); - } + (*s_etat_processus).erreur_systeme = d_es_pile_vide; + return(NULL); + } + while((*l_element_courant).suivant != NULL) + { l_element_courant = (*l_element_courant).suivant; } - // L'objet est toujours évaluable car il s'agit d'une expression - // algébrique (cela revient à dire qu'il n'y a qu'un seul arbre - // 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'); + (*l_element_courant).suivant = l_liste; + l_liste = (void *) (*l_pile_locale).donnee; - // On essaye déjà de voir si l'arbre est cohérent... - } - else - { - s_objet_simplifie = copie_objet(s_etat_processus, s_objet, 'P'); + l_nouvelle_pile_locale = (*l_pile_locale).suivant; + liberation_maillon(s_etat_processus, l_pile_locale); + l_pile_locale = l_nouvelle_pile_locale; } - 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 : -------------------------------------------------------------------------------- @@ -124,57 +114,53 @@ simplification(struct_processus *s_etat_ ================================================================================ */ -struct_arbre * -creation_arbre(struct_processus *s_etat_processus, - struct_objet **t_objets, unsigned long indice, - unsigned long indice_maximal) +static void +inversion_fonctions_arbre(struct_arbre *s_arbre) { - 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; - return(NULL); - } + // L'objet formant le noeud n'est pas une fonction. Il n'y a aucune + // simplification possible. -// indice ne peut jamais être supérieur à indice_maximal - -#if 0 - // Création de la racine de l'arbre + return; + } - 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; - - for(i = 0; i < nombre_elements; i++) + } + else 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++) { - 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 : -------------------------------------------------------------------------------- @@ -182,96 +168,299 @@ creation_arbre(struct_processus *s_etat_ ================================================================================ */ -void -simplification_arbre(struct_processus *s_etat_processus, struct_arbre *s_noeud) +struct_objet * +simplification(struct_processus *s_etat_processus, struct_objet *s_objet) { - unsigned long i; + struct_objet *s_objet_simplifie; + + integer8 i; + integer8 nombre_arguments; - if ((*s_noeud).feuilles != NULL) + struct_arbre *s_arbre; + + 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++) - { - simplification_arbre(s_etat_processus, (*s_noeud).feuilles[i]); + /* + * Transcription de l'expression algébrique en arbre q-aire + */ - /* - * Si le noeud est une fonction compatible avec une fonction - * présente dans les feuilles, on réunit les deux. - */ + l_liste_locale = NULL; + l_element_courant = (*s_objet).objet; - 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)) - .nom_fonction, "+") == 0) && (strcmp( - (*((struct_fonction *) (*(*((*s_noeud).feuilles[i])) - .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))) + // Toutes les fonctions (intrinsèques, extrinsèques et + // utilisateurs). + + 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).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); + } -/* -================================================================================ - Fonction parcourant l'arbre q-aire -================================================================================ - Entrées : pointeur sur une structure struct_arbre --------------------------------------------------------------------------------- - Sorties : --------------------------------------------------------------------------------- - Effets de bord : néant -================================================================================ -*/ + s_arbre = (void *) (*l_liste_locale).donnee; -void -parcours_arbre(struct_processus *s_etat_processus, struct_arbre *s_noeud) -{ - unsigned long i; + liberation_maillon(s_etat_processus, l_liste_locale); + l_liste_locale = NULL; - if ((*s_noeud).feuilles != NULL) - { - for(i = 0; i < (*s_noeud).nombre_feuilles; i++) + /* + * Simplification de l'arbre + */ + +# 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); -/* -================================================================================ - Fonction libérant l'arbre q-aire -================================================================================ - Entrées : pointeur sur une structure struct_arbre --------------------------------------------------------------------------------- - Sorties : --------------------------------------------------------------------------------- - Effets de bord : néant -================================================================================ -*/ + if ((s_objet_simplifie = allocation(s_etat_processus, ALG)) + == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return(NULL); + } -void -liberation_arbre(struct_processus *s_etat_processus, struct_arbre *s_noeud) -{ - unsigned long i; + // Ajout des délimiteurs '<<' et '>>' à la liste d'instructions - if ((*s_noeud).feuilles != NULL) - { - for(i = 0; i < (*s_noeud).nombre_feuilles; i++) + if (((*s_objet_simplifie).objet = allocation_maillon(s_etat_processus)) + == NULL) { + (*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