--- rpl/src/analyse.c	2013/02/26 19:56:11	1.80
+++ rpl/src/analyse.c	2015/06/08 14:11:28	1.100
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.12
-  Copyright (C) 1989-2013 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.22
+  Copyright (C) 1989-2015 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -61,7 +61,7 @@ creation_instruction(struct_processus *s
 		(*(*s_etat_processus).arbre_instructions).feuille = NULL;
 
 		if (((*(*s_etat_processus).arbre_instructions).noeuds =
-				malloc((*s_etat_processus).nombre_caracteres
+				malloc(((size_t) (*s_etat_processus).nombre_caracteres)
 				* sizeof(struct_instruction))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
@@ -101,7 +101,7 @@ creation_instruction(struct_processus *s
 
 			if (((*(*l_instruction_courante).noeuds[(*s_etat_processus)
 					.pointeurs_caracteres[*ptr]]).noeuds =
-					malloc((*s_etat_processus).nombre_caracteres
+					malloc(((size_t) (*s_etat_processus).nombre_caracteres)
 					* sizeof(struct_instruction))) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
@@ -180,7 +180,7 @@ initialisation_instructions(struct_proce
 	}
 
 	if (((*s_etat_processus).pointeurs_caracteres =
-			malloc(longueur_tableau * sizeof(int))) == NULL)
+			malloc(((size_t) longueur_tableau * sizeof(int)))) == NULL)
 	{
 		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 		return;
@@ -323,6 +323,7 @@ initialisation_instructions(struct_proce
 	INSTRUCTION("EGV", instruction_egv);
 	INSTRUCTION("END", instruction_end);
 	INSTRUCTION("ENG", instruction_eng);
+	INSTRUCTION("EQV", instruction_eqv);
 	INSTRUCTION("EXP", instruction_exp);
 	INSTRUCTION("FC?", instruction_fc_test);
 	INSTRUCTION("FFT", instruction_fft);
@@ -513,6 +514,8 @@ initialisation_instructions(struct_proce
 	INSTRUCTION("RECV", instruction_recv);
 	INSTRUCTION("REGV", instruction_regv);
 	INSTRUCTION("REPL", instruction_repl);
+	INSTRUCTION("RGDL", instruction_rgdl);
+	INSTRUCTION("RGDR", instruction_rgdr);
 	INSTRUCTION("RNRM", instruction_rnrm);
 	INSTRUCTION("ROLL", instruction_roll);
 	//INSTRUCTION("ROOT")
@@ -842,6 +845,7 @@ initialisation_instructions(struct_proce
 
 	INSTRUCTION("CLRCNTXT", instruction_clrcntxt);
 	INSTRUCTION("CLRSMPHR", instruction_clrsmphr);
+	INSTRUCTION("COMPRESS", instruction_compress);
 	INSTRUCTION("CONTINUE", instruction_continue);
 	INSTRUCTION("CRITICAL", instruction_critical);
 	INSTRUCTION("DUPCNTXT", instruction_dupcntxt);
@@ -901,6 +905,7 @@ initialisation_instructions(struct_proce
 	//pentes
 	//représentent la valeur de la fonction (x,y) en leur milieu.
 	//=> utile pour y'=F(x,y)
+	INSTRUCTION("UNCOMPRESS", instruction_uncompress);
 
 	INSTRUCTION("LOCALIZATION", instruction_localization);
 	INSTRUCTION("SMPHRTRYDECR", instruction_smphrtrydecr);
@@ -962,8 +967,6 @@ analyse_instruction(struct_processus *s_
 void
 analyse(struct_processus *s_etat_processus, void (*fonction)())
 {
-	static logical1					initialisation = d_faux;
-
 	real8							attente;
 	real8							pourcentage;
 	real8							temps_cpu;
@@ -1103,8 +1106,8 @@ analyse(struct_processus *s_etat_process
 		if ((position = index((*s_etat_processus).instruction_courante, '$'))
 				!= NULL)
 		{
-			if ((bibliotheque_candidate = malloc((position + 1
-					- (*s_etat_processus).instruction_courante)
+			if ((bibliotheque_candidate = malloc(((size_t) (position + 1
+					- (*s_etat_processus).instruction_courante))
 					* sizeof(unsigned char))) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
@@ -1113,8 +1116,8 @@ analyse(struct_processus *s_etat_process
 
 			(*bibliotheque_candidate) = d_code_fin_chaine;
 			strncat(bibliotheque_candidate,
-					(*s_etat_processus).instruction_courante,
-					position - (*s_etat_processus).instruction_courante);
+					(*s_etat_processus).instruction_courante, ((size_t)
+					(position - (*s_etat_processus).instruction_courante)));
 
 			position++;
 
@@ -1159,9 +1162,23 @@ analyse(struct_processus *s_etat_process
 	{
 		if ((*s_etat_processus).test_instruction == 'N')
 		{
-			if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
+			if (pthread_mutex_lock(&(*s_etat_processus).mutex_interruptions)
+					!= 0)
 			{
-				affectation_interruptions_logicielles(s_etat_processus);
+				(*s_etat_processus).erreur_systeme = d_es_processus;
+			}
+			else
+			{
+				if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
+				{
+					affectation_interruptions_logicielles(s_etat_processus);
+				}
+
+				if (pthread_mutex_unlock(&(*s_etat_processus)
+						.mutex_interruptions) != 0)
+				{
+					(*s_etat_processus).erreur_systeme = d_es_processus;
+				}
 			}
 
 			if (((*s_etat_processus).nombre_interruptions_en_queue != 0) &&
@@ -1194,7 +1211,7 @@ analyse(struct_processus *s_etat_process
 
 		gettimeofday(&horodatage_final, NULL);
 
-		if (initialisation == d_vrai)
+		if ((*s_etat_processus).initialisation_scheduler == d_vrai)
 		{
 			temps_reel = ((real8) (horodatage_final.tv_sec -
 					horodatage_initial.tv_sec)) +
@@ -1232,9 +1249,9 @@ analyse(struct_processus *s_etat_process
 							(*s_etat_processus).pourcentage_maximal_cpu)
 							- (pourcentage * temps_cpu / 100);
 
-					temporisation.tv_sec = floor(attente);
-					temporisation.tv_nsec = (attente - temporisation.tv_sec) *
-							1E9;
+					temporisation.tv_sec = (time_t) floor(attente);
+					temporisation.tv_nsec = (suseconds_t) ((attente
+							- ((real8) temporisation.tv_sec)) * 1E9);
 
 					while(nanosleep(&temporisation, &temporisation) == -1)
 					{
@@ -1251,7 +1268,7 @@ analyse(struct_processus *s_etat_process
 		}
 		else
 		{
-			initialisation = d_vrai;
+			(*s_etat_processus).initialisation_scheduler = d_vrai;
 
 			horodatage_initial = horodatage_final;
 			usage_initial = usage_final;
@@ -1259,7 +1276,7 @@ analyse(struct_processus *s_etat_process
 	}
 	else
 	{
-		initialisation = d_faux;
+		(*s_etat_processus).initialisation_scheduler = d_faux;
 	}
 
 /*