--- rpl/src/instructions_i2.c	2011/04/14 08:46:43	1.16.2.2
+++ rpl/src/instructions_i2.c	2020/01/10 11:15:46	1.74
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.0.23
-  Copyright (C) 1989-2011 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.
 
@@ -44,8 +44,8 @@ instruction_idn(struct_processus *s_etat
 	logical1							argument_nom;
 	logical1							variable_partagee;
 
-	unsigned long						i;
-	unsigned long						j;
+	integer8							i;
+	integer8							j;
 
 	(*s_etat_processus).erreur_execution = d_ex;
 
@@ -107,41 +107,24 @@ instruction_idn(struct_processus *s_etat
 
 		liberation(s_etat_processus, s_objet_argument);
 
-		if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
-				.position_variable_courante].variable_verrouillee == d_vrai)
+		if ((*(*s_etat_processus).pointeur_variable_courante)
+				.variable_verrouillee == d_vrai)
 		{
 			(*s_etat_processus).erreur_execution = d_ex_variable_verrouillee;
 			return;
 		}
 
-		s_objet_argument = (*s_etat_processus).s_liste_variables
-				[(*s_etat_processus).position_variable_courante].objet;
+		s_objet_argument = (*(*s_etat_processus).pointeur_variable_courante)
+				.objet;
 
 		if (s_objet_argument == NULL)
 		{
-			if (pthread_mutex_lock(&((*(*s_etat_processus)
-					.s_liste_variables_partagees).mutex)) != 0)
-			{
-				(*s_etat_processus).erreur_systeme = d_es_processus;
-				return;
-			}
-
 			if (recherche_variable_partagee(s_etat_processus,
-					(*s_etat_processus).s_liste_variables
-					[(*s_etat_processus).position_variable_courante].nom,
-					(*s_etat_processus).s_liste_variables
-					[(*s_etat_processus).position_variable_courante]
-					.variable_partagee, (*s_etat_processus).s_liste_variables
-					[(*s_etat_processus).position_variable_courante].origine)
-					== d_faux)
+					(*(*s_etat_processus).pointeur_variable_courante).nom,
+					(*(*s_etat_processus).pointeur_variable_courante)
+					.variable_partagee, (*(*s_etat_processus)
+					.pointeur_variable_courante).origine) == NULL)
 			{
-				if (pthread_mutex_unlock(&((*(*s_etat_processus)
-						.s_liste_variables_partagees).mutex)) != 0)
-				{
-					(*s_etat_processus).erreur_systeme = d_es_processus;
-					return;
-				}
-
 				(*s_etat_processus).erreur_systeme = d_es;
 				(*s_etat_processus).erreur_execution =
 						d_ex_variable_non_definie;
@@ -150,8 +133,7 @@ instruction_idn(struct_processus *s_etat
 			}
 
 			s_objet_argument = (*(*s_etat_processus)
-					.s_liste_variables_partagees).table[(*(*s_etat_processus)
-					.s_liste_variables_partagees).position_variable].objet;
+					.pointeur_variable_partagee_courante).objet;
 			variable_partagee = d_vrai;
 		}
 		else
@@ -184,7 +166,7 @@ instruction_idn(struct_processus *s_etat
 			if (variable_partagee == d_vrai)
 			{
 				if (pthread_mutex_unlock(&((*(*s_etat_processus)
-						.s_liste_variables_partagees).mutex)) != 0)
+						.pointeur_variable_partagee_courante).mutex)) != 0)
 				{
 					(*s_etat_processus).erreur_systeme = d_es_processus;
 					return;
@@ -218,7 +200,7 @@ instruction_idn(struct_processus *s_etat
 				if (variable_partagee == d_vrai)
 				{
 					if (pthread_mutex_unlock(&((*(*s_etat_processus)
-							.s_liste_variables_partagees).mutex)) != 0)
+							.pointeur_variable_partagee_courante).mutex)) != 0)
 					{
 						(*s_etat_processus).erreur_systeme = d_es_processus;
 						return;
@@ -241,13 +223,13 @@ instruction_idn(struct_processus *s_etat
 		}
 
 		if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
-				malloc((*((struct_matrice *) (*s_objet_resultat).objet))
-				.nombre_lignes * sizeof(integer8 *))) == NULL)
+				malloc(((size_t) (*((struct_matrice *) (*s_objet_resultat)
+				.objet)).nombre_lignes) * sizeof(integer8 *))) == NULL)
 		{
 			if (variable_partagee == d_vrai)
 			{
 				if (pthread_mutex_unlock(&((*(*s_etat_processus)
-						.s_liste_variables_partagees).mutex)) != 0)
+						.pointeur_variable_partagee_courante).mutex)) != 0)
 				{
 					(*s_etat_processus).erreur_systeme = d_es_processus;
 					return;
@@ -262,14 +244,14 @@ instruction_idn(struct_processus *s_etat
 				.nombre_lignes; i++)
 		{
 			if ((((integer8 **) (*((struct_matrice *) (*s_objet_resultat)
-					.objet)).tableau)[i] = malloc((*((struct_matrice *)
-					(*s_objet_resultat).objet)).nombre_colonnes *
-					sizeof(integer8))) == NULL)
+					.objet)).tableau)[i] = malloc(((size_t)
+					(*((struct_matrice *) (*s_objet_resultat).objet))
+					.nombre_colonnes) * sizeof(integer8))) == NULL)
 			{
 				if (variable_partagee == d_vrai)
 				{
 					if (pthread_mutex_unlock(&((*(*s_etat_processus)
-							.s_liste_variables_partagees).mutex)) != 0)
+							.pointeur_variable_partagee_courante).mutex)) != 0)
 					{
 						(*s_etat_processus).erreur_systeme = d_es_processus;
 						return;
@@ -300,7 +282,7 @@ instruction_idn(struct_processus *s_etat
 		if (variable_partagee == d_vrai)
 		{
 			if (pthread_mutex_unlock(&((*(*s_etat_processus)
-					.s_liste_variables_partagees).mutex)) != 0)
+					.pointeur_variable_partagee_courante).mutex)) != 0)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_processus;
 				return;
@@ -327,14 +309,12 @@ instruction_idn(struct_processus *s_etat
 	{
 		if (variable_partagee == d_vrai)
 		{
-			(*s_etat_processus).s_liste_variables[(*s_etat_processus)
-					.position_variable_courante].objet = NULL;
-			(*(*s_etat_processus).s_liste_variables_partagees).table
-					[(*(*s_etat_processus).s_liste_variables_partagees)
-					.position_variable].objet = s_objet_resultat;
+			(*(*s_etat_processus).pointeur_variable_courante).objet = NULL;
+			(*(*s_etat_processus).pointeur_variable_partagee_courante).objet =
+					s_objet_resultat;
 
 			if (pthread_mutex_unlock(&((*(*s_etat_processus)
-					.s_liste_variables_partagees).mutex)) != 0)
+					.pointeur_variable_partagee_courante).mutex)) != 0)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_processus;
 				return;
@@ -342,8 +322,8 @@ instruction_idn(struct_processus *s_etat
 		}
 		else
 		{
-			(*s_etat_processus).s_liste_variables[(*s_etat_processus)
-					.position_variable_courante].objet = s_objet_resultat;
+			(*(*s_etat_processus).pointeur_variable_courante).objet =
+					s_objet_resultat;
 		}
 	}
 
@@ -379,10 +359,10 @@ instruction_ifft(struct_processus *s_eta
 
 	logical1					presence_longueur_fft;
 
-	unsigned long				i;
-	unsigned long				j;
-	unsigned long				k;
-	unsigned long				longueur_fft;
+	integer8					i;
+	integer8					j;
+	integer8					k;
+	integer8					longueur_fft;
 
 	(*s_etat_processus).erreur_execution = d_ex;
 
@@ -488,18 +468,18 @@ instruction_ifft(struct_processus *s_eta
 	{
 		if (presence_longueur_fft == d_faux)
 		{
-			longueur_fft = pow(2, (integer4) ceil(log((real8)
+			longueur_fft = (integer8) pow(2, ceil(log((real8)
 					(*((struct_vecteur *)
 					(*s_objet_argument).objet)).taille) / log((real8) 2)));
 
-			if ((longueur_fft / ((real8) (*((struct_vecteur *)
+			if ((((real8) longueur_fft) / ((real8) (*((struct_vecteur *)
 					(*s_objet_argument).objet)).taille)) == 2)
 			{
 				longueur_fft /= 2;
 			}
 		}
 
-		if ((matrice_f77 = malloc(longueur_fft *
+		if ((matrice_f77 = malloc(((size_t) longueur_fft) *
 				sizeof(struct_complexe16))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
@@ -549,7 +529,7 @@ instruction_ifft(struct_processus *s_eta
 		}
 
 		nombre_lignes = 1;
-		nombre_colonnes = longueur_fft;
+		nombre_colonnes = (integer4) longueur_fft;
 		inverse = -1;
 
 		dft(matrice_f77, &nombre_lignes, &nombre_colonnes, &inverse, &erreur);
@@ -585,21 +565,20 @@ instruction_ifft(struct_processus *s_eta
 	{
 		if (presence_longueur_fft == d_faux)
 		{
-			longueur_fft = pow(2, (integer4) ceil(log((real8)
-					(*((struct_matrice *)
-					(*s_objet_argument).objet)).nombre_colonnes) /
-					log((real8) 2)));
+			longueur_fft = (integer8) pow(2, ceil(log((real8)
+					(*((struct_matrice *) (*s_objet_argument).objet))
+					.nombre_colonnes) / log((real8) 2)));
 
-			if ((longueur_fft / ((real8) (*((struct_matrice *)
+			if ((((real8) longueur_fft) / ((real8) (*((struct_matrice *)
 					(*s_objet_argument).objet)).nombre_colonnes)) == 2)
 			{
 				longueur_fft /= 2;
 			}
 		}
 
-		if ((matrice_f77 = malloc(longueur_fft *
-				(*((struct_matrice *) (*s_objet_argument).objet))
-				.nombre_lignes * sizeof(struct_complexe16))) == NULL)
+		if ((matrice_f77 = malloc(((size_t) longueur_fft) *
+				((size_t) (*((struct_matrice *) (*s_objet_argument).objet))
+				.nombre_lignes) * sizeof(struct_complexe16))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
@@ -675,9 +654,9 @@ instruction_ifft(struct_processus *s_eta
 			}
 		}
 
-		nombre_lignes = (*((struct_matrice *) (*s_objet_argument).objet))
-				.nombre_lignes;
-		nombre_colonnes = longueur_fft;
+		nombre_lignes = (integer4) (*((struct_matrice *)
+				(*s_objet_argument).objet)).nombre_lignes;
+		nombre_colonnes = (integer4) longueur_fft;
 		inverse = -1;
 
 		dft(matrice_f77, &nombre_lignes, &nombre_colonnes, &inverse, &erreur);
@@ -704,8 +683,8 @@ instruction_ifft(struct_processus *s_eta
 				longueur_fft;
 
 		if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
-				malloc((*((struct_matrice *) (*s_objet_resultat).objet))
-				.nombre_lignes * sizeof(struct_complexe16 *))) == NULL)
+				malloc(((size_t) (*((struct_matrice *) (*s_objet_resultat)
+				.objet)).nombre_lignes) * sizeof(struct_complexe16 *))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
@@ -716,8 +695,8 @@ instruction_ifft(struct_processus *s_eta
 		{
 			if ((((struct_complexe16 **) (*((struct_matrice *)
 					(*s_objet_resultat).objet)).tableau)[i] =
-					malloc((*((struct_matrice *)
-					(*s_objet_resultat).objet)).nombre_colonnes *
+					malloc(((size_t) (*((struct_matrice *)
+					(*s_objet_resultat).objet)).nombre_colonnes) *
 					sizeof(struct_complexe16))) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
@@ -786,7 +765,12 @@ instruction_input(struct_processus *s_et
 {
 	struct_objet				*s_objet_resultat;
 
+	unsigned char				*ptr_e;
+	unsigned char				*ptr_l;
 	unsigned char				*tampon;
+	unsigned char				*tampon2;
+
+	integer8					i;
 
 	(*s_etat_processus).erreur_execution = d_ex;
 
@@ -828,6 +812,7 @@ instruction_input(struct_processus *s_et
 	}
 
 	flockfile(stdin);
+
 	(*s_objet_resultat).objet = (void *) readline("");
 	funlockfile(stdin);
 
@@ -852,7 +837,45 @@ instruction_input(struct_processus *s_et
 	}
 
 	free((unsigned char *) (*s_objet_resultat).objet);
-	(*s_objet_resultat).objet = tampon;
+
+	ptr_l = tampon;
+	i = 0;
+
+	while((*ptr_l) != d_code_fin_chaine)
+	{
+		if ((*ptr_l) == '\"')
+		{
+			i++;
+		}
+
+		ptr_l++;
+	}
+
+	if ((tampon2 = malloc((strlen(tampon) + 1 + ((size_t) i)) *
+			sizeof(unsigned char))) == NULL)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+		return;
+	}
+
+	ptr_l = tampon;
+	ptr_e = tampon2;
+
+	while((*ptr_l) != d_code_fin_chaine)
+	{
+		if ((*ptr_l) == '\"')
+		{
+			(*ptr_e) = '\\';
+			ptr_e++;
+		}
+
+		(*ptr_e) = (*ptr_l);
+		ptr_e++;
+		ptr_l++;
+	}
+
+	free(tampon);
+	(*s_objet_resultat).objet = tampon2;
 
 	add_history((unsigned char *) (*s_objet_resultat).objet);
 	stifle_history(ds_longueur_historique);
@@ -1037,266 +1060,354 @@ instruction_int(struct_processus *s_etat
 
 		if ((*s_etat_processus).langue == 'F')
 		{
-			printf("(intégration numérique)\n\n");
+			printf("(intégration)\n\n");
 		}
 		else
 		{
-			printf("(numerical integration)\n\n");
+			printf("(numerical)\n\n");
 		}
 
-		printf("    3: %s, %s, %s\n", d_NOM, d_ALG, d_RPN);
+		printf("    3: %s, %s, %s, %s, %s\n", d_INT, d_REL,
+				d_NOM, d_ALG, d_RPN);
 		printf("    2: %s\n", d_LST);
 		printf("    1: %s, %s\n", d_INT, d_REL);
 		printf("->  2: %s, %s\n", d_INT, d_REL);
-		printf("    1: %s, %s\n", d_INT, d_REL);
+		printf("    1: %s, %s\n\n", d_INT, d_REL);
 
+		printf("    2: %s, %s, %s, %s\n", d_INT, d_REL, d_NOM, d_ALG);
+		printf("    1: %s\n", d_NOM);
+		printf("->  1: %s, %s, %s, %s\n", d_INT, d_REL, d_NOM, d_ALG);
 		return;
 	}
 	else if ((*s_etat_processus).test_instruction == 'Y')
 	{
-		(*s_etat_processus).nombre_arguments = 3;
+		(*s_etat_processus).nombre_arguments = -1;
 		return;
 	}
-	
-	if ((last_valide = test_cfsf(s_etat_processus, 31)) == d_vrai)
-	{
-		if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
-		{
-			return;
-		}
-	}
 
-	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
-			&s_objet_argument_1) == d_erreur)
+	if ((*s_etat_processus).l_base_pile == NULL)
 	{
 		(*s_etat_processus).erreur_execution = d_ex_manque_argument;
 		return;
 	}
 
-	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
-			&s_objet_argument_2) == d_erreur)
+	if ((*(*(*s_etat_processus).l_base_pile).donnee).type == NOM)
 	{
-		liberation(s_etat_processus, s_objet_argument_1);
+		// Intégration symbolique
 
-		(*s_etat_processus).erreur_execution = d_ex_manque_argument;
-		return;
-	}
+		if (test_cfsf(s_etat_processus, 31) == d_vrai)
+		{
+			if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
+			{
+				return;
+			}
+		}
 
-	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
-			&s_objet_argument_3) == d_erreur)
-	{
-		liberation(s_etat_processus, s_objet_argument_1);
-		liberation(s_etat_processus, s_objet_argument_2);
+		if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+				&s_objet_argument_1) == d_erreur)
+		{
+			(*s_etat_processus).erreur_execution = d_ex_manque_argument;
+			return;
+		}
 
-		(*s_etat_processus).erreur_execution = d_ex_manque_argument;
-		return;
-	}
+		if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+				&s_objet_argument_2) == d_erreur)
+		{
+			liberation(s_etat_processus, s_objet_argument_1);
 
-	if ((*s_objet_argument_1).type == INT)
-	{
-		precision = (*((integer8 *) (*s_objet_argument_1).objet));
-	}
-	else if ((*s_objet_argument_1).type == REL)
-	{
-		precision = (*((real8 *) (*s_objet_argument_1).objet));
+			(*s_etat_processus).erreur_execution = d_ex_manque_argument;
+			return;
+		}
+
+		if (((*s_objet_argument_1).type == NOM) &&
+				(((*s_objet_argument_2).type == NOM) ||
+				((*s_objet_argument_2).type == ALG) ||
+				((*s_objet_argument_2).type == REL) ||
+				((*s_objet_argument_2).type == INT)))
+		{
+			if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+					s_objet_argument_2) == d_erreur)
+			{
+				return;
+			}
+
+			if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+					s_objet_argument_1) == d_erreur)
+			{
+				return;
+			}
+
+			interface_cas(s_etat_processus, RPLCAS_INTEGRATION);
+		}
+		else
+		{
+			liberation(s_etat_processus, s_objet_argument_1);
+			liberation(s_etat_processus, s_objet_argument_2);
+
+			(*s_etat_processus).erreur_execution =
+					d_ex_erreur_type_argument;
+			return;
+		}
 	}
 	else
 	{
-		liberation(s_etat_processus, s_objet_argument_1);
-		liberation(s_etat_processus, s_objet_argument_2);
-		liberation(s_etat_processus, s_objet_argument_3);
+		// Intégration numérique
 
-		(*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
-		return;
-	}
+		if ((last_valide = test_cfsf(s_etat_processus, 31)) == d_vrai)
+		{
+			if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
+			{
+				return;
+			}
+		}
 
-	if ((*s_objet_argument_2).type == LST)
-	{
-		l_element_courant = (*s_objet_argument_2).objet;
+		if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+				&s_objet_argument_1) == d_erreur)
+		{
+			(*s_etat_processus).erreur_execution = d_ex_manque_argument;
+			return;
+		}
 
-		if ((*(*l_element_courant).donnee).type != NOM)
+		if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+				&s_objet_argument_2) == d_erreur)
 		{
 			liberation(s_etat_processus, s_objet_argument_1);
-			liberation(s_etat_processus, s_objet_argument_2);
-			liberation(s_etat_processus, s_objet_argument_3);
 
-			(*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
+			(*s_etat_processus).erreur_execution = d_ex_manque_argument;
 			return;
 		}
 
-		if ((nom_variable = malloc((strlen((*((struct_nom *)
-				(*(*l_element_courant).donnee).objet)).nom)
-				+ 1) * sizeof(unsigned char))) == NULL)
+		if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+				&s_objet_argument_3) == d_erreur)
 		{
-			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			liberation(s_etat_processus, s_objet_argument_1);
+			liberation(s_etat_processus, s_objet_argument_2);
+
+			(*s_etat_processus).erreur_execution = d_ex_manque_argument;
 			return;
 		}
 
-		strcpy(nom_variable, (*((struct_nom *) (*(*l_element_courant)
-				.donnee).objet)).nom);
+		if (((*s_objet_argument_3).type != NOM) &&
+				((*s_objet_argument_3).type != ALG) &&
+				((*s_objet_argument_3).type != RPN) &&
+				((*s_objet_argument_3).type != REL) &&
+				((*s_objet_argument_3).type != INT))
+		{
+			liberation(s_etat_processus, s_objet_argument_1);
+			liberation(s_etat_processus, s_objet_argument_2);
+			liberation(s_etat_processus, s_objet_argument_3);
 
-		l_element_courant = (*l_element_courant).suivant;
+			(*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
+			return;
+		}
 
-		if ((*(*l_element_courant).donnee).type == INT)
+		if ((*s_objet_argument_1).type == INT)
 		{
-			borne_minimale = (real8) (*((integer8 *)
-					(*(*l_element_courant).donnee).objet));
+			precision = (real8) (*((integer8 *) (*s_objet_argument_1).objet));
 		}
-		else if ((*(*l_element_courant).donnee).type == REL)
+		else if ((*s_objet_argument_1).type == REL)
 		{
-			borne_minimale = (*((real8 *) (*(*l_element_courant)
-					.donnee).objet));
+			precision = (*((real8 *) (*s_objet_argument_1).objet));
 		}
 		else
 		{
-			if (evaluation(s_etat_processus, (*l_element_courant).donnee,
-					'N') == d_erreur)
+			liberation(s_etat_processus, s_objet_argument_1);
+			liberation(s_etat_processus, s_objet_argument_2);
+			liberation(s_etat_processus, s_objet_argument_3);
+
+			(*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
+			return;
+		}
+
+		if ((*s_objet_argument_2).type == LST)
+		{
+			l_element_courant = (*s_objet_argument_2).objet;
+
+			if ((*(*l_element_courant).donnee).type != NOM)
 			{
-				free(nom_variable);
 				liberation(s_etat_processus, s_objet_argument_1);
 				liberation(s_etat_processus, s_objet_argument_2);
 				liberation(s_etat_processus, s_objet_argument_3);
 
+				(*s_etat_processus).erreur_execution =
+						d_ex_erreur_type_argument;
 				return;
 			}
 
-			if (depilement(s_etat_processus, &((*s_etat_processus)
-					.l_base_pile), &s_objet_evalue) == d_erreur)
+			if ((nom_variable = malloc((strlen((*((struct_nom *)
+					(*(*l_element_courant).donnee).objet)).nom)
+					+ 1) * sizeof(unsigned char))) == NULL)
 			{
-				free(nom_variable);
-				liberation(s_etat_processus, s_objet_argument_1);
-				liberation(s_etat_processus, s_objet_argument_2);
-				liberation(s_etat_processus, s_objet_argument_3);
-
-				(*s_etat_processus).erreur_execution =
-						d_ex_manque_argument;
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
 			}
 
-			if ((*s_objet_evalue).type == INT)
+			strcpy(nom_variable, (*((struct_nom *) (*(*l_element_courant)
+					.donnee).objet)).nom);
+
+			l_element_courant = (*l_element_courant).suivant;
+
+			if ((*(*l_element_courant).donnee).type == INT)
 			{
 				borne_minimale = (real8) (*((integer8 *)
-						(*s_objet_evalue).objet));
+						(*(*l_element_courant).donnee).objet));
 			}
-			else if ((*s_objet_evalue).type == REL)
+			else if ((*(*l_element_courant).donnee).type == REL)
 			{
-				borne_minimale = (*((real8 *) (*s_objet_evalue).objet));
+				borne_minimale = (*((real8 *) (*(*l_element_courant)
+						.donnee).objet));
 			}
 			else
 			{
-				free(nom_variable);
-				
-				liberation(s_etat_processus, s_objet_evalue);
-				liberation(s_etat_processus, s_objet_argument_1);
-				liberation(s_etat_processus, s_objet_argument_2);
-				liberation(s_etat_processus, s_objet_argument_3);
-
-				(*s_etat_processus).erreur_execution =
-						d_ex_erreur_type_argument;
-				return;
-			}
+				if (evaluation(s_etat_processus, (*l_element_courant).donnee,
+						'N') == d_erreur)
+				{
+					free(nom_variable);
+					liberation(s_etat_processus, s_objet_argument_1);
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_3);
 
-			liberation(s_etat_processus, s_objet_evalue);
-		}
+					return;
+				}
 
-		l_element_courant = (*l_element_courant).suivant;
+				if (depilement(s_etat_processus, &((*s_etat_processus)
+						.l_base_pile), &s_objet_evalue) == d_erreur)
+				{
+					free(nom_variable);
+					liberation(s_etat_processus, s_objet_argument_1);
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_3);
 
-		if ((*(*l_element_courant).donnee).type == INT)
-		{
-			borne_maximale = (real8) (*((integer8 *)
-					(*(*l_element_courant).donnee).objet));
-		}
-		else if ((*(*l_element_courant).donnee).type == REL)
-		{
-			borne_maximale = (*((real8 *) (*(*l_element_courant)
-					.donnee).objet));
-		}
-		else
-		{
-			if (evaluation(s_etat_processus, (*l_element_courant).donnee,
-					'N') == d_erreur)
-			{
-				free(nom_variable);
-				liberation(s_etat_processus, s_objet_argument_1);
-				liberation(s_etat_processus, s_objet_argument_2);
-				liberation(s_etat_processus, s_objet_argument_3);
+					(*s_etat_processus).erreur_execution =
+							d_ex_manque_argument;
+					return;
+				}
 
-				return;
-			}
+				if ((*s_objet_evalue).type == INT)
+				{
+					borne_minimale = (real8) (*((integer8 *)
+							(*s_objet_evalue).objet));
+				}
+				else if ((*s_objet_evalue).type == REL)
+				{
+					borne_minimale = (*((real8 *) (*s_objet_evalue).objet));
+				}
+				else
+				{
+					free(nom_variable);
+					
+					liberation(s_etat_processus, s_objet_evalue);
+					liberation(s_etat_processus, s_objet_argument_1);
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_3);
 
-			if (depilement(s_etat_processus, &((*s_etat_processus)
-					.l_base_pile), &s_objet_evalue) == d_erreur)
-			{
-				free(nom_variable);
-				liberation(s_etat_processus, s_objet_argument_1);
-				liberation(s_etat_processus, s_objet_argument_2);
-				liberation(s_etat_processus, s_objet_argument_3);
+					(*s_etat_processus).erreur_execution =
+							d_ex_erreur_type_argument;
+					return;
+				}
 
-				(*s_etat_processus).erreur_execution =
-						d_ex_manque_argument;
-				return;
+				liberation(s_etat_processus, s_objet_evalue);
 			}
 
-			if ((*s_objet_evalue).type == INT)
+			l_element_courant = (*l_element_courant).suivant;
+
+			if ((*(*l_element_courant).donnee).type == INT)
 			{
 				borne_maximale = (real8) (*((integer8 *)
-						(*s_objet_evalue).objet));
+						(*(*l_element_courant).donnee).objet));
 			}
-			else if ((*s_objet_evalue).type == REL)
+			else if ((*(*l_element_courant).donnee).type == REL)
 			{
-				borne_maximale = (*((real8 *) (*s_objet_evalue).objet));
+				borne_maximale = (*((real8 *) (*(*l_element_courant)
+						.donnee).objet));
 			}
 			else
 			{
-				free(nom_variable);
+				if (evaluation(s_etat_processus, (*l_element_courant).donnee,
+						'N') == d_erreur)
+				{
+					free(nom_variable);
+					liberation(s_etat_processus, s_objet_argument_1);
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_3);
 
-				liberation(s_etat_processus, s_objet_evalue);
-				liberation(s_etat_processus, s_objet_argument_1);
-				liberation(s_etat_processus, s_objet_argument_2);
-				liberation(s_etat_processus, s_objet_argument_3);
+					return;
+				}
 
-				(*s_etat_processus).erreur_execution =
-						d_ex_erreur_type_argument;
-				return;
+				if (depilement(s_etat_processus, &((*s_etat_processus)
+						.l_base_pile), &s_objet_evalue) == d_erreur)
+				{
+					free(nom_variable);
+					liberation(s_etat_processus, s_objet_argument_1);
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_3);
+
+					(*s_etat_processus).erreur_execution =
+							d_ex_manque_argument;
+					return;
+				}
+
+				if ((*s_objet_evalue).type == INT)
+				{
+					borne_maximale = (real8) (*((integer8 *)
+							(*s_objet_evalue).objet));
+				}
+				else if ((*s_objet_evalue).type == REL)
+				{
+					borne_maximale = (*((real8 *) (*s_objet_evalue).objet));
+				}
+				else
+				{
+					free(nom_variable);
+
+					liberation(s_etat_processus, s_objet_evalue);
+					liberation(s_etat_processus, s_objet_argument_1);
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_3);
+
+					(*s_etat_processus).erreur_execution =
+							d_ex_erreur_type_argument;
+					return;
+				}
+
+				liberation(s_etat_processus, s_objet_evalue);
 			}
 
-			liberation(s_etat_processus, s_objet_evalue);
-		}
+			/*
+			 * Le résultat est retourné sur la pile par la routine
+			 */
 
-		/*
-		 * Le résultat est retourné sur la pile par la routine
-		 */
+			if (last_valide == d_vrai)
+			{
+				cf(s_etat_processus, 31);
+			}
 
-		if (last_valide == d_vrai)
-		{
-			cf(s_etat_processus, 31);
-		}
+			integrale_romberg(s_etat_processus, s_objet_argument_3,
+					nom_variable, borne_minimale, borne_maximale, precision);
 
-		integrale_romberg(s_etat_processus, s_objet_argument_3, nom_variable,
-				borne_minimale, borne_maximale, precision);
+			if (last_valide == d_vrai)
+			{
+				sf(s_etat_processus, 31);
+			}
 
-		if (last_valide == d_vrai)
+			free(nom_variable);
+		}
+		else
 		{
-			sf(s_etat_processus, 31);
+			liberation(s_etat_processus, s_objet_argument_1);
+			liberation(s_etat_processus, s_objet_argument_2);
+			liberation(s_etat_processus, s_objet_argument_3);
+
+			(*s_etat_processus).erreur_execution =
+					d_ex_erreur_type_argument;
+			return;
 		}
 
-		free(nom_variable);
-	}
-	else
-	{
 		liberation(s_etat_processus, s_objet_argument_1);
 		liberation(s_etat_processus, s_objet_argument_2);
 		liberation(s_etat_processus, s_objet_argument_3);
-
-		(*s_etat_processus).erreur_execution =
-				d_ex_erreur_type_argument;
-		return;
 	}
 
-	liberation(s_etat_processus, s_objet_argument_1);
-	liberation(s_etat_processus, s_objet_argument_2);
-	liberation(s_etat_processus, s_objet_argument_3);
-
 	return;
 }
 
@@ -1397,33 +1508,20 @@ instruction_incr(struct_processus *s_eta
 
 		liberation(s_etat_processus, s_objet_argument);
 
-		if ((*s_etat_processus).s_liste_variables
-				[(*s_etat_processus).position_variable_courante]
+		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).s_liste_variables
-				[(*s_etat_processus).position_variable_courante].objet
-				== NULL)
+		if ((*(*s_etat_processus).pointeur_variable_courante).objet == NULL)
 		{
-			if (pthread_mutex_lock(&((*(*s_etat_processus)
-					.s_liste_variables_partagees).mutex)) != 0)
-			{
-				(*s_etat_processus).erreur_systeme = d_es_processus;
-				return;
-			}
-
 			if (recherche_variable_partagee(s_etat_processus,
-					(*s_etat_processus).s_liste_variables
-					[(*s_etat_processus).position_variable_courante].nom,
-					(*s_etat_processus).s_liste_variables
-					[(*s_etat_processus).position_variable_courante]
-					.variable_partagee, (*s_etat_processus).s_liste_variables
-					[(*s_etat_processus).position_variable_courante]
-					.origine) == d_faux)
+					(*(*s_etat_processus).pointeur_variable_courante).nom,
+					(*(*s_etat_processus).pointeur_variable_courante)
+					.variable_partagee, (*(*s_etat_processus)
+					.pointeur_variable_courante).origine) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es;
 				(*s_etat_processus).erreur_execution =
@@ -1433,15 +1531,13 @@ instruction_incr(struct_processus *s_eta
 			}
 
 			s_objet_argument = (*(*s_etat_processus)
-					.s_liste_variables_partagees).table
-					[(*(*s_etat_processus).s_liste_variables_partagees)
-					.position_variable].objet;
+					.pointeur_variable_partagee_courante).objet;
 			variable_partagee = d_vrai;
 		}
 		else
 		{
-			s_objet_argument = (*s_etat_processus).s_liste_variables
-					[(*s_etat_processus).position_variable_courante].objet;
+			s_objet_argument = (*(*s_etat_processus).pointeur_variable_courante)
+					.objet;
 			variable_partagee = d_faux;
 		}
 
@@ -1451,7 +1547,7 @@ instruction_incr(struct_processus *s_eta
 			if (variable_partagee == d_vrai)
 			{
 				if (pthread_mutex_unlock(&((*(*s_etat_processus)
-						.s_liste_variables_partagees).mutex)) != 0)
+						.pointeur_variable_partagee_courante).mutex)) != 0)
 				{
 					(*s_etat_processus).erreur_systeme = d_es_processus;
 					return;
@@ -1466,17 +1562,14 @@ instruction_incr(struct_processus *s_eta
 
 		if (variable_partagee == d_vrai)
 		{
-			(*s_etat_processus).s_liste_variables[(*s_etat_processus)
-					.position_variable_courante].objet = NULL;
-			(*(*s_etat_processus)
-					.s_liste_variables_partagees).table
-					[(*(*s_etat_processus).s_liste_variables_partagees)
-					.position_variable].objet = s_copie_argument;
+			(*(*s_etat_processus).pointeur_variable_courante).objet = NULL;
+			(*(*s_etat_processus).pointeur_variable_partagee_courante).objet =
+					s_copie_argument;
 		}
 		else
 		{
-			(*s_etat_processus).s_liste_variables[(*s_etat_processus)
-					.position_variable_courante].objet = s_copie_argument;
+			(*(*s_etat_processus).pointeur_variable_courante).objet =
+					s_copie_argument;
 		}
 
 		if ((*s_copie_argument).type == INT)
@@ -1486,7 +1579,7 @@ instruction_incr(struct_processus *s_eta
 			if (variable_partagee == d_vrai)
 			{
 				if (pthread_mutex_unlock(&((*(*s_etat_processus)
-						.s_liste_variables_partagees).mutex)) != 0)
+						.pointeur_variable_partagee_courante).mutex)) != 0)
 				{
 					(*s_etat_processus).erreur_systeme = d_es_processus;
 					return;
@@ -1498,7 +1591,7 @@ instruction_incr(struct_processus *s_eta
 			if (variable_partagee == d_vrai)
 			{
 				if (pthread_mutex_unlock(&((*(*s_etat_processus)
-						.s_liste_variables_partagees).mutex)) != 0)
+						.pointeur_variable_partagee_courante).mutex)) != 0)
 				{
 					(*s_etat_processus).erreur_systeme = d_es_processus;
 					return;