--- rpl/src/instructions_t3.c	2013/03/21 11:30:30	1.45
+++ rpl/src/instructions_t3.c	2020/01/10 11:15:49	1.72
@@ -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.32
+  Copyright (C) 1989-2020 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -275,6 +275,7 @@ instruction_trnc(struct_processus *s_eta
 				cf(s_etat_processus, 56);
 			}
 
+			(*s_etat_processus).type_en_cours = NON;
 			recherche_type(s_etat_processus);
 
 			free((*s_etat_processus).instruction_courante);
@@ -342,6 +343,10 @@ instruction_table_fleche(struct_processu
 	struct_objet					*s_objet;
 	struct_objet					*s_objet_resultat;
 
+	unsigned char					*registre_instruction_courante;
+	unsigned char					registre_instruction_valide;
+	unsigned char					registre_test;
+
 	integer8						i;
 
 	(*s_etat_processus).erreur_execution = d_ex;
@@ -416,12 +421,60 @@ instruction_table_fleche(struct_processu
 			return;
 		}
 
-		if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
-				(*((struct_tableau *) (*s_objet).objet)).elements[i])
-				== d_erreur)
+		if ((*((*((struct_tableau *) (*s_objet).objet)).elements[i])).type
+				!= FCT)
 		{
-			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
-			return;
+			if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+					(*((struct_tableau *) (*s_objet).objet)).elements[i])
+					== d_erreur)
+			{
+				return;
+			}
+		}
+		else
+		{
+			registre_test = (*s_etat_processus).test_instruction;
+			registre_instruction_courante = (*s_etat_processus)
+					.instruction_courante;
+			registre_instruction_valide = (*s_etat_processus)
+					.instruction_valide;
+
+			(*s_etat_processus).test_instruction = 'Y';
+			(*s_etat_processus).instruction_courante =
+					(*((struct_fonction *) (*((struct_tableau *)
+					(*s_objet).objet)).elements[i])).nom_fonction;
+
+			analyse(s_etat_processus, NULL);
+
+			(*s_etat_processus).test_instruction = registre_test;
+			(*s_etat_processus).instruction_courante =
+					registre_instruction_courante;
+
+			if (((*s_etat_processus).instruction_valide == 'Y') &&
+					(*s_etat_processus).constante_symbolique == 'Y')
+			{
+				if (evaluation(s_etat_processus, (*((struct_tableau *)
+						(*s_objet).objet)).elements[i], 'E') == d_erreur)
+				{
+					(*s_etat_processus).instruction_valide =
+							registre_instruction_valide;
+					return;
+				}
+			}
+			else
+			{
+				if (empilement(s_etat_processus, &((*s_etat_processus)
+						.l_base_pile), (*((struct_tableau *) (*s_objet).objet))
+						.elements[i]) == d_erreur)
+				{
+					(*s_etat_processus).instruction_valide =
+							registre_instruction_valide;
+					return;
+				}
+			}
+
+			(*s_etat_processus).instruction_valide =
+					registre_instruction_valide;
 		}
 	}
 
@@ -602,6 +655,7 @@ instruction_tokenize(struct_processus *s
 	unsigned char						*registre_instruction_courante;
 	unsigned char						*registre_definitions_chainees;
 	unsigned char						*tampon;
+	unsigned char						*tampon2;
 
 	integer8							nombre_caracteres_echappement;
 	integer8							registre_longueur_definitions_chainees;
@@ -652,7 +706,15 @@ instruction_tokenize(struct_processus *s
 	{
 		// Conversion des caractères d'échappement
 
-		ptr = (unsigned char *) (*s_objet_argument).objet;
+		if ((tampon2 = malloc((strlen((*s_objet_argument).objet) + 1) *
+				sizeof(unsigned char))) == NULL)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			return;
+		}
+
+		strcpy(tampon2, (*s_objet_argument).objet);
+		ptr = tampon2;
 		ptr2 = ptr;
 
 		while((*ptr) != d_code_fin_chaine)
@@ -706,7 +768,7 @@ instruction_tokenize(struct_processus *s
 		// Remplacement des éventuels retours à la ligne et tabulations par
 		// des espaces.
 
-		ptr = (unsigned char *) (*s_objet_argument).objet;
+		ptr = tampon2;
 
 		while((*ptr) != d_code_fin_chaine)
 		{
@@ -733,8 +795,7 @@ instruction_tokenize(struct_processus *s
 				.longueur_definitions_chainees;
 		registre_position_courante = (*s_etat_processus).position_courante;
 
-		(*s_etat_processus).definitions_chainees = (unsigned char *)
-				(*s_objet_argument).objet;
+		(*s_etat_processus).definitions_chainees = tampon2;
 		(*s_etat_processus).longueur_definitions_chainees =
 				(integer8) strlen((*s_etat_processus).definitions_chainees);
 		(*s_etat_processus).position_courante = 0;
@@ -757,6 +818,8 @@ instruction_tokenize(struct_processus *s
 				(*s_etat_processus).position_courante =
 						registre_position_courante;
 
+				free(tampon2);
+
 				liberation(s_etat_processus, s_objet_argument);
 				liberation(s_etat_processus, s_objet_resultat);
 
@@ -870,6 +933,8 @@ instruction_tokenize(struct_processus *s
 		(*s_etat_processus).longueur_definitions_chainees =
 				registre_longueur_definitions_chainees;
 		(*s_etat_processus).position_courante = registre_position_courante;
+
+		free(tampon2);
 	}
 
 /*
@@ -893,7 +958,6 @@ instruction_tokenize(struct_processus *s
 	}
 
 	liberation(s_etat_processus, s_objet_argument);
-
 	return;
 }