--- rpl/src/types.c	2013/02/27 17:11:46	1.57
+++ rpl/src/types.c	2020/01/10 11:15:52	1.97
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.13
-  Copyright (C) 1989-2013 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.32
+  Copyright (C) 1989-2020 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -38,7 +38,25 @@
 void
 recherche_type(struct_processus *s_etat_processus)
 {
-	int							nombre_elements_convertis;
+	integer8					i;
+	integer8					j;
+	integer8					niveau;
+	integer8					niveau_maximal;
+	integer8					nombre_colonnes;
+	integer8					nombre_egalites;
+	integer8					nombre_elements;
+	integer8					nombre_elements_convertis;
+	integer8					nombre_exposants;
+	integer8					nombre_lignes;
+	integer8					nombre_lignes_a_supprimer;
+	integer8					nombre_points;
+	integer8					nombre_virgules;
+	integer8					position_courante;
+	integer8					profondeur_finale;
+	integer8					profondeur_initiale;
+	integer8					sauvegarde_niveau_courant;
+	integer8					sauvegarde_longueur_definitions_chainees;
+	integer8					(*__type_new)(struct_processus *, void **);
 
 	struct_liste_chainee		*l_base_liste_fonctions;
 	struct_liste_chainee		*l_base_liste_decomposition;
@@ -60,6 +78,7 @@ recherche_type(struct_processus *s_etat_
 	logical1					drapeau_valeur_reelle;
 	logical1					erreur;
 	logical1					erreur_lecture_binaire;
+	logical1					tri_acheve;
 
 	logical8					ancienne_valeur_base;
 	logical8					valeur_base;
@@ -82,24 +101,6 @@ recherche_type(struct_processus *s_etat_
 	unsigned char				*tampon;
 	unsigned char				variable_implicite;
 
-	unsigned long				i;
-	unsigned long				j;
-	unsigned long				niveau;
-	unsigned long				niveau_maximal;
-	unsigned long				nombre_colonnes;
-	unsigned long				nombre_egalites;
-	unsigned long				nombre_elements;
-	unsigned long				nombre_exposants;
-	unsigned long				nombre_lignes;
-	unsigned long				nombre_lignes_a_supprimer;
-	unsigned long				nombre_points;
-	unsigned long				nombre_virgules;
-	unsigned long				position_courante;
-	unsigned long				profondeur_finale;
-	unsigned long				profondeur_initiale;
-	unsigned long				sauvegarde_niveau_courant;
-	unsigned long				sauvegarde_longueur_definitions_chainees;
-
 	void						*element;
 
 	if ((s_objet = allocation(s_etat_processus, NON)) == NULL)
@@ -144,8 +145,8 @@ recherche_type(struct_processus *s_etat_
 				 */
 
 				if (((*((struct_fonction *) element)).nom_fonction =
-						conversion_majuscule((*s_etat_processus)
-						.instruction_courante)) == NULL)
+						conversion_majuscule(s_etat_processus,
+						(*s_etat_processus).instruction_courante)) == NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
 							d_es_allocation_memoire;
@@ -192,7 +193,7 @@ recherche_type(struct_processus *s_etat_
 		}
 		else
 		{
-			if ((instruction_majuscule = conversion_majuscule(
+			if ((instruction_majuscule = conversion_majuscule(s_etat_processus,
 					(*s_etat_processus).instruction_courante)) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
@@ -261,6 +262,57 @@ recherche_type(struct_processus *s_etat_
 
 	(*s_etat_processus).instruction_valide = registre_instruction_valide;
 
+/*
+--------------------------------------------------------------------------------
+  Types externes
+--------------------------------------------------------------------------------
+*/
+
+	l_element_courant = (*s_etat_processus).s_bibliotheques;
+
+	while(l_element_courant != NULL)
+	{
+		if ((__type_new = dlsym((*((struct_bibliotheque *)
+				(*l_element_courant).donnee)).descripteur, "__type_new"))
+				!= NULL)
+		{
+			if (((*s_objet).extension_type = __type_new(s_etat_processus,
+					&element)) != 0)
+			{
+				// Le type peut être converti.
+
+				(*s_objet).objet = element;
+				(*s_objet).type = EXT;
+				(*s_objet).descripteur_bibliotheque =
+						(*((struct_bibliotheque *)
+						(*l_element_courant).donnee)).descripteur;
+
+				if (empilement(s_etat_processus,
+						&((*s_etat_processus).l_base_pile), s_objet)
+						== d_erreur)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					(*s_etat_processus).traitement_interruptible =
+							registre_interruption;
+					return;
+				}
+
+				(*s_etat_processus).traitement_interruptible =
+						registre_interruption;
+				return;
+			}
+		}
+
+		l_element_courant = (*l_element_courant).suivant;
+	}
+
+/*
+--------------------------------------------------------------------------------
+  Types internes
+--------------------------------------------------------------------------------
+*/
+
 	switch(*((*s_etat_processus).instruction_courante))
 	{
 
@@ -289,10 +341,10 @@ recherche_type(struct_processus *s_etat_
 			sauvegarde_longueur_definitions_chainees =
 					(*s_etat_processus).longueur_definitions_chainees;
 
-			tampon = (unsigned char *) malloc(
+			tampon = (unsigned char *) malloc(((size_t)
 					(((*s_etat_processus).longueur_definitions_chainees
-					= strlen((*s_etat_processus).instruction_courante)
-					+ 4) + 1) * sizeof(unsigned char));
+					= (integer8) strlen((*s_etat_processus)
+					.instruction_courante) + 4) + 1)) * sizeof(unsigned char));
 
 			if (tampon == NULL)
 			{
@@ -432,7 +484,7 @@ recherche_type(struct_processus *s_etat_
 				liberation(s_etat_processus, s_objet);
 				free(element);
 
-				for(i = 0; i < (unsigned long) nombre_elements_convertis; i++)
+				for(i = 0; i < nombre_elements_convertis; i++)
 				{
 					if (depilement(s_etat_processus, &((*s_etat_processus)
 							.l_base_pile), &s_sous_objet) == d_erreur)
@@ -458,7 +510,7 @@ recherche_type(struct_processus *s_etat_
 					if ((*s_sous_objet).type == INT)
 					{
 						(*((struct_complexe16 *) element)).partie_imaginaire =
-								(*((integer8 *) (*s_sous_objet).objet));
+								(real8) (*((integer8 *) (*s_sous_objet).objet));
 					}
 					else if ((*s_sous_objet).type == REL)
 					{
@@ -488,7 +540,8 @@ recherche_type(struct_processus *s_etat_
 						if ((*s_sous_objet).type == INT)
 						{
 							(*((struct_complexe16 *) element)).partie_reelle =
-									(*((integer8 *) (*s_sous_objet).objet));
+									(real8) (*((integer8 *)
+									(*s_sous_objet).objet));
 						}
 						else if ((*s_sous_objet).type == REL)
 						{
@@ -544,7 +597,8 @@ recherche_type(struct_processus *s_etat_
 			{
 				case 'b' :
 				{
-					i = strlen((*s_etat_processus).instruction_courante) - 2;
+					i = ((integer8) strlen((*s_etat_processus)
+							.instruction_courante)) - 2;
 					valeur_base = 1;
 					
 					(*((logical8 *) element)) = 0;
@@ -618,7 +672,8 @@ recherche_type(struct_processus *s_etat_
 
 				case 'o' :
 				{
-					i = strlen((*s_etat_processus).instruction_courante) - 2;
+					i = ((integer8) strlen((*s_etat_processus)
+							.instruction_courante)) - 2;
 					valeur_base = 1;
 					
 					(*((logical8 *) element)) = 0;
@@ -722,7 +777,8 @@ recherche_type(struct_processus *s_etat_
 
 				case 'd' :
 				{
-					i = strlen((*s_etat_processus).instruction_courante) - 2;
+					i = ((integer8) strlen((*s_etat_processus)
+							.instruction_courante)) - 2;
 					valeur_base = 1;
 					
 					(*((logical8 *) element)) = 0;
@@ -836,7 +892,8 @@ recherche_type(struct_processus *s_etat_
 
 				case 'h' :
 				{
-					i = strlen((*s_etat_processus).instruction_courante) - 2;
+					i = ((integer8) strlen((*s_etat_processus)
+							.instruction_courante)) - 2;
 					valeur_base = 1;
 					
 					(*((logical8 *) element)) = 0;
@@ -1089,10 +1146,11 @@ recherche_type(struct_processus *s_etat_
 					sauvegarde_longueur_definitions_chainees =
 							(*s_etat_processus).longueur_definitions_chainees;
 
-					tampon = (unsigned char *) malloc(
+					tampon = (unsigned char *) malloc(((size_t)
 							(((*s_etat_processus).longueur_definitions_chainees
-							= strlen((*s_etat_processus).instruction_courante)
-							+ 4) + 1) * sizeof(unsigned char));
+							= (integer8) strlen((*s_etat_processus)
+							.instruction_courante) + 4) + 1)) *
+							sizeof(unsigned char));
 
 					if (tampon == NULL)
 					{
@@ -1313,22 +1371,23 @@ recherche_type(struct_processus *s_etat_
 					if (drapeau_complexe == d_vrai)
 					{
 						(*((struct_vecteur *) element)).tableau = (void *)
-								((struct_complexe16 *) malloc(nombre_colonnes *
+								((struct_complexe16 *) malloc(((size_t)
+								nombre_colonnes) *
 								sizeof(struct_complexe16)));
 						(*((struct_vecteur *) element)).type = 'C';
 					}
 					else if (drapeau_reel == d_vrai)
 					{
 						(*((struct_vecteur *) element)).tableau = (void *)
-								((real8 *) malloc(nombre_colonnes *
+								((real8 *) malloc(((size_t) nombre_colonnes) *
 								sizeof(real8)));
 						(*((struct_vecteur *) element)).type = 'R';
 					}
 					else
 					{
 						(*((struct_vecteur *) element)).tableau = (void *)
-								((integer8 *) malloc(nombre_colonnes *
-								sizeof(integer8)));
+								((integer8 *) malloc(((size_t) nombre_colonnes)
+								* sizeof(integer8)));
 						(*((struct_vecteur *) element)).type = 'I';
 					}
 
@@ -1501,10 +1560,11 @@ recherche_type(struct_processus *s_etat_
 					sauvegarde_longueur_definitions_chainees =
 							(*s_etat_processus).longueur_definitions_chainees;
 
-					tampon = (unsigned char *) malloc(
+					tampon = (unsigned char *) malloc(((size_t)
 							(((*s_etat_processus).longueur_definitions_chainees
-							= strlen((*s_etat_processus).instruction_courante)
-							+ 4) + 1) * sizeof(unsigned char));
+							= (integer8) strlen((*s_etat_processus)
+							.instruction_courante) + 4) + 1)) *
+							sizeof(unsigned char));
 
 					if (tampon == NULL)
 					{
@@ -1791,7 +1851,7 @@ recherche_type(struct_processus *s_etat_
 						{
 							if (((*((struct_matrice *) element)).tableau =
 									(void **) ((struct_complexe16 **)
-									malloc(nombre_lignes * sizeof(
+									malloc(((size_t) nombre_lignes) * sizeof(
 									struct_complexe16 *)))) == NULL)
 							{
 								liberation(s_etat_processus, s_objet_registre);
@@ -1810,8 +1870,8 @@ recherche_type(struct_processus *s_etat_
 								if ((((*((struct_matrice *)
 										element)).tableau)[i] = (void *)
 										((struct_complexe16 *)
-										malloc(nombre_colonnes * sizeof(
-										struct_complexe16)))) == NULL)
+										malloc(((size_t) nombre_colonnes) *
+										sizeof(struct_complexe16)))) == NULL)
 								{
 									liberation(s_etat_processus,
 											s_objet_registre);
@@ -1828,8 +1888,8 @@ recherche_type(struct_processus *s_etat_
 						else if (drapeau_reel == d_vrai)
 						{
 							if (((*((struct_matrice *) element)).tableau =
-									(void **) ((real8 **)
-									malloc(nombre_lignes * sizeof(real8 *))))
+									(void **) ((real8 **) malloc(((size_t)
+									nombre_lignes) * sizeof(real8 *))))
 									== NULL)
 							{
 								liberation(s_etat_processus, s_objet_registre);
@@ -1847,7 +1907,7 @@ recherche_type(struct_processus *s_etat_
 							{
 								if ((((*((struct_matrice *)element)).tableau)[i]
 										= (void *) ((real8 *)
-										malloc(nombre_colonnes *
+										malloc(((size_t) nombre_colonnes) *
 										sizeof(real8)))) == NULL)
 								{
 									liberation(s_etat_processus,
@@ -1866,7 +1926,7 @@ recherche_type(struct_processus *s_etat_
 						{
 							if (((*((struct_matrice *) element)).tableau =
 									(void **) ((integer8 **)
-									malloc(nombre_lignes *
+									malloc(((size_t) nombre_lignes) *
 									sizeof(integer8 *)))) == NULL)
 							{
 								liberation(s_etat_processus, s_objet_registre);
@@ -1885,7 +1945,7 @@ recherche_type(struct_processus *s_etat_
 								if ((((*((struct_matrice *)
 										element)).tableau)[i] = (void *)
 										((integer8 *)
-										malloc(nombre_colonnes *
+										malloc(((size_t) nombre_colonnes) *
 										sizeof(integer8)))) == NULL)
 								{
 									liberation(s_etat_processus,
@@ -2132,10 +2192,10 @@ recherche_type(struct_processus *s_etat_
 			sauvegarde_longueur_definitions_chainees =
 					(*s_etat_processus).longueur_definitions_chainees;
 
-			tampon = (unsigned char *) malloc(
+			tampon = (unsigned char *) malloc(((size_t)
 					(((*s_etat_processus).longueur_definitions_chainees =
-					strlen((*s_etat_processus).instruction_courante) + 4) + 1)
-					* sizeof(unsigned char));
+					(integer8) strlen((*s_etat_processus)
+					.instruction_courante) + 4) + 1)) * sizeof(unsigned char));
 
 			if (tampon == NULL)
 			{
@@ -2659,7 +2719,8 @@ recherche_type(struct_processus *s_etat_
 						 * elle est convertie en majuscules.
 						 */
 
-						tampon = conversion_majuscule((*((struct_fonction *)
+						tampon = conversion_majuscule(s_etat_processus,
+								(*((struct_fonction *)
 								(*(*l_element_courant).donnee).objet))
 								.nom_fonction);
 
@@ -2697,6 +2758,7 @@ recherche_type(struct_processus *s_etat_
 								{
 									if ((fonction_majuscule =
 											conversion_majuscule(
+											s_etat_processus,
 											(*((struct_fonction *)
 											((*l_element_courant_fonctions)
 											.donnee))).nom_fonction)) == NULL)
@@ -2848,6 +2910,7 @@ recherche_type(struct_processus *s_etat_
 				free(l_element_courant_fonctions);
 			}
 
+			(*s_etat_processus).autorisation_empilement_programme = 'Y';
 			break;
 		}
 
@@ -2908,13 +2971,15 @@ recherche_type(struct_processus *s_etat_
 			{
 				// Tableau
 
+				(*s_etat_processus).type_en_cours = TBL;
 				sauvegarde_longueur_definitions_chainees =
 						(*s_etat_processus).longueur_definitions_chainees;
 
-				tampon = (unsigned char *) malloc(
+				tampon = (unsigned char *) malloc(((size_t)
 						(((*s_etat_processus).longueur_definitions_chainees
-						= strlen((*s_etat_processus).instruction_courante)
-						+ 2) + 1) * sizeof(unsigned char));
+						= (integer8) strlen((*s_etat_processus)
+						.instruction_courante) + 2) + 1)) *
+						sizeof(unsigned char));
 
 				if (tampon == NULL)
 				{
@@ -2968,14 +3033,21 @@ recherche_type(struct_processus *s_etat_
 
 				(*(*s_etat_processus).l_base_pile_systeme)
 						.retour_definition = 'Y';
+				(*(*s_etat_processus).l_base_pile_systeme)
+						.origine_routine_evaluation = 'N';
 				(*s_etat_processus).niveau_courant = 0;
 				(*s_etat_processus).autorisation_empilement_programme = 'N';
+
+				tampon = (*s_etat_processus).instruction_courante;
+				autorisation_evaluation_nom = (*s_etat_processus)
+						.autorisation_evaluation_nom;
+				(*s_etat_processus).autorisation_evaluation_nom = 'N';
+
 				registre_mode_execution_programme =
 						(*s_etat_processus).mode_execution_programme;
 				(*s_etat_processus).mode_execution_programme = 'Y';
 				(*s_etat_processus).erreur_scrutation = d_faux;
 
-				tampon = (*s_etat_processus).instruction_courante;
 				nombre_lignes_a_supprimer =
 						(*s_etat_processus).hauteur_pile_operationnelle;
 
@@ -3024,6 +3096,8 @@ recherche_type(struct_processus *s_etat_
 					}
 
 					(*s_etat_processus).instruction_courante = tampon;
+					(*s_etat_processus).autorisation_evaluation_nom =
+							autorisation_evaluation_nom;
 
 					effacement_pile_systeme(s_etat_processus);
 					(*s_etat_processus).l_base_pile_systeme =
@@ -3077,6 +3151,8 @@ recherche_type(struct_processus *s_etat_
 					}
 
 					(*s_etat_processus).instruction_courante = tampon;
+					(*s_etat_processus).autorisation_evaluation_nom =
+							autorisation_evaluation_nom;
 
 					effacement_pile_systeme(s_etat_processus);
 					(*s_etat_processus).l_base_pile_systeme =
@@ -3104,6 +3180,8 @@ recherche_type(struct_processus *s_etat_
 				}
 
 				(*s_etat_processus).instruction_courante = tampon;
+				(*s_etat_processus).autorisation_evaluation_nom =
+						autorisation_evaluation_nom;
 
 				(*s_etat_processus).l_base_pile_systeme = s_sauvegarde_pile;
 				(*s_etat_processus).niveau_courant =
@@ -3141,7 +3219,8 @@ recherche_type(struct_processus *s_etat_
 				(*((struct_tableau *) element)).nombre_elements = nombre_lignes;
 
 				if (((*((struct_tableau *) element)).elements =
-						malloc(nombre_lignes * sizeof(struct_objet *))) == NULL)
+						malloc(((size_t) nombre_lignes) *
+						sizeof(struct_objet *))) == NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
 							d_es_allocation_memoire;
@@ -3174,6 +3253,8 @@ recherche_type(struct_processus *s_etat_
 			{
 				// Définition
 
+				(*s_etat_processus).type_en_cours = RPN;
+
 				if (strlen((*s_etat_processus).instruction_courante) < 5)
 				{
 					liberation(s_etat_processus, s_objet);
@@ -3238,6 +3319,410 @@ recherche_type(struct_processus *s_etat_
 
 /*
 --------------------------------------------------------------------------------
+  Enregistrement
+--------------------------------------------------------------------------------
+*/
+
+		case '|' :
+		{
+			if ((*s_etat_processus).instruction_courante[1] == '[')
+			{
+				(*s_etat_processus).type_en_cours = REC;
+				sauvegarde_longueur_definitions_chainees =
+						(*s_etat_processus).longueur_definitions_chainees;
+
+				tampon = (unsigned char *) malloc(((size_t)
+						(((*s_etat_processus).longueur_definitions_chainees
+						= (integer8) strlen((*s_etat_processus)
+						.instruction_courante) + 2) + 1)) *
+						sizeof(unsigned char));
+
+				if (tampon == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					(*s_etat_processus).traitement_interruptible =
+							registre_interruption;
+					return;
+				}
+
+				strcpy(tampon, "<< ");
+				ptr_ecriture = tampon + 3;
+				ptr_lecture = (*s_etat_processus).instruction_courante + 2;
+
+				while((*ptr_lecture) != d_code_fin_chaine)
+				{
+					*ptr_ecriture++ = *ptr_lecture++;
+				}
+
+				ptr_ecriture -= 2;
+				(*ptr_ecriture) = d_code_fin_chaine;
+				strcat(ptr_ecriture, " >>");
+
+				position_courante = (*s_etat_processus).position_courante;
+				(*s_etat_processus).position_courante = 0;
+
+				profondeur_initiale = (*s_etat_processus)
+						.hauteur_pile_operationnelle;
+
+/*
+-- On met les éléments du tableau dans la pile opérationnelle ------------------
+*/
+
+				(*s_etat_processus).niveau_recursivite++;
+				definitions_chainees_precedentes = (*s_etat_processus)
+						.definitions_chainees;
+				(*s_etat_processus).definitions_chainees = tampon;
+
+				s_sauvegarde_pile = (*s_etat_processus).l_base_pile_systeme;
+				sauvegarde_niveau_courant = (*s_etat_processus).niveau_courant;
+
+				(*s_etat_processus).l_base_pile_systeme = NULL;
+				empilement_pile_systeme(s_etat_processus);
+
+				if ((*s_etat_processus).erreur_systeme != d_es)
+				{
+					(*s_etat_processus).traitement_interruptible =
+							registre_interruption;
+					return;
+				}
+
+				(*(*s_etat_processus).l_base_pile_systeme)
+						.retour_definition = 'Y';
+				(*(*s_etat_processus).l_base_pile_systeme)
+						.origine_routine_evaluation = 'N';
+				(*s_etat_processus).niveau_courant = 0;
+				(*s_etat_processus).autorisation_empilement_programme = 'N';
+
+				tampon = (*s_etat_processus).instruction_courante;
+				autorisation_evaluation_nom = (*s_etat_processus)
+						.autorisation_evaluation_nom;
+				(*s_etat_processus).autorisation_evaluation_nom = 'N';
+
+				registre_mode_execution_programme =
+						(*s_etat_processus).mode_execution_programme;
+				(*s_etat_processus).mode_execution_programme = 'Y';
+				(*s_etat_processus).erreur_scrutation = d_faux;
+
+				nombre_lignes_a_supprimer =
+						(*s_etat_processus).hauteur_pile_operationnelle;
+
+				if ((*s_etat_processus).profilage == d_vrai)
+				{
+					profilage(s_etat_processus, "RPL/2 internals");
+
+					if ((*s_etat_processus).erreur_systeme != d_es)
+					{
+						return;
+					}
+				}
+
+				registre_recherche_type = (*s_etat_processus).recherche_type;
+				(*s_etat_processus).recherche_type = 'Y';
+
+				variable_implicite =
+						(*s_etat_processus).autorisation_nom_implicite;
+				(*s_etat_processus).autorisation_nom_implicite = 'Y';
+
+				if (sequenceur(s_etat_processus) == d_erreur)
+				{
+					(*s_etat_processus).autorisation_nom_implicite =
+							variable_implicite;
+					(*s_etat_processus).erreur_execution = d_ex_syntaxe;
+					(*s_etat_processus).recherche_type =
+							registre_recherche_type;
+					(*s_etat_processus).mode_execution_programme =
+							registre_mode_execution_programme;
+					nombre_lignes_a_supprimer =
+							(*s_etat_processus).hauteur_pile_operationnelle
+							- nombre_lignes_a_supprimer;
+
+					for(i = 0; i < nombre_lignes_a_supprimer; i++)
+					{
+						if (depilement(s_etat_processus,
+								&((*s_etat_processus).l_base_pile),
+								&s_sous_objet) == d_erreur)
+						{
+							(*s_etat_processus).traitement_interruptible =
+									registre_interruption;
+							return;
+						}
+
+						liberation(s_etat_processus, s_sous_objet);
+					}
+
+					(*s_etat_processus).instruction_courante = tampon;
+					(*s_etat_processus).autorisation_evaluation_nom =
+							autorisation_evaluation_nom;
+
+					effacement_pile_systeme(s_etat_processus);
+					(*s_etat_processus).l_base_pile_systeme =
+							s_sauvegarde_pile;
+					(*s_etat_processus).niveau_courant =
+							sauvegarde_niveau_courant;
+
+					free((*s_etat_processus).definitions_chainees);
+					(*s_etat_processus).niveau_recursivite--;
+
+					(*s_etat_processus).definitions_chainees =
+							definitions_chainees_precedentes;
+					(*s_etat_processus).longueur_definitions_chainees =
+							sauvegarde_longueur_definitions_chainees;
+
+					(*s_etat_processus).position_courante =
+							position_courante;
+
+					liberation(s_etat_processus, s_objet);
+
+					(*s_etat_processus).erreur_execution = d_ex_syntaxe;
+					(*s_etat_processus).traitement_interruptible =
+							registre_interruption;
+					return;
+				}
+
+				(*s_etat_processus).autorisation_nom_implicite =
+						variable_implicite;
+				(*s_etat_processus).recherche_type = registre_recherche_type;
+				(*s_etat_processus).mode_execution_programme =
+						registre_mode_execution_programme;
+
+				if ((*s_etat_processus).erreur_scrutation == d_vrai)
+				{
+					nombre_lignes_a_supprimer =
+							(*s_etat_processus).hauteur_pile_operationnelle
+							- nombre_lignes_a_supprimer;
+
+					for(i = 0; i < nombre_lignes_a_supprimer; i++)
+					{
+						if (depilement(s_etat_processus,
+								&((*s_etat_processus).l_base_pile),
+								&s_sous_objet) == d_erreur)
+						{
+							(*s_etat_processus).traitement_interruptible =
+									registre_interruption;
+							return;
+						}
+
+						liberation(s_etat_processus, s_sous_objet);
+					}
+
+					(*s_etat_processus).instruction_courante = tampon;
+					(*s_etat_processus).autorisation_evaluation_nom =
+							autorisation_evaluation_nom;
+
+					effacement_pile_systeme(s_etat_processus);
+					(*s_etat_processus).l_base_pile_systeme =
+							s_sauvegarde_pile;
+					(*s_etat_processus).niveau_courant =
+							sauvegarde_niveau_courant;
+
+					free((*s_etat_processus).definitions_chainees);
+					(*s_etat_processus).niveau_recursivite--;
+
+					(*s_etat_processus).definitions_chainees =
+							definitions_chainees_precedentes;
+					(*s_etat_processus).longueur_definitions_chainees =
+							sauvegarde_longueur_definitions_chainees;
+
+					(*s_etat_processus).position_courante =
+							position_courante;
+
+					liberation(s_etat_processus, s_objet);
+
+					(*s_etat_processus).erreur_execution = d_ex_syntaxe;
+					(*s_etat_processus).traitement_interruptible =
+							registre_interruption;
+					return;
+				}
+
+				(*s_etat_processus).instruction_courante = tampon;
+				(*s_etat_processus).autorisation_evaluation_nom =
+						autorisation_evaluation_nom;
+
+				(*s_etat_processus).l_base_pile_systeme = s_sauvegarde_pile;
+				(*s_etat_processus).niveau_courant =
+						sauvegarde_niveau_courant;
+
+				free((*s_etat_processus).definitions_chainees);
+				(*s_etat_processus).definitions_chainees =
+						definitions_chainees_precedentes;
+				(*s_etat_processus).longueur_definitions_chainees =
+						sauvegarde_longueur_definitions_chainees;
+
+				(*s_etat_processus).niveau_recursivite--;
+
+				(*s_etat_processus).position_courante = position_courante;
+
+/*
+-- On relit la pile qui contient des sous-objets contenant les -----------------
+-- éléments du tableau ---------------------------------------------------------
+*/
+
+				profondeur_finale = (*s_etat_processus)
+						.hauteur_pile_operationnelle;
+
+				nombre_lignes = profondeur_finale - profondeur_initiale;
+
+				// Il ne peut y avoir que deux lignes.
+
+				if (nombre_lignes != 2)
+				{
+					(*s_etat_processus).traitement_interruptible =
+							registre_interruption;
+					(*s_etat_processus).erreur_execution =
+							d_ex_dimensions_invalides;
+					return;
+				}
+
+				if ((element = malloc(sizeof(struct_record))) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					(*s_etat_processus).traitement_interruptible =
+							registre_interruption;
+					return;
+				}
+
+				if (depilement(s_etat_processus,
+						&((*s_etat_processus).l_base_pile),
+						&((*((struct_record *) element)).donnees))
+						== d_erreur)
+				{
+					(*s_etat_processus).traitement_interruptible =
+							registre_interruption;
+					return;
+				}
+
+				if (depilement(s_etat_processus,
+						&((*s_etat_processus).l_base_pile),
+						&((*((struct_record *) element)).noms))
+						== d_erreur)
+				{
+					(*s_etat_processus).traitement_interruptible =
+							registre_interruption;
+					return;
+				}
+
+				(*s_objet).type = REC;
+				(*s_etat_processus).traitement_interruptible =
+						registre_interruption;
+
+				// Vérification des types.
+
+				if (((*(*((struct_record *) element)).donnees).type != TBL)
+						|| ((*(*((struct_record *) element)).noms).type != TBL))
+				{
+					(*s_objet).objet = element;
+					liberation(s_etat_processus, s_objet);
+
+					(*s_etat_processus).erreur_execution =
+							d_ex_erreur_type_argument;
+					return;
+				}
+
+				for(i = 0; i < (*((struct_tableau *) (*(*((struct_record *)
+						element)).noms).objet)).nombre_elements; i++)
+				{
+					if ((*(*((struct_tableau *) (*(*((struct_record *) element))
+							.noms).objet)).elements[i]).type != CHN)
+					{
+						(*s_objet).objet = element;
+						liberation(s_etat_processus, s_objet);
+
+						(*s_etat_processus).erreur_execution =
+								d_ex_erreur_type_argument;
+						return;
+					}
+				}
+
+				// Vérification des dimensions
+
+				if ((*((struct_tableau *) (*(*((struct_record *) element))
+                        .donnees).objet)).nombre_elements !=
+						(*((struct_tableau *) (*(*((struct_record *) element))
+						.noms).objet)).nombre_elements)
+				{
+					(*s_objet).objet = element;
+					liberation(s_etat_processus, s_objet);
+
+					(*s_etat_processus).erreur_execution =
+							d_ex_dimensions_invalides;
+					return;
+				}
+
+				// Tri de l'enregistrement (tri bull)
+
+				tri_acheve = d_faux;
+
+				while(tri_acheve == d_faux)
+				{
+					tri_acheve = d_vrai;
+
+					for(i = 0; i < (*((struct_tableau *) (*(*((struct_record *)
+							element)).noms).objet)).nombre_elements - 1; i++)
+					{
+						if (strcmp((unsigned char *) (*(*((struct_tableau *)
+								(*(*((struct_record *) element)).noms).objet))
+								.elements[i]).objet, (unsigned char *)
+								(*(*((struct_tableau *) (*(*((struct_record *)
+								element)).noms).objet)).elements[i + 1]).objet)
+								> 0)
+						{
+							tri_acheve = d_faux;
+
+							tampon = (unsigned char *) (*(*((struct_tableau *)
+									(*(*((struct_record *) element)).noms)
+									.objet)).elements[i + 1]).objet;
+							(*(*((struct_tableau *) (*(*((struct_record *)
+									element)).noms).objet)).elements[i + 1])
+									.objet = (*(*((struct_tableau *)
+									(*(*((struct_record *) element)).noms)
+									.objet)).elements[i]).objet;
+							(*(*((struct_tableau *) (*(*((struct_record *)
+									element)).noms).objet)).elements[i]).objet =
+									tampon;
+
+							s_objet_registre = (*((struct_tableau *)
+									(*(*((struct_record *) element)).donnees)
+									.objet)).elements[i + 1];
+							(*((struct_tableau *) (*(*((struct_record *)
+									element)).donnees).objet)).elements[i + 1] =
+									(*((struct_tableau *) (*(*((struct_record *)
+									element)).donnees).objet)).elements[i];
+							(*((struct_tableau *) (*(*((struct_record *)
+									element)).donnees).objet)).elements[i] =
+									s_objet_registre;
+						}
+					}
+				}
+
+				// Vérification de l'unicité des noms
+
+				for(i = 0; i < (*((struct_tableau *) (*(*((struct_record *)
+                            element)).noms).objet)).nombre_elements - 1; i++)
+				{
+					if (strcmp((unsigned char *) (*(*((struct_tableau *)
+							(*(*((struct_record *) element)).noms).objet))
+							.elements[i]).objet, (unsigned char *)
+							(*(*((struct_tableau *) (*(*((struct_record *)
+							element)).noms).objet)) .elements[i + 1]).objet)
+							== 0)
+					{
+						(*s_objet).objet = element;
+						liberation(s_etat_processus, s_objet);
+
+						(*s_etat_processus).erreur_execution =
+								d_ex_argument_invalide;
+						return;
+					}
+				}
+			}
+
+			break;
+		}
+
+/*
+--------------------------------------------------------------------------------
   Entier ou réel
 --------------------------------------------------------------------------------
 */
@@ -3462,20 +3947,23 @@ recherche_type(struct_processus *s_etat_
 
 				while((*ptr) != d_code_fin_chaine)
 				{
-					if ((isalnum((*ptr)) == 0) &&
-							((*ptr) != '_') &&
-							((*ptr) != '$'))
+					if (isalnum(*ptr) != 0)
+					{
+						ptr++;
+					}
+					else if (((*ptr) == '_') || ((*ptr == '$')))
+					{
+						ptr++;
+					}
+					else
 					{
 						liberation(s_etat_processus, s_objet);
 
 						(*s_etat_processus).erreur_execution = d_ex_syntaxe;
 						(*s_etat_processus).traitement_interruptible =
 								registre_interruption;
-
 						return;
 					}
-
-					ptr++;
 				}
 
 				(*s_objet).type = NOM;
@@ -3547,21 +4035,13 @@ recherche_type(struct_processus *s_etat_
 					integer8					conversion_entiere;
 					real8						conversion_reelle;
 
-					if (sscanf((*s_etat_processus).instruction_courante, "%lg",
-							&conversion_reelle) != 1)
-					{
-						(*s_etat_processus).erreur_execution = d_ex_syntaxe;
-					}
-
 					if (sscanf((*s_etat_processus).instruction_courante, "%lld",
 							&conversion_entiere) != 1)
 					{
 						(*s_etat_processus).erreur_execution = d_ex_syntaxe;
 					}
 
-					if (abs(nextafter(conversion_reelle, conversion_entiere)
-							- conversion_reelle) >= abs(conversion_reelle
-							- conversion_entiere))
+					if (errno != ERANGE)
 					{
 						(*s_objet).type = INT;
 
@@ -3580,6 +4060,12 @@ recherche_type(struct_processus *s_etat_
 					}
 					else
 					{
+						if (sscanf((*s_etat_processus).instruction_courante,
+								"%lg", &conversion_reelle) != 1)
+						{
+							(*s_etat_processus).erreur_execution = d_ex_syntaxe;
+						}
+
 						(*s_objet).type = REL;
 
 						element = malloc(sizeof(real8));