--- rpl/src/simplification.c	2011/06/21 15:26:36	1.22
+++ rpl/src/simplification.c	2021/03/13 12:50:52	1.76
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.0.prerelease.2
-  Copyright (C) 1989-2011 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.33
+  Copyright (C) 1989-2021 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 d'affichage d'un arbre q-aire
 ================================================================================
   Entrées : pointeur sur une structure struct_processus
 --------------------------------------------------------------------------------
@@ -35,88 +35,72 @@
 ================================================================================
 */
 
-struct_objet *
-simplification(struct_processus *s_etat_processus, struct_objet *s_objet)
+static void
+affichage_arbre(struct_processus *s_etat_processus, struct_arbre *s_arbre,
+		int niveau)
 {
+	int							i;
 
-	struct_arbre			*s_arbre;
-	struct_arbre			*s_noeud_courant;
-
-	struct_liste_chainee	*l_element_courant;
+	integer8					branche;
 
-	struct_objet			*s_objet_simplifie;
-	struct_objet			**t_expression;
+	struct_liste_chainee		*l_element_courant;
 
-	unsigned long			i;
-	unsigned long			nombre_elements;
+	unsigned char				*chaine;
 
-	s_arbre = NULL;
-
-	if ((*s_objet).type == ALG)
+	if (niveau == 0)
 	{
-#ifdef EXPERIMENTAL_CODE
-		// Inversion de l'ordre des instructions dans l'expression
+		printf("--- Arbre $%016X\n", s_arbre);
+	}
 
-		nombre_elements = 0;
-		l_element_courant = (*s_objet).objet;
+	// Affichage de la feuille (fonction ou donnée générale s'il n'y 
+	// a pas de branche)
 
-		while(l_element_courant != NULL)
-		{
-			nombre_elements++;
-			l_element_courant = (*l_element_courant).suivant;
-		}
+	l_element_courant = (*s_arbre).feuille;
 
-		if ((t_expression = malloc(nombre_elements * sizeof(struct_objet *)))
-				== NULL)
+	for(i = 0; i < niveau; i++)
+	{
+		printf("  ");
+	}
+
+	while(l_element_courant != NULL)
+	{
+		if ((chaine = formateur(s_etat_processus, 0,
+				(*l_element_courant).donnee)) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
-			return(NULL);
+			return;
 		}
 
-		i = nombre_elements - 1;
-		l_element_courant = (*s_objet).objet;
+		printf("%s ", chaine);
+		free(chaine);
 
-		while(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);
-			}
-
-			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
-		// 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
+	printf("\n");
 
-		s_objet_simplifie = copie_objet(s_etat_processus, s_objet, 'P');
+	// Affichage des branches (arguments de la fonction dans la feuille)
 
-		// On essaye déjà de voir si l'arbre est cohérent...
+	for(branche = 0; branche < (*s_arbre).nombre_branches; branche++)
+	{
+		affichage_arbre(s_etat_processus, (*s_arbre).branches[branche],
+				niveau + 1);
 	}
-	else
+
+	if (niveau == 0)
 	{
-		s_objet_simplifie = copie_objet(s_etat_processus, s_objet, 'P');
+		printf("--- Fin de l'arbre\n");
 	}
 
-	return(s_objet_simplifie);
+	return;
 }
 
 
 /*
 ================================================================================
-  Fonction créant un noeud dans l'arbre
+  Fonction de transcription d'un arbre en liste chaînée
 ================================================================================
-  Entrées : pointeur sur une structure struct_arbre
+  Entrées : pointeur sur une structure struct_processus
 --------------------------------------------------------------------------------
   Sorties :
 --------------------------------------------------------------------------------
@@ -124,57 +108,81 @@ 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 struct_liste_chainee *
+transcription_arbre(struct_processus *s_etat_processus, struct_arbre *s_arbre)
 {
-	struct_arbre		*s_noeud;
+	integer8				i;
 
-	unsigned long		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;
 
-	if ((s_noeud = malloc(sizeof(struct_arbre))) == NULL)
+	l_pile_locale = NULL;
+
+	for(i = 0; i < (*s_arbre).nombre_branches; i++)
 	{
-		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
-		return(NULL);
-	}
+		if ((l_nouvelle_pile_locale = allocation_maillon(s_etat_processus))
+				== NULL)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			return(NULL);
+		}
 
-// indice ne peut jamais être supérieur à indice_maximal
-	
-#if 0
-		// Création de la racine de l'arbre
+		(*l_nouvelle_pile_locale).suivant = l_pile_locale;
+		l_pile_locale = l_nouvelle_pile_locale;
 
-		if ((s_arbre = malloc(sizeof(struct_arbre))) == NULL)
+		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);
 		}
+	}
+
+	// Ajout des fonctions
+
+	if ((*s_arbre).nombre_branches != 0)
+	{
+		free((*s_arbre).branches);
+	}
+
+	l_liste = (*s_arbre).feuille;
+	free(s_arbre);
 
-		s_noeud_courant = s_arbre;
+	// Chaînage des arguments
 
-		for(i = 0; i < nombre_elements; i++)
+	while(l_pile_locale != NULL)
+	{
+		l_element_courant = (void *) (*l_pile_locale).donnee;
+
+		if (l_element_courant == NULL)
 		{
-			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
-				}
-			}
+			(*s_etat_processus).erreur_systeme = d_es_pile_vide;
+			return(NULL);
+		}
+
+		while((*l_element_courant).suivant != NULL)
+		{
+			l_element_courant = (*l_element_courant).suivant;
 		}
-#endif
-	return(NULL);
+
+		(*l_element_courant).suivant = l_liste;
+		l_liste = (void *) (*l_pile_locale).donnee;
+
+		l_nouvelle_pile_locale = (*l_pile_locale).suivant;
+		liberation_maillon(s_etat_processus, l_pile_locale);
+		l_pile_locale = l_nouvelle_pile_locale;
+	}
+
+	return(l_liste);
 }
 
 
 /*
 ================================================================================
-  Fonction simplifiant l'arbre q-aire en arbre q'-aire (q <= q')
+  Fonction de simplification d'un arbre
 ================================================================================
-  Entrées : pointeur sur une structure struct_arbre
+  Entrées : pointeur sur une structure struct_processus
 --------------------------------------------------------------------------------
   Sorties :
 --------------------------------------------------------------------------------
@@ -182,64 +190,283 @@ creation_arbre(struct_processus *s_etat_
 ================================================================================
 */
 
-void
-simplification_arbre(struct_processus *s_etat_processus, struct_arbre *s_noeud)
+static int
+ordonnancement_branches(const void *a1, const void *a2)
 {
-	unsigned long				i;
+	struct_arbre	**_a1;
+	struct_arbre	**_a2;
 
-	if ((*s_noeud).feuilles != NULL)
+	_a1 = (struct_arbre **) a1;
+	_a2 = (struct_arbre **) a2;
+
+	if (((**_a1).feuille != NULL) && ((**_a2).feuille != NULL))
 	{
-		for(i = 0; i < (*s_noeud).nombre_feuilles; i++)
+		// Si les types sont identiques, on ne change rien.
+
+		if ((*(*(**_a1).feuille).donnee).type ==
+				(*(*(**_a2).feuille).donnee).type)
 		{
-			simplification_arbre(s_etat_processus, (*s_noeud).feuilles[i]);
+			return(0);
+		}
 
-			/*
-			 * Si le noeud est une fonction compatible avec une fonction
-			 * présente dans les feuilles, on réunit les deux.
-			 */
+		// On rejette les nombres à la fin.
+
+		if (((*(*(**_a1).feuille).donnee).type == INT) ||
+				((*(*(**_a1).feuille).donnee).type == REL) ||
+				((*(*(**_a1).feuille).donnee).type == CPL))
+		{
+			return(1);
+		}
+		else
+		{
+			return(-1);
+		}
+	}
+
+	return(0);
+}
+
+
+static int
+ordonnancement_instructions_neg(const void *a1, const void *a2)
+{
+	struct_arbre	**_a1;
+
+	_a1 = (struct_arbre **) a1;
+
+	if ((**_a1).feuille != NULL)
+	{
+		// On rejette NEG à la fin de l'arbre.
 
-			if ((*(*((*s_noeud).feuilles[i])).objet).type == FCT)
+		if ((*(*(**_a1).feuille).donnee).type == FCT)
+		{
+			if (strcmp((*((struct_fonction *) (*(*(**_a1).feuille).donnee)
+					.objet)).nom_fonction, "NEG") == 0)
 			{
-				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)))
-				{
-				}
+				return(1);
+			}
+			else
+			{
+				return(-1);
 			}
 		}
+		else
+		{
+			return(0);
+		}
 	}
 
-	return;
+	return(0);
 }
 
 
-/*
-================================================================================
-  Fonction parcourant l'arbre q-aire
-================================================================================
-  Entrées : pointeur sur une structure struct_arbre
---------------------------------------------------------------------------------
-  Sorties :
---------------------------------------------------------------------------------
-  Effets de bord : néant
-================================================================================
-*/
-
-void
-parcours_arbre(struct_processus *s_etat_processus, struct_arbre *s_noeud)
+static void
+simplification_arbre(struct_processus *s_etat_processus,
+		struct_arbre *s_arbre)
 {
-	unsigned long				i;
+	integer8				i;
+	integer8				j;
+	integer8				nouveaux_elements;
+
+	struct_arbre			*s_branche;
+
+	struct_liste_chainee	*l_element_courant;
+	struct_liste_chainee	*l_element_suivant;
+
+	struct_objet			*s_objet;
+
+	if ((*(*(*s_arbre).feuille).donnee).type != FCT)
+	{
+		// L'objet formant le noeud n'est pas une fonction. Il n'y a aucune
+		// simplification possible.
+
+		return;
+	}
+
+	// Transformation des soustractions que l'on remplace par
+	// une addition de l'opposé. Si l'on a une soustraction,
+	// on greffe donc une instruction NEG dans l'arbre.
+	// Note : à cet instant, l'instruction '-' ne peut avoir que deux
+	// opérandes.
+
+	if (strcmp((*((struct_fonction *) (*(*((*s_arbre).feuille)).donnee).objet))
+			.nom_fonction, "-") == 0)
+	{
+		if ((*s_arbre).nombre_branches != 2)
+		{
+			(*s_etat_processus).erreur_execution = d_ex_simplification;
+			return;
+		}
+
+		liberation(s_etat_processus, (*((*s_arbre).feuille)).donnee);
+
+		if (((*((*s_arbre).feuille)).donnee = allocation(s_etat_processus,
+				FCT)) == NULL)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			return;
+		}
+
+		if (((*((struct_fonction *) (*(*((*s_arbre).feuille)).donnee).objet))
+				.nom_fonction = malloc(2 * sizeof(unsigned char))) == NULL)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			return;
+		}
+
+		strcpy((*((struct_fonction *) (*(*((*s_arbre).feuille)).donnee).objet))
+				.nom_fonction, "+");
+		(*((struct_fonction *) (*(*((*s_arbre).feuille)).donnee).objet))
+				.nombre_arguments = 1;
+
+		if ((s_branche = malloc(sizeof(struct_arbre))) == NULL)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			return;
+		}
+
+		if (((*s_branche).branches = malloc(sizeof(struct_arbre *))) == NULL)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			return;
+		}
 
-	if ((*s_noeud).feuilles != NULL)
+		if (((*s_branche).feuille = allocation_maillon(s_etat_processus))
+				== NULL)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			return;
+		}
+
+		(*(*s_branche).feuille).suivant = NULL;
+
+		if (((*(*s_branche).feuille).donnee = allocation(s_etat_processus, FCT))
+				== NULL)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			return;
+		}
+
+		if (((*((struct_fonction *) (*(*(*s_branche).feuille).donnee).objet))
+				.nom_fonction = malloc(4 * sizeof(unsigned char))) == NULL)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			return;
+		}
+
+		strcpy((*((struct_fonction *) (*(*(*s_branche).feuille).donnee).objet))
+				.nom_fonction, "NEG");
+		(*((struct_fonction *) (*(*(*s_branche).feuille).donnee).objet))
+				.nombre_arguments = 1;
+		(*s_branche).branches[0] = (*s_arbre).branches[1];
+		(*s_branche).nombre_branches = 1;
+		(*s_arbre).branches[1] = s_branche;
+	}
+
+	// La feuille est une fonction, on peut envisager la simplification
+	// de l'arbre. Pour cela, on descend d'un niveau pour greffer
+	// de nouvelles branches.
+
+	if (strcmp((*((struct_fonction *) (*(*(*s_arbre).feuille).donnee).objet))
+			.nom_fonction, "+") == 0)
 	{
-		for(i = 0; i < (*s_noeud).nombre_feuilles; i++)
+		qsort((*s_arbre).branches, (size_t) (*s_arbre)
+				.nombre_branches, sizeof(struct_arbre *),
+				ordonnancement_instructions_neg);
+
+		for(i = 0; i < (*s_arbre).nombre_branches; i++)
 		{
-			parcours_arbre(s_etat_processus, (*s_noeud).feuilles[i]);
+			s_objet = (*((*((*s_arbre).branches[i])).feuille)).donnee;
+
+			if ((*s_objet).type == FCT)
+			{
+				if (strcmp((*((struct_fonction *) (*s_objet).objet))
+						.nom_fonction, "-") == 0)
+				{
+					simplification_arbre(s_etat_processus,
+							(*s_arbre).branches[i]);
+					s_objet = (*((*((*s_arbre).branches[i])).feuille)).donnee;
+				}
+
+				if (strcmp((*((struct_fonction *) (*s_objet).objet))
+						.nom_fonction, "+") == 0)
+				{
+					simplification_arbre(s_etat_processus,
+							(*s_arbre).branches[i]);
+
+					/*
+					 On greffe.
++
+  +
+    2
+    SIN
+      3
+  10
+
+					 doit donner :
++
+  2
+  SIN
+    3
+  10
+					*/
+
+					nouveaux_elements = (*(*s_arbre).branches[i])
+							.nombre_branches;
+
+					if (((*s_arbre).branches = realloc((*s_arbre).branches,
+							((unsigned) ((*s_arbre).nombre_branches
+							+ nouveaux_elements))
+							* sizeof(struct_arbre *))) == NULL)
+					{
+						(*s_etat_processus).erreur_systeme =
+								d_es_allocation_memoire;
+						return;
+					}
+
+					for(j = 0; j < nouveaux_elements; j++)
+					{
+						(*s_arbre).branches[(*s_arbre).nombre_branches++] =
+								(*(*s_arbre).branches[i]).branches[j];
+					}
+
+					l_element_courant = (*s_arbre).feuille;
+					(*s_arbre).feuille = (*(*s_arbre).branches[i]).feuille;
+
+					l_element_suivant = (*s_arbre).feuille;
+					while((*l_element_suivant).suivant != NULL)
+					{
+						l_element_suivant = (*l_element_suivant).suivant;
+					}
+
+					(*l_element_suivant).suivant = l_element_courant;
+					free((*(*s_arbre).branches[i]).branches);
+					free((*s_arbre).branches[i]);
+
+					// Retrait de la branche
+				
+					for(j = i + 1; j < (*s_arbre).nombre_branches; j++)
+					{
+						(*s_arbre).branches[j - 1] = (*s_arbre).branches[j];
+					}
+
+					(*s_arbre).nombre_branches--;
+
+					// Réorganisation des valeurs numériques en queue.
+
+					qsort((*s_arbre).branches, (size_t) (*s_arbre)
+							.nombre_branches, sizeof(struct_arbre *),
+							ordonnancement_branches);
+				}
+			}
+		}
+
+		if (((*s_arbre).branches = realloc((*s_arbre).branches,
+				((unsigned) (*s_arbre).nombre_branches)
+				* sizeof(struct_arbre *))) == NULL)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			return;
 		}
 	}
 
@@ -249,9 +476,9 @@ parcours_arbre(struct_processus *s_etat_
 
 /*
 ================================================================================
-  Fonction libérant l'arbre q-aire
+  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 :
 --------------------------------------------------------------------------------
@@ -259,19 +486,299 @@ parcours_arbre(struct_processus *s_etat_
 ================================================================================
 */
 
-void
-liberation_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;
+
+	struct_arbre				*s_arbre;
+
+	struct_liste_chainee		*l_element_courant;
 
-	if ((*s_noeud).feuilles != NULL)
+	// 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
+		 */
+
+		l_liste_locale = NULL;
+		l_element_courant = (*s_objet).objet;
+
+		while(l_element_courant != NULL)
 		{
+			switch((*(*l_element_courant).donnee).type)
+			{
+				// 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;
+		}
+
+		// 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;
+
+		liberation_maillon(s_etat_processus, l_liste_locale);
+		l_liste_locale = NULL;
+
+		/*
+		 * Simplification de l'arbre
+		 */
+
+		affichage_arbre(s_etat_processus, s_arbre, 0);
+		simplification_arbre(s_etat_processus, s_arbre);
+		affichage_arbre(s_etat_processus, s_arbre, 0);
+
+		if ((*s_etat_processus).erreur_systeme != d_es)
+		{
+			return(NULL);
+		}
+
+		/*
+		 * 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)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			return(NULL);
+		}
+
+		// Ajout des délimiteurs '<<' et '>>' à la liste d'instructions
+
+		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