--- rpl/src/bibliotheques_externes.c	2011/06/20 17:54:13	1.25
+++ rpl/src/bibliotheques_externes.c	2018/12/21 10:56:11	1.78
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.0.prerelease.1
-  Copyright (C) 1989-2011 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.29
+  Copyright (C) 1989-2018 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -41,22 +41,24 @@ void *
 chargement_bibliotheque(struct_processus *s_etat_processus,
 		unsigned char *bibliotheque)
 {
-	char					**(*fonction)(unsigned long *, const char *);
+	char					**(*fonction)(struct_rpl_arguments *,
+									integer8 *, const char *);
 	char					*message;
 
-	long					i;
-	long					nombre_symboles;
+	integer8				i;
+	integer8				nombre_symboles;
 
 	struct_rpl_arguments	rpl_arguments;
 
 	struct_liste_chainee	*l_element_courant;
 	struct_liste_chainee	*l_nouvel_element;
 
+	unsigned char			*fleche;
 	unsigned char			**tableau;
 	unsigned char			*tampon;
 
 	void					*descripteur_bibliotheque;
-	void					(*onloading)(struct_rpl_arguments *);
+	int						(*onloading)(struct_rpl_arguments *, void *);
 
 	/*
 	 * On vérifie que la bibliothèque n'est pas déjà chargée.
@@ -162,32 +164,22 @@ chargement_bibliotheque(struct_processus
 		}
 
 #		ifndef SEMAPHORES_NOMMES
-		if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
-		{
-			(*s_etat_processus).erreur_systeme = d_es_processus;
-			return(NULL);
-		}
+			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(NULL);
 		}
-#		endif
 
-		(*onloading)(&rpl_arguments);
+		(*onloading)(&rpl_arguments, descripteur_bibliotheque);
 
 #		ifndef SEMAPHORES_NOMMES
-		while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
-		{
-			if (errno != EINTR)
-			{
-				(*s_etat_processus).erreur_systeme = d_es_processus;
-				return(NULL);
-			}
-		}
+			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)
 			{
@@ -195,7 +187,6 @@ chargement_bibliotheque(struct_processus
 				return(NULL);
 			}
 		}
-#		endif
 
 		if ((*s_etat_processus).profilage == d_vrai)
 		{
@@ -315,7 +306,7 @@ chargement_bibliotheque(struct_processus
 	}
 
 	dlerror();
-	fonction = dlsym(descripteur_bibliotheque, "__external_symbols");
+	fonction = dlsym(descripteur_bibliotheque, "___external_symbols");
 
 	if (fonction == NULL)
 	{
@@ -346,8 +337,8 @@ chargement_bibliotheque(struct_processus
 	 * Ajout des symboles externes
 	 */
 
-	if ((tableau = (unsigned char **) (*fonction)((&nombre_symboles),
-			d_version_rpl)) == NULL)
+	if ((tableau = (unsigned char **) (*fonction)(&rpl_arguments,
+			(&nombre_symboles), d_version_rpl)) == NULL)
 	{
 		/*
 		 * Nombre symboles :
@@ -373,9 +364,9 @@ chargement_bibliotheque(struct_processus
 	}
 
 	if (((*s_etat_processus).s_instructions_externes = realloc(
-			(*s_etat_processus).s_instructions_externes,
-			((*s_etat_processus).nombre_instructions_externes + nombre_symboles)
-			* sizeof(struct_instruction_externe))) == NULL)
+			(*s_etat_processus).s_instructions_externes, ((size_t)
+			((*s_etat_processus).nombre_instructions_externes +
+			nombre_symboles)) * sizeof(struct_instruction_externe))) == NULL)
 	{
 		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 		return(NULL);
@@ -383,6 +374,19 @@ chargement_bibliotheque(struct_processus
 
 	for(i = 0; i < nombre_symboles; i++)
 	{
+		if ((fleche = strstr(tableau[i], "->")) != NULL)
+		{
+			memcpy(fleche, "to", 2);
+			(*s_etat_processus).s_instructions_externes[(*s_etat_processus)
+					.nombre_instructions_externes].position_fleche =
+					fleche - tableau[i];
+		}
+		else
+		{
+			(*s_etat_processus).s_instructions_externes[(*s_etat_processus)
+					.nombre_instructions_externes].position_fleche = -1;
+		}
+
 		(*s_etat_processus).s_instructions_externes[(*s_etat_processus)
 				.nombre_instructions_externes].descripteur_bibliotheque =
 				descripteur_bibliotheque;
@@ -456,6 +460,10 @@ chargement_bibliotheque(struct_processus
 			[(*s_etat_processus).nombre_instructions_externes - 1]
 			.nom_bibliotheque);
 
+	// La nouvelle bibliothèque est mise en tête de la liste pour que
+	// les bibliothèques soient implicitement déchargées dans l'ordre
+	// inverse de leur chargement.
+
 	(*l_nouvel_element).suivant = (*s_etat_processus).s_bibliotheques;
 	(*s_etat_processus).s_bibliotheques = l_nouvel_element;
 
@@ -496,11 +504,11 @@ retrait_bibliotheque(struct_processus *s
 
 	unsigned char				*tampon;
 
-	unsigned long				i;
-	unsigned long				j;
-	unsigned long				nombre_symboles_residuels;
+	integer8					i;
+	integer8					j;
+	integer8					nombre_symboles_residuels;
 
-	void						(*onclosing)(struct_rpl_arguments *);
+	int							(*onclosing)(struct_rpl_arguments *, void *);
 
 	l_element_courant = (*s_etat_processus).s_bibliotheques;
 	presence_bibliotheque = d_faux;
@@ -592,32 +600,22 @@ retrait_bibliotheque(struct_processus *s
 			}
 
 #			ifndef SEMAPHORES_NOMMES
-			if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
-			{
-				(*s_etat_processus).erreur_systeme = d_es_processus;
-				return(d_erreur);
-			}
+				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(d_erreur);
 			}
-#			endif
 
-			(*onclosing)(&rpl_arguments);
+			(*onclosing)(&rpl_arguments, (*descripteur).descripteur);
 
 #			ifndef SEMAPHORES_NOMMES
-			while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
-			{
-				if (errno != EINTR)
-				{
-					(*s_etat_processus).erreur_systeme = d_es_processus;
-					return(d_erreur);
-				}
-			}
+				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)
 				{
@@ -625,7 +623,6 @@ retrait_bibliotheque(struct_processus *s
 					return(d_erreur);
 				}
 			}
-#			endif
 
 			if ((*s_etat_processus).profilage == d_vrai)
 			{
@@ -808,7 +805,7 @@ retrait_bibliotheque(struct_processus *s
 			registre = (*s_etat_processus).s_instructions_externes;
 
 			if (((*s_etat_processus).s_instructions_externes =
-					malloc(nombre_symboles_residuels *
+					malloc(((size_t) nombre_symboles_residuels) *
 					sizeof(struct_instruction_externe))) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
@@ -874,25 +871,26 @@ execution_fonction_de_bibliotheque(struc
 	logical1						presence_bibliotheque;
 	logical1						unicite_symbole;
 
-	long							difference;
-	long							difference_inferieure;
-	long							difference_superieure;
-	long							i;
+	int								difference;
+	int								difference_inferieure;
+	int								difference_superieure;
 
 	struct_liste_chainee			*l_element_courant;
 
 	struct_rpl_arguments			rpl_arguments;
 
+	unsigned char					*fleche;
 	unsigned char					*nom_fonction_externe;
 	unsigned char					*tampon;
 
-	unsigned long					borne_inferieure;
-	unsigned long					borne_superieure;
-	unsigned long					moyenne;
-	unsigned long					nombre_iterations_maximal;
-	unsigned long					ordre_iteration;
+	integer8						borne_inferieure;
+	integer8						borne_superieure;
+	integer8						i;
+	integer8						moyenne;
+	integer8						nombre_iterations_maximal;
+	integer8						ordre_iteration;
 
-	void							(*fonction)(struct_rpl_arguments *);
+	int								(*fonction)(struct_rpl_arguments *);
 
 	/*
 	 * Recherche dichotomique de la définition externe
@@ -926,10 +924,15 @@ execution_fonction_de_bibliotheque(struc
 		}
 	}
 
+	if ((fleche = strstr(nom_fonction, "->")) != NULL)
+	{
+		memcpy(fleche, "to", 2);
+	}
+
 	ordre_iteration = 0;
-	nombre_iterations_maximal = ((unsigned long)
-			(log((*s_etat_processus).nombre_instructions_externes) / log(2)))
-			+ 2;
+	nombre_iterations_maximal = ((integer8)
+			(log((real8) (*s_etat_processus).nombre_instructions_externes) /
+			log(2))) + 2;
 
 	borne_inferieure = 0;
 	borne_superieure = (*s_etat_processus).nombre_instructions_externes - 1;
@@ -939,7 +942,7 @@ execution_fonction_de_bibliotheque(struc
 		moyenne = (borne_inferieure + borne_superieure) / 2;
 		ordre_iteration++;
 
-		if ((2 * ((unsigned long) ((borne_inferieure + borne_superieure) / 2)))
+		if ((2 * ((integer8) ((borne_inferieure + borne_superieure) / 2)))
 				== (borne_inferieure + borne_superieure))
 		{
 			difference = strcmp(nom_fonction, (*s_etat_processus)
@@ -1026,8 +1029,7 @@ execution_fonction_de_bibliotheque(struc
 		{
 			i = moyenne;
 
-			while((unsigned long) i <
-					(*s_etat_processus).nombre_instructions_externes)
+			while(i < (*s_etat_processus).nombre_instructions_externes)
 			{
 				if (strcmp((*s_etat_processus).s_instructions_externes[i]
 						.nom, nom_fonction) != 0)
@@ -1178,32 +1180,22 @@ execution_fonction_de_bibliotheque(struc
 	}
 
 #	ifndef SEMAPHORES_NOMMES
-	if (sem_post(&((*s_etat_processus).semaphore_fork)) != 0)
-	{
-		(*s_etat_processus).erreur_systeme = d_es_processus;
-		return(d_faux);
-	}
+		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(d_faux);
 	}
-#	endif
 
 	(*fonction)(&rpl_arguments);
 
 #	ifndef SEMAPHORES_NOMMES
-	while(sem_wait(&((*s_etat_processus).semaphore_fork)) == -1)
-	{
-		if (errno != EINTR)
-		{
-			(*s_etat_processus).erreur_systeme = d_es_processus;
-			return(d_faux);
-		}
-	}
+		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)
 		{
@@ -1211,7 +1203,6 @@ execution_fonction_de_bibliotheque(struc
 			return(d_faux);
 		}
 	}
-#	endif
 
 	if ((*s_etat_processus).profilage == d_vrai)
 	{
@@ -1439,7 +1430,10 @@ empilement_pile_operationnelle(struct_rp
 	struct_liste_chainee		*l_ancienne_base_liste;
 	struct_liste_chainee		*l_nouvelle_base_liste;
 
+	struct_processus			*s_etat_processus;
+
 	l_ancienne_base_liste = (*s_rpl_arguments).l_base_pile;
+	s_etat_processus = (*s_rpl_arguments).s_etat_processus;
 
 	l_nouvelle_base_liste = (struct_liste_chainee *) malloc(
 			sizeof(struct_liste_chainee));
@@ -1475,6 +1469,8 @@ depilement_pile_operationnelle(struct_rp
 	struct_liste_chainee		*l_ancienne_base_liste;
 	struct_liste_chainee		*l_nouvelle_base_liste;
 
+	struct_processus			*s_etat_processus;
+
 	if ((*s_rpl_arguments).l_base_pile == NULL)
 	{
 		*s_objet = NULL;
@@ -1484,6 +1480,7 @@ depilement_pile_operationnelle(struct_rp
 	{
 		l_ancienne_base_liste = (*s_rpl_arguments).l_base_pile;
 		l_nouvelle_base_liste = (*l_ancienne_base_liste).suivant;
+		s_etat_processus = (*s_rpl_arguments).s_etat_processus;
 
 		*s_objet = (*l_ancienne_base_liste).donnee;
 		free(l_ancienne_base_liste);
@@ -1509,7 +1506,7 @@ depilement_pile_operationnelle(struct_rp
 
 struct_liste_chainee *
 sauvegarde_arguments(struct_rpl_arguments *s_rpl_arguments,
-		unsigned long nombre_arguments)
+		integer8 nombre_arguments)
 {
 	struct_liste_chainee			*l_ancienne_base_liste;
 	struct_liste_chainee			*l_element_courant;
@@ -1527,7 +1524,7 @@ sauvegarde_arguments(struct_rpl_argument
 	unsigned char					indice_drapeau;
 	unsigned char					taille_bloc;
 
-	unsigned long					i;
+	integer8						i;
 
 	struct_processus				*s_etat_processus;
 
@@ -1540,7 +1537,7 @@ sauvegarde_arguments(struct_rpl_argument
 	indice_bloc = indice_drapeau / taille_bloc;
 	indice_bit = indice_drapeau % taille_bloc;
 
-	masque = ((t_8_bits) 1) << (taille_bloc - indice_bit - 1);
+	masque = (t_8_bits) ((1 << (taille_bloc - indice_bit - 1)) & 0xFF);
 
 	if (((*s_rpl_arguments).drapeaux_etat[indice_bloc] & masque) == 0)
 	{
@@ -1638,15 +1635,14 @@ tri_base_symboles_externes(struct_proces
 	logical1			terminaison_boucle_2;
 	logical1			terminaison_boucle_3;
 
-	signed long			indice_i;
-	signed long			indice_j;
-	signed long			indice_k;
-	signed long			indice_l;
-
-	unsigned long		borne_inferieure;
-	unsigned long		borne_superieure;
-	unsigned long		ecartement;
-	unsigned long		indice;
+	integer8			borne_inferieure;
+	integer8			borne_superieure;
+	integer8			ecartement;
+	integer8			indice;
+	integer8			indice_i;
+	integer8			indice_j;
+	integer8			indice_k;
+	integer8			indice_l;
 
 	ecartement = (*s_etat_processus).nombre_instructions_externes;
 
@@ -1725,7 +1721,7 @@ tri_base_symboles_externes(struct_proces
 	{
 		indice_j = indice_i;
 
-		while(((unsigned long) (indice_i + 1) < (*s_etat_processus)
+		while(((indice_i + 1) < (*s_etat_processus)
 				.nombre_instructions_externes) && (strcmp(((*s_etat_processus)
 				.s_instructions_externes[indice_i]).nom, ((*s_etat_processus)
 				.s_instructions_externes[indice_i + 1]).nom) == 0))
@@ -1759,8 +1755,7 @@ tri_base_symboles_externes(struct_proces
 		} while(terminaison_boucle == d_faux);
 
 		indice_i++;
-	} while((unsigned long) (indice_i + 1) <
-			(*s_etat_processus).nombre_instructions_externes);
+	} while((indice_i + 1) < (*s_etat_processus).nombre_instructions_externes);
 
 	return;
 }