--- rpl/src/simplification.c 2014/07/17 08:07:27 1.49 +++ rpl/src/simplification.c 2014/10/13 07:12:54 1.50 @@ -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,90 +35,85 @@ ================================================================================ */ -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) { -#ifdef EXPERIMENTAL_CODE - struct_arbre *s_arbre; - struct_arbre *s_noeud_courant; + integer8 i; struct_liste_chainee *l_element_courant; -#endif - struct_objet *s_objet_simplifie; -#ifdef EXPERIMENTAL_CODE - struct_objet **t_expression; + struct_liste_chainee *l_liste; + struct_liste_chainee *l_nouvelle_pile_locale; + struct_liste_chainee *l_pile_locale; - unsigned long i; - unsigned long nombre_elements; + l_pile_locale = NULL; - s_arbre = NULL; -#endif - - 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; + if ((l_liste = allocation_maillon(s_etat_processus)) == NULL) + { + (*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, - (*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 '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 : -------------------------------------------------------------------------------- @@ -126,153 +121,288 @@ simplification(struct_processus *s_etat_ ================================================================================ */ -struct_arbre * -creation_arbre(struct_processus *s_etat_processus, - struct_objet **t_objets, integer8 indice, integer8 indice_maximal) +struct_objet * +simplification(struct_processus *s_etat_processus, struct_objet *s_objet) { - struct_arbre *s_noeud; + struct_objet *s_objet_simplifie; - //unsigned long i; +# ifdef EXPERIMENTAL_CODE - if ((s_noeud = malloc(sizeof(struct_arbre))) == NULL) - { - (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; - return(NULL); - } + integer8 i; + integer8 nombre_arguments; -// indice ne peut jamais être supérieur à indice_maximal - -#if 0 - // Création de la racine de l'arbre + struct_arbre *s_arbre; - if ((s_arbre = malloc(sizeof(struct_arbre))) == NULL) - { - (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; - return(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; - 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)) - .nom_fonction, "<<") != 0) && - (strcmp((*((struct_fonction *) - (*t_expression[i]).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).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. -/* -================================================================================ - Fonction simplifiant l'arbre q-aire en arbre q'-aire (q <= q') -================================================================================ - Entrées : pointeur sur une structure struct_arbre --------------------------------------------------------------------------------- - Sorties : --------------------------------------------------------------------------------- - Effets de bord : néant -================================================================================ -*/ + 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); + } -void -simplification_arbre(struct_processus *s_etat_processus, struct_arbre *s_noeud) -{ - unsigned long i; + s_arbre = (void *) (*l_liste_locale).donnee; - if ((*s_noeud).feuilles != NULL) - { - for(i = 0; i < (*s_noeud).nombre_feuilles; i++) + liberation_maillon(s_etat_processus, l_liste_locale); + l_liste_locale = NULL; + + /* + * 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); + } - /* - * Si le noeud est une fonction compatible avec une fonction - * présente dans les feuilles, on réunit les deux. - */ + // Ajout des délimiteurs '<<' et '>>' à la liste d'instructions - if ((*(*((*s_noeud).feuilles[i])).objet).type == FCT) - { - 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))) - { - } - } + if (((*s_objet_simplifie).objet = allocation_maillon(s_etat_processus)) + == NULL) + { + (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; + return(NULL); } - } - 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); + } -/* -================================================================================ - Fonction parcourant l'arbre q-aire -================================================================================ - Entrées : pointeur sur une structure struct_arbre --------------------------------------------------------------------------------- - Sorties : --------------------------------------------------------------------------------- - Effets de bord : néant -================================================================================ -*/ + (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) + .nombre_arguments = 0; + (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) + .fonction = instruction_vers_niveau_superieur; -void -parcours_arbre(struct_processus *s_etat_processus, struct_arbre *s_noeud) -{ - unsigned long i; + 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); + } - if ((*s_noeud).feuilles != NULL) - { - for(i = 0; i < (*s_noeud).nombre_feuilles; i++) + strcpy((*((struct_fonction *) (*(*l_element_courant).donnee).objet)) + .nom_fonction, "<<"); + + (*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; -/* -================================================================================ - Fonction libérant l'arbre q-aire -================================================================================ - Entrées : pointeur sur une structure struct_arbre --------------------------------------------------------------------------------- - Sorties : --------------------------------------------------------------------------------- - Effets de bord : néant -================================================================================ -*/ + if (((*l_element_courant).donnee = allocation(s_etat_processus, + FCT)) == 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; + (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) + .nombre_arguments = 0; + (*((struct_fonction *) (*(*l_element_courant).donnee).objet)) + .fonction = instruction_vers_niveau_inferieur; - if ((*s_noeud).feuilles != NULL) - { - for(i = 0; i < (*s_noeud).nombre_feuilles; i++) + 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 +# endif + { + s_objet_simplifie = copie_objet(s_etat_processus, s_objet, 'P'); } - return; + return(s_objet_simplifie); } // vim: ts=4