--- rpl/src/rpl.c	2017/06/28 09:20:38	1.193
+++ rpl/src/rpl.c	2017/07/30 21:59:41	1.197
@@ -86,6 +86,10 @@ rplinit(int argc, char *argv[], char *en
 
 	struct_processus					*s_etat_processus;
 
+	struct_liste_chainee				*l_bibliotheques;
+	struct_liste_chainee				*l_bibliotheque_courante;
+	struct_liste_chainee				*l_nouvelle_bibliotheque;
+
 	struct_liste_variables_partagees	*l_element_partage_courant;
 	struct_liste_variables_partagees	*l_element_partage_suivant;
 
@@ -1004,6 +1008,7 @@ rplinit(int argc, char *argv[], char *en
 	drapeau_encart = 'Y';
 	debug = d_faux;
 	arguments = NULL;
+	l_bibliotheques = NULL;
 
 	(*s_etat_processus).s_fichiers = NULL;
 	(*s_etat_processus).s_sockets = NULL;
@@ -1594,6 +1599,301 @@ rplinit(int argc, char *argv[], char *en
 							break;
 						}
 
+						case 'm' :
+						{
+							while(*(++argv[0]) == ' ');
+							argv[0]--;
+
+							if ((*(++argv[0])) != '\0')
+							{
+								if ((l_nouvelle_bibliotheque = malloc(
+										sizeof(struct_liste_chainee))) == NULL)
+								{
+#									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_destroy3((*s_etat_processus)
+											.semaphore_fork, getpid(),
+											pthread_self(), SEM_FORK);
+#									endif
+
+									liberation_contexte_cas(s_etat_processus);
+									destruction_queue_signaux(s_etat_processus);
+
+#									ifdef HAVE_STACK_OVERFLOW_RECOVERY
+									stackoverflow_deinstall_handler();
+#									endif
+
+									if ((*s_etat_processus).langue == 'F')
+									{
+										printf("+++Système : Mémoire "
+												"insuffisante\n");
+									}
+									else
+									{
+										printf("+++System : Not enough "
+												"memory\n");
+									}
+
+									return(EXIT_FAILURE);
+								}
+
+								(*l_nouvelle_bibliotheque).suivant =
+										l_bibliotheques;
+
+								if (((*l_nouvelle_bibliotheque).donnee =
+										allocation(s_etat_processus, CHN))
+										== NULL)
+								{
+#									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_destroy3((*s_etat_processus)
+											.semaphore_fork, getpid(),
+											pthread_self(), SEM_FORK);
+#									endif
+
+									liberation_contexte_cas(s_etat_processus);
+									destruction_queue_signaux(s_etat_processus);
+
+#									ifdef HAVE_STACK_OVERFLOW_RECOVERY
+									stackoverflow_deinstall_handler();
+#									endif
+
+									if ((*s_etat_processus).langue == 'F')
+									{
+										printf("+++Système : Mémoire "
+												"insuffisante\n");
+									}
+									else
+									{
+										printf("+++System : Not enough "
+												"memory\n");
+									}
+
+									return(EXIT_FAILURE);
+								}
+
+								if (((*(*l_nouvelle_bibliotheque).donnee)
+										.objet = malloc((strlen(argv[0]) + 1) *
+										sizeof(unsigned char))) == NULL)
+								{
+#									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_destroy3((*s_etat_processus)
+											.semaphore_fork, getpid(),
+											pthread_self(), SEM_FORK);
+#									endif
+
+									liberation_contexte_cas(s_etat_processus);
+									destruction_queue_signaux(s_etat_processus);
+
+#									ifdef HAVE_STACK_OVERFLOW_RECOVERY
+									stackoverflow_deinstall_handler();
+#									endif
+
+									if ((*s_etat_processus).langue == 'F')
+									{
+										printf("+++Système : Mémoire "
+												"insuffisante\n");
+									}
+									else
+									{
+										printf("+++System : Not enough "
+												"memory\n");
+									}
+
+									return(EXIT_FAILURE);
+								}
+
+								strcpy((*(*l_nouvelle_bibliotheque).donnee)
+										.objet, argv[0]);
+								argv[0] += strlen((unsigned char *)
+										(*(*l_nouvelle_bibliotheque).donnee)
+										.objet) - 1;
+
+								l_bibliotheques = l_nouvelle_bibliotheque;
+							}
+							else if ((--argc) > 0)
+							{
+								argv++;
+
+								if ((l_nouvelle_bibliotheque = malloc(
+										sizeof(struct_liste_chainee))) == NULL)
+								{
+#									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_destroy3((*s_etat_processus)
+											.semaphore_fork, getpid(),
+											pthread_self(), SEM_FORK);
+#									endif
+
+									liberation_contexte_cas(s_etat_processus);
+									destruction_queue_signaux(s_etat_processus);
+
+#									ifdef HAVE_STACK_OVERFLOW_RECOVERY
+									stackoverflow_deinstall_handler();
+#									endif
+
+									if ((*s_etat_processus).langue == 'F')
+									{
+										printf("+++Système : Mémoire "
+												"insuffisante\n");
+									}
+									else
+									{
+										printf("+++System : Not enough "
+												"memory\n");
+									}
+
+									return(EXIT_FAILURE);
+								}
+
+								(*l_nouvelle_bibliotheque).suivant =
+										l_bibliotheques;
+
+								if (((*l_nouvelle_bibliotheque).donnee =
+										allocation(s_etat_processus, CHN))
+										== NULL)
+								{
+#									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_destroy3((*s_etat_processus)
+											.semaphore_fork, getpid(),
+											pthread_self(), SEM_FORK);
+#									endif
+
+									liberation_contexte_cas(s_etat_processus);
+									destruction_queue_signaux(s_etat_processus);
+
+#									ifdef HAVE_STACK_OVERFLOW_RECOVERY
+									stackoverflow_deinstall_handler();
+#									endif
+
+									if ((*s_etat_processus).langue == 'F')
+									{
+										printf("+++Système : Mémoire "
+												"insuffisante\n");
+									}
+									else
+									{
+										printf("+++System : Not enough "
+												"memory\n");
+									}
+
+									return(EXIT_FAILURE);
+								}
+
+								if (((*(*l_nouvelle_bibliotheque).donnee)
+										.objet = malloc((strlen(argv[0]) + 1) *
+										sizeof(unsigned char))) == NULL)
+								{
+#									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_destroy3((*s_etat_processus)
+											.semaphore_fork, getpid(),
+											pthread_self(), SEM_FORK);
+#									endif
+
+									liberation_contexte_cas(s_etat_processus);
+									destruction_queue_signaux(s_etat_processus);
+
+#									ifdef HAVE_STACK_OVERFLOW_RECOVERY
+									stackoverflow_deinstall_handler();
+#									endif
+
+									if ((*s_etat_processus).langue == 'F')
+									{
+										printf("+++Système : Mémoire "
+												"insuffisante\n");
+									}
+									else
+									{
+										printf("+++System : Not enough "
+												"memory\n");
+									}
+
+									return(EXIT_FAILURE);
+								}
+
+								strcpy((*(*l_nouvelle_bibliotheque).donnee)
+										.objet, argv[0]);
+								argv[0] += strlen((unsigned char *)
+										(*(*l_nouvelle_bibliotheque).donnee)
+										.objet) - 1;
+
+								l_bibliotheques = l_nouvelle_bibliotheque;
+							}
+							else
+							{
+#								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_destroy3((*s_etat_processus).semaphore_fork,
+										getpid(), pthread_self(), SEM_FORK);
+#								endif
+
+								liberation_contexte_cas(s_etat_processus);
+								destruction_queue_signaux(s_etat_processus);
+
+#								ifdef HAVE_STACK_OVERFLOW_RECOVERY
+								stackoverflow_deinstall_handler();
+#								endif
+
+								if ((*s_etat_processus).langue == 'F')
+								{
+									printf("+++Erreur : Aucune bibliothèque "
+											"spécifiée après l'option -A\n");
+								}
+								else
+								{
+									printf("+++Error : Library required after "
+											"-m option\n");
+								}
+
+								return(EXIT_FAILURE);
+							}
+
+							break;
+						}
+
 						case 'n' :
 						{
 							if (option_n == d_vrai)
@@ -3765,6 +4065,138 @@ rplinit(int argc, char *argv[], char *en
 						}
 					}
 
+					/*
+					 * Chargement des bibliothèques pour gérer des
+					 * types externes lors des l'analyse syntaxique et
+					 * compilation.
+					 */
+
+					l_bibliotheque_courante = l_bibliotheques;
+
+					while(l_bibliotheque_courante != NULL)
+					{
+						if (empilement(s_etat_processus, &((*s_etat_processus)
+								.l_base_pile), (*l_bibliotheque_courante)
+								.donnee) == d_erreur)
+						{
+#							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_destroy3((*s_etat_processus).semaphore_fork,
+										getpid(), pthread_self(), SEM_FORK);
+#							endif
+
+							liberation_contexte_cas(s_etat_processus);
+							destruction_queue_signaux(s_etat_processus);
+
+#							ifdef HAVE_STACK_OVERFLOW_RECOVERY
+								stackoverflow_deinstall_handler();
+#							endif
+
+#							ifdef HAVE_SIGSEGV_RECOVERY
+								if (debug == d_faux)
+								{
+									sigsegv_deinstall_handler();
+								}
+#							endif
+
+							if ((*s_etat_processus).langue == 'F')
+							{
+								printf("+++Fatal :"
+										" Chargement de la bibliothèse %s"
+										" impossible\n", (unsigned char *)
+										(*(*l_bibliotheque_courante).donnee)
+										.objet);
+							}
+							else
+							{
+								printf("+++Fatal : Cannot load library %s\n",
+										(*(*l_bibliotheque_courante).donnee)
+										.objet);
+							}
+
+							if (traitement_fichier_temporaire == 'Y')
+							{
+								if (destruction_fichier(
+										nom_fichier_temporaire)
+										== d_erreur)
+								{
+									return(EXIT_FAILURE);
+								}
+
+								free(nom_fichier_temporaire);
+							}
+
+							return(EXIT_FAILURE);
+						}
+
+						instruction_use(s_etat_processus);
+
+						if (depilement(s_etat_processus, &((*s_etat_processus)
+								.l_base_pile), &((*l_bibliotheque_courante)
+								.donnee)) == d_erreur)
+						{
+#							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_destroy3((*s_etat_processus).semaphore_fork,
+										getpid(), pthread_self(), SEM_FORK);
+#							endif
+
+							liberation_contexte_cas(s_etat_processus);
+							destruction_queue_signaux(s_etat_processus);
+
+#							ifdef HAVE_STACK_OVERFLOW_RECOVERY
+								stackoverflow_deinstall_handler();
+#							endif
+
+#							ifdef HAVE_SIGSEGV_RECOVERY
+								if (debug == d_faux)
+								{
+									sigsegv_deinstall_handler();
+								}
+#							endif
+
+							if ((*s_etat_processus).langue == 'F')
+							{
+								printf("+++Fatal :"
+										" Chargement de la bibliothèse %s"
+										" impossible\n", (unsigned char *)
+										(*(*l_bibliotheque_courante).donnee)
+										.objet);
+							}
+							else
+							{
+								printf("+++Fatal : Cannot load library %s\n",
+										(*(*l_bibliotheque_courante).donnee)
+										.objet);
+							}
+
+							if (traitement_fichier_temporaire == 'Y')
+							{
+								if (destruction_fichier(
+										nom_fichier_temporaire)
+										== d_erreur)
+								{
+									return(EXIT_FAILURE);
+								}
+
+								free(nom_fichier_temporaire);
+							}
+
+							return(EXIT_FAILURE);
+						}
+
+						l_bibliotheque_courante =
+								(*l_bibliotheque_courante).suivant;
+					}
+
 					if ((erreur = compilation(s_etat_processus)) !=
 							d_absence_erreur)
 					{
@@ -4751,7 +5183,8 @@ rplinit(int argc, char *argv[], char *en
 						{
 							if (setjmp(contexte_initial) == 0)
 							{
-								erreur = sequenceur_optimise(s_etat_processus);
+								erreur = sequenceur_optimise(s_etat_processus,
+										l_bibliotheques);
 
 								if (erreur == d_absence_erreur)
 								{
@@ -5467,41 +5900,6 @@ rplinit(int argc, char *argv[], char *en
 						l_element_courant = l_element_suivant;
 					}
 
-					for(i = 0; i < (*s_etat_processus)
-							.nombre_instructions_externes; i++)
-					{
-						free((*s_etat_processus).s_instructions_externes[i]
-								.nom);
-						free((*s_etat_processus).s_instructions_externes[i]
-								.nom_bibliotheque);
-					}
-
-					if ((*s_etat_processus).nombre_instructions_externes != 0)
-					{
-						free((*s_etat_processus).s_instructions_externes);
-					}
-
-					l_element_courant = (void *) (*s_etat_processus)
-							.s_bibliotheques;
-					
-					while(l_element_courant != NULL)
-					{
-						l_element_suivant = (*((struct_liste_chainee *)
-								l_element_courant)).suivant;
-
-						free((*((struct_bibliotheque *)
-								(*((struct_liste_chainee *)
-								l_element_courant)).donnee)).nom);
-						dlclose((*((struct_bibliotheque *)
-								(*((struct_liste_chainee *)
-								l_element_courant)).donnee)).descripteur);
-						free((*((struct_liste_chainee *) l_element_courant))
-								.donnee);
-						free(l_element_courant);
-
-						l_element_courant = l_element_suivant;
-					}
-
 					l_element_courant = (void *) (*s_etat_processus)
 							.l_base_pile_last;
 					while(l_element_courant != NULL)
@@ -5517,6 +5915,14 @@ rplinit(int argc, char *argv[], char *en
 						l_element_courant = l_element_suivant;
 					}
 
+					while((*s_etat_processus).s_bibliotheques != NULL)
+					{
+						retrait_bibliotheque(s_etat_processus,
+								(struct_bibliotheque *)
+								(*((struct_liste_chainee *)
+								(*s_etat_processus).s_bibliotheques)).donnee);
+					}
+
 					l_element_courant = (void *) (*s_etat_processus)
 							.l_base_pile_systeme;
 					while(l_element_courant != NULL)
@@ -5788,6 +6194,8 @@ informations(struct_processus *s_etat_pr
 		printf("      -i : fonctionnement interactif\n");
 		printf("      -l : licence d'utilisation\n");
 		printf("      -n : ignorance du signal HUP\n");
+		printf("      -m : chargement d'un module RPL/SO avant la "
+				"compilation\n");
 		printf("      -p : précompilation du script avant exécution\n");
 		printf("      -P : profilage (-P ou -PP)\n");
 		printf("      -s : empêchement de l'ouverture de l'écran initial\n");
@@ -5809,6 +6217,7 @@ informations(struct_processus *s_etat_pr
 		printf("      -i : runs the RPL/2 sequencer in interactive mode\n");
 		printf("      -l : prints the user licence of the software\n");
 		printf("      -n : ignores HUP signal\n");
+		printf("      -m : loads RPL/SO object before compilation\n");
 		printf("      -p : precompiles script\n");
 		printf("      -P : computes profile data (-P or -PP)\n");
 		printf("      -s : disables splash screen\n");