--- rpl/src/instructions_f1.c	2013/03/22 10:20:35	1.55
+++ rpl/src/instructions_f1.c	2018/05/30 09:27:34	1.79
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.13
-  Copyright (C) 1989-2013 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.29
+  Copyright (C) 1989-2018 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -53,6 +53,8 @@ instruction_fleche(struct_processus *s_e
 	logical1							fin_scrutation;
 	logical1							presence_expression_algebrique;
 
+	pthread_mutexattr_t					attributs_mutex;
+
 	union_position_variable				position_variable;
 
 	unsigned char						instruction_valide;
@@ -108,7 +110,9 @@ instruction_fleche(struct_processus *s_e
 
 		printf("    -> (variables) %s\n\n", d_RPN);
 
-		printf("    -> (variables) %s\n", d_ALG);
+		printf("    -> (variables) %s\n\n", d_ALG);
+
+		printf("    -> (variables) %s\n", d_NOM);
 
 		return;
 	}
@@ -187,6 +191,7 @@ instruction_fleche(struct_processus *s_e
 
 			if ((*s_etat_processus).instruction_valide == 'N')
 			{
+				(*s_etat_processus).type_en_cours = NON;
 				recherche_type(s_etat_processus);
 
 				if ((*s_etat_processus).erreur_execution != d_ex)
@@ -221,9 +226,19 @@ instruction_fleche(struct_processus *s_e
 				else if ((*((struct_nom *) (*(*(*s_etat_processus).l_base_pile)
 						.donnee).objet)).symbole == d_vrai)
 				{
-					(*s_etat_processus).erreur_execution = d_ex_nom_invalide;
-					(*s_etat_processus).instruction_courante = tampon;
-					return;
+					(*s_etat_processus).niveau_courant++;
+					fin_scrutation = d_vrai;
+					presence_expression_algebrique = d_vrai;
+
+					if (depilement(s_etat_processus, &((*s_etat_processus)
+							.l_base_pile), &s_expression_algebrique)
+							== d_erreur)
+					{
+						(*s_etat_processus).erreur_execution =
+								d_ex_manque_argument;
+						(*s_etat_processus).instruction_courante = tampon;
+						return;
+					}
 				}
 				else
 				{
@@ -290,6 +305,15 @@ instruction_fleche(struct_processus *s_e
 				(*s_etat_processus).erreur_execution = d_ex_nom_invalide;
 				return;
 			}
+			else if ((*((struct_nom *) (*(*l_element_courant).donnee).objet))
+					.symbole == d_vrai)
+			{
+				(*s_etat_processus).niveau_courant++;
+				fin_scrutation = d_vrai;
+				presence_expression_algebrique = d_vrai;
+
+				s_expression_algebrique = (*l_element_courant).donnee;
+			}
 			else
 			{
 				if ((s_objet_elementaire = copie_objet(s_etat_processus,
@@ -593,20 +617,13 @@ instruction_fleche(struct_processus *s_e
 			}
 			else
 			{
-				// Variable partagee à créer
+				// Variable partagée à créer
 
 				(*s_etat_processus).erreur_systeme = d_es;
 
 				if ((s_variable_partagee.nom = malloc((strlen(s_variable.nom)
 						+ 1) * sizeof(unsigned char))) == NULL)
 				{
-					if (pthread_mutex_unlock(&((*(*s_etat_processus)
-							.pointeur_variable_partagee_courante).mutex)) != 0)
-					{
-						(*s_etat_processus).erreur_systeme = d_es_processus;
-						return;
-					}
-
 					(*s_etat_processus).erreur_systeme =
 							d_es_allocation_memoire;
 					return;
@@ -647,6 +664,15 @@ instruction_fleche(struct_processus *s_e
 							(*s_etat_processus).objet_courant;
 				}
 
+				// Création du mutex
+
+				pthread_mutexattr_init(&attributs_mutex);
+				pthread_mutexattr_settype(&attributs_mutex,
+						PTHREAD_MUTEX_RECURSIVE);
+				pthread_mutex_init(&(s_variable_partagee.mutex),
+						&attributs_mutex);
+				pthread_mutexattr_destroy(&attributs_mutex);
+
 				s_variable_partagee.objet = (*l_emplacement_valeurs).donnee;
 				(*l_emplacement_valeurs).donnee = NULL;
 
@@ -722,21 +748,37 @@ instruction_fleche(struct_processus *s_e
 
 	if (presence_expression_algebrique == d_vrai)
 	{
+		// Si l'expression algébrique est réduite à un simple nom, il
+		// s'agit toujours d'un nom symbolique. Il faut alors lui retirer
+		// son caractère de constante symbolique pour faire remonter les
+		// erreurs de type 'variable indéfinie'.
+
+		if ((*s_expression_algebrique).type == NOM)
+		{
+			(*((struct_nom *) (*s_expression_algebrique).objet)).symbole =
+					d_faux;
+		}
+
 		evaluation(s_etat_processus, s_expression_algebrique, 'N');
 
+		if ((*s_expression_algebrique).type == NOM)
+		{
+			(*((struct_nom *) (*s_expression_algebrique).objet)).symbole =
+					d_vrai;
+		}
+
 		if ((*s_etat_processus).mode_execution_programme == 'Y')
 		{
 			liberation(s_etat_processus, s_expression_algebrique);
 		}
 
+		(*s_etat_processus).autorisation_empilement_programme = 'Y';
 		(*s_etat_processus).niveau_courant--;
 
 		if (retrait_variables_par_niveau(s_etat_processus) == d_erreur)
 		{
 			return;
 		}
-
-		(*s_etat_processus).autorisation_empilement_programme = 'Y';
 	}
 
 	return;
@@ -1004,8 +1046,7 @@ instruction_for(struct_processus *s_etat
 		return;
 	}
 
-	if (((*s_objet_2).type != INT) &&
-			((*s_objet_2).type != REL))
+	if (((*s_objet_2).type != INT) && ((*s_objet_2).type != REL))
 	{
 		liberation(s_etat_processus, s_objet_1);
 		liberation(s_etat_processus, s_objet_2);
@@ -1014,11 +1055,6 @@ instruction_for(struct_processus *s_etat
 		return;
 	}
 
-	tampon = (*s_etat_processus).instruction_courante;
-	test_instruction = (*s_etat_processus).test_instruction;
-	instruction_valide = (*s_etat_processus).instruction_valide;
-	(*s_etat_processus).test_instruction = 'Y';
-
 	empilement_pile_systeme(s_etat_processus);
 
 	if ((*s_etat_processus).erreur_systeme != d_es)
@@ -1028,6 +1064,11 @@ instruction_for(struct_processus *s_etat
 
 	if ((*s_etat_processus).mode_execution_programme == 'Y')
 	{
+		tampon = (*s_etat_processus).instruction_courante;
+		test_instruction = (*s_etat_processus).test_instruction;
+		instruction_valide = (*s_etat_processus).instruction_valide;
+		(*s_etat_processus).test_instruction = 'Y';
+
 		if (recherche_instruction_suivante(s_etat_processus) == d_erreur)
 		{
 			return;
@@ -1042,6 +1083,8 @@ instruction_for(struct_processus *s_etat
 
 			free((*s_etat_processus).instruction_courante);
 			(*s_etat_processus).instruction_courante = tampon;
+			(*s_etat_processus).instruction_valide = instruction_valide;
+			(*s_etat_processus).test_instruction = test_instruction;
 
 			depilement_pile_systeme(s_etat_processus);
 
@@ -1049,10 +1092,13 @@ instruction_for(struct_processus *s_etat
 			return;
 		}
 
+		(*s_etat_processus).type_en_cours = NON;
 		recherche_type(s_etat_processus);
 
 		free((*s_etat_processus).instruction_courante);
 		(*s_etat_processus).instruction_courante = tampon;
+		(*s_etat_processus).instruction_valide = instruction_valide;
+		(*s_etat_processus).test_instruction = test_instruction;
 
 		if ((*s_etat_processus).erreur_execution != d_ex)
 		{
@@ -1144,9 +1190,6 @@ instruction_for(struct_processus *s_etat
 
 	liberation(s_etat_processus, s_objet_3);
 
-	(*s_etat_processus).test_instruction = test_instruction;
-	(*s_etat_processus).instruction_valide = instruction_valide;
-
 	(*(*s_etat_processus).l_base_pile_systeme).limite_indice_boucle = s_objet_1;
 
 	if ((*s_etat_processus).mode_execution_programme == 'Y')