--- rpl/src/instructions_n1.c	2012/01/05 10:19:02	1.32
+++ rpl/src/instructions_n1.c	2020/01/10 11:15:46	1.72
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.5
-  Copyright (C) 1989-2012 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.
 
@@ -48,8 +48,8 @@ instruction_neg(struct_processus *s_etat
 	struct_objet				*s_objet_argument;
 	struct_objet				*s_objet_resultat;
 
-	unsigned long				i;
-	unsigned long				j;
+	integer8					i;
+	integer8					j;
 
 	(*s_etat_processus).erreur_execution = d_ex;
 
@@ -112,22 +112,37 @@ instruction_neg(struct_processus *s_etat
 
 	if ((*s_objet_argument).type == INT)
 	{
-		if ((s_objet_resultat = copie_objet(s_etat_processus,
-				s_objet_argument, 'Q')) == NULL)
+		if ((*((integer8 *) (*s_objet_argument).objet)) != INT64_MIN)
 		{
-			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
-			return;
-		}
+			if ((s_objet_resultat = copie_objet(s_etat_processus,
+					s_objet_argument, 'Q')) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
 
-		/*
-		 * Permet d'éviter les résultats du type -0. Valable pour tous
-		 * les types...
-		 */
+			/*
+			 * Permet d'éviter les résultats du type -0. Valable pour tous
+			 * les types...
+			 */
 
-		if ((*((integer8 *) (*s_objet_argument).objet)) != 0)
+			if ((*((integer8 *) (*s_objet_argument).objet)) != 0)
+			{
+				(*((integer8 *) (*s_objet_resultat).objet)) =
+						-(*((integer8 *) (*s_objet_argument).objet));
+			}
+		}
+		else
 		{
-			(*((integer8 *) (*s_objet_resultat).objet)) =
-					-(*((integer8 *) (*s_objet_argument).objet));
+			if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			(*((real8 *) (*s_objet_resultat).objet)) =
+					-((real8) (*((integer8 *) (*s_objet_argument).objet)));
+
 		}
 	}
 
@@ -194,23 +209,73 @@ instruction_neg(struct_processus *s_etat
 
 	else if ((*s_objet_argument).type == VIN)
 	{
-		if ((s_objet_resultat = copie_objet(s_etat_processus,
-				s_objet_argument, 'Q')) == NULL)
+		drapeau = d_faux;
+
+		for(i = 0; i < (*((struct_vecteur *) (*s_objet_argument).objet))
+				.taille; i++)
 		{
-			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
-			return;
+			if (((integer8 *) (*((struct_vecteur *)
+					(*s_objet_argument).objet)).tableau)[i] == INT64_MIN)
+			{
+				drapeau = d_vrai;
+				break;
+			}
 		}
 
-		for(i = 0; i < (*(((struct_vecteur *) (*s_objet_argument).objet)))
-				.taille; i++)
+		if (drapeau == d_vrai)
 		{
-			if (((integer8 *) (*(((struct_vecteur *)
-					(*s_objet_argument).objet))).tableau)[i] != 0)
+			if ((s_objet_resultat = allocation(s_etat_processus, VRL)) == NULL)
 			{
-				((integer8 *) (*(((struct_vecteur *) (*s_objet_resultat)
-						.objet))).tableau)[i] = -((integer8 *)
-						(*(((struct_vecteur *)
-						(*s_objet_argument).objet))).tableau)[i];
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
+					malloc(((size_t) (*((struct_vecteur *) (*s_objet_argument)
+					.objet)).taille) * sizeof(real8))) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			for(i = 0; i < (*((struct_vecteur *) (*s_objet_argument).objet))
+					.taille; i++)
+			{
+				if (((real8 *) (*(((struct_vecteur *)
+						(*s_objet_argument).objet))).tableau)[i] != 0)
+				{
+					((real8 *) (*((struct_vecteur *) (*s_objet_resultat)
+							.objet)).tableau)[i] = -((real8) ((integer8 *)
+							(*((struct_vecteur *)
+							(*s_objet_argument).objet)).tableau)[i]);
+				}
+				else
+				{
+					((real8 *) (*((struct_vecteur *) (*s_objet_resultat)
+							.objet)).tableau)[i] = 0;
+				}
+			}
+		}
+		else
+		{
+			if ((s_objet_resultat = copie_objet(s_etat_processus,
+					s_objet_argument, 'Q')) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			for(i = 0; i < (*(((struct_vecteur *) (*s_objet_argument).objet)))
+					.taille; i++)
+			{
+				if (((integer8 *) (*(((struct_vecteur *)
+						(*s_objet_argument).objet))).tableau)[i] != 0)
+				{
+					((integer8 *) (*(((struct_vecteur *) (*s_objet_resultat)
+							.objet))).tableau)[i] = -((integer8 *)
+							(*(((struct_vecteur *)
+							(*s_objet_argument).objet))).tableau)[i];
+				}
 			}
 		}
 	}
@@ -293,26 +358,99 @@ instruction_neg(struct_processus *s_etat
 
 	else if ((*s_objet_argument).type == MIN)
 	{
-		if ((s_objet_resultat = copie_objet(s_etat_processus,
-				s_objet_argument, 'Q')) == NULL)
-		{
-			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
-			return;
-		}
+		drapeau = d_faux;
 
-		for(i = 0; i < (*(((struct_matrice *) (*s_objet_argument).objet)))
+		for(i = 0; i < (*((struct_matrice *) (*s_objet_argument).objet))
 				.nombre_lignes; i++)
 		{
-			for(j = 0; j < (*(((struct_matrice *) (*s_objet_argument).objet)))
+			for(j = 0; j < (*((struct_matrice *) (*s_objet_argument).objet))
 					.nombre_colonnes; j++)
 			{
-				if (((integer8 **) (*(((struct_matrice *) (*s_objet_argument)
-						.objet))).tableau)[i][j] != 0)
+				if (((integer8 **) (*((struct_matrice *)
+						(*s_objet_argument).objet)).tableau)[i][j] == INT64_MIN)
 				{
-					((integer8 **) (*(((struct_matrice *) (*s_objet_resultat)
-							.objet))).tableau)[i][j] = -((integer8 **)
-							(*(((struct_matrice *)
-							(*s_objet_argument).objet))).tableau)[i][j];
+					drapeau = d_vrai;
+					break;
+				}
+			}
+
+			if (drapeau == d_vrai)
+			{
+				break;
+			}
+		}
+
+		if (drapeau == d_vrai)
+		{
+			if ((s_objet_resultat = allocation(s_etat_processus, MRL)) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
+					malloc(((size_t) (*((struct_matrice *) (*s_objet_argument)
+					.objet)).nombre_lignes) * sizeof(real8 *))) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			for(i = 0; i < (*((struct_matrice *) (*s_objet_argument).objet))
+					.nombre_lignes; i++)
+			{
+				if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat)
+						.objet)).tableau)[i] = malloc(((size_t)
+						((*((struct_matrice *) (*s_objet_argument).objet))
+						.nombre_colonnes)) * sizeof(real8))) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				for(j = 0; j < (*((struct_matrice *) (*s_objet_argument)
+						.objet)).nombre_colonnes; j++)
+				{
+					if (((integer8 **) (*((struct_matrice *)
+							(*s_objet_argument).objet)).tableau)[i][j] != 0)
+					{
+						((real8 **) (*((struct_matrice *) (*s_objet_resultat)
+								.objet)).tableau)[i][j] = -((real8)
+								((integer8 **) (*(((struct_matrice *)
+								(*s_objet_argument).objet))).tableau)[i][j]);
+					}
+					else
+					{
+						((real8 **) (*((struct_matrice *) (*s_objet_resultat)
+								.objet)).tableau)[i][j] = 0;
+					}
+				}
+			}
+		}
+		else
+		{
+			if ((s_objet_resultat = copie_objet(s_etat_processus,
+					s_objet_argument, 'Q')) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			for(i = 0; i < (*((struct_matrice *) (*s_objet_argument).objet))
+					.nombre_lignes; i++)
+			{
+				for(j = 0; j < (*((struct_matrice *) (*s_objet_argument)
+						.objet)).nombre_colonnes; j++)
+				{
+					if (((integer8 **) (*((struct_matrice *)
+							(*s_objet_argument).objet)).tableau)[i][j] != 0)
+					{
+						((integer8 **) (*((struct_matrice *)
+								(*s_objet_resultat).objet)).tableau)[i][j] =
+								-((integer8 **) (*((struct_matrice *)
+								(*s_objet_argument).objet)).tableau)[i][j];
+					}
 				}
 			}
 		}
@@ -667,7 +805,7 @@ instruction_not(struct_processus *s_etat
 
 		if ((*s_etat_processus).langue == 'F')
 		{
-			printf("(complément)\n\n");
+			printf("(complément)\n\n");
 		}
 		else
 		{
@@ -1003,9 +1141,9 @@ instruction_ne(struct_processus *s_etat_
 
 	logical1					difference;
 
-	unsigned long				i;
-	unsigned long				j;
-	unsigned long				nombre_elements;
+	integer8					i;
+	integer8					j;
+	integer8					nombre_elements;
 
 	(*s_etat_processus).erreur_execution = d_ex;
 
@@ -1015,7 +1153,7 @@ instruction_ne(struct_processus *s_etat_
 
 		if ((*s_etat_processus).langue == 'F')
 		{
-			printf("(opérateur différence)\n\n");
+			printf("(opérateur différence)\n\n");
 		}
 		else
 		{
@@ -2058,6 +2196,7 @@ instruction_next(struct_processus *s_eta
 	struct_objet				*s_objet;
 	struct_objet				*s_copie_objet;
 
+	logical1					fin_boucle;
 	logical1					presence_compteur;
 
 	(*s_etat_processus).erreur_execution = d_ex;
@@ -2068,7 +2207,7 @@ instruction_next(struct_processus *s_eta
 
 		if ((*s_etat_processus).langue == 'F')
 		{
-			printf("(fin d'une boucle définie)\n\n");
+			printf("(fin d'une boucle définie)\n\n");
 		}
 		else
 		{
@@ -2106,189 +2245,353 @@ instruction_next(struct_processus *s_eta
 		return;
 	}
 
-	presence_compteur = ((*(*s_etat_processus).l_base_pile_systeme)
-			.type_cloture == 'F') ? d_vrai : d_faux;
+	if ((*(*s_etat_processus).l_base_pile_systeme).type_cloture != 'A')
+	{ // FOR ou START
+		presence_compteur = ((*(*s_etat_processus).l_base_pile_systeme)
+				.type_cloture == 'F') ? d_vrai : d_faux;
 
-	if (((*(*s_etat_processus).l_base_pile_systeme).type_cloture != 'S')
-			&& (presence_compteur == d_faux))
-	{
-		(*s_etat_processus).erreur_execution = d_ex_erreur_traitement_boucle;
-		return;
-	}
+		if (((*(*s_etat_processus).l_base_pile_systeme).type_cloture != 'S')
+				&& (presence_compteur == d_faux))
+		{
+			(*s_etat_processus).erreur_execution =
+					d_ex_erreur_traitement_boucle;
+			return;
+		}
 
-	/*
-	 * Pour une boucle avec indice, on fait pointer 
-	 * (*(*s_etat_processus).l_base_pile_systeme).indice_boucle sur
-	 * la variable correspondante. Remarque, le contenu de la variable
-	 * est détruit au courant de l'opération.
-	 */
+		/*
+		 * Pour une boucle avec indice, on fait pointer 
+		 * (*(*s_etat_processus).l_base_pile_systeme).indice_boucle sur
+		 * la variable correspondante. Remarque, le contenu de la variable
+		 * est détruit au courant de l'opération.
+		 */
 
-	if (presence_compteur == d_vrai)
-	{
-		if (recherche_variable(s_etat_processus, (*(*s_etat_processus)
-				.l_base_pile_systeme).nom_variable) == d_faux)
+		if (presence_compteur == d_vrai)
 		{
-			(*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
-			return;
+			if (recherche_variable(s_etat_processus, (*(*s_etat_processus)
+					.l_base_pile_systeme).nom_variable) == d_faux)
+			{
+				(*s_etat_processus).erreur_execution =
+						d_ex_variable_non_definie;
+				return;
+			}
+
+			if ((*(*s_etat_processus).pointeur_variable_courante)
+					.variable_verrouillee == d_vrai)
+			{
+				(*s_etat_processus).erreur_execution =
+						d_ex_variable_verrouillee;
+				return;
+			}
+
+			if ((*(*s_etat_processus).pointeur_variable_courante).objet == NULL)
+			{
+				(*s_etat_processus).erreur_execution = d_ex_variable_partagee;
+				return;
+			}
+
+			(*(*s_etat_processus).l_base_pile_systeme).indice_boucle =
+					(*(*s_etat_processus).pointeur_variable_courante).objet;
 		}
 
-		if ((*(*s_etat_processus).pointeur_variable_courante)
-				.variable_verrouillee == d_vrai)
+		/*
+		 * Empilement pour calculer le nouvel indice. Au passage, la
+		 * variable (*(*s_etat_processus).l_base_pile_systeme).indice_boucle
+		 * est libérée.
+		 */
+
+		if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+				(*(*s_etat_processus).l_base_pile_systeme).indice_boucle)
+				== d_erreur)
 		{
-			(*s_etat_processus).erreur_execution = d_ex_variable_verrouillee;
 			return;
 		}
 
-		if ((*(*s_etat_processus).pointeur_variable_courante).objet == NULL)
+		if ((s_objet = allocation(s_etat_processus, INT)) == NULL)
 		{
-			(*s_etat_processus).erreur_execution = d_ex_variable_partagee;
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
 		}
 
-		(*(*s_etat_processus).l_base_pile_systeme).indice_boucle =
-				(*(*s_etat_processus).pointeur_variable_courante).objet;
-	}
-
-	/*
-	 * Empilement pour calculer le nouvel indice. Au passage, la
-	 * variable (*(*s_etat_processus).l_base_pile_systeme).indice_boucle
-	 * est libérée.
-	 */
+		(*((integer8 *) (*s_objet).objet)) = 1;
 
-	if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
-			(*(*s_etat_processus).l_base_pile_systeme).indice_boucle)
-			== d_erreur)
-	{
-		return;
-	}
-
-	if ((s_objet = allocation(s_etat_processus, INT)) == NULL)
-	{
-		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
-		return;
-	}
-
-	(*((integer8 *) (*s_objet).objet)) = 1;
-
-	if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
-			s_objet) == d_erreur)
-	{
-		return;
-	}
+		if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+				s_objet) == d_erreur)
+		{
+			return;
+		}
 
-	instruction_plus(s_etat_processus);
+		instruction_plus(s_etat_processus);
 
-	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
-			&s_objet) == d_erreur)
-	{
-		liberation(s_etat_processus, s_objet);
+		if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+				&s_objet) == d_erreur)
+		{
+			liberation(s_etat_processus, s_objet);
 
-		(*s_etat_processus).erreur_execution = d_ex_manque_argument;
-		return;
-	}
+			(*s_etat_processus).erreur_execution = d_ex_manque_argument;
+			return;
+		}
 
-	if (((*s_objet).type != INT) &&
-			((*s_objet).type != REL))
-	{
-		liberation(s_etat_processus, s_objet);
+		if (((*s_objet).type != INT) && ((*s_objet).type != REL))
+		{
+			liberation(s_etat_processus, s_objet);
 
-		(*s_etat_processus).erreur_execution = d_ex_erreur_traitement_boucle;
-		return;
-	}
+			(*s_etat_processus).erreur_execution =
+					d_ex_erreur_traitement_boucle;
+			return;
+		}
 
-	if (presence_compteur == d_vrai)
-	{
-		/*
-		 * L'addition crée si besoin une copie de l'objet
-		 */
+		if (presence_compteur == d_vrai)
+		{
+			/*
+			 * L'addition crée si besoin une copie de l'objet
+			 */
 
-		(*(*s_etat_processus).l_base_pile_systeme).indice_boucle = NULL;
-		(*(*s_etat_processus).pointeur_variable_courante).objet = s_objet;
-	}
-	else
-	{
-		(*(*s_etat_processus).l_base_pile_systeme).indice_boucle = s_objet;
-	}
+			(*(*s_etat_processus).l_base_pile_systeme).indice_boucle = NULL;
+			(*(*s_etat_processus).pointeur_variable_courante).objet = s_objet;
+		}
+		else
+		{
+			(*(*s_etat_processus).l_base_pile_systeme).indice_boucle = s_objet;
+		}
 
-	if ((s_copie_objet = copie_objet(s_etat_processus, s_objet, 'P')) == NULL)
-	{
-		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
-		return;
-	}
+		if ((s_copie_objet = copie_objet(s_etat_processus, s_objet, 'P'))
+				== NULL)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			return;
+		}
 
-	if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
-			s_copie_objet) == d_erreur)
-	{
-		return;
-	}
+		if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+				s_copie_objet) == d_erreur)
+		{
+			return;
+		}
 
-	if ((s_copie_objet = copie_objet(s_etat_processus,
-			(*(*s_etat_processus).l_base_pile_systeme)
-			.limite_indice_boucle, 'P')) == NULL)
-	{
-		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
-		return;
-	}
+		if ((s_copie_objet = copie_objet(s_etat_processus,
+				(*(*s_etat_processus).l_base_pile_systeme)
+				.limite_indice_boucle, 'P')) == NULL)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			return;
+		}
 
-	if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
-			s_copie_objet) == d_erreur)
-	{
-		return;
-	}
+		if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+				s_copie_objet) == d_erreur)
+		{
+			return;
+		}
 
-	instruction_le(s_etat_processus);
+		instruction_le(s_etat_processus);
 
-	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
-			&s_objet) == d_erreur)
-	{
-		(*s_etat_processus).erreur_execution = d_ex_manque_argument;
-		return;
-	}
+		if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+				&s_objet) == d_erreur)
+		{
+			(*s_etat_processus).erreur_execution = d_ex_manque_argument;
+			return;
+		}
 
-	if ((*s_objet).type != INT)
-	{
-		liberation(s_etat_processus, s_objet);
+		if ((*s_objet).type != INT)
+		{
+			liberation(s_etat_processus, s_objet);
 
-		(*s_etat_processus).erreur_execution = d_ex_erreur_traitement_boucle;
-		return;
-	}
+			(*s_etat_processus).erreur_execution =
+					d_ex_erreur_traitement_boucle;
+			return;
+		}
 
-	if ((*((integer8 *) (*s_objet).objet)) != 0)
-	{
-		if ((*(*s_etat_processus).l_base_pile_systeme)
-				.origine_routine_evaluation == 'N')
+		if ((*((integer8 *) (*s_objet).objet)) != 0)
 		{
-			(*s_etat_processus).position_courante = (*(*s_etat_processus)
-					.l_base_pile_systeme).adresse_retour;
+			if ((*(*s_etat_processus).l_base_pile_systeme)
+					.origine_routine_evaluation == 'N')
+			{
+				(*s_etat_processus).position_courante = (*(*s_etat_processus)
+						.l_base_pile_systeme).adresse_retour;
+			}
+			else
+			{
+				(*s_etat_processus).expression_courante = (*(*s_etat_processus)
+						.l_base_pile_systeme).pointeur_objet_retour;
+			}
 		}
 		else
 		{
-			(*s_etat_processus).expression_courante = (*(*s_etat_processus)
-					.l_base_pile_systeme).pointeur_objet_retour;
+			depilement_pile_systeme(s_etat_processus);
+
+			if ((*s_etat_processus).erreur_systeme != d_es)
+			{
+				return;
+			}
+
+			if (presence_compteur == d_vrai)
+			{
+				(*s_etat_processus).niveau_courant--;
+
+				if (retrait_variables_par_niveau(s_etat_processus) == d_erreur)
+				{
+					return;
+				}
+			}
 		}
+
+		liberation(s_etat_processus, s_objet);
 	}
 	else
-	{
-		depilement_pile_systeme(s_etat_processus);
+	{ // FORALL
+		if ((*(*(*s_etat_processus).l_base_pile_systeme).limite_indice_boucle)
+				.type == NON)
+		{ // L'objet initial était vide.
+			(*s_etat_processus).niveau_courant--;
+			depilement_pile_systeme(s_etat_processus);
 
-		if ((*s_etat_processus).erreur_systeme != d_es)
-		{
+			liberation(s_etat_processus, (*(*s_etat_processus)
+					.l_base_pile_systeme).limite_indice_boucle);
 			return;
 		}
+		else if ((*(*(*s_etat_processus).l_base_pile_systeme)
+				.limite_indice_boucle).type == LST)
+		{ // FORALL sur une liste
+			if ((*((struct_liste_chainee *) (*(*(*s_etat_processus)
+					.l_base_pile_systeme).indice_boucle).objet)).suivant
+					!= NULL)
+			{
+				if (recherche_variable(s_etat_processus, (*(*s_etat_processus)
+						.l_base_pile_systeme).nom_variable) == d_faux)
+				{
+					(*s_etat_processus).erreur_execution =
+							d_ex_variable_non_definie;
+					return;
+				}
 
-		if (presence_compteur == d_vrai)
+				if ((*(*s_etat_processus).pointeur_variable_courante)
+						.variable_verrouillee == d_vrai)
+				{
+					(*s_etat_processus).erreur_execution =
+							d_ex_variable_verrouillee;
+					return;
+				}
+
+				if ((*(*s_etat_processus).pointeur_variable_courante).objet
+						== NULL)
+				{
+					(*s_etat_processus).erreur_execution
+							= d_ex_variable_partagee;
+					return;
+				}
+
+				(*(*(*s_etat_processus).l_base_pile_systeme).indice_boucle)
+						.objet = (*((struct_liste_chainee *)
+						(*(*(*s_etat_processus).l_base_pile_systeme)
+						.indice_boucle).objet)).suivant;
+				liberation(s_etat_processus, (*(*s_etat_processus)
+						.pointeur_variable_courante).objet);
+
+				if (((*(*s_etat_processus).pointeur_variable_courante).objet
+						= copie_objet(s_etat_processus,
+						(*((struct_liste_chainee *) (*(*(*s_etat_processus)
+						.l_base_pile_systeme).indice_boucle).objet)).donnee,
+						'P')) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme
+							= d_es_allocation_memoire;
+					return;
+				}
+
+				fin_boucle = d_faux;
+			}
+			else
+			{
+				fin_boucle = d_vrai;
+			}
+		}
+		else
+		{ // FORALL sur une table
+			(*((integer8 *) (*(*(*s_etat_processus).l_base_pile_systeme)
+					.indice_boucle).objet))++;
+
+			if ((*((integer8 *) (*(*(*s_etat_processus).l_base_pile_systeme)
+					.indice_boucle).objet)) < (integer8) (*((struct_tableau *)
+					(*(*(*s_etat_processus).l_base_pile_systeme)
+					.limite_indice_boucle).objet)).nombre_elements)
+			{
+				if (recherche_variable(s_etat_processus, (*(*s_etat_processus)
+						.l_base_pile_systeme).nom_variable) == d_faux)
+				{
+					(*s_etat_processus).erreur_execution =
+							d_ex_variable_non_definie;
+					return;
+				}
+
+				if ((*(*s_etat_processus).pointeur_variable_courante)
+						.variable_verrouillee == d_vrai)
+				{
+					(*s_etat_processus).erreur_execution =
+							d_ex_variable_verrouillee;
+					return;
+				}
+
+				if ((*(*s_etat_processus).pointeur_variable_courante).objet
+						== NULL)
+				{
+					(*s_etat_processus).erreur_execution
+							= d_ex_variable_partagee;
+					return;
+				}
+
+				liberation(s_etat_processus, (*(*s_etat_processus)
+						.pointeur_variable_courante).objet);
+
+				if (((*(*s_etat_processus).pointeur_variable_courante).objet
+						= copie_objet(s_etat_processus, (*((struct_tableau *)
+						(*(*(*s_etat_processus).l_base_pile_systeme)
+						.limite_indice_boucle).objet)).elements[(*((integer8 *)
+						(*(*(*s_etat_processus).l_base_pile_systeme)
+						.indice_boucle).objet))], 'P')) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme
+							= d_es_allocation_memoire;
+					return;
+				}
+
+				fin_boucle = d_faux;
+			}
+			else
+			{
+				fin_boucle = d_vrai;
+			}
+		}
+
+		if (fin_boucle == d_vrai)
 		{
+			depilement_pile_systeme(s_etat_processus);
+
+			if ((*s_etat_processus).erreur_systeme != d_es)
+			{
+				return;
+			}
+
 			(*s_etat_processus).niveau_courant--;
 
-			if (retrait_variable_par_niveau(s_etat_processus) == d_erreur)
+			if (retrait_variables_par_niveau(s_etat_processus) == d_erreur)
 			{
 				return;
 			}
 		}
+		else
+		{
+			if ((*(*s_etat_processus).l_base_pile_systeme)
+					.origine_routine_evaluation == 'N')
+			{
+				(*s_etat_processus).position_courante = (*(*s_etat_processus)
+						.l_base_pile_systeme).adresse_retour;
+			}
+			else
+			{
+				(*s_etat_processus).expression_courante = (*(*s_etat_processus)
+						.l_base_pile_systeme).pointeur_objet_retour;
+			}
+		}
 	}
 
-	liberation(s_etat_processus, s_objet);
-
 	return;
 }
 
@@ -2318,7 +2621,7 @@ instruction_nrand(struct_processus *s_et
 
 		if ((*s_etat_processus).langue == 'F')
 		{
-			printf("(valeur aléatoire gaussienne)\n\n");
+			printf("(valeur aléatoire gaussienne)\n\n");
 		}
 		else
 		{