--- rpl/src/instructions_s8.c	2010/04/29 07:30:57	1.9
+++ rpl/src/instructions_s8.c	2013/05/21 12:10:12	1.59
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.0.15
-  Copyright (C) 1989-2010 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.
 
@@ -20,7 +20,7 @@
 */
 
 
-#include "rpl.conv.h"
+#include "rpl-conv.h"
 
 
 /*
@@ -102,7 +102,7 @@ instruction_splash(struct_processus *s_e
 			return;
 		}
 
-		encart(s_etat_processus, (unsigned long) (attente * 1E6));
+		encart(s_etat_processus, (integer8) (attente * 1E6));
 	}
 	else
 	{
@@ -133,10 +133,6 @@ instruction_splash(struct_processus *s_e
 void
 instruction_send(struct_processus *s_etat_processus)
 {
-	pid_t						pid;
-
-	pthread_t					tid;
-
 	sig_atomic_t				registre;
 
 	ssize_t						longueur_ecriture;
@@ -145,6 +141,7 @@ instruction_send(struct_processus *s_eta
 
 	struct timespec				attente;
 
+	unsigned char				caractere;
 	unsigned char				tampon;
 
 	(*s_etat_processus).erreur_execution = d_ex;
@@ -242,84 +239,29 @@ instruction_send(struct_processus *s_eta
 			}
 		}
 
-		pid = -3;
-
-		attente.tv_sec = 0;
-		attente.tv_nsec = GRANULARITE_us * 1000;
-
 #		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
-
-		while((longueur_ecriture = write_atomic(s_etat_processus,
-				(*s_etat_processus).pipe_nombre_objets_attente,
-				&pid, sizeof(pid))) != sizeof(pid))
-		{
-#			ifndef SEMAPHORES_NOMMES
-			while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
-#			else
-			while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
-#			endif
-			{
-				if (errno != EINTR)
-				{
-					(*s_etat_processus).erreur_systeme = d_es_processus;
-					return;
-				}
-			}
-
-			if (longueur_ecriture == -1)
-			{
-				if ((*s_etat_processus).profilage == d_vrai)
-				{
-					profilage(s_etat_processus, NULL);
-				}
-
-				(*s_etat_processus).erreur_systeme = d_es_processus;
-				return;
-			}
-
-			nanosleep(&attente, NULL);
-			INCR_GRANULARITE(attente.tv_nsec);
-
-#			ifndef SEMAPHORES_NOMMES
-			if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
-			{
-				(*s_etat_processus).erreur_systeme = d_es_processus;
-				return;
-			}
-#			else
-			if (sem_post((*s_etat_processus).semaphore_fork) != 0)
-			{
-				(*s_etat_processus).erreur_systeme = d_es_processus;
-				return;
-			}
-#			endif
-		}
 
-		pid = getpid();
+		caractere = 1;
 
 		attente.tv_sec = 0;
 		attente.tv_nsec = GRANULARITE_us * 1000;
 
 		while((longueur_ecriture = write_atomic(s_etat_processus,
-				(*s_etat_processus).pipe_nombre_objets_attente,
-				&pid, sizeof(pid))) != sizeof(pid))
+				(*s_etat_processus).pipe_nombre_elements_attente,
+				&caractere, sizeof(caractere))) != sizeof(caractere))
 		{
 #			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)
@@ -344,20 +286,22 @@ instruction_send(struct_processus *s_eta
 			INCR_GRANULARITE(attente.tv_nsec);
 
 #			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;
 				return;
 			}
+
+			scrutation_interruptions(s_etat_processus);
 		}
 
 #		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)
@@ -379,84 +323,32 @@ instruction_send(struct_processus *s_eta
 			}
 		}
 
-		tid = -3;
-
 		attente.tv_sec = 0;
 		attente.tv_nsec = GRANULARITE_us * 1000;
 
 #		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
-
-		while((longueur_ecriture = write_atomic(s_etat_processus,
-				(*s_etat_processus).pipe_nombre_objets_attente,
-				&tid, sizeof(tid))) != sizeof(tid))
-		{
-#			ifndef SEMAPHORES_NOMMES
-			while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
-#			else
-			while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
-#			endif
-			{
-				if (errno != EINTR)
-				{
-					(*s_etat_processus).erreur_systeme = d_es_processus;
-					return;
-				}
-			}
-
-			if (longueur_ecriture == -1)
-			{
-				if ((*s_etat_processus).profilage == d_vrai)
-				{
-					profilage(s_etat_processus, NULL);
-				}
 
-				(*s_etat_processus).erreur_systeme = d_es_processus;
-				return;
-			}
-
-			nanosleep(&attente, NULL);
-			INCR_GRANULARITE(attente.tv_nsec);
-
-#			ifndef SEMAPHORES_NOMMES
-			if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
-			{
-				(*s_etat_processus).erreur_systeme = d_es_processus;
-				return;
-			}
-#			else
-			if (sem_post((*s_etat_processus).semaphore_fork) != 0)
-			{
-				(*s_etat_processus).erreur_systeme = d_es_processus;
-				return;
-			}
-#			endif
-		}
-
-		tid = pthread_self();
+		caractere = 1;
 
 		attente.tv_sec = 0;
 		attente.tv_nsec = GRANULARITE_us * 1000;
 
 		while((longueur_ecriture = write_atomic(s_etat_processus,
-				(*s_etat_processus).pipe_nombre_objets_attente,
-				&tid, sizeof(tid))) != sizeof(tid))
+				(*s_etat_processus).pipe_nombre_elements_attente,
+				&caractere, sizeof(caractere))) != sizeof(caractere))
 		{
 #			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)
@@ -481,31 +373,26 @@ instruction_send(struct_processus *s_eta
 			INCR_GRANULARITE(attente.tv_nsec);
 
 #			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
+
+			scrutation_interruptions(s_etat_processus);
 		}
 
 #		ifndef SEMAPHORES_NOMMES
-		while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
+			if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
 #		else
-		while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
+			if (sem_post((*s_etat_processus).semaphore_fork) != 0)
 #		endif
 		{
-			if (errno != EINTR)
-			{
-				(*s_etat_processus).erreur_systeme = d_es_processus;
-				return;
-			}
+			(*s_etat_processus).erreur_systeme = d_es_processus;
+			return;
 		}
 	}
 
@@ -515,26 +402,22 @@ instruction_send(struct_processus *s_eta
 	attente.tv_nsec = GRANULARITE_us * 1000;
 
 #	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
 
 	while(read_atomic(s_etat_processus, (*s_etat_processus).pipe_acquittement,
 			&tampon, sizeof(unsigned char)) != sizeof(unsigned char))
 	{
 #		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)
@@ -548,20 +431,22 @@ instruction_send(struct_processus *s_eta
 		INCR_GRANULARITE(attente.tv_nsec);
 
 #		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;
 			return;
 		}
+
+		scrutation_interruptions(s_etat_processus);
 	}
 
 #	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)
@@ -571,181 +456,25 @@ instruction_send(struct_processus *s_eta
 		}
 	}
 
-	// Envoi d'un PID invalide (-1) pour ne pas bloquer le thread
-	// de surveillance.
-
-	if ((*s_etat_processus).processus_detache == d_vrai)
-	{
-		pid = -1;
-
-		attente.tv_sec = 0;
-		attente.tv_nsec = GRANULARITE_us * 1000;
-
-#		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_processus;
-			return;
-		}
-
-		while((longueur_ecriture = write_atomic(s_etat_processus,
-				(*s_etat_processus).pipe_nombre_interruptions_attente,
-				&pid, sizeof(pid))) != sizeof(pid))
-		{
-#			ifndef SEMAPHORES_NOMMES
-			while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
-#			else
-			while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
-#			endif
-			{
-				if (errno != EINTR)
-				{
-					(*s_etat_processus).erreur_systeme = d_es_processus;
-					return;
-				}
-			}
-
-			if (longueur_ecriture == -1)
-			{
-				if ((*s_etat_processus).profilage == d_vrai)
-				{
-					profilage(s_etat_processus, NULL);
-				}
-
-				(*s_etat_processus).erreur_systeme = d_es_processus;
-				return;
-			}
-
-			nanosleep(&attente, NULL);
-			INCR_GRANULARITE(attente.tv_nsec);
-
-#			ifndef SEMAPHORES_NOMMES
-			if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
-			{
-				(*s_etat_processus).erreur_systeme = d_es_processus;
-				return;
-			}
-#			else
-			if (sem_post((*s_etat_processus).semaphore_fork) != 0)
-			{
-				(*s_etat_processus).erreur_systeme = d_es_processus;
-				return;
-			}
-#			endif
-		}
-
-#		ifndef SEMAPHORES_NOMMES
-		while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
-#		else
-		while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
-#		endif
-		{
-			if (errno != EINTR)
-			{
-				(*s_etat_processus).erreur_systeme = d_es_processus;
-				return;
-			}
-		}
-	}
-	else
-	{
-		tid = -1;
-
-		attente.tv_sec = 0;
-		attente.tv_nsec = GRANULARITE_us * 1000;
-
-#		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_processus;
-			return;
-		}
-
-		while((longueur_ecriture = write_atomic(s_etat_processus,
-				(*s_etat_processus).pipe_nombre_interruptions_attente,
-				&tid, sizeof(tid))) != sizeof(tid))
-		{
-#			ifndef SEMAPHORES_NOMMES
-			while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
-#			else
-			while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
-#			endif
-			{
-				if (errno != EINTR)
-				{
-					(*s_etat_processus).erreur_systeme = d_es_processus;
-					return;
-				}
-			}
-
-			if (longueur_ecriture == -1)
-			{
-				if ((*s_etat_processus).profilage == d_vrai)
-				{
-					profilage(s_etat_processus, NULL);
-				}
-
-				(*s_etat_processus).erreur_systeme = d_es_processus;
-				return;
-			}
-
-			nanosleep(&attente, NULL);
-			INCR_GRANULARITE(attente.tv_nsec);
-
-#			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_processus;
-				return;
-			}
-		}
-
-#		ifndef SEMAPHORES_NOMMES
-		while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
-#		else
-		while(sem_wait((*s_etat_processus).semaphore_fork) == -1)
-#		endif
-		{
-			if (errno != EINTR)
-			{
-				(*s_etat_processus).erreur_systeme = d_es_processus;
-				return;
-			}
-		}
-	}
-
 	// ecriture_pipe() ne peut être interrompu par un signal.
 
 #	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 (ecriture_pipe(s_etat_processus, (*s_etat_processus).pipe_donnees,
 			s_objet) == d_erreur)
 	{
 #		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)
@@ -765,9 +494,9 @@ instruction_send(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)
@@ -812,27 +541,15 @@ instruction_send(struct_processus *s_eta
 void
 instruction_sqlquery(struct_processus *s_etat_processus)
 {
-#	define							d_LONGUEUR	1024
-
 	logical1						connexion_permanente;
-	logical1						presence_resultat;
 
 	struct_objet					*s_copie_1;
 	struct_objet					*s_objet_1;
 	struct_objet					*s_copie_2;
 	struct_objet					*s_objet_2;
-	struct_objet					*s_objet_resultat;
-
-	struct_liste_chainee			*l_element_courant;
-	struct_liste_chainee			*l_element_courant_ligne;
 
 	unsigned char					*tampon;
 
-	unsigned int					i;
-	unsigned int					j;
-	unsigned int					nombre_colonnes;
-	unsigned int					nombre_lignes;
-
 	(*s_etat_processus).erreur_execution = d_ex;
 
 	if ((*s_etat_processus).affichage_arguments == 'Y')
@@ -872,6 +589,8 @@ instruction_sqlquery(struct_processus *s
 		printf("          { \"postgresql:iso-8859-1\" \"server\" "
 				"\"database\" \"user\" \"password\" port }\n");
 		printf("          SQLQUERY\n");
+		printf("    \"select * from table\"\n");
+		printf("          { \"sqlite\" \"file\" } SQLQUERY\n");
 
 		return;
 	}
@@ -918,6 +637,16 @@ instruction_sqlquery(struct_processus *s
 			return;
 		}
 
+		if ((*s_etat_processus).erreur_execution ==
+				d_ex_instruction_indisponible)
+		{
+			liberation(s_etat_processus, s_objet_1);
+			liberation(s_etat_processus, s_objet_2);
+			liberation(s_etat_processus, s_copie_1);
+
+			return;
+		}
+
 		liberation(s_etat_processus, s_copie_1);
 	}
 	else
@@ -979,8 +708,18 @@ instruction_sqlquery(struct_processus *s
 		{
 #			ifdef MYSQL_SUPPORT
 
-			MYSQL_RES		*resultat_mysql;
-			MYSQL_ROW		ligne;
+			unsigned int				i;
+			unsigned int				nombre_colonnes;
+
+			logical1					presence_resultat;
+
+			MYSQL_RES					*resultat_mysql;
+			MYSQL_ROW					ligne;
+
+			struct_objet				*s_objet_resultat;
+
+			struct_liste_chainee		*l_element_courant;
+			struct_liste_chainee		*l_element_courant_ligne;
 
 			if (mysql_real_query((*((struct_connecteur_sql *) (*s_objet_1)
 					.objet)).descripteur.mysql, (unsigned char *) (*s_objet_2)
@@ -1182,7 +921,19 @@ instruction_sqlquery(struct_processus *s
 		{
 #			ifdef POSTGRESQL_SUPPORT
 
-			PGresult		*resultat_postgresql;
+			int							i;
+			int							j;
+			int							nombre_colonnes;
+			int							nombre_lignes;
+
+			logical1					presence_resultat;
+
+			PGresult					*resultat_postgresql;
+
+			struct_objet				*s_objet_resultat;
+
+			struct_liste_chainee		*l_element_courant;
+			struct_liste_chainee		*l_element_courant_ligne;
 
 			if (PQstatus((*((struct_connecteur_sql *) (*s_objet_1).objet))
 					.descripteur.postgresql) != CONNECTION_OK)
@@ -1348,8 +1099,8 @@ instruction_sqlquery(struct_processus *s
 							else
 							{
 								if (((*(*l_element_courant_ligne).donnee).objet
-										= malloc((PQgetlength(
-										resultat_postgresql, i, j) + 1) *
+										= malloc(((size_t) (PQgetlength(
+										resultat_postgresql, i, j) + 1)) *
 										sizeof(unsigned char))) == NULL)
 								{
 									(*s_etat_processus).erreur_systeme =
@@ -1426,6 +1177,255 @@ instruction_sqlquery(struct_processus *s
 			fflush(stdout);
 #			endif
 		}
+		else if (strcmp((*((struct_connecteur_sql *) (*s_objet_1).objet)).type,
+				"SQLITE") == 0)
+		{
+			const char					*queue;
+			const unsigned char			*resultat;
+
+			int							i;
+			int							ios;
+			int							nombre_colonnes;
+
+			logical1					presence_resultat;
+
+			sqlite3_stmt				*ppStmt;
+
+			struct_liste_chainee		*l_element_courant;
+			struct_liste_chainee		*l_element_courant_ligne;
+
+			struct_objet				*s_objet_resultat;
+
+			struct timespec				attente;
+
+			if (sqlite3_prepare_v2((*((struct_connecteur_sql *)
+					(*s_objet_1).objet)).descripteur.sqlite,
+					(unsigned char *) (*s_objet_2).objet,
+					(int) strlen((unsigned char *) (*s_objet_2).objet),
+					&ppStmt, &queue) != SQLITE_OK)
+			{
+				if (connexion_permanente == d_faux)
+				{
+					sqlite3_close((*((struct_connecteur_sql *)
+						  	(*s_objet_1).objet)).descripteur.sqlite);
+				}
+
+				liberation(s_etat_processus, s_objet_1);
+				liberation(s_etat_processus, s_objet_2);
+
+				(*s_etat_processus).erreur_execution = d_ex_erreur_sql;
+				return;
+			}
+
+			presence_resultat = d_faux;
+			s_objet_resultat = NULL;
+			l_element_courant = NULL;
+
+			attente.tv_sec = 0;
+			attente.tv_nsec = GRANULARITE_us * 1000;
+
+			do
+			{
+				switch(ios = sqlite3_step(ppStmt))
+				{
+					case SQLITE_ROW:
+					{
+						if (s_objet_resultat == NULL)
+						{
+							if ((s_objet_resultat =
+									allocation(s_etat_processus, LST)) == NULL)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_allocation_memoire;
+								return;
+							}
+
+							presence_resultat = d_vrai;
+
+							// Création d'une liste vide
+
+							(*s_objet_resultat).objet = NULL;
+							l_element_courant = (*s_objet_resultat).objet;
+						}
+
+						// Ajout d'une liste au bout de la liste
+						// contenant les lignes
+
+						if (l_element_courant == NULL)
+						{
+							if (((*s_objet_resultat).objet =
+									allocation_maillon(s_etat_processus))
+									== NULL)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_allocation_memoire;
+							}
+
+							l_element_courant = (struct_liste_chainee *)
+									(*s_objet_resultat).objet;
+						}
+						else
+						{
+							if (((*l_element_courant).suivant =
+									allocation_maillon(s_etat_processus))
+									== NULL)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_allocation_memoire;
+								return;
+							}
+
+							l_element_courant = (*l_element_courant).suivant;
+						}
+
+						(*l_element_courant).suivant = NULL;
+
+						// Création de la liste fille
+
+						if (((*l_element_courant).donnee =
+								allocation(s_etat_processus, LST)) == NULL)
+						{
+							(*s_etat_processus).erreur_systeme =
+									d_es_allocation_memoire;
+							return;
+						}
+
+						(*(*l_element_courant).donnee).objet = NULL;
+
+						// Lecture de la ligne
+
+						nombre_colonnes = sqlite3_data_count(ppStmt);
+						l_element_courant_ligne = NULL;
+
+						for(i = 0; i < nombre_colonnes; i++)
+						{
+							if (l_element_courant_ligne == NULL)
+							{
+								if (((*(*l_element_courant).donnee).objet =
+										allocation_maillon(s_etat_processus))
+										== NULL)
+								{
+									(*s_etat_processus).erreur_systeme =
+											d_es_allocation_memoire;
+									return;
+								}
+
+								l_element_courant_ligne =
+										(struct_liste_chainee *)
+										(*(*l_element_courant).donnee).objet;
+							}
+							else
+							{
+								if (((*l_element_courant_ligne).suivant =
+										allocation_maillon(s_etat_processus))
+										== NULL)
+								{
+									l_element_courant_ligne =
+											(*l_element_courant_ligne).suivant;
+								}
+
+								l_element_courant_ligne =
+										(*l_element_courant_ligne).suivant;
+							}
+
+							(*l_element_courant_ligne).suivant = NULL;
+
+							if (((*l_element_courant_ligne).donnee =
+									allocation(s_etat_processus, CHN))
+									== NULL)
+							{
+								(*s_etat_processus).erreur_systeme =
+										d_es_allocation_memoire;
+								return;
+							}
+
+							if (sqlite3_column_type(ppStmt, i) == SQLITE_NULL)
+							{
+								if (((*(*l_element_courant_ligne).donnee).objet
+										= malloc(5 * sizeof(unsigned char)))
+										== NULL)
+								{
+									(*s_etat_processus).erreur_systeme =
+											d_es_allocation_memoire;
+									return;
+								}
+
+								strcpy((unsigned char *)
+										(*(*l_element_courant_ligne).donnee)
+										.objet, "NULL");
+							}
+							else
+							{
+								if ((resultat = sqlite3_column_text(ppStmt, i))
+										== NULL)
+								{
+									(*s_etat_processus).erreur_systeme =
+											d_es_allocation_memoire;
+									return;
+								}
+
+								if (((*(*l_element_courant_ligne).donnee).objet
+										= malloc((strlen(resultat) + 1 ) *
+										sizeof(unsigned char))) == NULL)
+								{
+									(*s_etat_processus).erreur_systeme =
+											d_es_allocation_memoire;
+									return;
+								}
+
+								strcpy((unsigned char *)
+										(*(*l_element_courant_ligne).donnee)
+										.objet, resultat);
+							}
+						}
+
+						break;
+					}
+
+					case SQLITE_DONE:
+					{
+						// Fin de la lecture des données
+						break;
+					}
+
+					case SQLITE_BUSY:
+					case SQLITE_LOCKED:
+					{
+						nanosleep(&attente, NULL);
+						INCR_GRANULARITE(attente.tv_nsec);
+						break;
+					}
+
+					default:
+					{
+						(*s_etat_processus).erreur_systeme =
+								d_es_erreur_fichier;
+						return;
+					}
+				}
+			} while(ios != SQLITE_DONE);
+
+			if (sqlite3_finalize(ppStmt) != SQLITE_OK)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
+				return;
+			}
+
+			if (connexion_permanente == d_faux)
+			{
+				sqlite3_close((*((struct_connecteur_sql *) (*s_objet_1).objet))
+						.descripteur.sqlite);
+			}
+
+			if (presence_resultat == d_vrai)
+			{
+				if (empilement(s_etat_processus, &((*s_etat_processus)
+						.l_base_pile), s_objet_resultat) == d_erreur)
+				{
+					return;
+				}
+			}
+		}
 		else
 		{
 			liberation(s_etat_processus, s_objet_1);
@@ -1470,11 +1470,6 @@ instruction_stop(struct_processus *s_eta
 
 	struct_objet				*s_objet;
 
-	struct timespec				attente;
-
-	attente.tv_sec = 0;
-	attente.tv_nsec = GRANULARITE_us * 1000;
-
 	(*s_etat_processus).erreur_execution = d_ex;
 
 	if ((*s_etat_processus).affichage_arguments == 'Y')
@@ -1520,8 +1515,8 @@ instruction_stop(struct_processus *s_eta
 		if ((*(*((struct_processus_fils *) (*s_objet).objet)).thread)
 				.processus_detache == d_vrai)
 		{
-			kill((*(*((struct_processus_fils *) (*s_objet).objet)).thread).pid,
-					SIGFSTOP);
+			envoi_signal_processus((*(*((struct_processus_fils *)
+					(*s_objet).objet)).thread).pid, rpl_sigstop);
 		}
 		else
 		{
@@ -1581,8 +1576,8 @@ instruction_stop(struct_processus *s_eta
 					if ((*(*((struct_processus_fils *)
 							(*s_objet).objet)).thread).thread_actif == d_vrai)
 					{
-						pthread_kill((*(*((struct_processus_fils *)
-								(*s_objet).objet)).thread).tid, SIGFSTOP);
+						envoi_signal_thread((*(*((struct_processus_fils *)
+								(*s_objet).objet)).thread).tid, rpl_sigstop);
 					}
 
 					if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)