--- rpl/src/instructions_v1.c	2011/08/09 11:31:35	1.31
+++ rpl/src/instructions_v1.c	2014/01/26 18:21:34	1.58
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.3
-  Copyright (C) 1989-2011 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.17
+  Copyright (C) 1989-2014 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -42,7 +42,7 @@ instruction_var(struct_processus *s_etat
 	struct_objet						*s_objet_resultat;
 	struct_objet						*s_objet_temporaire;
 
-	unsigned long						nombre_colonnes;
+	integer8							nombre_colonnes;
 
 	(*s_etat_processus).erreur_execution = d_ex;
 
@@ -500,16 +500,12 @@ instruction_version(struct_processus *s_
 		return;
 	}
 
-	if (((*(*l_element_courant).donnee).objet = malloc((strlen(d_date_en_rpl)
-			+ 1) * sizeof(unsigned char))) == NULL)
+	if (((*(*l_element_courant).donnee).objet = date_compilation()) == NULL)
 	{
 		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 		return;
 	}
 
-	strcpy((unsigned char *) (*(*l_element_courant).donnee).objet,
-			d_date_en_rpl);
-
 	/*
 	 * Ajout des options de compilation
 	 */
@@ -909,7 +905,7 @@ instruction_version(struct_processus *s_
 		return;
 	}
 
-	sprintf(tampon, "%d BITS ABI", sizeof(void *) * 8);
+	sprintf(tampon, "%zu BITS ABI", sizeof(void *) * 8);
 
 	if (((*(*l_element_courant).donnee).objet = malloc((strlen(tampon) + 1 )
 			* sizeof(unsigned char))) == NULL)
@@ -973,8 +969,8 @@ instruction_version(struct_processus *s_
 void
 instruction_vars(struct_processus *s_etat_processus)
 {
-	int									i;
-	int									nb_variables;
+	integer8							i;
+	integer8							nb_variables;
 
 	logical1							variable_partagee;
 
@@ -1027,18 +1023,18 @@ instruction_vars(struct_processus *s_eta
 	(*s_objet_resultat).objet = NULL;
 	l_element_precedent = NULL;
 
-	nb_variables = nombre_variables(s_etat_processus,
-			(*s_etat_processus).s_arbre_variables);
+	nb_variables = nombre_variables(s_etat_processus);
 
-	if ((tableau = malloc(nb_variables * sizeof(struct_tableau_variables)))
-			== NULL)
+	if ((tableau = malloc(((size_t) nb_variables) *
+			sizeof(struct_tableau_variables))) == NULL)
 	{
+		liberation_mutexes_arbre_variables_partagees(s_etat_processus,
+				(*(*s_etat_processus).s_arbre_variables_partagees));
 		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 		return;
 	}
 
-	liste_variables(s_etat_processus, tableau, 0,
-			(*s_etat_processus).s_arbre_variables);
+	nb_variables = liste_variables(s_etat_processus, tableau);
 
 	for(i = 0; i < nb_variables; i++)
 	{
@@ -1092,26 +1088,11 @@ instruction_vars(struct_processus *s_eta
 
 		if (tableau[i].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,
 					tableau[i].nom, tableau[i].variable_partagee,
-					tableau[i].origine) == d_faux)
+					tableau[i].origine) == NULL)
 			{
 				// La variable partagée n'existe plus.
-
-				if (pthread_mutex_unlock(&((*(*s_etat_processus)
-						.s_liste_variables_partagees).mutex)) != 0)
-				{
-					(*s_etat_processus).erreur_systeme = d_es_processus;
-					return;
-				}
-
 				continue;
 			}
 
@@ -1133,13 +1114,19 @@ instruction_vars(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;
 				}
 			}
 
+			if (tableau[i].mutex != NULL)
+			{
+				// La variable est une variable partagée. On libère le mutex.
+				pthread_mutex_unlock(tableau[i].mutex);
+			}
+
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
 		}
@@ -1156,13 +1143,19 @@ instruction_vars(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;
 				}
 			}
 
+			if (tableau[i].mutex != NULL)
+			{
+				// La variable est une variable partagée. On libère le mutex.
+				pthread_mutex_unlock(tableau[i].mutex);
+			}
+
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
 		}
@@ -1182,13 +1175,19 @@ instruction_vars(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;
 				}
 			}
 
+			if (tableau[i].mutex != NULL)
+			{
+				// La variable est une variable partagée. On libère le mutex.
+				pthread_mutex_unlock(tableau[i].mutex);
+			}
+
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
 		}
@@ -1200,13 +1199,19 @@ instruction_vars(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;
 				}
 			}
 
+			if (tableau[i].mutex != NULL)
+			{
+				// La variable est une variable partagée. On libère le mutex.
+				pthread_mutex_unlock(tableau[i].mutex);
+			}
+
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
 		}
@@ -1226,13 +1231,19 @@ instruction_vars(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;
 				}
 			}
 
+			if (tableau[i].mutex != NULL)
+			{
+				// La variable est une variable partagée. On libère le mutex.
+				pthread_mutex_unlock(tableau[i].mutex);
+			}
+
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
 		}
@@ -1244,25 +1255,37 @@ instruction_vars(struct_processus *s_eta
 			if (((*(*(*((struct_liste_chainee *) (*((struct_objet *)
 					(*l_element_courant).donnee)).objet)).suivant).suivant)
 					.donnee = copie_objet(s_etat_processus,
-					(*(*s_etat_processus)
-					.s_liste_variables_partagees).table[(*(*s_etat_processus)
-					.s_liste_variables_partagees).position_variable].objet,
-					'P')) == NULL)
+					(*(*s_etat_processus).pointeur_variable_partagee_courante)
+					.objet, 'P')) == NULL)
 			{
 				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;
 				}
 
+				if (tableau[i].mutex != NULL)
+				{
+					// La variable est une variable partagée. On libère
+					// le mutex.
+					pthread_mutex_unlock(tableau[i].mutex);
+				}
+
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
 			}
 
 			if (pthread_mutex_unlock(&((*(*s_etat_processus)
-					.s_liste_variables_partagees).mutex)) != 0)
+					.pointeur_variable_partagee_courante).mutex)) != 0)
 			{
+				if (tableau[i].mutex != NULL)
+				{
+					// La variable est une variable partagée. On libère
+					// le mutex.
+					pthread_mutex_unlock(tableau[i].mutex);
+				}
+
 				(*s_etat_processus).erreur_systeme = d_es_processus;
 				return;
 			}
@@ -1276,6 +1299,13 @@ instruction_vars(struct_processus *s_eta
 					.donnee = copie_objet(s_etat_processus, tableau[i].objet,
 					'P')) == NULL)
 			{
+				if (tableau[i].mutex != NULL)
+				{
+					// La variable est une variable partagée. On libère
+					// le mutex.
+					pthread_mutex_unlock(tableau[i].mutex);
+				}
+
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
 			}
@@ -1289,6 +1319,12 @@ instruction_vars(struct_processus *s_eta
 				(*l_element_courant).donnee)).objet)).suivant).suivant)
 				.suivant = allocation_maillon(s_etat_processus)) == NULL)
 		{
+			if (tableau[i].mutex != NULL)
+			{
+				// La variable est une variable partagée. On libère le mutex.
+				pthread_mutex_unlock(tableau[i].mutex);
+			}
+
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
 		}
@@ -1297,6 +1333,12 @@ instruction_vars(struct_processus *s_eta
 				(*l_element_courant).donnee)).objet)).suivant).suivant).suivant)
 				.donnee = allocation(s_etat_processus, CHN)) == NULL)
 		{
+			if (tableau[i].mutex != NULL)
+			{
+				// La variable est une variable partagée. On libère le mutex.
+				pthread_mutex_unlock(tableau[i].mutex);
+			}
+
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
 		}
@@ -1310,13 +1352,31 @@ instruction_vars(struct_processus *s_eta
 					.suivant).donnee).objet = malloc(7 *
 					sizeof(unsigned char))) == NULL)
 			{
+				if (tableau[i].mutex != NULL)
+				{
+					// La variable est une variable partagée. On libère
+					// le mutex.
+					pthread_mutex_unlock(tableau[i].mutex);
+				}
+
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
 			}
 
-			strcpy((unsigned char *) (*(*(*(*(*((struct_liste_chainee *)
-					(*((struct_objet *) (*l_element_courant).donnee)).objet))
-					.suivant).suivant) .suivant).donnee).objet, "STATIC");
+			if (tableau[i].variable_masquee == d_vrai)
+			{
+				strcpy((unsigned char *) (*(*(*(*(*((struct_liste_chainee *)
+						(*((struct_objet *) (*l_element_courant).donnee))
+						.objet)).suivant).suivant).suivant).donnee).objet,
+						"SHADOW");
+			}
+			else
+			{
+				strcpy((unsigned char *) (*(*(*(*(*((struct_liste_chainee *)
+						(*((struct_objet *) (*l_element_courant).donnee))
+						.objet)).suivant).suivant).suivant).donnee).objet,
+						"STATIC");
+			}
 		}
 		else
 		{
@@ -1324,7 +1384,14 @@ instruction_vars(struct_processus *s_eta
 					(*l_element_courant).donnee)).objet)).suivant).suivant)
 					.suivant).donnee).objet = malloc(9 *
 					sizeof(unsigned char))) == NULL)
-			{
+			{ 
+				if (tableau[i].mutex != NULL)
+				{
+					// La variable est une variable partagée. On libère
+					// le mutex.
+					pthread_mutex_unlock(tableau[i].mutex);
+				}
+
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
 			}
@@ -1343,6 +1410,12 @@ instruction_vars(struct_processus *s_eta
 				.suivant).suivant = allocation_maillon(s_etat_processus))
 				== NULL)
 		{
+			if (tableau[i].mutex != NULL)
+			{
+				// La variable est une variable partagée. On libère le mutex.
+				pthread_mutex_unlock(tableau[i].mutex);
+			}
+
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
 		}
@@ -1352,6 +1425,12 @@ instruction_vars(struct_processus *s_eta
 				.suivant).donnee = allocation(s_etat_processus, CHN))
 				== NULL)
 		{
+			if (tableau[i].mutex != NULL)
+			{
+				// La variable est une variable partagée. On libère le mutex.
+				pthread_mutex_unlock(tableau[i].mutex);
+			}
+
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
 		}
@@ -1363,6 +1442,13 @@ instruction_vars(struct_processus *s_eta
 					.suivant).suivant).donnee).objet = malloc(7 *
 					sizeof(unsigned char))) == NULL)
 			{
+				if (tableau[i].mutex != NULL)
+				{
+					// La variable est une variable partagée. On libère
+					// le mutex.
+					pthread_mutex_unlock(tableau[i].mutex);
+				}
+
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
 			}
@@ -1379,6 +1465,13 @@ instruction_vars(struct_processus *s_eta
 					.suivant).suivant).donnee).objet = malloc(9 *
 					sizeof(unsigned char))) == NULL)
 			{
+				if (tableau[i].mutex != NULL)
+				{
+					// La variable est une variable partagée. On libère
+					// le mutex.
+					pthread_mutex_unlock(tableau[i].mutex);
+				}
+
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
 			}
@@ -1390,7 +1483,7 @@ instruction_vars(struct_processus *s_eta
 		}
 
 		/*
-		 * Préparation du drapeau PRIVATE/SHARED
+		 * Préparation du drapeau PRIVATE/SHARED/MAPPED
 		 */
 
 		if (((*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
@@ -1398,6 +1491,12 @@ instruction_vars(struct_processus *s_eta
 				.suivant).suivant).suivant =
 				allocation_maillon(s_etat_processus)) == NULL)
 		{
+			if (tableau[i].mutex != NULL)
+			{
+				// La variable est une variable partagée. On libère le mutex.
+				pthread_mutex_unlock(tableau[i].mutex);
+			}
+
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
 		}
@@ -1407,6 +1506,12 @@ instruction_vars(struct_processus *s_eta
 				.suivant).suivant).donnee = allocation(s_etat_processus,
 				CHN)) == NULL)
 		{
+			if (tableau[i].mutex != NULL)
+			{
+				// La variable est une variable partagée. On libère le mutex.
+				pthread_mutex_unlock(tableau[i].mutex);
+			}
+
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
 		}
@@ -1418,6 +1523,36 @@ instruction_vars(struct_processus *s_eta
 					.suivant).suivant).suivant).donnee).objet = malloc(7 *
 					sizeof(unsigned char))) == NULL)
 			{
+				if (tableau[i].mutex != NULL)
+				{
+					// La variable est une variable partagée. On libère
+					// le mutex.
+					pthread_mutex_unlock(tableau[i].mutex);
+				}
+
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			strcpy((unsigned char *) (*(*(*(*(*(*(*((struct_liste_chainee *)
+					(*((struct_objet *) (*l_element_courant).donnee)).objet))
+					.suivant).suivant).suivant).suivant).suivant).donnee).objet,
+					"MAPPED");
+		}
+		else if (tableau[i].mutex != NULL)
+		{
+			if (((*(*(*(*(*(*(*((struct_liste_chainee *) (*((struct_objet *)
+					(*l_element_courant).donnee)).objet)).suivant).suivant)
+					.suivant).suivant).suivant).donnee).objet = malloc(7 *
+					sizeof(unsigned char))) == NULL)
+			{
+				if (tableau[i].mutex != NULL)
+				{
+					// La variable est une variable partagée. On libère
+					// le mutex.
+					pthread_mutex_unlock(tableau[i].mutex);
+				}
+
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
 			}
@@ -1434,6 +1569,13 @@ instruction_vars(struct_processus *s_eta
 					.suivant).suivant).suivant).donnee).objet = malloc(8 *
 					sizeof(unsigned char))) == NULL)
 			{
+				if (tableau[i].mutex != NULL)
+				{
+					// La variable est une variable partagée. On libère
+					// le mutex.
+					pthread_mutex_unlock(tableau[i].mutex);
+				}
+
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
 			}
@@ -1453,6 +1595,13 @@ instruction_vars(struct_processus *s_eta
 		 		.suivant).suivant).suivant).suivant = NULL;
 
 		l_element_precedent = l_element_courant;
+
+		if (tableau[i].mutex != NULL)
+		{
+			// La variable est une variable partagée. On libère
+			// le mutex.
+			pthread_mutex_unlock(tableau[i].mutex);
+		}
 	}
 
 	free(tableau);
@@ -1486,7 +1635,7 @@ instruction_visit(struct_processus *s_et
 
 	struct_objet						*s_objet;
 
-	unsigned long						profondeur_initiale;
+	integer8							profondeur_initiale;
 
 	(*s_etat_processus).erreur_execution = d_ex;