--- rpl/src/instructions_w1.c	2012/10/01 11:05:07	1.67
+++ rpl/src/instructions_w1.c	2013/05/28 22:09:55	1.84
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.11
-  Copyright (C) 1989-2012 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.14
+  Copyright (C) 1989-2013 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -245,9 +245,9 @@ instruction_wait(struct_processus *s_eta
 			return;
 		}
 
-		temporisation.tv_sec = (long) floor((double) attente);
-		temporisation.tv_nsec = (attente - temporisation.tv_sec) *
-				(long) 1000000000;
+		temporisation.tv_sec = (time_t) floor((double) attente);
+		temporisation.tv_nsec = (long) ((attente -
+				((real8) temporisation.tv_sec)) * (integer8) 1000000000);
 
 		if ((*s_etat_processus).profilage == d_vrai)
 		{
@@ -289,11 +289,25 @@ instruction_wait(struct_processus *s_eta
 
 			scrutation_injection(s_etat_processus);
 
+			if (pthread_mutex_lock(&(*s_etat_processus).mutex_interruptions)
+					!= 0)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_processus;
+				return;
+			}
+
 			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;
+				return;
+			}
+
 			if ((*s_etat_processus).nombre_interruptions_en_queue != 0)
 			{
 				traitement_interruptions_logicielles(s_etat_processus);
@@ -385,18 +399,19 @@ instruction_write(struct_processus *s_et
 
 	int									adresse[16];
 	int									port;
+	int									sqlite_status;
 
 	integer8							clef;
 	integer8							compteur;
 	integer8							id;
+	integer8							longueur;
+	integer8							longueur_effective;
 	integer8							ordre;
+	integer8							recursivite;
 
 	logical1							format_degenere;
 	logical1							mise_a_jour;
 
-	long								longueur;
-	long								longueur_effective;
-	long								recursivite;
 
 	sqlite3_stmt						*ppStmt;
 
@@ -424,6 +439,8 @@ instruction_write(struct_processus *s_et
 
 	struct flock						lock;
 
+	struct timespec						attente;
+
 	uint32_t							calcul_adresse;
 
 	unsigned char						*chaine;
@@ -589,7 +606,7 @@ instruction_write(struct_processus *s_et
 				if ((chaine = formateur_fichier(s_etat_processus,
 						s_objet_argument_2, (*((struct_fichier *)
 						(*s_objet_argument_1).objet)).format, 0, 0, ' ', 'F',
-						&longueur_effective, &recursivite)) == NULL)
+						&longueur_effective, &recursivite, d_vrai)) == NULL)
 				{
 					liberation(s_etat_processus, s_objet_argument_2);
 					liberation(s_etat_processus, s_objet_argument_1);
@@ -671,7 +688,8 @@ instruction_write(struct_processus *s_et
 				if ((chaine = formateur_fichier(s_etat_processus,
 						s_objet_argument_3, (*((struct_fichier *)
 						(*s_objet_argument_1).objet)).format, 0, 0, ' ',
-						'F', &longueur_effective, &recursivite)) == NULL)
+						'F', &longueur_effective, &recursivite, d_vrai))
+						== NULL)
 				{
 					liberation(s_etat_processus, s_objet_argument_3);
 					liberation(s_etat_processus, s_objet_argument_2);
@@ -706,7 +724,7 @@ instruction_write(struct_processus *s_et
 				free(chaine_utf8);
 
 				if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
-						commande, strlen(commande), &ppStmt, &queue)
+						commande, (int) strlen(commande), &ppStmt, &queue)
 						!= SQLITE_OK)
 				{
 					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
@@ -753,18 +771,37 @@ instruction_write(struct_processus *s_et
 				}
 
 				if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
-						commande, strlen(commande), &ppStmt, &queue)
+						commande, (int) strlen(commande), &ppStmt, &queue)
 						!= SQLITE_OK)
 				{
 					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
 					return;
 				}
 
-				if (sqlite3_step(ppStmt) != SQLITE_ROW)
+				attente.tv_sec = 0;
+				attente.tv_nsec = GRANULARITE_us * 1000;
+
+				do
 				{
-					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
-					return;
-				}
+					sqlite_status = sqlite3_step(ppStmt);
+
+					if (sqlite_status == SQLITE_ROW)
+					{
+						break;
+					}
+					else if ((sqlite_status == SQLITE_BUSY) ||
+							(sqlite_status == SQLITE_LOCKED))
+					{
+						nanosleep(&attente, NULL);
+						INCR_GRANULARITE(attente.tv_nsec);
+					}
+					else
+					{
+						(*s_etat_processus).erreur_systeme =
+								d_es_erreur_fichier;
+						return;
+					}
+				} while(sqlite_status != SQLITE_ROW);
 
 				if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
 				{
@@ -875,7 +912,8 @@ instruction_write(struct_processus *s_et
 
 				if ((chaine = formateur_fichier(s_etat_processus,
 						s_element, s_format, 0, 0, ' ',
-						'F', &longueur_effective, &recursivite)) == NULL)
+						'F', &longueur_effective, &recursivite, d_vrai))
+						== NULL)
 				{
 					liberation(s_etat_processus, s_element);
 					liberation(s_etat_processus, s_format);
@@ -910,107 +948,114 @@ instruction_write(struct_processus *s_et
 				}
 
 				if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
-						commande, strlen(commande), &ppStmt, &queue)
+						commande, (int) strlen(commande), &ppStmt, &queue)
 						!= SQLITE_OK)
 				{
 					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
 					return;
 				}
 
-				switch(sqlite3_step(ppStmt))
+				attente.tv_sec = 0;
+				attente.tv_nsec = GRANULARITE_us * 1000;
+
+				do
 				{
-					case SQLITE_ROW:
+					switch(sqlite_status = sqlite3_step(ppStmt))
 					{
-						// Une clef existe.
+						case SQLITE_ROW:
+						{
+							// Une clef existe.
 
-						mise_a_jour = d_vrai;
-						break;
-					}
+							mise_a_jour = d_vrai;
+							break;
+						}
 
-					case SQLITE_DONE:
-					{
-						// Aucune clef n'existe.
+						case SQLITE_DONE:
+						{
+							// Aucune clef n'existe.
 
-						mise_a_jour = d_faux;
+							mise_a_jour = d_faux;
 
-						if (sqlite3_finalize(ppStmt) != SQLITE_OK)
-						{
-							(*s_etat_processus).erreur_systeme =
-									d_es_erreur_fichier;
-							return;
-						}
+							if (sqlite3_finalize(ppStmt) != SQLITE_OK)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_erreur_fichier;
+								return;
+							}
 
-						free(commande);
+							free(commande);
 
-						if (alsprintf(&commande, "insert into key "
-								"(key) values ('%s')", clef_utf8) < 0)
-						{
-							(*s_etat_processus).erreur_systeme =
-									d_es_allocation_memoire;
-							return;
-						}
+							if (alsprintf(&commande, "insert into key "
+									"(key) values ('%s')", clef_utf8) < 0)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_allocation_memoire;
+								return;
+							}
 
-						if (sqlite3_prepare_v2((*descripteur)
-								.descripteur_sqlite,
-								commande, strlen(commande), &ppStmt, &queue)
-								!= SQLITE_OK)
-						{
-							(*s_etat_processus).erreur_systeme =
-									d_es_erreur_fichier;
-							return;
-						}
+							if (sqlite3_prepare_v2((*descripteur)
+									.descripteur_sqlite, commande,
+									(int) strlen(commande), &ppStmt, &queue)
+									!= SQLITE_OK)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_erreur_fichier;
+								return;
+							}
 
-						if (sqlite3_step(ppStmt) != SQLITE_DONE)
-						{
-							(*s_etat_processus).erreur_systeme =
-									d_es_erreur_fichier;
-							return;
-						}
+							if (sqlite3_step(ppStmt) != SQLITE_DONE)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_erreur_fichier;
+								return;
+							}
 
-						if (sqlite3_finalize(ppStmt) != SQLITE_OK)
-						{
-							(*s_etat_processus).erreur_systeme =
-									d_es_erreur_fichier;
-							return;
-						}
+							if (sqlite3_finalize(ppStmt) != SQLITE_OK)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_erreur_fichier;
+								return;
+							}
 
-						free(commande);
+							free(commande);
 
-						if (alsprintf(&commande, "select id from key "
-								"where key = '%s'", clef_utf8) < 0)
-						{
-							(*s_etat_processus).erreur_systeme =
-									d_es_allocation_memoire;
-							return;
+							if (alsprintf(&commande, "select id from key "
+									"where key = '%s'", clef_utf8) < 0)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_allocation_memoire;
+								return;
+							}
+
+							if (sqlite3_prepare_v2((*descripteur)
+									.descripteur_sqlite, commande,
+									(int) strlen(commande), &ppStmt, &queue)
+									!= SQLITE_OK)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_erreur_fichier;
+								return;
+							}
+
+							break;
 						}
 
-						if (sqlite3_prepare_v2((*descripteur)
-								.descripteur_sqlite,
-								commande, strlen(commande), &ppStmt, &queue)
-								!= SQLITE_OK)
+						case SQLITE_BUSY:
+						case SQLITE_LOCKED:
 						{
-							(*s_etat_processus).erreur_systeme =
-									d_es_erreur_fichier;
-							return;
+							nanosleep(&attente, NULL);
+							INCR_GRANULARITE(attente.tv_nsec);
+							break;
 						}
 
-						if (sqlite3_step(ppStmt) != SQLITE_ROW)
+						default:
 						{
 							(*s_etat_processus).erreur_systeme =
 									d_es_erreur_fichier;
 							return;
 						}
-
-						break;
 					}
-
-					default:
-					{
-						(*s_etat_processus).erreur_systeme =
-								d_es_erreur_fichier;
-						return;
-					}
-				}
+				} while(sqlite_status != SQLITE_ROW);
 
 				if (sqlite3_column_type(ppStmt, 0) != SQLITE_INTEGER)
 				{
@@ -1047,7 +1092,7 @@ instruction_write(struct_processus *s_et
 					}
 
 					if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
-							commande, strlen(commande), &ppStmt, &queue)
+							commande, (int) strlen(commande), &ppStmt, &queue)
 							!= SQLITE_OK)
 					{
 						(*s_etat_processus).erreur_systeme =
@@ -1083,7 +1128,7 @@ instruction_write(struct_processus *s_et
 				}
 
 				if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
-						commande, strlen(commande), &ppStmt, &queue)
+						commande, (int) strlen(commande), &ppStmt, &queue)
 						!= SQLITE_OK)
 				{
 					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
@@ -1182,7 +1227,8 @@ instruction_write(struct_processus *s_et
 
 					if ((chaine = formateur_fichier(s_etat_processus,
 							s_element, s_format, 0, 0, ' ',
-							'F', &longueur_effective, &recursivite)) == NULL)
+							'F', &longueur_effective, &recursivite, d_vrai))
+							== NULL)
 					{
 						free(clef_utf8);
 
@@ -1218,7 +1264,7 @@ instruction_write(struct_processus *s_et
 					}
 
 					if (sqlite3_prepare_v2((*descripteur).descripteur_sqlite,
-							commande, strlen(commande), &ppStmt, &queue)
+							commande, (int) strlen(commande), &ppStmt, &queue)
 							!= SQLITE_OK)
 					{
 						(*s_etat_processus).erreur_systeme =
@@ -1275,20 +1321,30 @@ instruction_write(struct_processus *s_et
 			 * Fichiers non formatés
 			 */
 
-			if ((chaine = formateur_fichier(s_etat_processus,
-					s_objet_argument_2, (*((struct_fichier *)
-					(*s_objet_argument_1).objet)).format, 0, 0, ' ', 'U',
-					&longueur_effective, &recursivite)) == NULL)
-			{
-				liberation(s_etat_processus, s_objet_argument_2);
-				liberation(s_etat_processus, s_objet_argument_1);
-
-				return;
-			}
-
 			if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
 					== 'S')
 			{
+				if ((*s_objet_argument_2).type != LST)
+				{
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_1);
+
+					(*s_etat_processus).erreur_execution =
+							d_ex_erreur_type_argument;
+					return;
+				}
+
+				if ((chaine = formateur_fichier(s_etat_processus,
+						s_objet_argument_2, (*((struct_fichier *)
+						(*s_objet_argument_1).objet)).format, 0, 0, ' ', 'U',
+						&longueur_effective, &recursivite, d_vrai)) == NULL)
+				{
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_1);
+
+					return;
+				}
+
 				BUG(((*descripteur).type != 'C'), uprintf("Bad filetype !\n"));
 
 				if (fseek((*descripteur).descripteur_c, (long) 0, SEEK_END)
@@ -1301,7 +1357,8 @@ instruction_write(struct_processus *s_et
 					return;
 				}
 
-				if (fwrite(chaine, sizeof(unsigned char), longueur_effective,
+				if (fwrite(chaine, sizeof(unsigned char),
+						(size_t) longueur_effective,
 						(*descripteur).descripteur_c) !=
 						(size_t) longueur_effective)
 				{
@@ -1312,10 +1369,67 @@ instruction_write(struct_processus *s_et
 			else if ((*((struct_fichier *) (*s_objet_argument_1).objet)).acces
 					== 'D')
 			{
+				if ((*s_objet_argument_2).type != INT)
+				{
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_1);
+
+					(*s_etat_processus).erreur_execution =
+							d_ex_erreur_type_argument;
+					return;
+				}
+
+				if (depilement(s_etat_processus, &((*s_etat_processus)
+						.l_base_pile), &s_objet_argument_3) == d_erreur)
+				{
+					(*s_etat_processus).erreur_execution = d_ex_manque_argument;
+					return;
+				}
+
+				if ((*s_objet_argument_3).type != LST)
+				{
+					liberation(s_etat_processus, s_objet_argument_3);
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_1);
+
+					(*s_etat_processus).erreur_execution =
+							d_ex_erreur_type_argument;
+					return;
+				}
+
+				if ((chaine = formateur_fichier(s_etat_processus,
+						s_objet_argument_2, (*((struct_fichier *)
+						(*s_objet_argument_1).objet)).format, 0, 0, ' ', 'U',
+						&longueur_effective, &recursivite, d_faux)) == NULL)
+				{
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_1);
+
+					return;
+				}
 			}
-			else
+			else // Fichiers indexés
 			{
-				/* Fichiers indexés : panique totale ! */
+				if ((*s_objet_argument_2).type != LST)
+				{
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_1);
+
+					(*s_etat_processus).erreur_execution =
+							d_ex_erreur_type_argument;
+					return;
+				}
+
+				if ((chaine = formateur_fichier(s_etat_processus,
+						s_objet_argument_2, (*((struct_fichier *)
+						(*s_objet_argument_1).objet)).format, 0, 0, ' ', 'U',
+						&longueur_effective, &recursivite, d_faux)) == NULL)
+				{
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_1);
+
+					return;
+				}
 			}
 
 			free(chaine);
@@ -1401,7 +1515,7 @@ instruction_write(struct_processus *s_et
 						return;
 					}
 
-					longueur = strlen(format_chaine);
+					longueur = (integer8) strlen(format_chaine);
 
 					if (format_chaine[longueur - 1] != ')')
 					{
@@ -1426,7 +1540,7 @@ instruction_write(struct_processus *s_et
 						// Détermination de la longueur
 						format_degenere = d_faux;
 
-						if (sscanf(&(format_chaine[8]), "%ld", &longueur) != 1)
+						if (sscanf(&(format_chaine[8]), "%lld", &longueur) != 1)
 						{
 							free(format_chaine);
 
@@ -1454,7 +1568,7 @@ instruction_write(struct_processus *s_et
 							(longueur_effective < longueur))
 					{
 						if (fwrite(chaine, sizeof(unsigned char),
-								longueur_effective,
+								(size_t) longueur_effective,
 								(*descripteur).descripteur_c) !=
 								(size_t) longueur_effective)
 						{
@@ -1466,7 +1580,7 @@ instruction_write(struct_processus *s_et
 					else
 					{
 						if (fwrite(chaine, sizeof(unsigned char),
-								longueur_effective,
+								(size_t) longueur_effective,
 								(*descripteur).descripteur_c) !=
 								(size_t) longueur)
 						{
@@ -1531,7 +1645,7 @@ instruction_write(struct_processus *s_et
 			if ((chaine = formateur_fichier(s_etat_processus,
 					s_objet_argument_2, (*((struct_socket *)
 					(*s_objet_argument_1).objet)).format, 0, 0, ' ', 'F',
-					&longueur_effective, &recursivite)) == NULL)
+					&longueur_effective, &recursivite, d_faux)) == NULL)
 			{
 				liberation(s_etat_processus, s_objet_argument_2);
 				liberation(s_etat_processus, s_objet_argument_1);
@@ -1546,7 +1660,16 @@ instruction_write(struct_processus *s_et
 			 * Sockets non formatées
 			 */
 
-			chaine = NULL;
+			if ((chaine = formateur_fichier(s_etat_processus,
+					s_objet_argument_2, (*((struct_socket *)
+					(*s_objet_argument_1).objet)).format, 0, 0, ' ', 'U',
+					&longueur_effective, &recursivite, d_faux)) == NULL)
+			{
+				liberation(s_etat_processus, s_objet_argument_2);
+				liberation(s_etat_processus, s_objet_argument_1);
+
+				return;
+			}
 		}
 		else
 		{
@@ -1608,7 +1731,7 @@ instruction_write(struct_processus *s_et
 			}
 
 			if (send((*((struct_socket *) (*s_objet_argument_1).objet))
-					.socket, chaine, longueur_effective, 0) < 0)
+					.socket, chaine, (size_t) longueur_effective, 0) < 0)
 			{
 				ios = errno;
 
@@ -1711,7 +1834,7 @@ instruction_write(struct_processus *s_et
 
 				if (sendto((*((struct_socket *)
 						(*s_objet_argument_1).objet)).socket, chaine,
-						longueur_effective, 0, (struct sockaddr *)
+						(size_t) longueur_effective, 0, (struct sockaddr *)
 						&adresse_unix, sizeof(adresse_unix)) < 0)
 				{
 					ios = errno;
@@ -1737,6 +1860,12 @@ instruction_write(struct_processus *s_et
 						return;
 					}
 
+					if (ios == EMSGSIZE)
+					{
+						(*s_etat_processus).erreur_execution =
+								d_ex_taille_message;
+						return;
+					}
 
 					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
 					return;
@@ -1766,11 +1895,12 @@ instruction_write(struct_processus *s_et
 				{ // Adresse IPv4
 					calcul_adresse = 0;
 					for(i = 0; i < 4; calcul_adresse =
-							(256 * calcul_adresse) + adresse[i++]);
+							(256 * calcul_adresse) +
+							((unsigned char) adresse[i++]));
 
 					memset(&adresse_ipv4, 0, sizeof(adresse_ipv4));
 					adresse_ipv4.sin_family = AF_INET;
-					adresse_ipv4.sin_port = htons(port);
+					adresse_ipv4.sin_port = htons((uint16_t) port);
 					adresse_ipv4.sin_addr.s_addr = htonl(calcul_adresse);
 
 #					ifndef SEMAPHORES_NOMMES
@@ -1786,9 +1916,11 @@ instruction_write(struct_processus *s_et
 
 					if (sendto((*((struct_socket *)
 							(*s_objet_argument_1).objet)).socket, chaine,
-							longueur_effective, 0, (struct sockaddr *)
+							(size_t) longueur_effective, 0, (struct sockaddr *)
 							&adresse_ipv4, sizeof(adresse_ipv4)) < 0)
 					{
+						ios = errno;
+
 #						ifndef SEMAPHORES_NOMMES
 							while(sem_wait(&((*s_etat_processus)
 									.semaphore_fork)) != 0)
@@ -1805,6 +1937,20 @@ instruction_write(struct_processus *s_et
 							}
 						}
 
+						if ((ios == EPIPE) || (ios == ECONNRESET))
+						{
+							(*s_etat_processus).erreur_execution =
+									d_ex_erreur_acces_fichier;
+							return;
+						}
+
+						if (ios == EMSGSIZE)
+						{
+							(*s_etat_processus).erreur_execution =
+									d_ex_taille_message;
+							return;
+						}
+
 						(*s_etat_processus).erreur_systeme =
 								d_es_erreur_fichier;
 						return;
@@ -1854,7 +2000,7 @@ instruction_write(struct_processus *s_et
 
 					for(i = 0; i < 16;
 							adresse_ipv6.sin6_addr.s6_addr[i] =
-							adresse[i], i++);
+							(unsigned char) adresse[i], i++);
 
 #					ifndef SEMAPHORES_NOMMES
 						if (sem_post(&((*s_etat_processus).semaphore_fork))
@@ -1869,9 +2015,11 @@ instruction_write(struct_processus *s_et
 
 					if (sendto((*((struct_socket *)
 							(*s_objet_argument_1).objet)).socket, chaine,
-							longueur_effective, 0, (struct sockaddr *)
+							(size_t) longueur_effective, 0, (struct sockaddr *)
 							&adresse_ipv6, sizeof(adresse_ipv6)) < 0)
 					{
+						ios = errno;
+
 #						ifndef SEMAPHORES_NOMMES
 							while(sem_wait(&((*s_etat_processus)
 									.semaphore_fork)) != 0)
@@ -1888,6 +2036,20 @@ instruction_write(struct_processus *s_et
 							}
 						}
 
+						if ((ios == EPIPE) || (ios == ECONNRESET))
+						{
+							(*s_etat_processus).erreur_execution =
+									d_ex_erreur_acces_fichier;
+							return;
+						}
+
+						if (ios == EMSGSIZE)
+						{
+							(*s_etat_processus).erreur_execution =
+									d_ex_taille_message;
+							return;
+						}
+
 						(*s_etat_processus).erreur_systeme =
 								d_es_erreur_fichier;
 						return;
@@ -2131,13 +2293,26 @@ instruction_wflock(struct_processus *s_e
 			}
 			else
 			{
+				if (pthread_mutex_lock(&(*s_etat_processus).mutex_interruptions)
+						!= 0)
+				{
+					(*s_etat_processus).erreur_systeme = d_es_processus;
+					return;
+				}
+
 				if ((*s_etat_processus).nombre_interruptions_non_affectees != 0)
 				{
 					affectation_interruptions_logicielles(s_etat_processus);
 				}
 
-				if ((*s_etat_processus).nombre_interruptions_en_queue
-						!= 0)
+				if (pthread_mutex_unlock(&(*s_etat_processus)
+						.mutex_interruptions) != 0)
+				{
+					(*s_etat_processus).erreur_systeme = d_es_processus;
+					return;
+				}
+
+				if ((*s_etat_processus).nombre_interruptions_en_queue != 0)
 				{
 					registre_instruction_valide =
 							(*s_etat_processus).instruction_valide;
@@ -2396,8 +2571,11 @@ instruction_wfproc(struct_processus *s_e
 					 * Le processus n'est pas terminé
 					 */
 
-					if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
+					if (pthread_mutex_lock(&((*s_etat_processus)
+							.mutex_interruptions)) != 0)
 					{
+						pthread_mutex_unlock(&((*s_etat_processus).mutex));
+
 						if ((*s_etat_processus).profilage == d_vrai)
 						{
 							profilage(s_etat_processus, NULL);
@@ -2414,8 +2592,34 @@ instruction_wfproc(struct_processus *s_e
 						affectation_interruptions_logicielles(s_etat_processus);
 					}
 
-					if ((*s_etat_processus).nombre_interruptions_en_queue
-							!= 0)
+					if (pthread_mutex_unlock(&((*s_etat_processus)
+							.mutex_interruptions)) != 0)
+					{
+						pthread_mutex_unlock(&((*s_etat_processus).mutex));
+
+						if ((*s_etat_processus).profilage == d_vrai)
+						{
+							profilage(s_etat_processus, NULL);
+						}
+
+						(*s_etat_processus).erreur_systeme =
+								d_es_processus;
+						return;
+					}
+
+					if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
+					{
+						if ((*s_etat_processus).profilage == d_vrai)
+						{
+							profilage(s_etat_processus, NULL);
+						}
+
+						(*s_etat_processus).erreur_systeme =
+								d_es_processus;
+						return;
+					}
+
+					if ((*s_etat_processus).nombre_interruptions_en_queue != 0)
 					{
 						registre_instruction_valide =
 								(*s_etat_processus).instruction_valide;
@@ -2723,12 +2927,26 @@ instruction_wfdata(struct_processus *s_e
 
 					scrutation_injection(s_etat_processus);
 
+					if (pthread_mutex_lock(&(*s_etat_processus)
+							.mutex_interruptions) != 0)
+					{
+						(*s_etat_processus).erreur_systeme = d_es_processus;
+						return;
+					}
+
 					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;
+						return;
+					}
+
 					if ((*s_etat_processus).nombre_interruptions_en_queue != 0)
 					{
 						registre_instruction_valide =
@@ -3459,11 +3677,25 @@ instruction_wfswi(struct_processus *s_et
 				return;
 			}
 
+			if (pthread_mutex_lock(&(*s_etat_processus).mutex_interruptions)
+					!= 0)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_processus;
+				return;
+			}
+
 			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;
+				return;
+			}
+
 			if ((*s_etat_processus).queue_interruptions[interruption - 1] > 0)
 			{
 				drapeau_fin = d_vrai;
@@ -3596,11 +3828,23 @@ instruction_wfpoke(struct_processus *s_e
 
 		scrutation_injection(s_etat_processus);
 
+		if (pthread_mutex_lock(&(*s_etat_processus).mutex_interruptions) != 0)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_processus;
+			return;
+		}
+
 		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;
+			return;
+		}
+
 		if ((*s_etat_processus).nombre_interruptions_en_queue != 0)
 		{
 			registre_instruction_valide =
@@ -3703,11 +3947,23 @@ instruction_wfack(struct_processus *s_et
 	{
 		scrutation_injection(s_etat_processus);
 
+		if (pthread_mutex_lock(&(*s_etat_processus).mutex_interruptions) != 0)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_processus;
+			return;
+		}
+
 		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;
+			return;
+		}
+
 		if ((*s_etat_processus).nombre_interruptions_en_queue != 0)
 		{
 			registre_instruction_valide =