--- rpl/src/optimisation.c	2010/01/26 15:22:45	1.1
+++ rpl/src/optimisation.c	2020/01/10 11:15:50	1.84
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.0.9
-  Copyright (C) 1989-2010 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.32
+  Copyright (C) 1989-2020 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -20,12 +20,12 @@
 */
 
 
-#include "rpl.conv.h"
+#include "rpl-conv.h"
 
 
 /*
 ================================================================================
-  Boucle principale optimisé de l'interpréteur RPL/2
+  Boucle principale optimisée de l'interprète RPL/2
 ================================================================================
   Entrées : structure sur l'état du processus
 --------------------------------------------------------------------------------
@@ -36,16 +36,23 @@
 */
 
 logical1
-sequenceur_optimise(struct_processus *s_etat_processus)
+sequenceur_optimise(struct_processus *s_etat_processus, struct_liste_chainee
+		*l_bibliotheques)
 {
-	logical1				erreur;
+	integer8					adresse_point_entree;
+	integer8					i;
+	integer8					j;
+	integer8					nb_variables;
+	integer8					point_entree;
 
-	long					i;
-	long					point_entree;
+	logical1					erreur;
 
-	unsigned char			*message;
+	struct_objet				*programme_principal;
 
-	unsigned long			adresse_point_entree;
+	struct_tableau_variables	*tableau;
+
+	unsigned char				*message;
+	unsigned char				registre;
 
 	if ((*s_etat_processus).debug == d_vrai)
 		if (((*s_etat_processus).type_debug &
@@ -53,11 +60,11 @@ sequenceur_optimise(struct_processus *s_
 	{
 		if ((*s_etat_processus).langue == 'F')
 		{
-			printf("[%d] Optimisation\n", (int) getpid());
+			printf("+++Compilation [%d]\n", (int) getpid());
 		}
 		else
 		{
-			printf("+++Optimization [%d]\n", (int) getpid());
+			printf("+++Compilation [%d]\n", (int) getpid());
 		}
 
 		printf("\n");
@@ -66,20 +73,42 @@ sequenceur_optimise(struct_processus *s_
 
 	point_entree = -1;
 	adresse_point_entree = 0;
+	programme_principal = NULL;
 
 	empilement_pile_systeme(s_etat_processus);
 	(*(*s_etat_processus).l_base_pile_systeme).retour_definition = 'Y';
 	(*s_etat_processus).autorisation_empilement_programme = 'Y';
 	(*s_etat_processus).mode_execution_programme = 'N';
 
-	for(i = 0; i < (long) (*s_etat_processus).nombre_variables; i++)
+	nb_variables = nombre_variables(s_etat_processus);
+
+	if ((tableau = malloc(((size_t) nb_variables) *
+			sizeof(struct_tableau_variables))) == NULL)
 	{
-		if ((*s_etat_processus).s_liste_variables[i].niveau == 0)
+		if ((*s_etat_processus).langue == 'F')
+		{
+			printf("+++Système : Mémoire insuffisante\n");
+		}
+		else
+		{
+			printf("+++System : Not enough memory\n");
+		}
+
+		liberation_mutexes_arbre_variables_partagees(s_etat_processus,
+				(*(*s_etat_processus).s_arbre_variables_partagees));
+		return(d_erreur);
+	}
+
+	nb_variables = liste_variables(s_etat_processus, tableau);
+
+	for(i = 0; i < nb_variables; i++)
+	{
+		if (tableau[i].niveau == 0)
 		{
 			// Variables qui contiennent les points d'entrée des définitions.
 
-			(*s_etat_processus).position_courante = (*((unsigned long *)
-					(*((*s_etat_processus).s_liste_variables[i].objet)).objet));
+			(*s_etat_processus).position_courante = (*((integer8 *)
+					(*(tableau[i].objet)).objet));
 
 			if (point_entree == -1)
 			{
@@ -102,54 +131,154 @@ sequenceur_optimise(struct_processus *s_
 			{
 				if ((*s_etat_processus).langue == 'F')
 				{
-					printf("+++Fatal : Optimisation impossible\n");
+					printf("+++Fatal : Compilation impossible\n");
 				}
 				else
 				{
-					printf("+++Fatal : Optimization failed\n");
+					printf("+++Fatal : Compilation failed\n");
+				}
+
+				for(j = 0; j < nb_variables; j++)
+				{
+					if (tableau[j].mutex != NULL)
+					{
+						pthread_mutex_unlock(tableau[j].mutex);
+					}
 				}
 
+				free(tableau);
 				return(d_erreur);
 			}
 
+			// Il faut désactiver la vérification des variables
+			// implicites car aucune variable de niveau strictement
+			// positif étant créée, la fonction recherche_type() pourrait
+			// échouer.
+
+			registre = (*s_etat_processus).autorisation_nom_implicite;
+			(*s_etat_processus).autorisation_nom_implicite = 'Y';
+			(*s_etat_processus).type_en_cours = NON;
 			recherche_type(s_etat_processus);
+			(*s_etat_processus).autorisation_nom_implicite = registre;
 
 			if (((*s_etat_processus).erreur_execution != d_ex) ||
 					((*s_etat_processus).erreur_systeme != d_es))
 			{
+				if ((*s_etat_processus).core == d_vrai)
+				{
+					if ((*s_etat_processus).langue == 'F')
+					{
+						printf("+++Information : "
+								"Génération du fichier rpl-core "
+								"[%d]\n", (int) getpid());
+					}
+					else
+					{
+						printf("+++Information : "
+								"Writing rpl-core file [%d]\n",
+								(int) getpid());
+					}
+
+					rplcore(s_etat_processus);
+
+					if ((*s_etat_processus).langue == 'F')
+					{
+						printf("+++Information : "
+								"Processus tracé [%d]\n",
+								(int) getpid());
+					}
+					else
+					{
+						printf("+++Information : Done [%d]\n",
+								(int) getpid());
+					}
+
+					fflush(stdout);
+				}
+
+				if ((*s_etat_processus).langue == 'F')
+				{
+					printf("+++Fatal : Compilation impossible\n");
+				}
+				else
+				{
+					printf("+++Fatal : Compilation failed\n");
+				}
+
+				for(j = 0; j < nb_variables; j++)
+				{
+					if (tableau[j].mutex != NULL)
+					{
+						pthread_mutex_unlock(tableau[j].mutex);
+					}
+				}
+
+				free(tableau);
+				return(d_erreur);
+			}
+
+			// Modification de la variable. Il n'existe à cet instant
+			// que des variables de niveau 0.
+
+			if (recherche_variable(s_etat_processus, tableau[i].nom) ==
+					d_faux)
+			{
 				if ((*s_etat_processus).langue == 'F')
 				{
-					printf("+++Fatal : Optimisation impossible\n");
+					printf("+++Fatal : Compilation impossible\n");
 				}
 				else
 				{
-					printf("+++Fatal : Optimization failed\n");
+					printf("+++Fatal : Compilation failed\n");
 				}
 
+				for(j = 0; j < nb_variables; j++)
+				{
+					if (tableau[j].mutex != NULL)
+					{
+						pthread_mutex_unlock(tableau[j].mutex);
+					}
+				}
+
+				free(tableau);
 				return(d_erreur);
 			}
 
-			liberation(s_etat_processus,
-					(*s_etat_processus).s_liste_variables[i].objet);
+			liberation(s_etat_processus, tableau[i].objet);
 
 			if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
-					&((*s_etat_processus).s_liste_variables[i].objet))
+					&((*(*s_etat_processus).pointeur_variable_courante).objet))
 					== d_erreur)
 			{
 				if ((*s_etat_processus).langue == 'F')
 				{
-					printf("+++Fatal : Optimisation impossible\n");
+					printf("+++Fatal : Compilation impossible\n");
 				}
 				else
 				{
-					printf("+++Fatal : Optimization failed\n");
+					printf("+++Fatal : Compilation failed\n");
 				}
 
+				for(j = 0; j < nb_variables; j++)
+				{
+					if (tableau[j].mutex != NULL)
+					{
+						pthread_mutex_unlock(tableau[j].mutex);
+					}
+				}
+
+				free(tableau);
 				return(d_erreur);
 			}
 
-			(*s_etat_processus).s_liste_variables[i].origine = 'E';
+			(*(*s_etat_processus).pointeur_variable_courante).origine = 'E';
 			free((*s_etat_processus).instruction_courante);
+
+			if (point_entree == i)
+			{
+				programme_principal = (*(*s_etat_processus)
+						.pointeur_variable_courante).objet;
+			}
 		}
 	}
 
@@ -157,13 +286,22 @@ sequenceur_optimise(struct_processus *s_
 	{
 		if ((*s_etat_processus).langue == 'F')
 		{
-			printf("+++Fatal : Optimisation impossible\n");
+			printf("+++Fatal : Compilation impossible\n");
 		}
 		else
 		{
-			printf("+++Fatal : Optimization failed\n");
+			printf("+++Fatal : Compilation failed\n");
+		}
+
+		for(j = 0; j < nb_variables; j++)
+		{
+			if (tableau[j].mutex != NULL)
+			{
+				pthread_mutex_unlock(tableau[j].mutex);
+			}
 		}
 
+		free(tableau);
 		return(d_erreur);
 	}
 
@@ -176,11 +314,11 @@ sequenceur_optimise(struct_processus *s_
 
 			if ((*s_etat_processus).langue == 'F')
 			{
-				printf("[%d] Optimisation achevée\n", (int) getpid());
+				printf("[%d] Compilation achevée\n", (int) getpid());
 			}
 			else
 			{
-				printf("[%d] Optimization done\n", (int) getpid());
+				printf("[%d] Compilation done\n", (int) getpid());
 			}
 
 			printf("\n");
@@ -197,13 +335,22 @@ sequenceur_optimise(struct_processus *s_
 	{
 		if ((*s_etat_processus).langue == 'F')
 		{
-			printf("+++Fatal : Optimisation impossible\n");
+			printf("+++Fatal : Compilation impossible\n");
 		}
 		else
 		{
-			printf("+++Fatal : Optimization failed\n");
+			printf("+++Fatal : Compilation failed\n");
 		}
 
+		for(j = 0; j < nb_variables; j++)
+		{
+			if (tableau[j].mutex != NULL)
+			{
+				pthread_mutex_unlock(tableau[j].mutex);
+			}
+		}
+
+		free(tableau);
 		return(d_erreur);
 	}
 
@@ -213,8 +360,7 @@ sequenceur_optimise(struct_processus *s_
 
 	if ((*s_etat_processus).profilage == d_vrai)
 	{
-		profilage(s_etat_processus, (*s_etat_processus).s_liste_variables
-				[point_entree].nom);
+		profilage(s_etat_processus, tableau[point_entree].nom);
 	}
 
 	if ((*s_etat_processus).erreur_systeme != d_es)
@@ -228,11 +374,29 @@ sequenceur_optimise(struct_processus *s_
 			printf("+++System : Not enough memory\n");
 		}
 
+		for(j = 0; j < nb_variables; j++)
+		{
+			if (tableau[j].mutex != NULL)
+			{
+				pthread_mutex_unlock(tableau[j].mutex);
+			}
+		}
+
+		free(tableau);
 		return(d_erreur);
 	}
 
-	erreur = evaluation(s_etat_processus, (*s_etat_processus).s_liste_variables
-			[point_entree].objet, 'E');
+	for(j = 0; j < nb_variables; j++)
+	{
+		if (tableau[j].mutex != NULL)
+		{
+			pthread_mutex_unlock(tableau[j].mutex);
+		}
+	}
+
+	free(tableau);
+
+	erreur = evaluation(s_etat_processus, programme_principal, 'E');
 
 	if ((*s_etat_processus).profilage == d_vrai)
 	{