--- rpl/src/instructions_c2.c	2010/09/23 15:27:36	1.14
+++ rpl/src/instructions_c2.c	2020/01/10 11:15:44	1.76
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.0.20
-  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.
 
@@ -47,7 +47,7 @@ instruction_cycle(struct_processus *s_et
 	unsigned char					*instruction_majuscule;
 	unsigned char					*tampon;
 
-	unsigned long					niveau;
+	integer8						niveau;
 
 	void							(*fonction)();
 
@@ -74,6 +74,12 @@ instruction_cycle(struct_processus *s_et
 		printf("        ...\n");
 		printf("    NEXT/STEP\n\n");
 
+		printf("    FORALL (variable)\n");
+		printf("        ...\n");
+		printf("        CYCLE\n");
+		printf("        ...\n");
+		printf("    NEXT\n\n");
+
 		printf("    START\n");
 		printf("        ...\n");
 		printf("        CYCLE\n");
@@ -98,7 +104,8 @@ instruction_cycle(struct_processus *s_et
 	while((l_element_pile_systeme != NULL) && (presence_boucle == d_faux))
 	{
 		if (((*l_element_pile_systeme).type_cloture == 'S') ||
-				((*l_element_pile_systeme).type_cloture == 'F'))
+				((*l_element_pile_systeme).type_cloture == 'F') ||
+				((*l_element_pile_systeme).type_cloture == 'A'))
 		{
 			presence_boucle = d_vrai;
 		}
@@ -118,7 +125,7 @@ instruction_cycle(struct_processus *s_et
 		tampon = (*s_etat_processus).instruction_courante;
 		niveau = 1;
 
-		instruction_majuscule = conversion_majuscule("");
+		instruction_majuscule = conversion_majuscule(s_etat_processus, "");
 
 		while(!(((strcmp(instruction_majuscule, "NEXT") == 0) ||
 				(strcmp(instruction_majuscule, "STEP") == 0)) && (niveau == 0)))
@@ -132,204 +139,112 @@ instruction_cycle(struct_processus *s_et
 				return;
 			}
 
-			if (recherche_variable(s_etat_processus,
-					(*s_etat_processus).instruction_courante) == d_vrai)
+			instruction_majuscule = conversion_majuscule(s_etat_processus,
+					(*s_etat_processus).instruction_courante);
+
+			if (instruction_majuscule == NULL)
 			{
-				instruction_majuscule = conversion_majuscule("");
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
 
-				if (((*s_etat_processus).s_liste_variables
-						[(*s_etat_processus).position_variable_courante]).objet
-						== NULL)
+			/*
+			 * Traitement de la pile système par les
+			 * différentes instructions.
+			 */
+
+			if ((strcmp(instruction_majuscule, "IF") == 0) ||
+					(strcmp(instruction_majuscule, "IFERR") == 0) ||
+					(strcmp(instruction_majuscule, "DO") == 0) ||
+					(strcmp(instruction_majuscule, "WHILE") == 0) ||
+					(strcmp(instruction_majuscule, "FOR") == 0) ||
+					(strcmp(instruction_majuscule, "FORALL") == 0) ||
+					(strcmp(instruction_majuscule, "START") == 0) ||
+					(strcmp(instruction_majuscule, "SELECT") == 0)
+					|| (strcmp(instruction_majuscule, "CRITICAL") == 0)
+					|| (strcmp(instruction_majuscule, "CASE") == 0)
+					|| (strcmp(instruction_majuscule, "<<") == 0))
+			{
+				if (strcmp(instruction_majuscule, "<<") == 0)
 				{
-					// Variable partagée
-
-					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, 'E') == d_vrai)
-					{
-						if ((*((*(*s_etat_processus)
-								.s_liste_variables_partagees).table
-								[(*(*s_etat_processus)
-								.s_liste_variables_partagees)
-								.position_variable])
-								.objet).type == ADR)
-						{
-							empilement_pile_systeme(s_etat_processus);
-
-							if ((*s_etat_processus).erreur_systeme != d_es)
-							{
-								if (pthread_mutex_unlock(&((*(*s_etat_processus)
-										.s_liste_variables_partagees).mutex))
-										!= 0)
-								{
-									(*s_etat_processus).erreur_systeme =
-											d_es_processus;
-									return;
-								}
-
-								return;
-							}
-
-							(*(*s_etat_processus).l_base_pile_systeme)
-									.adresse_retour =
-									(*s_etat_processus).position_courante;
-
-							(*(*s_etat_processus).l_base_pile_systeme)
-									.retour_definition = 'Y';
-							(*(*s_etat_processus).l_base_pile_systeme)
-									.niveau_courant =
-									(*s_etat_processus).niveau_courant;
-
-							(*s_etat_processus).position_courante =
-									(*((unsigned long *) ((*((*s_etat_processus)
-									.s_liste_variables[(*s_etat_processus)
-									.position_variable_courante].objet))
-									.objet)));
-
-							(*s_etat_processus)
-									.autorisation_empilement_programme = 'N';
-						}
-					}
-
-					if (pthread_mutex_unlock(&((*(*s_etat_processus)
-							.s_liste_variables_partagees).mutex)) != 0)
-					{
-						(*s_etat_processus).erreur_systeme = d_es_processus;
-						return;
-					}
+					analyse(s_etat_processus, NULL);
 				}
 				else
 				{
-					// Variable privée
-
-					if ((*((*s_etat_processus).s_liste_variables
-							[(*s_etat_processus).position_variable_courante])
-							.objet).type == ADR)
+					if ((strcmp(instruction_majuscule, "FOR") == 0) ||
+							(strcmp(instruction_majuscule, "FORALL") == 0) ||
+							(strcmp(instruction_majuscule, "START") == 0))
 					{
-						empilement_pile_systeme(s_etat_processus);
-
-						if ((*s_etat_processus).erreur_systeme != d_es)
-						{
-							return;
-						}
+						niveau++;
+					}
 
-						(*(*s_etat_processus).l_base_pile_systeme)
-								.adresse_retour =
-								(*s_etat_processus).position_courante;
-
-						(*(*s_etat_processus).l_base_pile_systeme)
-								.retour_definition = 'Y';
-						(*(*s_etat_processus).l_base_pile_systeme)
-								.niveau_courant =
-								(*s_etat_processus).niveau_courant;
-
-						(*s_etat_processus).position_courante =
-								(*((unsigned long *) ((*((*s_etat_processus)
-								.s_liste_variables[(*s_etat_processus)
-								.position_variable_courante].objet)).objet)));
+					empilement_pile_systeme(s_etat_processus);
 
-						(*s_etat_processus).autorisation_empilement_programme
-								= 'N';
+					if ((*s_etat_processus).erreur_systeme != d_es)
+					{
+						return;
 					}
 				}
 			}
-			else
+			else if ((strcmp(instruction_majuscule, "END") == 0) ||
+					(strcmp(instruction_majuscule, "NEXT") == 0) ||
+					(strcmp(instruction_majuscule, "STEP") == 0) ||
+					(strcmp(instruction_majuscule, ">>") == 0))
 			{
-				(*s_etat_processus).erreur_systeme = d_es;
-				instruction_majuscule = conversion_majuscule(
-						(*s_etat_processus).instruction_courante);
-
-				if (instruction_majuscule == NULL)
+				if (strcmp(instruction_majuscule, ">>") == 0)
 				{
-					(*s_etat_processus).erreur_systeme =
-							d_es_allocation_memoire;
-					return;
-				}
+					analyse(s_etat_processus, NULL);
 
-				/*
-				 * Traitement de la pile système par les
-				 * différentes instructions.
-				 */
-
-				if ((strcmp(instruction_majuscule, "IF") == 0) ||
-						(strcmp(instruction_majuscule, "IFERR") == 0) ||
-						(strcmp(instruction_majuscule, "DO") == 0) ||
-						(strcmp(instruction_majuscule, "WHILE") == 0) ||
-						(strcmp(instruction_majuscule, "FOR") == 0) ||
-						(strcmp(instruction_majuscule, "START") == 0) ||
-						(strcmp(instruction_majuscule, "SELECT") == 0)
-						|| (strcmp(instruction_majuscule, "CASE") == 0)
-						|| (strcmp(instruction_majuscule, "<<") == 0))
-				{
-					if (strcmp(instruction_majuscule, "<<") == 0)
+					if ((*s_etat_processus).retour_routine_evaluation
+							== 'Y')
 					{
-						analyse(s_etat_processus, NULL);
-					}
-					else
-					{
-						if ((strcmp(instruction_majuscule, "FOR") == 0) ||
-								(strcmp(instruction_majuscule, "START") == 0))
-						{
-							niveau++;
-						}
-
-						empilement_pile_systeme(s_etat_processus);
+						drapeau_presence_fin_boucle = d_faux;
+						free((*s_etat_processus).instruction_courante);
 
-						if ((*s_etat_processus).erreur_systeme != d_es)
-						{
-							return;
-						}
+						break;
 					}
 				}
-				else if ((strcmp(instruction_majuscule, "END") == 0) ||
-						(strcmp(instruction_majuscule, "NEXT") == 0) ||
-						(strcmp(instruction_majuscule, "STEP") == 0) ||
-						(strcmp(instruction_majuscule, ">>") == 0))
+				else
 				{
-					if (strcmp(instruction_majuscule, ">>") == 0)
+					if ((strcmp(instruction_majuscule, "NEXT") == 0) ||
+							(strcmp(instruction_majuscule, "STEP") == 0))
 					{
-						analyse(s_etat_processus, NULL);
+						niveau--;
 
-						if ((*s_etat_processus).retour_routine_evaluation
-								== 'Y')
+						if (niveau != 0)
 						{
-							drapeau_presence_fin_boucle = d_faux;
-							free((*s_etat_processus).instruction_courante);
-
-							break;
+							depilement_pile_systeme(s_etat_processus);
 						}
 					}
 					else
 					{
-						if ((strcmp(instruction_majuscule, "NEXT") == 0) ||
-								(strcmp(instruction_majuscule, "STEP") == 0))
+						if ((*s_etat_processus).l_base_pile_systeme == NULL)
 						{
-							niveau--;
+							(*s_etat_processus).erreur_systeme =
+									d_es_processus;
+							return;
+						}
 
-							if (niveau != 0)
+						if ((*(*s_etat_processus).l_base_pile_systeme)
+								.type_cloture == 'Q')
+						{
+							if (pthread_mutex_unlock(
+									&mutex_sections_critiques) != 0)
 							{
-								depilement_pile_systeme(s_etat_processus);
+								(*s_etat_processus).erreur_systeme =
+										d_es_processus;
+								return;
 							}
-						}
-						else
-						{
-							depilement_pile_systeme(s_etat_processus);
-						}
 
-						if ((*s_etat_processus).erreur_systeme != d_es)
-						{
-							return;
+							(*s_etat_processus).sections_critiques--;
 						}
+
+						depilement_pile_systeme(s_etat_processus);
+					}
+
+					if ((*s_etat_processus).erreur_systeme != d_es)
+					{
+						return;
 					}
 				}
 			}
@@ -385,9 +300,11 @@ instruction_cycle(struct_processus *s_et
 					(fonction == instruction_do) ||
 					(fonction == instruction_while) ||
 					(fonction == instruction_for) ||
+					(fonction == instruction_forall) ||
 					(fonction == instruction_start) ||
 					(fonction == instruction_select) ||
 					(fonction == instruction_case) ||
+					(fonction == instruction_critical) ||
 					(fonction == instruction_vers_niveau_superieur))
 			{
 				if (fonction == instruction_vers_niveau_superieur)
@@ -398,6 +315,7 @@ instruction_cycle(struct_processus *s_et
 				else
 				{
 					if ((fonction == instruction_for) ||
+							(fonction == instruction_forall) ||
 							(fonction == instruction_start))
 					{
 						niveau++;
@@ -440,6 +358,27 @@ instruction_cycle(struct_processus *s_et
 					}
 					else
 					{
+						if ((*s_etat_processus).l_base_pile_systeme == NULL)
+						{
+							(*s_etat_processus).erreur_systeme =
+									d_es_processus;
+							return;
+						}
+
+						if ((*(*s_etat_processus).l_base_pile_systeme)
+							   	.type_cloture == 'Q')
+						{
+							if (pthread_mutex_unlock(&mutex_sections_critiques)
+									!= 0)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_processus;
+								return;
+							}
+
+							(*s_etat_processus).sections_critiques--;
+						}	
+
 						depilement_pile_systeme(s_etat_processus);
 					}
 
@@ -499,12 +438,13 @@ instruction_con(struct_processus *s_etat
 	struct_objet					*s_objet_resultat;
 
 	logical1						argument_nom;
+	logical1						variable_partagee;
 
-	unsigned long					i;
-	unsigned long					j;
-	unsigned long					nombre_colonnes;
-	unsigned long					nombre_dimensions;
-	unsigned long					nombre_lignes;
+	integer8						i;
+	integer8						j;
+	integer8						nombre_colonnes;
+	integer8						nombre_dimensions;
+	integer8						nombre_lignes;
 
 	(*s_etat_processus).erreur_execution = d_ex;
 
@@ -603,8 +543,8 @@ instruction_con(struct_processus *s_etat
 
 		liberation(s_etat_processus, s_objet_2);
 
-		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)
 		{
 			liberation(s_etat_processus, s_objet_1);
 
@@ -612,66 +552,44 @@ instruction_con(struct_processus *s_etat
 			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)
 		{
 			// Variable partagée
 
-			if (pthread_mutex_lock(&((*(*s_etat_processus)
-					.s_liste_variables_partagees).mutex)) != 0)
-			{
-				(*s_etat_processus).erreur_systeme = d_es_processus;
-				return;
-			}
+			variable_partagee = d_vrai;
 
 			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 =
 						d_ex_variable_non_definie;
 
-				if (pthread_mutex_unlock(&((*(*s_etat_processus)
-						.s_liste_variables_partagees).mutex)) != 0)
-				{
-					(*s_etat_processus).erreur_systeme = d_es_processus;
-					return;
-				}
-
 				liberation(s_etat_processus, s_objet_1);
 				liberation(s_etat_processus, s_objet_2);
 
 				return;
 			}
 
-			s_objet_2 = (*(*s_etat_processus).s_liste_variables_partagees)
-					.table[(*(*s_etat_processus).s_liste_variables_partagees)
-					.position_variable].objet;
-
-			if (pthread_mutex_unlock(&((*(*s_etat_processus)
-					.s_liste_variables_partagees).mutex)) != 0)
-			{
-				(*s_etat_processus).erreur_systeme = d_es_processus;
-				return;
-			}
+			s_objet_2 = (*(*s_etat_processus)
+					.pointeur_variable_partagee_courante).objet;
 		}
 		else
 		{
 			// Variable privée
 
-			s_objet_2 = (*s_etat_processus).s_liste_variables
-					[(*s_etat_processus).position_variable_courante].objet;
+			s_objet_2 = (*(*s_etat_processus).pointeur_variable_courante).objet;
+			variable_partagee = d_faux;
 		}
 	}
 	else
 	{
 		argument_nom = d_faux;
+		variable_partagee = d_faux;
 	}
 	
 /*
@@ -699,6 +617,18 @@ instruction_con(struct_processus *s_etat
 			{
 				liberation(s_etat_processus, s_objet_2);
 			}
+			else
+			{
+				if (variable_partagee == d_vrai)
+				{
+					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_execution = d_ex_dimensions_invalides;
 			return;
@@ -719,6 +649,19 @@ instruction_con(struct_processus *s_etat
 				{
 					liberation(s_etat_processus, s_objet_2);
 				}
+				else
+				{
+					if (variable_partagee == d_vrai)
+					{
+						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_execution =
 						d_ex_erreur_type_argument;
@@ -733,6 +676,19 @@ instruction_con(struct_processus *s_etat
 				{
 					liberation(s_etat_processus, s_objet_2);
 				}
+				else
+				{
+					if (variable_partagee == d_vrai)
+					{
+						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_execution = d_ex_argument_invalide;
 				return;
@@ -790,6 +746,18 @@ instruction_con(struct_processus *s_etat
 		{
 			liberation(s_etat_processus, s_objet_2);
 		}
+		else
+		{
+			if (variable_partagee == d_vrai)
+			{
+				if (pthread_mutex_unlock(&((*(*s_etat_processus)
+						.pointeur_variable_partagee_courante).mutex)) != 0)
+				{
+					(*s_etat_processus).erreur_systeme = d_es_processus;
+					return;
+				}
+			}
+		}
 
 		liberation(s_etat_processus, s_objet_1);
 
@@ -811,6 +779,18 @@ instruction_con(struct_processus *s_etat
 		{
 			liberation(s_etat_processus, s_objet_2);
 		}
+		else
+		{
+			if (variable_partagee == d_vrai)
+			{
+				if (pthread_mutex_unlock(&((*(*s_etat_processus)
+						.pointeur_variable_partagee_courante).mutex)) != 0)
+				{
+					(*s_etat_processus).erreur_systeme = d_es_processus;
+					return;
+				}
+			}
+		}
 
 		liberation(s_etat_processus, s_objet_1);
 
@@ -837,7 +817,8 @@ instruction_con(struct_processus *s_etat
 					nombre_lignes;
 
 			if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
-					malloc(nombre_lignes * sizeof(integer8))) == NULL)
+					malloc(((size_t) nombre_lignes) * sizeof(integer8)))
+					== NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
@@ -863,7 +844,7 @@ instruction_con(struct_processus *s_etat
 					nombre_lignes;
 
 			if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
-					malloc(nombre_lignes * sizeof(real8))) == NULL)
+					malloc(((size_t) nombre_lignes) * sizeof(real8))) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
@@ -889,7 +870,8 @@ instruction_con(struct_processus *s_etat
 					nombre_lignes;
 
 			if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
-					malloc(nombre_lignes * sizeof(struct_complexe16))) == NULL)
+					malloc(((size_t) nombre_lignes) *
+					sizeof(struct_complexe16))) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
@@ -929,7 +911,8 @@ instruction_con(struct_processus *s_etat
 					nombre_colonnes;
 
 			if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
-					malloc(nombre_lignes * sizeof(integer8 *))) == NULL)
+					malloc(((size_t) nombre_lignes) * sizeof(integer8 *)))
+					== NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
@@ -938,8 +921,8 @@ instruction_con(struct_processus *s_etat
 			for(i = 0; i < nombre_lignes; i++)
 			{
 				if ((((integer8 **) (*((struct_matrice *) (*s_objet_resultat)
-						.objet)).tableau)[i] = malloc(
-						nombre_colonnes * sizeof(integer8))) == NULL)
+						.objet)).tableau)[i] = malloc(((size_t)
+						nombre_colonnes) * sizeof(integer8))) == NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
 							d_es_allocation_memoire;
@@ -969,7 +952,7 @@ instruction_con(struct_processus *s_etat
 					nombre_colonnes;
 
 			if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
-					malloc(nombre_lignes * sizeof(real8 *))) == NULL)
+					malloc(((size_t) nombre_lignes) * sizeof(real8 *))) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
@@ -978,8 +961,8 @@ instruction_con(struct_processus *s_etat
 			for(i = 0; i < nombre_lignes; i++)
 			{
 				if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat)
-						.objet)).tableau)[i] = malloc(
-						nombre_colonnes * sizeof(real8))) == NULL)
+						.objet)).tableau)[i] = malloc(((size_t)
+						nombre_colonnes) * sizeof(real8))) == NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
 							d_es_allocation_memoire;
@@ -1009,8 +992,8 @@ instruction_con(struct_processus *s_etat
 					nombre_colonnes;
 
 			if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
-					malloc(nombre_lignes * sizeof(struct_complexe16 *)))
-					== NULL)
+					malloc(((size_t) nombre_lignes) *
+					sizeof(struct_complexe16 *))) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
@@ -1020,7 +1003,7 @@ instruction_con(struct_processus *s_etat
 			{
 				if ((((struct_complexe16 **) (*((struct_matrice *)
 						(*s_objet_resultat).objet)).tableau)[i] =
-						malloc(nombre_colonnes *
+						malloc(((size_t) nombre_colonnes) *
 						sizeof(struct_complexe16))) == NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
@@ -1056,9 +1039,23 @@ instruction_con(struct_processus *s_etat
 	}
 	else
 	{
-		(*s_etat_processus).s_liste_variables
-				[(*s_etat_processus).position_variable_courante].objet =
-				s_objet_resultat;
+		if (variable_partagee == d_vrai)
+		{
+			(*(*s_etat_processus).pointeur_variable_partagee_courante).objet =
+					s_objet_resultat;
+
+			if (pthread_mutex_unlock(&((*(*s_etat_processus)
+					.pointeur_variable_partagee_courante).mutex)) != 0)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_processus;
+				return;
+			}
+		}
+		else
+		{
+			(*(*s_etat_processus).pointeur_variable_courante).objet =
+					s_objet_resultat;
+		}
 	}
 
 	return;
@@ -1197,9 +1194,7 @@ instruction_cross(struct_processus *s_et
 				.tableau)[2]), &(((integer8 *) (*((struct_vecteur *)
 				(*s_objet_argument_1).objet)).tableau)[1]), &(tampon_2));
 
-		tampon_2 = -tampon_2;
-
-		depassement |= depassement_addition(&(tampon_1), &(tampon_2),
+		depassement |= depassement_soustraction(&(tampon_1), &(tampon_2),
 				&(((integer8 *) (*((struct_vecteur *) (*s_objet_resultat)
 				.objet)).tableau)[0]));
 
@@ -1213,9 +1208,7 @@ instruction_cross(struct_processus *s_et
 				.tableau)[0]), &(((integer8 *) (*((struct_vecteur *)
 				(*s_objet_argument_1).objet)).tableau)[2]), &(tampon_2));
 
-		tampon_2 = -tampon_2;
-
-		depassement |= depassement_addition(&(tampon_1), &(tampon_2),
+		depassement |= depassement_soustraction(&(tampon_1), &(tampon_2),
 				&(((integer8 *) (*((struct_vecteur *) (*s_objet_resultat)
 				.objet)).tableau)[1]));
 
@@ -1229,9 +1222,7 @@ instruction_cross(struct_processus *s_et
 				.tableau)[1]), &(((integer8 *) (*((struct_vecteur *)
 				(*s_objet_argument_1).objet)).tableau)[0]), &(tampon_2));
 
-		tampon_2 = -tampon_2;
-
-		depassement |= depassement_addition(&(tampon_1), &(tampon_2),
+		depassement |= depassement_soustraction(&(tampon_1), &(tampon_2),
 				&(((integer8 *) (*((struct_vecteur *) (*s_objet_resultat)
 				.objet)).tableau)[2]));
 
@@ -1313,25 +1304,28 @@ instruction_cross(struct_processus *s_et
 		}
 
 		((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
-				.tableau)[0] = (((integer8 *) (*((struct_vecteur *)
+				.tableau)[0] = ((real8) ((integer8 *) (*((struct_vecteur *)
 				(*s_objet_argument_2).objet)).tableau)[1] * ((real8 *)
 				(*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[2])
-				- (((integer8 *) (*((struct_vecteur *) (*s_objet_argument_2)
-				.objet)).tableau)[2] * ((real8 *) (*((struct_vecteur *)
+				- ((real8) ((integer8 *) (*((struct_vecteur *)
+				(*s_objet_argument_2).objet)).tableau)[2] *
+				((real8 *) (*((struct_vecteur *)
 				(*s_objet_argument_1).objet)).tableau)[1]);
 		((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
-				.tableau)[1] = (((integer8 *) (*((struct_vecteur *)
+				.tableau)[1] = ((real8) ((integer8 *) (*((struct_vecteur *)
 				(*s_objet_argument_2).objet)).tableau)[2] * ((real8 *)
 				(*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[0])
-				- (((integer8 *) (*((struct_vecteur *) (*s_objet_argument_2)
-				.objet)).tableau)[0] * ((real8 *) (*((struct_vecteur *)
+				- ((real8) ((integer8 *) (*((struct_vecteur *)
+				(*s_objet_argument_2) .objet)).tableau)[0] *
+				((real8 *) (*((struct_vecteur *)
 				(*s_objet_argument_1).objet)).tableau)[2]);
 		((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
-				.tableau)[2] = (((integer8 *) (*((struct_vecteur *)
+				.tableau)[2] = ((real8) ((integer8 *) (*((struct_vecteur *)
 				(*s_objet_argument_2).objet)).tableau)[0] * ((real8 *)
 				(*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[1])
-				- (((integer8 *) (*((struct_vecteur *) (*s_objet_argument_2)
-				.objet)).tableau)[1] * ((real8 *) (*((struct_vecteur *)
+				- ((real8) ((integer8 *) (*((struct_vecteur *)
+				(*s_objet_argument_2).objet)).tableau)[1] *
+				((real8 *) (*((struct_vecteur *)
 				(*s_objet_argument_1).objet)).tableau)[0]);
 	}
 	else if (((*s_objet_argument_1).type == VIN) &&
@@ -1366,24 +1360,28 @@ instruction_cross(struct_processus *s_et
 
 		((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
 				.tableau)[0] = (((real8 *) (*((struct_vecteur *)
-				(*s_objet_argument_2).objet)).tableau)[1] * ((integer8 *)
-				(*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[2])
+				(*s_objet_argument_2).objet)).tableau)[1] * (real8)
+				((integer8 *) (*((struct_vecteur *)
+				(*s_objet_argument_1).objet)).tableau)[2])
 				- (((real8 *) (*((struct_vecteur *) (*s_objet_argument_2)
-				.objet)).tableau)[2] * ((integer8 *) (*((struct_vecteur *)
+				.objet)).tableau)[2] * (real8) ((integer8 *)
+				(*((struct_vecteur *)
 				(*s_objet_argument_1).objet)).tableau)[1]);
 		((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
 				.tableau)[1] = (((real8 *) (*((struct_vecteur *)
-				(*s_objet_argument_2).objet)).tableau)[2] * ((integer8 *)
-				(*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[0])
-				- (((real8 *) (*((struct_vecteur *) (*s_objet_argument_2)
-				.objet)).tableau)[0] * ((integer8 *) (*((struct_vecteur *)
+				(*s_objet_argument_2).objet)).tableau)[2] * (real8)
+				((integer8 *) (*((struct_vecteur *) (*s_objet_argument_1)
+				.objet)).tableau)[0]) - (((real8 *) (*((struct_vecteur *)
+				(*s_objet_argument_2) .objet)).tableau)[0] * (real8)
+				((integer8 *) (*((struct_vecteur *)
 				(*s_objet_argument_1).objet)).tableau)[2]);
 		((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
 				.tableau)[2] = (((real8 *) (*((struct_vecteur *)
-				(*s_objet_argument_2).objet)).tableau)[0] * ((integer8 *)
-				(*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau)[1])
-				- (((real8 *) (*((struct_vecteur *) (*s_objet_argument_2)
-				.objet)).tableau)[1] * ((integer8 *) (*((struct_vecteur *)
+				(*s_objet_argument_2).objet)).tableau)[0] * (real8)
+				((integer8 *) (*((struct_vecteur *) (*s_objet_argument_1)
+				.objet)).tableau)[1]) - (((real8 *) (*((struct_vecteur *)
+				(*s_objet_argument_2) .objet)).tableau)[1] * (real8)
+				((integer8 *) (*((struct_vecteur *)
 				(*s_objet_argument_1).objet)).tableau)[0]);
 	}
 	else if (((*s_objet_argument_1).type == VRL) &&