--- rpl/src/rpl.c	2010/02/10 08:09:29	1.6
+++ rpl/src/rpl.c	2010/05/16 19:36:20	1.24
@@ -1,6 +1,6 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.0.10
+  RPL/2 (R) version 4.0.15
   Copyright (C) 1989-2010 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
@@ -31,7 +31,7 @@
 */
 
 int
-rplinit(int argc, char *argv[], unsigned char ***resultats)
+rplinit(int argc, char *argv[], unsigned char ***resultats, char *rpl_home)
 {
 #	include								"copyright.conv.h"
 #	include								"licence.conv.h"
@@ -102,30 +102,81 @@ rplinit(int argc, char *argv[], unsigned
 	setvbuf(stdout, NULL, _IOLBF, 0);
 	setvbuf(stderr, NULL, _IOLBF, 0);
 
+#	ifndef SEMAPHORES_NOMMES
 	sem_init(&semaphore_liste_threads, 0, 1);
 	sem_init(&semaphore_gestionnaires_signaux, 0, 0);
 	sem_init(&semaphore_gestionnaires_signaux_atomique, 0, 1);
+#	else
+	semaphore_liste_threads = sem_init2(1, sem_liste_threads);
+	semaphore_gestionnaires_signaux = sem_init2(0, sem_gestionnaires_signaux);
+	semaphore_gestionnaires_signaux_atomique = sem_init2(1,
+			sem_gestionnaires_signaux_atomique);
+
+	if ((semaphore_liste_threads == SEM_FAILED) ||
+			(semaphore_gestionnaires_signaux == SEM_FAILED) ||
+			(semaphore_gestionnaires_signaux_atomique == SEM_FAILED))
+	{
+		erreur = d_es_allocation_memoire;
+
+		if ((langue = getenv("LANG")) != NULL)
+		{
+			if (strncmp(langue, "fr", 2) == 0)
+			{
+				uprintf("+++Système : Mémoire insuffisante\n");
+			}
+			else
+			{
+				uprintf("+++System : Not enough memory\n");
+			}
+		}
+		else
+		{
+			uprintf("+++System : Not enough memory\n");
+		}
+
+		return(EXIT_FAILURE);
+	}
+#	endif
 
 	if ((s_etat_processus = malloc(sizeof(struct_processus))) == NULL)
 	{
 		erreur = d_es_allocation_memoire;
 
-		if ((*s_etat_processus).langue == 'F')
+		if ((langue = getenv("LANG")) != NULL)
 		{
-			printf("+++Système : Mémoire insuffisante\n");
+			if (strncmp(langue, "fr", 2) == 0)
+			{
+				uprintf("+++Système : Mémoire insuffisante\n");
+			}
+			else
+			{
+				uprintf("+++System : Not enough memory\n");
+			}
 		}
 		else
 		{
-			printf("+++System : Not enough memory\n");
+			uprintf("+++System : Not enough memory\n");
 		}
 
 		return(EXIT_FAILURE);
 	}
 
+	if ((langue = getenv("LANG")) != NULL)
+	{
+		(*s_etat_processus).langue = (strncmp(langue, "fr", 2) == 0)
+				? 'F' : 'E';
+	}
+	else
+	{
+		(*s_etat_processus).langue = 'E';
+	}
+
 	(*s_etat_processus).exception = d_ep;
 	(*s_etat_processus).erreur_systeme = d_es;
 	(*s_etat_processus).erreur_execution = d_ex;
 
+	(*s_etat_processus).rpl_home = rpl_home;
+
 	insertion_thread(s_etat_processus, d_vrai);
 
 	pthread_mutexattr_init(&attributs_mutex);
@@ -133,7 +184,24 @@ rplinit(int argc, char *argv[], unsigned
 	pthread_mutex_init(&((*s_etat_processus).mutex), &attributs_mutex);
 	pthread_mutexattr_destroy(&attributs_mutex);
 
+#	ifndef SEMAPHORES_NOMMES
 	sem_init(&((*s_etat_processus).semaphore_fork), 0, 0);
+#	else
+	if (((*s_etat_processus).semaphore_fork = sem_init2(0, sem_fork)) ==
+			SEM_FAILED)
+	{
+		if ((*s_etat_processus).langue == 'F')
+		{
+			uprintf("+++Système : Mémoire insuffisante\n");
+		}
+		else
+		{
+			uprintf("+++System : Not enough memory\n");
+		}
+
+		return(EXIT_FAILURE);
+	}
+#	endif
 
 	pthread_mutexattr_init(&attributs_mutex);
 	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
@@ -153,30 +221,27 @@ rplinit(int argc, char *argv[], unsigned
 			.mutex), &attributs_mutex);
 	pthread_mutexattr_destroy(&attributs_mutex);
 
-	if ((langue = getenv("LANG")) != NULL)
-	{
-		(*s_etat_processus).langue = (strncmp(langue, "fr", 2) == 0)
-				? 'F' : 'E';
-	}
-	else
-	{
-		(*s_etat_processus).langue = 'E';
-	}
-
 	localisation_courante(s_etat_processus);
+	(*s_etat_processus).erreur_systeme = d_es;
 
-	if ((*s_etat_processus).erreur_systeme != d_es)
+	if ((*s_etat_processus).localisation == NULL)
 	{
-		if ((*s_etat_processus).langue == 'F')
+		if (((*s_etat_processus).localisation = malloc((strlen(d_locale) + 1) *
+				sizeof(unsigned char))) == NULL)
 		{
-			uprintf("+++Système : Mémoire insuffisante\n");
-		}
-		else
-		{
-			uprintf("+++System : Not enough memory\n");
+			if ((*s_etat_processus).langue == 'F')
+			{
+				uprintf("+++Système : Mémoire insuffisante\n");
+			}
+			else
+			{
+				uprintf("+++System : Not enough memory\n");
+			}
+
+			return(EXIT_FAILURE);
 		}
 
-		return(EXIT_FAILURE);
+		strcpy((*s_etat_processus).localisation, d_locale);
 	}
 
 	printf("+++RPL/2 (R) version %s (%s)\n", d_version_rpl,
@@ -229,8 +294,13 @@ rplinit(int argc, char *argv[], unsigned
 		return(EXIT_FAILURE);
 	}
 
+#	ifndef SEMAPHORES_NOMMES
 	if (pthread_setspecific(semaphore_fork_processus_courant,
 			&((*s_etat_processus).semaphore_fork)) != 0)
+#	else
+	if (pthread_setspecific(semaphore_fork_processus_courant,
+			(*s_etat_processus).semaphore_fork) != 0)
+#	endif
 	{
 		if ((*s_etat_processus).langue == 'F')
 		{
@@ -247,6 +317,7 @@ rplinit(int argc, char *argv[], unsigned
 	// Initialisation d'une pile de signal pour récupérer les
 	// débordement de pile
 
+#	ifndef Cygwin
 	if (((*s_etat_processus).pile_signal.ss_sp =
 			malloc((*s_etat_processus).pile_signal.ss_size =
 			SIGSTKSZ)) == NULL)
@@ -283,6 +354,7 @@ rplinit(int argc, char *argv[], unsigned
 
 		return(EXIT_FAILURE);
 	}
+#	endif
 
 	action.sa_sigaction = interruption1;
 	action.sa_flags = SA_ONSTACK | SA_SIGINFO;
@@ -375,6 +447,23 @@ rplinit(int argc, char *argv[], unsigned
 		return(EXIT_FAILURE);
 	}
 
+	if (sigaction(SIGFABORT, &action, NULL) != 0)
+	{
+		erreur = d_es_signal;
+
+		if ((*s_etat_processus).langue == 'F')
+		{
+			printf("+++Système : Initialisation des signaux POSIX "
+					"impossible\n");
+		}
+		else
+		{
+			printf("+++System : Initialization of POSIX signals failed\n");
+		}
+
+		return(EXIT_FAILURE);
+	}
+
 	action.sa_sigaction = interruption8;
 	action.sa_flags = SA_NODEFER | SA_ONSTACK | SA_SIGINFO;
 
@@ -481,7 +570,7 @@ rplinit(int argc, char *argv[], unsigned
 	(*s_etat_processus).chemin_fichiers_temporaires =
 			recherche_chemin_fichiers_temporaires(s_etat_processus);
 
-	erreur = d_os;
+	erreur = d_absence_erreur;
 	core = d_faux;
 	mode_interactif = d_faux;
 	(*s_etat_processus).nom_fichier_source = NULL;
@@ -502,7 +591,7 @@ rplinit(int argc, char *argv[], unsigned
 
 	if (argc == 1)
 	{
-		erreur = d_os_ligne_de_commande;
+		erreur = d_erreur;
 		informations(s_etat_processus);
 	}
 	else
@@ -554,31 +643,6 @@ rplinit(int argc, char *argv[], unsigned
 							}
 
 							option_a = d_vrai;
-							printf("\n");
-
-							if ((*s_etat_processus).langue == 'F')
-							{
-								printf("  Auteur: Joël BERTRAND,\n");
-								printf("    Email              : "
-										"joel.bertrand@systella.fr\n");
-								printf("    Liste de diffusion : "
-										"rpl2@systella.fr\n");
-								printf("    Page               : "
-										"http://www.rpl2.fr");
-								printf("\n");
-							}
-							else
-							{
-								printf("  Author: Joël BERTRAND,\n");
-								printf("    Email              : "
-										"joel.bertrand@systella.fr\n");
-								printf("    Mailing list       : "
-										"rpl2@systella.fr\n");
-								printf("    Web page           : "
-										"http://www.rpl2/net");
-								printf("\n");
-							}
-
 							break;
 						}
 
@@ -1293,6 +1357,7 @@ rplinit(int argc, char *argv[], unsigned
 								return(EXIT_FAILURE);
 							}
 
+							free(type_debug);
 							break;
 						}
 
@@ -1380,7 +1445,7 @@ rplinit(int argc, char *argv[], unsigned
 						printf("+++Error : More than one definition\n");
 					}
 
-					erreur = d_os_ligne_de_commande;
+					erreur = d_erreur;
 				}
 				else
 				{
@@ -1582,7 +1647,7 @@ rplinit(int argc, char *argv[], unsigned
 							(*s_etat_processus).nom_fichier_source);
 				}
 
-				erreur = d_os_fichier_introuvable;
+				erreur = d_erreur;
 			}
 			else
 			{
@@ -1629,7 +1694,7 @@ rplinit(int argc, char *argv[], unsigned
 			}
 		}
 
-		if ((erreur == d_os) && (presence_definition == 'O'))
+		if ((erreur == d_absence_erreur) && (presence_definition == 'O'))
 		{
 			(*s_etat_processus).profilage = (option_P != 0) ? d_vrai : d_faux;
 			(*s_etat_processus).niveau_profilage = option_P;
@@ -1644,6 +1709,7 @@ rplinit(int argc, char *argv[], unsigned
 			(*s_etat_processus).affichage_arguments = 'N';
 			(*s_etat_processus).autorisation_conversion_chaine = 'Y';
 			(*s_etat_processus).autorisation_evaluation_nom = 'Y';
+			(*s_etat_processus).autorisation_nom_implicite = 'Y';
 			(*s_etat_processus).autorisation_empilement_programme = 'N';
 			(*s_etat_processus).requete_arret = 'N';
 			(*s_etat_processus).evaluation_forcee = 'N';
@@ -1791,6 +1857,8 @@ rplinit(int argc, char *argv[], unsigned
 				(*s_etat_processus).pile_origine_interruptions[i] = NULL;
 			}
 
+			(*s_etat_processus).at_exit = NULL;
+
 			(*s_etat_processus).pointeurs_caracteres = NULL;
 			(*s_etat_processus).arbre_instructions = NULL;
 
@@ -1806,6 +1874,7 @@ rplinit(int argc, char *argv[], unsigned
 			(*s_etat_processus).var_volatile_traitement_sigint = 0;
 			(*s_etat_processus).var_volatile_recursivite = 0;
 			(*s_etat_processus).var_volatile_exception_gsl = 0;
+			(*s_etat_processus).arret_depuis_abort = 0;
 
 			initialisation_allocateur(s_etat_processus);
 			initialisation_drapeaux(s_etat_processus);
@@ -2543,24 +2612,47 @@ rplinit(int argc, char *argv[], unsigned
 						free(arguments);
 					}
 
-					if (option_D == d_vrai)
+					if (option_a == d_vrai)
 					{
-						lancement_daemon(s_etat_processus);
+						fprintf(stdout, "%s\n", (*s_etat_processus)
+								.definitions_chainees);
 					}
-
-					if (option_p == d_faux)
+					else
 					{
-						if (setjmp(contexte_initial) == 0)
+						if (option_D == d_vrai)
 						{
-							erreur = sequenceur(s_etat_processus);
+							lancement_daemon(s_etat_processus);
 						}
-					}
-					else
-					{
-						if (setjmp(contexte_initial) == 0)
+
+						if (option_p == d_faux)
+						{
+							if (setjmp(contexte_initial) == 0)
+							{
+								erreur = sequenceur(s_etat_processus);
+							}
+						}
+						else
 						{
-							erreur = sequenceur_optimise(s_etat_processus);
+							if (setjmp(contexte_initial) == 0)
+							{
+								erreur = sequenceur_optimise(s_etat_processus);
+							}
 						}
+
+						if (erreur == d_absence_erreur)
+						{
+							if (((*s_etat_processus).var_volatile_alarme == 0)
+									&& ((*s_etat_processus).arret_depuis_abort
+									== 0) && ((*s_etat_processus).at_exit
+									!= NULL))
+							{
+								erreur = evaluation(s_etat_processus,
+										(*s_etat_processus).at_exit, 'E');
+							}
+						}
+
+						liberation(s_etat_processus,
+								(*s_etat_processus).at_exit);
 					}
 
 					if ((*s_etat_processus).generateur_aleatoire != NULL)
@@ -2679,10 +2771,21 @@ rplinit(int argc, char *argv[], unsigned
 							}
 							else
 							{
-								kill((*(*((struct_processus_fils *)
-										(*(*((struct_liste_chainee *)
-										l_element_courant)).donnee).objet))
-										.thread).pid, SIGFSTOP);
+								if ((*s_etat_processus).arret_depuis_abort
+										== -1)
+								{
+									kill((*(*((struct_processus_fils *)
+											(*(*((struct_liste_chainee *)
+											l_element_courant)).donnee).objet))
+											.thread).pid, SIGFABORT);
+								}
+								else
+								{
+									kill((*(*((struct_processus_fils *)
+											(*(*((struct_liste_chainee *)
+											l_element_courant)).donnee).objet))
+											.thread).pid, SIGFSTOP);
+								}
 							}
 						}
 						else
@@ -2707,10 +2810,25 @@ rplinit(int argc, char *argv[], unsigned
 								}
 								else
 								{
-									pthread_kill((*(*((struct_processus_fils *)
-											(*(*((struct_liste_chainee *)
-											l_element_courant)).donnee).objet))
-											.thread).tid, SIGFSTOP);
+									if ((*s_etat_processus).arret_depuis_abort
+											== -1)
+									{
+										pthread_kill(
+												(*(*((struct_processus_fils *)
+												(*(*((struct_liste_chainee *)
+												l_element_courant)).donnee)
+												.objet)).thread).tid,
+												SIGFABORT);
+									}
+									else
+									{
+										pthread_kill(
+												(*(*((struct_processus_fils *)
+												(*(*((struct_liste_chainee *)
+												l_element_courant)).donnee)
+												.objet)).thread).tid,
+												SIGFSTOP);
+									}
 								}
 							}
 
@@ -2743,13 +2861,6 @@ rplinit(int argc, char *argv[], unsigned
 						l_element_courant = (void *)
 								(*s_etat_processus).l_base_pile_processus;
 
-						if ((*s_etat_processus)
-								.nombre_interruptions_non_affectees != 0)
-						{
-							affectation_interruptions_logicielles(
-									s_etat_processus);
-						}
-
 						for(i = 0; i < (unsigned long)
 								(*(*((struct_processus_fils *)
 								(*(*((struct_liste_chainee *)
@@ -2808,6 +2919,14 @@ rplinit(int argc, char *argv[], unsigned
 						}
 
 						pthread_mutex_unlock(&((*s_etat_processus).mutex));
+
+						if ((*s_etat_processus)
+								.nombre_interruptions_non_affectees != 0)
+						{
+							affectation_interruptions_logicielles(
+									s_etat_processus);
+						}
+
 						nanosleep(&attente, NULL);
 						pthread_mutex_lock(&((*s_etat_processus).mutex));
 					}
@@ -3186,7 +3305,17 @@ rplinit(int argc, char *argv[], unsigned
 						fclose((*((struct_descripteur_fichier *)
 								(*((struct_liste_chainee *)
 								l_element_courant)).donnee))
-								.descripteur);
+								.descripteur_c);
+
+						if ((*((struct_descripteur_fichier *)
+								(*((struct_liste_chainee *)
+								l_element_courant)).donnee)).type != 'C')
+						{
+							sqlite3_close((*((struct_descripteur_fichier *)
+									(*((struct_liste_chainee *)
+									l_element_courant)).donnee))
+									.descripteur_sqlite);
+						}
 
 						if ((*((struct_descripteur_fichier *)
 								(*((struct_liste_chainee *)
@@ -3320,7 +3449,10 @@ rplinit(int argc, char *argv[], unsigned
 		}
 	}
 
+#	ifndef Cygwin
 	free((*s_etat_processus).pile_signal.ss_sp);
+#	endif
+
 	closelog();
 
 	pthread_mutex_destroy(&((*s_etat_processus).protection_liste_mutexes));
@@ -3330,18 +3462,40 @@ rplinit(int argc, char *argv[], unsigned
 	retrait_thread(s_etat_processus);
 
 	pthread_mutex_destroy(&((*s_etat_processus).mutex));
+#	ifndef SEMAPHORES_NOMMES
 	sem_post(&((*s_etat_processus).semaphore_fork));
 	sem_destroy(&((*s_etat_processus).semaphore_fork));
+#	else
+	sem_post((*s_etat_processus).semaphore_fork);
+	sem_destroy2((*s_etat_processus).semaphore_fork, sem_fork);
+#	endif
 
 	free((*s_etat_processus).localisation);
-	free(s_etat_processus);
 
+#	ifndef SEMAPHORES_NOMMES
 	sem_destroy(&semaphore_liste_threads);
+#	else
+	sem_destroy2(semaphore_liste_threads, sem_liste_threads);
+#	endif
+#	ifndef SEMAPHORES_NOMMES
 	sem_post(&semaphore_gestionnaires_signaux);
 	sem_destroy(&semaphore_gestionnaires_signaux);
 	sem_destroy(&semaphore_gestionnaires_signaux_atomique);
+#	else
+	sem_post(semaphore_gestionnaires_signaux);
+	sem_destroy2(semaphore_gestionnaires_signaux, sem_gestionnaires_signaux);
+	sem_destroy2(semaphore_gestionnaires_signaux_atomique,
+			sem_gestionnaires_signaux_atomique);
+#	endif
+
+	free(s_etat_processus);
+
+#	ifdef DEBUG_MEMOIRE
+	debug_memoire_verification();
+	analyse_post_mortem();
+#	endif
 
-	return((erreur == d_os) ? EXIT_SUCCESS : EXIT_FAILURE);
+	return((erreur == d_absence_erreur) ? EXIT_SUCCESS : EXIT_FAILURE);
 }
 
 
@@ -3353,7 +3507,7 @@ informations(struct_processus *s_etat_pr
 	if ((*s_etat_processus).langue == 'F')
 	{
 		printf("  rpl [-options] [programme]\n");
-		printf("      -a : informations sur l'auteur\n");
+		printf("      -a : analyse du code\n");
 		printf("      -A : paramètres passés au programme principal\n");
 		printf("      -c : génération de fichier de débogage (rpl-core)\n");
 		printf("      -d : option de déverminage interne\n");
@@ -3372,7 +3526,7 @@ informations(struct_processus *s_etat_pr
 	else
 	{
 		printf("  rpl [-options] [program]\n");
-		printf("      -a : displays informations about the author\n");
+		printf("      -a : analyzes program\n");
 		printf("      -A : sends parameters to main program\n");
 		printf("      -c : allows creation of a rpl-core file, providing a way"
 				"\n"