--- rpl/src/simplification.c	2014/10/20 19:01:35	1.51
+++ rpl/src/simplification.c	2019/11/04 10:05:25	1.69
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.19
-  Copyright (C) 1989-2014 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.32
+  Copyright (C) 1989-2019 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -25,6 +25,77 @@
 
 /*
 ================================================================================
+  Fonction d'affichage d'un arbre q-aire
+================================================================================
+  Entrées : pointeur sur une structure struct_processus
+--------------------------------------------------------------------------------
+  Sorties :
+--------------------------------------------------------------------------------
+  Effets de bord : néant
+================================================================================
+*/
+
+static void
+affichage_arbre(struct_processus *s_etat_processus, struct_arbre *s_arbre,
+		int niveau)
+{
+	int							i;
+
+	integer8					branche;
+
+	struct_liste_chainee		*l_element_courant;
+
+	unsigned char				*chaine;
+
+	if (niveau == 0)
+	{
+		printf("Arbre $%016X\n", s_arbre);
+	}
+
+	// Affichage de la feuille (fonction ou donnée générale s'il n'y 
+	// a pas de branche)
+
+	l_element_courant = (*s_arbre).feuille;
+
+	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;
+		}
+
+		for(i = 0; i < niveau; i++)
+		{
+			printf("  ");
+		}
+
+		printf("%s\n", chaine);
+		free(chaine);
+
+		l_element_courant = (*l_element_courant).suivant;
+	}
+
+	// Affichage des branches (arguments de la fonction dans la feuille)
+
+	for(branche = 0; branche < (*s_arbre).nombre_branches; branche++)
+	{
+		affichage_arbre(s_etat_processus, (*s_arbre).branches[branche],
+				niveau + 1);
+	}
+
+	if (niveau == 0)
+	{
+		printf("---\n");
+	}
+
+	return;
+}
+
+
+/*
+================================================================================
   Fonction de transcription d'un arbre en liste chaînée
 ================================================================================
   Entrées : pointeur sur une structure struct_processus
@@ -66,16 +137,9 @@ transcription_arbre(struct_processus *s_
 		}
 	}
 
-	if ((l_liste = allocation_maillon(s_etat_processus)) == NULL)
-	{
-		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
-		return(NULL);
-	}
+	// Ajout des fonctions
 
-	// Ajout de la fonction
-
-	(*l_liste).suivant = NULL;
-	(*l_liste).donnee = (*s_arbre).feuille;
+	l_liste = (*s_arbre).feuille;
 
 	free((*s_arbre).branches);
 	free(s_arbre);
@@ -130,8 +194,35 @@ inversion_fonctions_arbre(struct_arbre *
 
 static void
 simplification_arbre(struct_processus *s_etat_processus,
-		struct_arbre **s_arbre)
+		struct_arbre *s_arbre)
 {
+	integer8				i;
+
+	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;
+	}
+
+	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++)
+		{
+		}
+	}
+	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++)
+		{
+		}
+	}
+
 	return;
 }
 
@@ -210,10 +301,20 @@ simplification(struct_processus *s_etat_
 							return(NULL);
 						}
 
-						(*s_arbre).inversion = d_faux;
 						(*s_arbre).nombre_branches = nombre_arguments;
-						(*s_arbre).feuille = copie_objet(s_etat_processus,
-								(*l_element_courant).donnee, 'P');
+
+						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 *)))
@@ -283,9 +384,17 @@ simplification(struct_processus *s_etat_
 						return(NULL);
 					}
 
-					(*s_arbre).feuille = copie_objet(s_etat_processus,
-							(*l_element_courant).donnee, 'P');
-					(*s_arbre).inversion = d_faux;
+					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;
 
@@ -321,8 +430,10 @@ simplification(struct_processus *s_etat_
 		 * Simplification de l'arbre
 		 */
 
+		affichage_arbre(s_etat_processus, s_arbre, 0);
+
 #		ifdef	EXPERIMENTAL_CODE 
-		simplification_arbre(s_etat_processus, &s_arbre);
+		simplification_arbre(s_etat_processus, s_arbre);
 
 		if ((*s_etat_processus).erreur_systeme != d_es)
 		{