--- rpl/src/instructions_w1.c	2011/12/02 10:43:22	1.54
+++ rpl/src/instructions_w1.c	2012/07/05 08:05:50	1.65
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.5
-  Copyright (C) 1989-2011 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.9
+  Copyright (C) 1989-2012 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -391,8 +391,10 @@ instruction_write(struct_processus *s_et
 	integer8							id;
 	integer8							ordre;
 
+	logical1							format_degenere;
 	logical1							mise_a_jour;
 
+	long								longueur;
 	long								longueur_effective;
 	long								recursivite;
 
@@ -428,6 +430,7 @@ instruction_write(struct_processus *s_et
 	unsigned char						*chaine_utf8;
 	unsigned char						*clef_utf8;
 	unsigned char						*commande;
+	unsigned char						*format_chaine;
 
 	unsigned long						i;
 
@@ -1328,8 +1331,7 @@ instruction_write(struct_processus *s_et
 			{
 				BUG(((*descripteur).type != 'C'), uprintf("Bad filetype !\n"));
 
-				if ((*((*((struct_liste_chainee *) (*s_objet_argument_2).objet))
-						.donnee)).type != CHN)
+				if ((*s_objet_argument_2).type != LST)
 				{
 					liberation(s_etat_processus, s_objet_argument_2);
 					liberation(s_etat_processus, s_objet_argument_1);
@@ -1339,24 +1341,158 @@ instruction_write(struct_processus *s_et
 					return;
 				}
 
-				if ((chaine = formateur_flux(s_etat_processus, (unsigned char *)
-						(*((*((struct_liste_chainee *) (*s_objet_argument_2)
-						.objet)).donnee)).objet, &longueur_effective)) == NULL)
+				if ((*((struct_liste_chainee *) (*s_objet_argument_2).objet))
+						.donnee == NULL)
 				{
-					(*s_etat_processus).erreur_systeme =
-							d_es_allocation_memoire;
+					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 (fwrite(chaine, sizeof(unsigned char), longueur_effective,
-						(*descripteur).descripteur_c) !=
-						(size_t) longueur_effective)
+				l_element_courant = (*s_objet_argument_2).objet;
+				l_element_courant_format = (struct_liste_chainee *)
+						(*(*((struct_fichier *) (*s_objet_argument_1).objet))
+						.format).objet;
+
+				while((l_element_courant != NULL) &&
+						(l_element_courant_format != NULL))
 				{
-					(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
-					return;
+					if ((*(*l_element_courant).donnee).type != CHN)
+					{
+						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 ((*(*l_element_courant_format).donnee).type != CHN)
+					{
+						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 ((format_chaine = conversion_majuscule((unsigned char *)
+							(*(*l_element_courant_format).donnee).objet))
+							== NULL)
+					{
+						(*s_etat_processus).erreur_systeme =
+								d_es_allocation_memoire;
+						return;
+					}
+
+					if (strncmp("LENGTH*(", format_chaine, 8) != 0)
+					{
+						free(format_chaine);
+
+						liberation(s_etat_processus, s_objet_argument_2);
+						liberation(s_etat_processus, s_objet_argument_1);
+
+						(*s_etat_processus).erreur_execution =
+								d_ex_erreur_format_fichier;
+						return;
+					}
+
+					longueur = strlen(format_chaine);
+
+					if (format_chaine[longueur - 1] != ')')
+					{
+						free(format_chaine);
+
+						liberation(s_etat_processus, s_objet_argument_2);
+						liberation(s_etat_processus, s_objet_argument_1);
+
+						(*s_etat_processus).erreur_execution =
+								d_ex_erreur_format_fichier;
+						return;
+					}
+
+					format_chaine[longueur] = d_code_fin_chaine;
+
+					if (format_chaine[8] == '*')
+					{
+						format_degenere = d_vrai;
+					}
+					else
+					{
+						// Détermination de la longueur
+						format_degenere = d_faux;
+
+						if (sscanf(&(format_chaine[8]), "%ld", &longueur) != 1)
+						{
+							free(format_chaine);
+
+							liberation(s_etat_processus, s_objet_argument_2);
+							liberation(s_etat_processus, s_objet_argument_1);
+
+							(*s_etat_processus).erreur_execution =
+									d_ex_erreur_format_fichier;
+							return;
+						}
+					}
+
+					free(format_chaine);
+
+					if ((chaine = formateur_flux(s_etat_processus,
+							(unsigned char *) (*(*l_element_courant).donnee)
+							.objet, &longueur_effective)) == NULL)
+					{
+						(*s_etat_processus).erreur_systeme =
+								d_es_allocation_memoire;
+						return;
+					}
+
+					if ((format_degenere == d_vrai) ||
+							(longueur_effective < longueur))
+					{
+						if (fwrite(chaine, sizeof(unsigned char),
+								longueur_effective,
+								(*descripteur).descripteur_c) !=
+								(size_t) longueur_effective)
+						{
+							(*s_etat_processus).erreur_systeme =
+									d_es_erreur_fichier;
+							return;
+						}
+					}
+					else
+					{
+						if (fwrite(chaine, sizeof(unsigned char),
+								longueur_effective,
+								(*descripteur).descripteur_c) !=
+								(size_t) longueur)
+						{
+							(*s_etat_processus).erreur_systeme =
+									d_es_erreur_fichier;
+							return;
+						}
+					}
+
+					free(chaine);
+
+					l_element_courant = (*l_element_courant).suivant;
+					l_element_courant_format = (*l_element_courant_format)
+							.suivant;
 				}
 
-				free(chaine);
+				if ((l_element_courant_format != NULL) ||
+						(l_element_courant != NULL))
+				{
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_1);
+
+					(*s_etat_processus).erreur_execution =
+							d_ex_erreur_format_fichier;
+					return;
+				}
 			}
 			else
 			{
@@ -2753,15 +2889,72 @@ instruction_wfsock(struct_processus *s_e
 			s_poll.events = POLLIN;
 			s_poll.revents = 0;
 
-			while(poll(&s_poll, 1, -1) < 0)
+			do
 			{
-				if (errno != EINTR)
+				drapeau = d_vrai;
+
+#				ifndef SEMAPHORES_NOMMES
+				if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
+#				else
+				if (sem_post((*s_etat_processus).semaphore_fork) != 0)
+#				endif
 				{
-					(*s_etat_processus).erreur_systeme =
-							d_es_erreur_fichier;
-					return;  
+					(*s_etat_processus).erreur_systeme = d_es_processus;
+					return;
 				}
-			}
+
+				if (poll(&s_poll, 1, -1) < 0)
+				{
+					erreur = errno;
+
+#					ifndef SEMAPHORES_NOMMES
+					while(sem_wait(&((*s_etat_processus)
+							.semaphore_fork)) != 0)
+#					else
+					while(sem_wait((*s_etat_processus).semaphore_fork)
+							!= 0)
+#					endif
+
+					if (erreur != EINTR)
+					{
+						liberation(s_etat_processus, s_objet_argument);
+						liberation(s_etat_processus, s_objet_resultat);
+
+						(*s_etat_processus).erreur_execution =
+								d_ex_erreur_acces_fichier;
+						return;
+					}
+
+					scrutation_injection(s_etat_processus);
+
+					if ((*s_etat_processus).var_volatile_requete_arret != 0)
+					{
+						drapeau = d_vrai;
+					}
+					else
+					{
+						drapeau = d_faux;
+					}
+				}
+				else
+				{
+#					ifndef SEMAPHORES_NOMMES
+						while(sem_wait(&((*s_etat_processus)
+								.semaphore_fork)) != 0)
+#					else
+						while(sem_wait((*s_etat_processus).semaphore_fork)
+								!= 0)
+#					endif
+					{
+						if (errno != EINTR)
+						{
+							(*s_etat_processus).erreur_systeme =
+									d_es_processus;
+							return;
+						}
+					}
+				}
+			} while(drapeau == d_faux);
 
 			if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
 					s_objet_argument) == d_erreur)
@@ -2818,13 +3011,13 @@ instruction_wfsock(struct_processus *s_e
 					{
 						erreur = errno;
 
-#					ifndef SEMAPHORES_NOMMES
-							while(sem_wait(&((*s_etat_processus)
-									.semaphore_fork)) != 0)
-#					else
-							while(sem_wait((*s_etat_processus).semaphore_fork)
-									!= 0)
-#					endif
+#						ifndef SEMAPHORES_NOMMES
+						while(sem_wait(&((*s_etat_processus)
+								.semaphore_fork)) != 0)
+#						else
+						while(sem_wait((*s_etat_processus).semaphore_fork)
+								!= 0)
+#						endif
 						{
 							if (errno != EINTR)
 							{