--- rpl/src/simplification.c	2014/10/13 07:12:54	1.50
+++ rpl/src/simplification.c	2015/01/05 13:12:42	1.53
@@ -1,7 +1,7 @@
 /*
 ================================================================================
   RPL/2 (R) version 4.1.19
-  Copyright (C) 1989-2014 Dr. BERTRAND Joël
+  Copyright (C) 1989-2015 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -66,16 +66,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);
@@ -111,6 +104,60 @@ transcription_arbre(struct_processus *s_
 
 /*
 ================================================================================
+  Fonction de simplification d'un arbre
+================================================================================
+  Entrées : pointeur sur une structure struct_processus
+--------------------------------------------------------------------------------
+  Sorties :
+--------------------------------------------------------------------------------
+  Effets de bord : néant
+================================================================================
+*/
+
+static void
+inversion_fonctions_arbre(struct_arbre *s_arbre)
+{
+	return;
+}
+
+
+static void
+simplification_arbre(struct_processus *s_etat_processus,
+		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;
+}
+
+
+/*
+================================================================================
   Fonction 'simplification' (ne libère pas les paramètres)
 ================================================================================
   Entrées : pointeur sur une structure struct_processus
@@ -126,8 +173,6 @@ simplification(struct_processus *s_etat_
 {
 	struct_objet				*s_objet_simplifie;
 
-#	ifdef	EXPERIMENTAL_CODE 
-
 	integer8					i;
 	integer8					nombre_arguments;
 
@@ -185,9 +230,21 @@ simplification(struct_processus *s_etat_
 							return(NULL);
 						}
 
-						(*s_arbre).inversion = d_faux;
 						(*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)
@@ -197,7 +254,7 @@ simplification(struct_processus *s_etat_
 							return(NULL);
 						}
 
-						for(i = 0; i < nombre_arguments; i++)
+						for(i = nombre_arguments - 1; i >= 0; i--)
 						{
 							if (l_liste_locale == NULL)
 							{
@@ -206,19 +263,8 @@ simplification(struct_processus *s_etat_
 								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 =
+							(*s_arbre).branches[i] = (struct_arbre *)
 									(*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;
@@ -267,9 +313,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;
 
@@ -305,8 +359,13 @@ simplification(struct_processus *s_etat_
 		 * Simplification de l'arbre
 		 */
 
-#		if 0
-		simplification_arbre();
+#		ifdef	EXPERIMENTAL_CODE 
+		simplification_arbre(s_etat_processus, s_arbre);
+
+		if ((*s_etat_processus).erreur_systeme != d_es)
+		{
+			return(NULL);
+		}
 #		endif
 
 		/*
@@ -397,7 +456,6 @@ simplification(struct_processus *s_etat_
 				.nom_fonction, ">>");
 	}
 	else
-#	endif
 	{
 		s_objet_simplifie = copie_objet(s_etat_processus, s_objet, 'P');
 	}