--- rpl/src/types.c	2010/01/26 15:22:44	1.1
+++ rpl/src/types.c	2018/05/30 09:27:39	1.91
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.0.9
-  Copyright (C) 1989-2010 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.
 
@@ -20,7 +20,7 @@
 */
 
 
-#include "rpl.conv.h"
+#include "rpl-conv.h"
 
 
 /*
@@ -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;
@@ -49,6 +67,7 @@ recherche_type(struct_processus *s_etat_
 	struct_liste_pile_systeme	*s_sauvegarde_pile;
 
 	struct_objet				*s_objet;
+	struct_objet				*s_objet_registre;
 	struct_objet				*s_sous_objet;
 
 	logical1					drapeau_chaine;
@@ -75,42 +94,24 @@ recherche_type(struct_processus *s_etat_
 	unsigned char				registre_instruction_valide;
 	unsigned char				registre_interruption;
 	unsigned char				registre_mode_execution_programme;
+	unsigned char				registre_recherche_type;
 	unsigned char				registre_test;
 	unsigned char				registre_test_bis;
 	unsigned char				*tampon;
-
-	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;
+	unsigned char				variable_implicite;
 
 	void						*element;
 
-	s_objet = (struct_objet *) malloc(sizeof(struct_objet));
-	element = NULL;
-	nombre_egalites = 0;
-	i = 0;
-
-	if (s_objet == NULL)
+	if ((s_objet = allocation(s_etat_processus, NON)) == NULL)
 	{
 		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 		return;
 	}
 
-	initialisation_objet(s_objet);
+	element = NULL;
+	nombre_egalites = 0;
+	i = 0;
+
 	registre_test = (*s_etat_processus).test_instruction;
 	registre_instruction_valide = (*s_etat_processus).instruction_valide;
 	registre_interruption = (*s_etat_processus).traitement_interruptible;
@@ -143,8 +144,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;
@@ -176,6 +177,9 @@ recherche_type(struct_processus *s_etat_
 
 			(*s_objet).type = FCT;
 			(*s_objet).objet = element;
+			(*((struct_fonction *) (*s_objet).objet)).prediction_saut = NULL;
+			(*((struct_fonction *) (*s_objet).objet)).prediction_execution
+					= d_faux;
 
 			if (empilement(s_etat_processus,
 					&((*s_etat_processus).l_base_pile), s_objet) == d_erreur)
@@ -188,7 +192,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;
@@ -203,7 +207,7 @@ recherche_type(struct_processus *s_etat_
 				(*s_etat_processus).test_instruction = 'N';
 				analyse(s_etat_processus, NULL);
 				(*s_etat_processus).test_instruction = registre_test_bis;
-				free(s_objet);
+				liberation(s_etat_processus, s_objet);
 			}
 			else
 			{
@@ -257,6 +261,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))
 	{
 
@@ -268,8 +323,6 @@ recherche_type(struct_processus *s_etat_
 
 		case '(' :
 		{
-			(*s_objet).type = CPL;
-
 			element = (void *) ((struct_complexe16 *) malloc(
 					sizeof(struct_complexe16)));
 
@@ -287,10 +340,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)
 			{
@@ -367,12 +420,18 @@ recherche_type(struct_processus *s_etat_
 				}
 			}
 
+			registre_recherche_type = (*s_etat_processus).recherche_type;
+			(*s_etat_processus).recherche_type = 'Y';
+
 			if (sequenceur(s_etat_processus) == d_erreur)
 			{
+				(*s_etat_processus).erreur_execution = d_ex_syntaxe;
+				(*s_etat_processus).recherche_type = registre_recherche_type;
 				(*s_etat_processus).instruction_courante = tampon;
 				(*s_etat_processus).mode_execution_programme =
 						registre_mode_execution_programme;
 
+				effacement_pile_systeme(s_etat_processus);
 				(*s_etat_processus).l_base_pile_systeme = s_sauvegarde_pile;
 				(*s_etat_processus).niveau_courant = sauvegarde_niveau_courant;
 
@@ -386,13 +445,14 @@ recherche_type(struct_processus *s_etat_
 						sauvegarde_longueur_definitions_chainees;
 
 				free(element);
-				free(s_objet);
+				liberation(s_etat_processus, s_objet);
 
 				(*s_etat_processus).traitement_interruptible =
 						registre_interruption;
 				return;
 			}
 
+			(*s_etat_processus).recherche_type = registre_recherche_type;
 			(*s_etat_processus).instruction_courante = tampon;
 			(*s_etat_processus).mode_execution_programme =
 					registre_mode_execution_programme;
@@ -420,10 +480,10 @@ recherche_type(struct_processus *s_etat_
 			{
 				(*s_etat_processus).erreur_execution = d_ex_syntaxe;
 
-				free(s_objet);
+				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)
@@ -449,7 +509,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)
 					{
@@ -461,7 +521,7 @@ recherche_type(struct_processus *s_etat_
 						(*s_etat_processus).erreur_execution = d_ex_syntaxe;
 
 						free(element);
-						free(s_objet);
+						liberation(s_etat_processus, s_objet);
 
 						liberation(s_etat_processus, s_sous_objet);
 
@@ -479,7 +539,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)
 						{
@@ -491,7 +552,7 @@ recherche_type(struct_processus *s_etat_
 							(*s_etat_processus).erreur_execution = d_ex_syntaxe;
 
 							free(element);
-							free(s_objet);
+							liberation(s_etat_processus, s_objet);
 
 							liberation(s_etat_processus, s_sous_objet);
 
@@ -505,6 +566,7 @@ recherche_type(struct_processus *s_etat_
 				}
 			}
 
+			(*s_objet).type = CPL;
 			break;
 		}
 
@@ -516,8 +578,6 @@ recherche_type(struct_processus *s_etat_
 
 		case '#' :
 		{
-			(*s_objet).type = BIN;
-
 			element = (void *) ((logical8 *) malloc(
 					sizeof(logical8)));
 
@@ -536,7 +596,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;
@@ -568,7 +629,7 @@ recherche_type(struct_processus *s_etat_
 							if (i != 0)
 							{
 								free(element);
-								free(s_objet);
+								liberation(s_etat_processus, s_objet);
 
 								(*s_etat_processus).erreur_execution =
 										d_ex_syntaxe;
@@ -610,7 +671,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;
@@ -672,7 +734,7 @@ recherche_type(struct_processus *s_etat_
 							if (i != 0)
 							{
 								free(element);
-								free(s_objet);
+								liberation(s_etat_processus, s_objet);
 
 								(*s_etat_processus).erreur_execution =
 										d_ex_syntaxe;
@@ -714,7 +776,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;
@@ -786,7 +849,7 @@ recherche_type(struct_processus *s_etat_
 							if (i != 0)
 							{
 								free(element);
-								free(s_objet);
+								liberation(s_etat_processus, s_objet);
 
 								(*s_etat_processus).erreur_execution =
 										d_ex_syntaxe;
@@ -828,7 +891,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;
@@ -930,7 +994,7 @@ recherche_type(struct_processus *s_etat_
 							if (i != 0)
 							{
 								free(element);
-								free(s_objet);
+								liberation(s_etat_processus, s_objet);
 
 								(*s_etat_processus).erreur_execution =
 										d_ex_syntaxe;
@@ -981,7 +1045,7 @@ recherche_type(struct_processus *s_etat_
 					(erreur_lecture_binaire == d_vrai))
 			{
 				free(element);
-				free(s_objet);
+				liberation(s_etat_processus, s_objet);
 
 				(*s_etat_processus).erreur_execution = d_ex_syntaxe;
 				(*s_etat_processus).traitement_interruptible =
@@ -989,6 +1053,7 @@ recherche_type(struct_processus *s_etat_
 				return;
 			}
 
+			(*s_objet).type = BIN;
 			break;
 		}
 
@@ -1049,7 +1114,7 @@ recherche_type(struct_processus *s_etat_
 
 			if (niveau != 0)
 			{
-				free(s_objet);
+				liberation(s_etat_processus, s_objet);
 
 				(*s_etat_processus).erreur_execution = d_ex_syntaxe;
 				(*s_etat_processus).traitement_interruptible =
@@ -1073,17 +1138,18 @@ recherche_type(struct_processus *s_etat_
 
 /*
 -- Sauvegarde des paramètres du processus pour analyser le vecteur -------------
--- Analyse récursive en appelant l'interpréteur sur le vecteur moins -----------
+-- Analyse récursive en appelant l'interprète sur le vecteur moins -------------
 -- ses délimiteurs -------------------------------------------------------------
 */
 
 					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)
 					{
@@ -1158,8 +1224,15 @@ recherche_type(struct_processus *s_etat_
 						}
 					}
 
+					registre_recherche_type =
+							(*s_etat_processus).recherche_type;
+					(*s_etat_processus).recherche_type = 'Y';
+
 					if (sequenceur(s_etat_processus) == d_erreur)
 					{
+						(*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 =
@@ -1182,6 +1255,7 @@ recherche_type(struct_processus *s_etat_
 
 						(*s_etat_processus).instruction_courante = tampon;
 
+						effacement_pile_systeme(s_etat_processus);
 						(*s_etat_processus).l_base_pile_systeme =
 								s_sauvegarde_pile;
 						(*s_etat_processus).niveau_courant =
@@ -1197,7 +1271,7 @@ recherche_type(struct_processus *s_etat_
 						(*s_etat_processus).longueur_definitions_chainees =
 								sauvegarde_longueur_definitions_chainees;
 
-						free(s_objet);
+						liberation(s_etat_processus, s_objet);
 
 						(*s_etat_processus).erreur_execution = d_ex_syntaxe;
 						(*s_etat_processus).traitement_interruptible =
@@ -1205,6 +1279,8 @@ recherche_type(struct_processus *s_etat_
 						return;
 					}
 
+					(*s_etat_processus).recherche_type =
+							registre_recherche_type;
 					(*s_etat_processus).mode_execution_programme =
 							registre_mode_execution_programme;
 
@@ -1230,6 +1306,7 @@ recherche_type(struct_processus *s_etat_
 
 						(*s_etat_processus).instruction_courante = tampon;
 
+						effacement_pile_systeme(s_etat_processus);
 						(*s_etat_processus).l_base_pile_systeme =
 								s_sauvegarde_pile;
 						(*s_etat_processus).niveau_courant =
@@ -1245,7 +1322,7 @@ recherche_type(struct_processus *s_etat_
 						(*s_etat_processus).longueur_definitions_chainees =
 								sauvegarde_longueur_definitions_chainees;
 
-						free(s_objet);
+						liberation(s_etat_processus, s_objet);
 
 						(*s_etat_processus).erreur_execution = d_ex_syntaxe;
 						(*s_etat_processus).traitement_interruptible =
@@ -1293,22 +1370,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';
 					}
 
@@ -1322,7 +1400,7 @@ recherche_type(struct_processus *s_etat_
 					}
 
 					erreur = d_absence_erreur;
-					free(s_objet);
+					s_objet_registre = s_objet;
 
 					for(i = 0; (i < nombre_colonnes) &&
 							(erreur == d_absence_erreur); i++)
@@ -1419,6 +1497,8 @@ recherche_type(struct_processus *s_etat_
 										(*s_etat_processus)
 												.traitement_interruptible =
 												registre_interruption;
+										liberation(s_etat_processus,
+												s_objet_registre);
 										return;
 									}
 
@@ -1431,6 +1511,7 @@ recherche_type(struct_processus *s_etat_
 								free((*((struct_vecteur *) element)).tableau);
 								free(element);
 
+								liberation(s_etat_processus, s_objet_registre);
 								(*s_etat_processus).traitement_interruptible =
 										registre_interruption;
 								return;
@@ -1438,6 +1519,8 @@ recherche_type(struct_processus *s_etat_
 						}
 						else
 						{
+							liberation(s_etat_processus, s_objet_registre);
+
 							(*s_etat_processus).erreur_systeme = d_es_pile_vide;
 							(*s_etat_processus).traitement_interruptible =
 									registre_interruption;
@@ -1445,18 +1528,7 @@ recherche_type(struct_processus *s_etat_
 						}
 					}
 
-					s_objet = (struct_objet *) malloc(sizeof(struct_objet));
-
-					if (s_objet == NULL)
-					{
-						(*s_etat_processus).erreur_systeme =
-								d_es_allocation_memoire;
-						(*s_etat_processus).traitement_interruptible =
-								registre_interruption;
-						return;
-					}
-
-					initialisation_objet(s_objet);
+					s_objet = s_objet_registre;
 
 					if (drapeau_complexe == d_vrai)
 					{
@@ -1487,10 +1559,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)
 					{
@@ -1564,9 +1637,16 @@ recherche_type(struct_processus *s_etat_
 							return;
 						}
 					}
+ 
+					registre_recherche_type = (*s_etat_processus)
+							.recherche_type;
+					(*s_etat_processus).recherche_type = 'Y';
 
 					if (sequenceur(s_etat_processus) == d_erreur)
 					{
+						(*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 =
@@ -1589,6 +1669,7 @@ recherche_type(struct_processus *s_etat_
 
 						(*s_etat_processus).instruction_courante = tampon;
 
+						effacement_pile_systeme(s_etat_processus);
 						(*s_etat_processus).l_base_pile_systeme =
 						   		s_sauvegarde_pile;
 						(*s_etat_processus).niveau_courant =
@@ -1605,7 +1686,7 @@ recherche_type(struct_processus *s_etat_
 						(*s_etat_processus).position_courante =
 								position_courante;
 
-						free(s_objet);
+						liberation(s_etat_processus, s_objet);
 
 						(*s_etat_processus).erreur_execution = d_ex_syntaxe;
 						(*s_etat_processus).traitement_interruptible =
@@ -1613,6 +1694,8 @@ recherche_type(struct_processus *s_etat_
 						return;
 					}
 
+					(*s_etat_processus).recherche_type =
+							registre_recherche_type;
 					(*s_etat_processus).mode_execution_programme =
 							registre_mode_execution_programme;
 
@@ -1638,6 +1721,7 @@ recherche_type(struct_processus *s_etat_
 
 						(*s_etat_processus).instruction_courante = tampon;
 
+						effacement_pile_systeme(s_etat_processus);
 						(*s_etat_processus).l_base_pile_systeme =
 						   		s_sauvegarde_pile;
 						(*s_etat_processus).niveau_courant =
@@ -1654,7 +1738,7 @@ recherche_type(struct_processus *s_etat_
 						(*s_etat_processus).position_courante =
 								position_courante;
 
-						free(s_objet);
+						liberation(s_etat_processus, s_objet);
 
 						(*s_etat_processus).erreur_execution = d_ex_syntaxe;
 						(*s_etat_processus).traitement_interruptible =
@@ -1737,7 +1821,7 @@ recherche_type(struct_processus *s_etat_
 							}
 
 							free(element);
-							free(s_objet);
+							liberation(s_etat_processus, s_objet);
 
 							(*s_etat_processus).traitement_interruptible =
 									registre_interruption;
@@ -1758,7 +1842,7 @@ recherche_type(struct_processus *s_etat_
 						l_element_courant = (*l_element_courant).suivant;
 					}
 
-					free(s_objet);
+					s_objet_registre = s_objet;
 
 					if ((*s_etat_processus).erreur_execution == d_ex)
 					{
@@ -1766,9 +1850,11 @@ 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);
+
 								(*s_etat_processus).erreur_systeme =
 										d_es_allocation_memoire;
 								(*s_etat_processus).traitement_interruptible =
@@ -1783,9 +1869,12 @@ 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);
+
 									(*s_etat_processus).erreur_systeme =
 											d_es_allocation_memoire;
 									(*s_etat_processus)
@@ -1798,10 +1887,12 @@ 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);
+
 								(*s_etat_processus).erreur_systeme =
 										d_es_allocation_memoire;
 								(*s_etat_processus).traitement_interruptible =
@@ -1815,9 +1906,12 @@ 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,
+											s_objet_registre);
+
 									(*s_etat_processus).erreur_systeme =
 											d_es_allocation_memoire;
 									(*s_etat_processus)
@@ -1831,9 +1925,11 @@ 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);
+
 								(*s_etat_processus).erreur_systeme =
 										d_es_allocation_memoire;
 								(*s_etat_processus).traitement_interruptible =
@@ -1848,9 +1944,12 @@ 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,
+											s_objet_registre);
+
 									(*s_etat_processus).erreur_systeme =
 											d_es_allocation_memoire;
 									(*s_etat_processus)
@@ -1993,6 +2092,9 @@ recherche_type(struct_processus *s_etat_
 												.l_base_pile), &s_objet)
 												== d_erreur)
 										{
+											liberation(s_etat_processus,
+													s_objet_registre);
+
 											(*s_etat_processus)
 													.traitement_interruptible =
 													registre_interruption;
@@ -2016,6 +2118,9 @@ recherche_type(struct_processus *s_etat_
 											.tableau);
 									free(element);
 
+									liberation(s_etat_processus,
+											s_objet_registre);
+
 									(*s_etat_processus)
 											.traitement_interruptible =
 											registre_interruption;
@@ -2024,6 +2129,9 @@ recherche_type(struct_processus *s_etat_
 							}
 							else
 							{
+								liberation(s_etat_processus,
+										s_objet_registre);
+
 								(*s_etat_processus).erreur_systeme =
 										d_es_pile_vide;
 								(*s_etat_processus).traitement_interruptible =
@@ -2032,18 +2140,7 @@ recherche_type(struct_processus *s_etat_
 							}
 						}
 
-						s_objet = (struct_objet *) malloc(sizeof(struct_objet));
-
-						if (s_objet == NULL)
-						{
-							(*s_etat_processus).erreur_systeme =
-									d_es_allocation_memoire;
-							(*s_etat_processus).traitement_interruptible =
-									registre_interruption;
-							return;
-						}
-
-						initialisation_objet(s_objet);
+						s_objet = s_objet_registre;
 
 						if (drapeau_complexe == d_vrai)
 						{
@@ -2094,10 +2191,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)
 			{
@@ -2184,13 +2281,32 @@ recherche_type(struct_processus *s_etat_
 				if ((*s_etat_processus).definitions_chainees
 						[(*s_etat_processus).position_courante] == '"')
 				{
-					if (drapeau_chaine == d_faux)
+					if ((*s_etat_processus).position_courante > 0)
 					{
-						drapeau_chaine = d_vrai;
+						if ((*s_etat_processus).definitions_chainees
+								[(*s_etat_processus).position_courante - 1]
+								!= '\\')
+						{
+							if (drapeau_chaine == d_faux)
+							{
+								drapeau_chaine = d_vrai;
+							}
+							else
+							{
+								drapeau_chaine = d_faux;
+							}
+						}
 					}
-					else
+					else 
 					{
-						drapeau_chaine = d_faux;
+						if (drapeau_chaine == d_faux)
+						{
+							drapeau_chaine = d_vrai;
+						}
+						else
+						{
+							drapeau_chaine = d_faux;
+						}
 					}
 				}
 				else if (drapeau_chaine == d_faux)
@@ -2248,11 +2364,12 @@ recherche_type(struct_processus *s_etat_
 				(*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);
-				free(s_objet);
+				liberation(s_etat_processus, s_objet);
 
 				(*s_etat_processus).definitions_chainees =
 						definitions_chainees_precedentes;
@@ -2284,11 +2401,24 @@ recherche_type(struct_processus *s_etat_
 				}
 			}
 
+			variable_implicite = (*s_etat_processus).autorisation_nom_implicite;
+			registre_recherche_type = (*s_etat_processus).recherche_type;
+			(*s_etat_processus).recherche_type = 'Y';
+			(*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).recherche_type = registre_recherche_type;
 				(*s_etat_processus).mode_execution_programme =
 						registre_mode_execution_programme;
-				(*s_etat_processus).erreur_execution = d_ex_syntaxe;
+
+				if ((*s_etat_processus).erreur_execution !=
+						d_ex_nom_implicite)
+				{
+					(*s_etat_processus).erreur_execution = d_ex_syntaxe;
+				}
 
 				nombre_lignes_a_supprimer =
 						(*s_etat_processus).hauteur_pile_operationnelle
@@ -2315,11 +2445,12 @@ recherche_type(struct_processus *s_etat_
 				(*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);
-				free(s_objet);
+				liberation(s_etat_processus, s_objet);
 
 				(*s_etat_processus).definitions_chainees =
 						definitions_chainees_precedentes;
@@ -2333,6 +2464,8 @@ recherche_type(struct_processus *s_etat_
 				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;
 
@@ -2363,11 +2496,12 @@ recherche_type(struct_processus *s_etat_
 				(*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);
-				free(s_objet);
+				liberation(s_etat_processus, s_objet);
 
 				(*s_etat_processus).definitions_chainees =
 						definitions_chainees_precedentes;
@@ -2407,8 +2541,7 @@ recherche_type(struct_processus *s_etat_
 			profondeur_finale = (*s_etat_processus).hauteur_pile_operationnelle;
 
 			l_element_courant = NULL;
-
-			free(s_objet);
+			s_objet_registre = s_objet;
 
 			for(i = 0; i < (profondeur_finale - profondeur_initiale); i++)
 			{
@@ -2416,6 +2549,7 @@ recherche_type(struct_processus *s_etat_
 						&((*s_etat_processus).l_base_pile),
 						&s_objet) == d_erreur)
 				{
+					liberation(s_etat_processus, s_objet_registre);
 					(*s_etat_processus).traitement_interruptible =
 							registre_interruption;
 					return;
@@ -2424,23 +2558,14 @@ recherche_type(struct_processus *s_etat_
 				if (empilement(s_etat_processus, &l_element_courant,
 						s_objet) == d_erreur)
 				{
+					liberation(s_etat_processus, s_objet_registre);
 					(*s_etat_processus).traitement_interruptible =
 							registre_interruption;
 					return;
 				}
 			}
 
-			s_objet = (struct_objet *) malloc(sizeof(struct_objet));
-
-			if (s_objet == NULL)
-			{
-				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
-				(*s_etat_processus).traitement_interruptible =
-						registre_interruption;
-				return;
-			}
-
-			initialisation_objet(s_objet);
+			s_objet = s_objet_registre;
 			(*s_objet).type = LST;
 			element = (void *) l_element_courant;
 
@@ -2476,7 +2601,7 @@ recherche_type(struct_processus *s_etat_
 					free(l_element_courant_fonctions);
 				}
 
-				free(s_objet);
+				liberation(s_etat_processus, s_objet);
 
 				(*s_etat_processus).traitement_interruptible =
 						registre_interruption;
@@ -2515,7 +2640,8 @@ recherche_type(struct_processus *s_etat_
 					 * puis on renvoie une erreur.
 					 */
 
-					free(s_objet);
+					(*s_objet).type = NON;
+					liberation(s_etat_processus, s_objet);
 
 					l_element_courant = l_base_liste_decomposition;
 
@@ -2592,7 +2718,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);
 
@@ -2630,6 +2757,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)
@@ -2731,7 +2859,7 @@ recherche_type(struct_processus *s_etat_
 									(*s_sous_objet).type = FCT;
 							
 									if (((*s_sous_objet).objet = (void *)
-											allocation(s_etat_processus, FCT))
+											malloc(sizeof(struct_fonction)))
 											== NULL)
 									{
 										(*s_etat_processus).erreur_systeme =
@@ -2781,6 +2909,7 @@ recherche_type(struct_processus *s_etat_
 				free(l_element_courant_fonctions);
 			}
 
+			(*s_etat_processus).autorisation_empilement_programme = 'Y';
 			break;
 		}
 
@@ -2811,59 +2940,18 @@ recherche_type(struct_processus *s_etat_
 
 			while((*ptr_lecture) != d_code_fin_chaine)
 			{
-				if ((*ptr_lecture) == '\\')
-				{
-					if ((*(ptr_lecture + 1)) == '"')
-					{
-						if ((*(ptr_lecture + 2)) != d_code_fin_chaine)
-						{
-							ptr_lecture++;
-						}
-					}
-					else if ((*(ptr_lecture + 1)) == 'b')
-					{
-						if ((*(ptr_lecture + 2)) != d_code_fin_chaine)
-						{
-							ptr_lecture++;
-							(*ptr_lecture) = '\b';
-						}
-					}
-					else if ((*(ptr_lecture + 1)) == 'n')
-					{
-						if ((*(ptr_lecture + 2)) != d_code_fin_chaine)
-						{
-							ptr_lecture++;
-							(*ptr_lecture) = '\n';
-						}
-					}
-					else if ((*(ptr_lecture + 1)) == 't')
-					{
-						if ((*(ptr_lecture + 2)) != d_code_fin_chaine)
-						{
-							ptr_lecture++;
-							(*ptr_lecture) = '\t';
-						}
-					}
-					else if ((*(ptr_lecture + 1)) == '\\')
-					{
-						if ((*(ptr_lecture + 2)) != d_code_fin_chaine)
-						{
-							ptr_lecture++;
-						}
-					}
-				}
-
 				*ptr_ecriture++ = *ptr_lecture++;
 			}
 
 			(*(--ptr_ecriture)) = d_code_fin_chaine;
 
-			if ((element = realloc(element, (strlen((unsigned char *)
-					element) + 1) * sizeof(unsigned char))) == NULL)
+			if (validation_chaine((unsigned char *) element) == d_faux)
 			{
-				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				(*s_etat_processus).erreur_execution = d_ex_syntaxe;
 				(*s_etat_processus).traitement_interruptible =
 						registre_interruption;
+
+				free(element);
 				return;
 			}
 
@@ -2882,13 +2970,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)
 				{
@@ -2942,14 +3032,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;
 
@@ -2963,8 +3060,20 @@ recherche_type(struct_processus *s_etat_
 					}
 				}
 
+				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 =
@@ -2986,7 +3095,10 @@ 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 =
 							s_sauvegarde_pile;
 					(*s_etat_processus).niveau_courant =
@@ -3003,7 +3115,7 @@ recherche_type(struct_processus *s_etat_
 					(*s_etat_processus).position_courante =
 							position_courante;
 
-					free(s_objet);
+					liberation(s_etat_processus, s_objet);
 
 					(*s_etat_processus).erreur_execution = d_ex_syntaxe;
 					(*s_etat_processus).traitement_interruptible =
@@ -3011,6 +3123,9 @@ recherche_type(struct_processus *s_etat_
 					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;
 
@@ -3035,7 +3150,10 @@ 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 =
 							s_sauvegarde_pile;
 					(*s_etat_processus).niveau_courant =
@@ -3052,7 +3170,7 @@ recherche_type(struct_processus *s_etat_
 					(*s_etat_processus).position_courante =
 							position_courante;
 
-					free(s_objet);
+					liberation(s_etat_processus, s_objet);
 
 					(*s_etat_processus).erreur_execution = d_ex_syntaxe;
 					(*s_etat_processus).traitement_interruptible =
@@ -3061,6 +3179,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 =
@@ -3086,10 +3206,7 @@ recherche_type(struct_processus *s_etat_
 
 				nombre_lignes = profondeur_finale - profondeur_initiale;
 
-				element = (void *) ((struct_tableau *) malloc(
-						sizeof(struct_tableau)));
-
-				if (element == NULL)
+				if ((element = malloc(sizeof(struct_tableau))) == NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
 							d_es_allocation_memoire;
@@ -3101,7 +3218,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;
@@ -3134,9 +3252,11 @@ recherche_type(struct_processus *s_etat_
 			{
 				// Définition
 
+				(*s_etat_processus).type_en_cours = RPN;
+
 				if (strlen((*s_etat_processus).instruction_courante) < 5)
 				{
-					free(s_objet);
+					liberation(s_etat_processus, s_objet);
 
 					(*s_etat_processus).erreur_execution = d_ex_syntaxe;
 					(*s_etat_processus).traitement_interruptible =
@@ -3148,7 +3268,7 @@ recherche_type(struct_processus *s_etat_
 						!= 0) && (strcmp((*s_etat_processus)
 						.instruction_courante, "<<") != 0))
 				{
-					free(s_objet);
+					liberation(s_etat_processus, s_objet);
 
 					(*s_etat_processus).erreur_execution = d_ex_syntaxe;
 					(*s_etat_processus).traitement_interruptible =
@@ -3169,6 +3289,8 @@ recherche_type(struct_processus *s_etat_
 								d_es_allocation_memoire;
 					}
 
+					liberation(s_etat_processus, s_objet);
+
 					(*s_etat_processus).traitement_interruptible =
 							registre_interruption;
 					return;
@@ -3196,95 +3318,6 @@ recherche_type(struct_processus *s_etat_
 
 /*
 --------------------------------------------------------------------------------
-  Adresse
---------------------------------------------------------------------------------
-*/
-
-		case '@' :
-		{
-			if ((*s_etat_processus).recherche_types_speciaux == 'Y')
-			{
-				if (strlen((*s_etat_processus).instruction_courante) > 2)
-				{
-					tampon = (*s_etat_processus).instruction_courante;
-
-					if (((*s_etat_processus).instruction_courante =
-							malloc((strlen(tampon) + 2) *
-							sizeof(unsigned char))) == NULL)
-					{
-						(*s_etat_processus).erreur_systeme =
-								d_es_allocation_memoire;
-						(*s_etat_processus).traitement_interruptible =
-								registre_interruption;
-						return;
-					}
-
-					strcpy((*s_etat_processus).instruction_courante, tampon);
-					(*s_etat_processus).instruction_courante[0] = '#';
-					(*s_etat_processus).instruction_courante
-							[strlen((*s_etat_processus).instruction_courante)
-							+ 1] = d_code_fin_chaine;
-					(*s_etat_processus).instruction_courante
-							[strlen((*s_etat_processus).instruction_courante)]
-							= 'h';
-
-					recherche_type(s_etat_processus);
-
-					free((*s_etat_processus).instruction_courante);
-					(*s_etat_processus).instruction_courante = tampon;
-
-					if (((*s_etat_processus).erreur_systeme == d_es) &&
-							((*s_etat_processus).erreur_execution == d_ex))
-					{
-						if (depilement(s_etat_processus,
-								&((*s_etat_processus).l_base_pile),
-								&s_sous_objet) == d_absence_erreur)
-						{
-							if ((*s_sous_objet).type == BIN)
-							{
-								(*s_objet).type = ADR;
-
-								if ((element =
-										malloc(sizeof(unsigned long))) == NULL)
-								{
-									(*s_etat_processus).erreur_systeme =
-											d_es_allocation_memoire;
-									(*s_etat_processus)
-											.traitement_interruptible =
-											registre_interruption;
-									return;
-								}
-
-								(*((unsigned long *) element)) = (*((logical8 *)
-										(*s_sous_objet).objet));
-							}
-							else
-							{
-								(*s_etat_processus).erreur_execution =
-										d_ex_syntaxe;
-							}
-
-							liberation(s_etat_processus, s_sous_objet);
-						}
-						else
-						{
-							(*s_etat_processus).traitement_interruptible =
-									registre_interruption;
-							return;
-						}
-					}
-				}
-				else
-				{
-					(*s_etat_processus).erreur_execution = d_ex_syntaxe;
-				}
-
-				break;
-			}
-		}
-
-/*
---------------------------------------------------------------------------------
   Entier ou réel
 --------------------------------------------------------------------------------
 */
@@ -3505,6 +3538,29 @@ recherche_type(struct_processus *s_etat_
 			if ((drapeau_valeur_reelle == d_faux) &&
 					(drapeau_valeur_entiere == d_faux))
 			{
+				ptr = (*s_etat_processus).instruction_courante;
+
+				while((*ptr) != d_code_fin_chaine)
+				{
+					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;
+					}
+				}
+
 				(*s_objet).type = NOM;
 
 				element = malloc(sizeof(struct_nom));
@@ -3564,27 +3620,61 @@ recherche_type(struct_processus *s_etat_
 				}
 				else
 				{
-					(*s_objet).type = INT;
+					// Le format ressemble à un entier mais il peut y avoir
+					// un dépassement de capacité lors de la conversion.
+					// On convertit donc en entier et en réel. Si les
+					// deux conversions donnent le même résultat, on
+					// considère que la conversion en entier est bonne. Dans
+					// le cas contraire, on garde la conversion en réel.
 
-					element = (void *) ((integer8 *) malloc(
-							sizeof(integer8)));
+					integer8					conversion_entiere;
+					real8						conversion_reelle;
 
-					if (element == NULL)
+					if (sscanf((*s_etat_processus).instruction_courante, "%lld",
+							&conversion_entiere) != 1)
 					{
-						(*s_etat_processus).erreur_systeme =
-								d_es_allocation_memoire;
-						(*s_etat_processus).traitement_interruptible =
-								registre_interruption;
-						return;
+						(*s_etat_processus).erreur_execution = d_ex_syntaxe;
 					}
 
-					nombre_elements_convertis = sscanf(
-							(*s_etat_processus).instruction_courante, "%lld",
-							(integer8 *) element);
+					if (errno != ERANGE)
+					{
+						(*s_objet).type = INT;
 
-					if (nombre_elements_convertis != 1)
+						element = malloc(sizeof(integer8));
+
+						if (element == NULL)
+						{
+							(*s_etat_processus).erreur_systeme =
+									d_es_allocation_memoire;
+							(*s_etat_processus).traitement_interruptible =
+									registre_interruption;
+							return;
+						}
+
+						(*((integer8 *) element)) = conversion_entiere;
+					}
+					else
 					{
-						(*s_etat_processus).erreur_execution = d_ex_syntaxe;
+						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));
+
+						if (element == NULL)
+						{
+							(*s_etat_processus).erreur_systeme =
+									d_es_allocation_memoire;
+							(*s_etat_processus).traitement_interruptible =
+									registre_interruption;
+							return;
+						}
+
+						(*((real8 *) element)) = conversion_reelle;
 					}
 				}
 			}
@@ -3608,7 +3698,8 @@ recherche_type(struct_processus *s_etat_
 			&((*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;
+		(*s_etat_processus).traitement_interruptible =
+				registre_interruption;
 		return;
 	}