--- rpl/src/instructions_r6.c	2011/04/11 12:10:10	1.20
+++ rpl/src/instructions_r6.c	2016/09/27 15:29:38	1.67
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.0.prerelease.0
-  Copyright (C) 1989-2011 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.26
+  Copyright (C) 1989-2016 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -109,7 +109,8 @@ instruction_recv(struct_processus *s_eta
 		 * de la structure présente dans la pile opérationnelle.
 		 */
 
-		if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
+		if (pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus))
+				!= 0)
 		{
 			(*s_etat_processus).erreur_systeme_processus_fils =
 					d_es_processus;
@@ -207,7 +208,8 @@ instruction_recv(struct_processus *s_eta
 
 		if (nombre_donnees == -1)
 		{
-			if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
+			if (pthread_mutex_unlock(&((*s_etat_processus)
+					.mutex_pile_processus)) != 0)
 			{
 				(*s_etat_processus).erreur_systeme_processus_fils =
 						d_es_processus;
@@ -223,7 +225,8 @@ instruction_recv(struct_processus *s_eta
 			 * On empile une valeur nulle
 			 */
 
-			if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
+			if (pthread_mutex_unlock(&((*s_etat_processus)
+					.mutex_pile_processus)) != 0)
 			{
 				(*s_etat_processus).erreur_systeme_processus_fils =
 						d_es_processus;
@@ -266,27 +269,23 @@ instruction_recv(struct_processus *s_eta
 		}
 
 #		ifndef SEMAPHORES_NOMMES
-		if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
-		{
-			(*s_etat_processus).erreur_systeme = d_es_processus;
-			return;
-		}
+			if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
 #		else
-		if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+			if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+#		endif
 		{
 			(*s_etat_processus).erreur_systeme = d_es_processus;
 			return;
 		}
-#		endif
 
 		if ((s_objet_resultat = lecture_pipe(s_etat_processus,
 				(*(*((struct_processus_fils *) (*s_objet_argument).objet))
 				.thread).pipe_objets[0])) == NULL)
 		{
 #			ifndef SEMAPHORES_NOMMES
-			while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+				while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #			else
-			while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
+				while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #			endif
 			{
 				if (errno != EINTR)
@@ -313,14 +312,14 @@ instruction_recv(struct_processus *s_eta
 				profilage(s_etat_processus, NULL);
 			}
 
-			pthread_mutex_unlock(&((*s_etat_processus).mutex));
+			pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus));
 			return;
 		}
 
 #		ifndef SEMAPHORES_NOMMES
-		while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+			while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #		else
-		while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
+			while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #		endif
 		{
 			if (errno != EINTR)
@@ -364,7 +363,7 @@ instruction_recv(struct_processus *s_eta
 						= registre_stop;
 			}
 
-			pthread_mutex_unlock(&((*s_etat_processus).mutex));
+			pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus));
 
 			if ((*s_etat_processus).profilage == d_vrai)
 			{
@@ -376,9 +375,9 @@ instruction_recv(struct_processus *s_eta
 		}
 
 #		ifndef SEMAPHORES_NOMMES
-		if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
+			if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
 #		else
-		if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+			if (sem_post((*s_etat_processus).semaphore_fork) != 0)
 #		endif
 		{
 			(*s_etat_processus).erreur_systeme = d_es_processus;
@@ -398,9 +397,9 @@ instruction_recv(struct_processus *s_eta
 		}
 
 #		ifndef SEMAPHORES_NOMMES
-		while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+			while(sem_wait(&((*s_etat_processus).semaphore_fork)) != 0)
 #		else
-		while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
+			while(sem_wait((*s_etat_processus).semaphore_fork) != 0)
 #		endif
 		{
 			if (errno != EINTR)
@@ -428,13 +427,14 @@ instruction_recv(struct_processus *s_eta
 
 		if (sigaction(SIGPIPE, &registre, NULL) != 0)
 		{
-			pthread_mutex_unlock(&((*s_etat_processus).mutex));
+			pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus));
 
 			(*s_etat_processus).erreur_systeme = d_es_signal;
 			return;
 		}
 
-		if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
+		if (pthread_mutex_unlock(&((*s_etat_processus).mutex_pile_processus))
+				!= 0)
 		{
 			(*s_etat_processus).erreur_systeme_processus_fils =
 					d_es_processus;
@@ -496,8 +496,8 @@ instruction_row_fleche(struct_processus
 	struct_objet				*s_objet;
 	struct_objet				*s_objet_elementaire;
 
-	unsigned long				i;
-	unsigned long				j;
+	integer8					i;
+	integer8					j;
 
 	(*s_etat_processus).erreur_execution = d_ex;
 
@@ -569,9 +569,9 @@ instruction_row_fleche(struct_processus
 			}
 
 			if ((((integer8 **) (*((struct_matrice *) (*s_objet_elementaire)
-					.objet)).tableau)[0] = malloc((*((struct_matrice *)
-					(*s_objet_elementaire).objet)).nombre_colonnes *
-					sizeof(integer8))) == NULL)
+					.objet)).tableau)[0] = malloc(((size_t)
+					(*((struct_matrice *) (*s_objet_elementaire).objet))
+					.nombre_colonnes) * sizeof(integer8))) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme =
 						d_es_allocation_memoire;
@@ -621,9 +621,9 @@ instruction_row_fleche(struct_processus
 			}
 
 			if ((((real8 **) (*((struct_matrice *) (*s_objet_elementaire)
-					.objet)).tableau)[0] = malloc((*((struct_matrice *)
-					(*s_objet_elementaire).objet)).nombre_colonnes *
-					sizeof(real8))) == NULL)
+					.objet)).tableau)[0] = malloc(((size_t)
+					(*((struct_matrice *) (*s_objet_elementaire).objet))
+					.nombre_colonnes) * sizeof(real8))) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme =
 						d_es_allocation_memoire;
@@ -673,9 +673,9 @@ instruction_row_fleche(struct_processus
 			}
 
 			if ((((complex16 **) (*((struct_matrice *) (*s_objet_elementaire)
-					.objet)).tableau)[0] = malloc((*((struct_matrice *)
-					(*s_objet_elementaire).objet)).nombre_colonnes *
-					sizeof(complex16))) == NULL)
+					.objet)).tableau)[0] = malloc(((size_t)
+					(*((struct_matrice *) (*s_objet_elementaire).objet))
+					.nombre_colonnes) * sizeof(complex16))) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme =
 						d_es_allocation_memoire;
@@ -797,7 +797,8 @@ instruction_rdate(struct_processus *s_et
 	if ((*s_objet_argument).type == INT)
 	{
 		gettimeofday(&horodatage, NULL);
-		horodatage.tv_sec += (*((integer8 *) (*s_objet_argument).objet));
+		horodatage.tv_sec += (time_t) (*((integer8 *)
+				(*s_objet_argument).objet));
 
 		if (horodatage.tv_sec < 0)
 		{
@@ -1209,6 +1210,7 @@ instruction_rdgn(struct_processus *s_eta
 	long						dernier;
 	long						i;
 	long						j;
+	long						nombre_types;
 	long						premier;
 
     struct_objet                *s_objet_argument;
@@ -1218,8 +1220,6 @@ instruction_rdgn(struct_processus *s_eta
     unsigned char               *requete;
 	unsigned char				**types_generateurs;
 
-	unsigned long				nombre_types;
-
     (*s_etat_processus).erreur_execution = d_ex;
 
     types = gsl_rng_types_setup();
@@ -1254,8 +1254,8 @@ instruction_rdgn(struct_processus *s_eta
         for(nombre_types = 0, type_courant = types;
 				(*type_courant) != NULL; type_courant++, nombre_types++);
 
-		if ((types_generateurs = malloc(nombre_types * sizeof(unsigned char *)))
-				== NULL)
+		if ((types_generateurs = malloc(((size_t) nombre_types) *
+				sizeof(unsigned char *))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
@@ -1320,7 +1320,7 @@ instruction_rdgn(struct_processus *s_eta
 			premier = j;
 		}
 
-		for(i = 0; i < (long) nombre_types; i++)
+		for(i = 0; i < nombre_types; i++)
 		{
             printf("  - %s\n", types_generateurs[i]);
 			free(types_generateurs[i]);
@@ -1352,7 +1352,7 @@ instruction_rdgn(struct_processus *s_eta
 
 	if ((*s_objet_argument).type == CHN)
 	{
-		if ((requete = conversion_majuscule((unsigned char *)
+		if ((requete = conversion_majuscule(s_etat_processus, (unsigned char *)
 				(*s_objet_argument).objet)) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
@@ -1388,7 +1388,7 @@ instruction_rdgn(struct_processus *s_eta
 			else
 			{
 				if (((*s_objet_resultat).objet = conversion_majuscule(
-						(unsigned char *) gsl_rng_name(
+						s_etat_processus, (unsigned char *) gsl_rng_name(
 						(*s_etat_processus).generateur_aleatoire))) == NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
@@ -1642,15 +1642,15 @@ instruction_recode(struct_processus *s_e
 			((*s_objet_argument_2).type == CHN) &&
 			((*s_objet_argument_3).type == CHN))
 	{
-		if ((encodage_source = conversion_majuscule((unsigned char *)
-				(*s_objet_argument_2).objet)) == NULL)
+		if ((encodage_source = conversion_majuscule(s_etat_processus,
+				(unsigned char *) (*s_objet_argument_2).objet)) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
 		}
 
-		if ((encodage_destination = conversion_majuscule((unsigned char *)
-				(*s_objet_argument_1).objet)) == NULL)
+		if ((encodage_destination = conversion_majuscule(s_etat_processus,
+				(unsigned char *) (*s_objet_argument_1).objet)) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
@@ -1718,13 +1718,12 @@ instruction_recode(struct_processus *s_e
 void
 instruction_repl(struct_processus *s_etat_processus)
 {
+	integer8						difference;
+	integer8						difference_ecriture;
+	integer8						difference_lecture;
+	integer8						nombre_occurrences;
 	integer8						position;
 
-	long							difference;
-	long							difference_ecriture;
-	long							difference_lecture;
-	long							nombre_occurrences;
-
 	struct_liste_chainee			*l_element_a_supprimer;
 	struct_liste_chainee			*l_element_courant;
 	struct_liste_chainee			*l_element_courant_2;
@@ -1843,8 +1842,9 @@ instruction_repl(struct_processus *s_eta
 		// Différence est positive si la nouvelle chaîne est plus longue
 		// que la chaîne originelle.
 
-		difference = strlen((unsigned char *) (*s_objet_argument_1).objet)
-				- strlen((unsigned char *) (*s_objet_argument_2).objet);
+		difference = ((integer8) strlen((unsigned char *) (*s_objet_argument_1)
+				.objet)) - ((integer8) strlen((unsigned char *)
+				(*s_objet_argument_2).objet));
 
 		if ((s_objet_resultat = allocation(s_etat_processus, CHN)) == NULL)
 		{
@@ -1853,8 +1853,8 @@ instruction_repl(struct_processus *s_eta
 		}
 
 		if (((*s_objet_resultat).objet = malloc((strlen((unsigned char *)
-				(*s_objet_argument_3).objet) + (nombre_occurrences *
-				difference) + 1) * sizeof(unsigned char))) == NULL)
+				(*s_objet_argument_3).objet) + ((size_t) (nombre_occurrences *
+				difference)) + 1) * sizeof(unsigned char))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
@@ -1862,9 +1862,9 @@ instruction_repl(struct_processus *s_eta
 
 		pointeur_lecture = (unsigned char *) (*s_objet_argument_3).objet;
 		pointeur_ecriture = (unsigned char *) (*s_objet_resultat).objet;
-		difference_lecture = strlen((unsigned char *)
+		difference_lecture = (integer8) strlen((unsigned char *)
 				(*s_objet_argument_2).objet);
-		difference_ecriture = strlen((unsigned char *)
+		difference_ecriture = (integer8) strlen((unsigned char *)
 				(*s_objet_argument_1).objet);
 
 		for(;;)
@@ -1882,7 +1882,7 @@ instruction_repl(struct_processus *s_eta
 			}
 
 			strncpy(ancien_pointeur_ecriture, ancien_pointeur_lecture,
-					pointeur_lecture - ancien_pointeur_lecture);
+					(size_t) (pointeur_lecture - ancien_pointeur_lecture));
 			strcpy(ancien_pointeur_ecriture +
 					(pointeur_lecture - ancien_pointeur_lecture),
 					(unsigned char *) (*s_objet_argument_1).objet);