--- rpl/src/instructions_r3.c	2010/01/27 22:22:15	1.2
+++ rpl/src/instructions_r3.c	2020/01/10 11:15:47	1.78
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.0.10
-  Copyright (C) 1989-2010 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.
 
@@ -20,7 +20,7 @@
 */
 
 
-#include "rpl.conv.h"
+#include "rpl-conv.h"
 
 
 /*
@@ -353,8 +353,8 @@ instruction_rnrm(struct_processus *s_eta
 	struct_objet				*s_objet_argument;
 	struct_objet				*s_objet_resultat;
 
-	unsigned long				i;
-	unsigned long				j;
+	integer8					i;
+	integer8					j;
 
 	void						*accumulateur;
 
@@ -410,25 +410,67 @@ instruction_rnrm(struct_processus *s_eta
 
 	if ((*s_objet_argument).type == VIN)
 	{
-		if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
+		depassement = d_faux;
+
+		for(i = 0; i < (*((struct_vecteur *) (*s_objet_argument).objet)).taille;
+				i++)
 		{
-			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
-			return;
+			if (((integer8 *) (*((struct_vecteur *) (*s_objet_argument)
+					.objet)).tableau)[i] == INT64_MIN)
+			{
+				depassement = d_vrai;
+				break;
+			}
 		}
 
-		(*((integer8 *) (*s_objet_resultat).objet)) = abs(((integer8 *)
-				(*((struct_vecteur *) (*s_objet_argument).objet)).tableau)[0]);
+		if (depassement == d_faux)
+		{
+			if ((s_objet_resultat = allocation(s_etat_processus, INT)) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
 
-		for(i = 1; i < (*((struct_vecteur *) (*s_objet_argument).objet)).taille;
-				i++)
+			(*((integer8 *) (*s_objet_resultat).objet)) = abs(((integer8 *)
+					(*((struct_vecteur *) (*s_objet_argument).objet))
+					.tableau)[0]);
+
+			for(i = 1; i < (*((struct_vecteur *) (*s_objet_argument).objet))
+					.taille; i++)
+			{
+				if (abs(((integer8 *) (*((struct_vecteur *) (*s_objet_argument)
+						.objet)).tableau)[i]) > (*((integer8 *)
+						(*s_objet_resultat).objet)))
+				{
+					(*((integer8 *) (*s_objet_resultat).objet)) =
+							abs(((integer8 *) (*((struct_vecteur *)
+							(*s_objet_argument).objet)).tableau)[i]);
+				}
+			}
+		}
+		else
 		{
-			if (abs(((integer8 *) (*((struct_vecteur *) (*s_objet_argument)
-					.objet)).tableau)[i]) > (*((integer8 *)
-					(*s_objet_resultat).objet)))
+			if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL)
 			{
-				(*((integer8 *) (*s_objet_resultat).objet)) =
-						abs(((integer8 *) (*((struct_vecteur *)
-						(*s_objet_argument).objet)).tableau)[i]);
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			(*((real8 *) (*s_objet_resultat).objet)) = abs((real8) ((integer8 *)
+					(*((struct_vecteur *) (*s_objet_argument).objet))
+					.tableau)[0]);
+
+			for(i = 1; i < (*((struct_vecteur *) (*s_objet_argument).objet))
+					.taille; i++)
+			{
+				if (abs((real8) ((integer8 *) (*((struct_vecteur *)
+						(*s_objet_argument).objet)).tableau)[i]) > (*((real8 *)
+						(*s_objet_resultat).objet)))
+				{
+					(*((real8 *) (*s_objet_resultat).objet)) =
+							abs((real8) ((integer8 *) (*((struct_vecteur *)
+							(*s_objet_argument).objet)).tableau)[i]);
+				}
 			}
 		}
 	}
@@ -501,6 +543,13 @@ instruction_rnrm(struct_processus *s_eta
 		for(j = 0; j < (*((struct_matrice *) (*s_objet_argument).objet))
 				.nombre_colonnes; j++)
 		{
+			if (((integer8 **) (*((struct_matrice *) (*s_objet_argument).objet))
+					.tableau)[0][j] == INT64_MIN)
+			{
+				depassement = d_vrai;
+				break;
+			}
+
 			entier_courant = abs(((integer8 **)
 					(*((struct_matrice *) (*s_objet_argument).objet))
 					.tableau)[0][j]);
@@ -525,6 +574,14 @@ instruction_rnrm(struct_processus *s_eta
 				for(j = 0; j < (*((struct_matrice *) (*s_objet_argument).objet))
 						.nombre_colonnes; j++)
 				{
+					if (((integer8 **) (*((struct_matrice *)
+							(*s_objet_argument).objet)).tableau)[i][j]
+							== INT64_MIN)
+					{
+						depassement = d_vrai;
+						break;
+					}
+
 					entier_courant = abs(((integer8 **) (*((struct_matrice *)
 							(*s_objet_argument).objet)).tableau)[i][j]);
 
@@ -565,8 +622,8 @@ instruction_rnrm(struct_processus *s_eta
 				return;
 			}
 
-			if ((accumulateur = malloc((*((struct_matrice *)
-					(*s_objet_argument).objet)).nombre_colonnes *
+			if ((accumulateur = malloc(((size_t) (*((struct_matrice *)
+					(*s_objet_argument).objet)).nombre_colonnes) *
 					sizeof(real8))) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
@@ -614,8 +671,8 @@ instruction_rnrm(struct_processus *s_eta
 			return;
 		}
 
-		if ((accumulateur = malloc((*((struct_matrice *)
-				(*s_objet_argument).objet)).nombre_colonnes * sizeof(real8)))
+		if ((accumulateur = malloc(((size_t) (*((struct_matrice *)
+				(*s_objet_argument).objet)).nombre_colonnes) * sizeof(real8)))
 				== NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
@@ -661,8 +718,8 @@ instruction_rnrm(struct_processus *s_eta
 			return;
 		}
 
-		if ((accumulateur = malloc((*((struct_matrice *)
-				(*s_objet_argument).objet)).nombre_colonnes * sizeof(real8)))
+		if ((accumulateur = malloc(((size_t) (*((struct_matrice *)
+				(*s_objet_argument).objet)).nombre_colonnes) * sizeof(real8)))
 				== NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
@@ -741,10 +798,6 @@ instruction_rnrm(struct_processus *s_eta
 void
 instruction_rceq(struct_processus *s_etat_processus)
 {
-	logical1				presence_variable;
-
-	long					i;
-
 	struct_objet			*s_objet_variable;
 
 	(*s_etat_processus).erreur_execution = d_ex;
@@ -766,10 +819,10 @@ instruction_rceq(struct_processus *s_eta
 				"       %s, %s, %s, %s, %s,\n"
 				"       %s, %s, %s, %s, %s,\n"
 				"       %s, %s, %s, %s,\n"
-				"       %s, %s\n",
+				"       %s, %s, %s\n",
 				d_INT, d_REL, d_CPL, d_VIN, d_VRL, d_VCX, d_MIN, d_MRL, d_MCX,
 				d_TAB, d_BIN, d_NOM, d_CHN, d_LST, d_ALG, d_RPN, d_FCH, d_SCK,
-				d_SQL, d_SLB, d_PRC, d_MTX);
+				d_SQL, d_SLB, d_PRC, d_MTX, d_REC);
 
 		return;
 	}
@@ -787,48 +840,20 @@ instruction_rceq(struct_processus *s_eta
 		}
 	}
 
-	if (recherche_variable(s_etat_processus, "EQ") == d_vrai)
+	if (recherche_variable_globale(s_etat_processus, "EQ") == d_faux)
 	{
-		i = (*s_etat_processus).position_variable_courante;
-		presence_variable = d_faux;
-
-		while(i >= 0)
-		{
-			if ((strcmp((*s_etat_processus).s_liste_variables[i].nom, "EQ")
-					== 0) && ((*s_etat_processus).s_liste_variables[i]
-					.niveau == 1))
-			{
-				presence_variable = d_vrai;
-				break;
-			}
-
-			i--;
-		}
-
-		(*s_etat_processus).position_variable_courante = i;
+		(*s_etat_processus).erreur_systeme = d_es;
 
-		if (presence_variable == d_faux)
+		if ((*s_etat_processus).erreur_execution == d_ex)
 		{
 			(*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
-			return;
 		}
 
-		if ((*s_etat_processus).s_liste_variables[i].objet == NULL)
-		{
-			(*s_etat_processus).erreur_execution = d_ex_variable_partagee;
-			return;
-		}
-	}
-	else
-	{
-		(*s_etat_processus).erreur_systeme = d_es;
-		(*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
 		return;
 	}
 
 	if ((s_objet_variable = copie_objet(s_etat_processus,
-			((*s_etat_processus).s_liste_variables)
-			[(*s_etat_processus).position_variable_courante].objet, 'P'))
+			(*(*s_etat_processus).pointeur_variable_courante).objet, 'P'))
 			== NULL)
 	{
 		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
@@ -961,20 +986,45 @@ instruction_recall(struct_processus *s_e
 	int						caractere;
 	int						ios;
 
+	logical1				drapeau_fin;
+	logical1				indicateur_48;
+	logical1				presence_chaine;
+
 	long					i;
 	long					nombre_caracteres_source;
 
 	struct_objet			*s_objet;
-	struct_objet			*s_objet_temporaire;
 
+	unsigned char			autorisation_empilement_programme;
+	unsigned char			*chaine;
 	unsigned char			*commande;
+	unsigned char			*executable_candidat;
+
+#	ifndef OS2
 	unsigned char			*instructions = "%s/bin/rpliconv %s "
 									"`%s/bin/rplfile "
-									"-m %s/share/rplfiles -i %s | awk "
-									"'{ print $3; }' | awk -F= '{ if "
+									"-m %s/share/rplfiles -i %s | "
+									"%s/bin/rplawk "
+									"'{ print $3; }' | %s/bin/rplawk -F= '{ if "
 									"($2 != \"\") printf(\"-f %%s\", $2); }'` "
 									"-t `locale charmap` | %s/bin/%s -o %s";
+#	else
+	unsigned char			*instructions = BOURNE_SHELL
+									" -c \"%s/bin/rpliconv %s "
+									"`%s/bin/rplfile "
+									"-m %s/share/rplfiles -i %s | "
+									"%s/bin/rplawk "
+									"'{ print $3; }' | %s/bin/rplawk -F= '{ if "
+									"($2 != \\\"\\\") printf(\\\"-f %%s\\\", "
+									"$2); }'` -t `" d_locale
+									"` | %s/bin/%s -o %s\"";
+#	endif
+
 	unsigned char			*nom_fichier_temporaire;
+	unsigned char			*tampon_definitions_chainees;
+	unsigned char			*tampon_instruction_courante;
+
+	integer8				position_courante;
 
 	(*s_etat_processus).erreur_execution = d_ex;
 
@@ -1044,20 +1094,173 @@ instruction_recall(struct_processus *s_e
 			return;
 		}
 
-		if ((commande = malloc((strlen(ds_preprocesseur) +
-				(2 * strlen((unsigned char *) (*s_objet).objet)) +
-				(4 * strlen(d_exec_path)) + 
-				strlen(nom_fichier_temporaire) + strlen(instructions) - 11) *
-				sizeof(unsigned char))) == NULL)
+		if ((*s_etat_processus).rpl_home == NULL)
 		{
-			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
-			return;
+			if ((commande = malloc((strlen(ds_preprocesseur) +
+					(2 * strlen((unsigned char *) (*s_objet).objet)) +
+					(6 * strlen(d_exec_path)) + 
+					strlen(nom_fichier_temporaire) + strlen(instructions) - 19)
+					* sizeof(unsigned char))) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			sprintf(commande, instructions, d_exec_path,
+					(unsigned char *) (*s_objet).objet,
+					d_exec_path, d_exec_path,
+					(unsigned char *) (*s_objet).objet,
+					d_exec_path, d_exec_path,
+					d_exec_path, ds_preprocesseur, nom_fichier_temporaire);
+
+			if (alsprintf(s_etat_processus, &executable_candidat,
+					"%s/bin/rpliconv", d_exec_path) < 0)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			if (controle_integrite(s_etat_processus, executable_candidat,
+					"rpliconv") != d_vrai)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_somme_controle;
+				return;
+			}
+
+			free(executable_candidat);
+
+			if (alsprintf(s_etat_processus, &executable_candidat,
+					"%s/bin/rplfile", d_exec_path) < 0)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			if (controle_integrite(s_etat_processus, executable_candidat,
+					"rplfile") != d_vrai)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_somme_controle;
+				return;
+			}
+
+			free(executable_candidat);
+
+			if (alsprintf(s_etat_processus, &executable_candidat,
+					"%s/bin/rplpp", d_exec_path) < 0)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			if (controle_integrite(s_etat_processus, executable_candidat,
+					"rplpp") != d_vrai)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_somme_controle;
+				return;
+			}
+
+			free(executable_candidat);
+
+			if (alsprintf(s_etat_processus, &executable_candidat,
+					"%s/bin/rplawk", d_exec_path) < 0)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			if (controle_integrite(s_etat_processus, executable_candidat,
+					"rplawk") != d_vrai)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_somme_controle;
+				return;
+			}
+
+			free(executable_candidat);
 		}
+		else
+		{
+			if ((commande = malloc((strlen(ds_preprocesseur) +
+					(2 * strlen((unsigned char *) (*s_objet).objet)) +
+					(6 * strlen((*s_etat_processus).rpl_home)) + 
+					strlen(nom_fichier_temporaire) + strlen(instructions) - 19)
+					* sizeof(unsigned char))) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			sprintf(commande, instructions, (*s_etat_processus).rpl_home,
+					(unsigned char *) (*s_objet).objet,
+					(*s_etat_processus).rpl_home, (*s_etat_processus).rpl_home,
+					(unsigned char *) (*s_objet).objet,
+					(*s_etat_processus).rpl_home, (*s_etat_processus).rpl_home,
+					(*s_etat_processus).rpl_home, ds_preprocesseur,
+					nom_fichier_temporaire);
 
-		sprintf(commande, instructions, d_exec_path,
-				(unsigned char *) (*s_objet).objet,
-				d_exec_path, d_exec_path, (unsigned char *) (*s_objet).objet,
-				d_exec_path, ds_preprocesseur, nom_fichier_temporaire);
+			if (alsprintf(s_etat_processus, &executable_candidat,
+					"%s/bin/rpliconv", (*s_etat_processus).rpl_home) < 0)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			if (controle_integrite(s_etat_processus, executable_candidat,
+					"rpliconv") != d_vrai)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_somme_controle;
+				return;
+			}
+
+			free(executable_candidat);
+
+			if (alsprintf(s_etat_processus, &executable_candidat,
+					"%s/bin/rplfile", (*s_etat_processus).rpl_home) < 0)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			if (controle_integrite(s_etat_processus, executable_candidat,
+					"rplfile") != d_vrai)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_somme_controle;
+				return;
+			}
+
+			free(executable_candidat);
+
+			if (alsprintf(s_etat_processus, &executable_candidat,
+					"%s/bin/rplpp", (*s_etat_processus).rpl_home) < 0)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			if (controle_integrite(s_etat_processus, executable_candidat,
+					"rplpp") != d_vrai)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_somme_controle;
+				return;
+			}
+
+			free(executable_candidat);
+
+			if (alsprintf(s_etat_processus, &executable_candidat,
+					"%s/bin/rplawk", d_exec_path) < 0)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			if (controle_integrite(s_etat_processus, executable_candidat,
+					"rplawk") != d_vrai)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_somme_controle;
+				return;
+			}
+
+			free(executable_candidat);
+		}
 
 		if ((pipe = popen(commande, "r")) == NULL)
 		{
@@ -1116,13 +1319,7 @@ instruction_recall(struct_processus *s_e
 			return;
 		}
 
-		if ((s_objet_temporaire = allocation(s_etat_processus, CHN)) == NULL)
-		{
-			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
-			return;
-		}
-
-		if (((*s_objet_temporaire).objet = malloc((nombre_caracteres_source + 1)
+		if ((chaine = malloc((((size_t) nombre_caracteres_source) + 1)
 				* sizeof(unsigned char))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
@@ -1132,35 +1329,67 @@ instruction_recall(struct_processus *s_e
 		rewind(pipe);
 
 		i = 0;
-		while((caractere = getc(pipe)) != EOF)
+		drapeau_fin = d_faux;
+		presence_chaine = d_faux;
+
+		while(drapeau_fin == d_faux)
 		{
-			if ((caractere == d_code_retour_chariot) ||
-					(caractere == d_code_tabulation))
+			if ((caractere = getc(pipe)) != EOF)
 			{
-				do
+				if ((caractere == d_code_retour_chariot) ||
+						(caractere == d_code_tabulation) ||
+						((caractere == d_code_espace) &&
+						(presence_chaine == d_faux)))
 				{
-					caractere = getc(pipe);
-				} while(((caractere == d_code_retour_chariot) ||
-						(caractere == d_code_tabulation)) &&
-						(caractere != EOF));
+					do
+					{
+						caractere = getc(pipe);
+					} while(((caractere == d_code_retour_chariot) ||
+							(caractere == d_code_tabulation) ||
+							((caractere == d_code_espace) &&
+							(presence_chaine == d_faux))) &&
+							(caractere != EOF));
 
-				if (caractere != EOF)
+					if (caractere != EOF)
+					{
+						chaine[i++] = d_code_espace;
+					}
+					else
+					{
+						drapeau_fin = d_vrai;
+					}
+				}
+
+				if ((chaine[i] = (unsigned char) caractere) == '\"')
 				{
-					((unsigned char *) (*s_objet_temporaire).objet)[i++] =
-							d_code_espace;
+					if (i > 0)
+					{
+						if (chaine[i - 1] != '\\')
+						{
+							presence_chaine = (presence_chaine == d_faux)
+									? d_vrai : d_faux;
+						}
+					}
+
+					i++;
+				}
+				else
+				{
+					i++;
 				}
 			}
-
-			((unsigned char *) (*s_objet_temporaire).objet)[i++] =
-					caractere;
+			else
+			{
+				drapeau_fin = d_vrai;
+			}
 		}
 
-		if (caractere == EOF)
+		if ((caractere == EOF) && (i > 0))
 		{
 			i--;
 		}
 
-		((unsigned char *) (*s_objet_temporaire).objet)[i] = d_code_fin_chaine;
+		chaine[i] = d_code_fin_chaine;
 
 		if (fclose(pipe) != 0)
 		{
@@ -1168,14 +1397,158 @@ instruction_recall(struct_processus *s_e
 			return;
 		}
 
-		if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
-				s_objet_temporaire) == d_erreur)
+		indicateur_48 = test_cfsf(s_etat_processus, 48);
+		cf(s_etat_processus, 48);
+
+		tampon_definitions_chainees = (*s_etat_processus).definitions_chainees;
+		tampon_instruction_courante = (*s_etat_processus).instruction_courante;
+		position_courante = (*s_etat_processus).position_courante;
+		autorisation_empilement_programme = (*s_etat_processus)
+				.autorisation_empilement_programme;
+
+		(*s_etat_processus).instruction_courante = NULL;
+
+		if (((*s_etat_processus).definitions_chainees = transliteration(
+				s_etat_processus, chaine, "UTF-8", d_locale)) == NULL)
 		{
+			if (indicateur_48 == d_vrai)
+			{
+				sf(s_etat_processus, 48);
+			}
+			else
+			{
+				cf(s_etat_processus, 48);
+			}
+
+			if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
+				return;
+			}
+
 			free(nom_fichier_temporaire);
+			free((*s_etat_processus).instruction_courante);
+			free(chaine);
+
+			(*s_etat_processus).position_courante = position_courante;
+			(*s_etat_processus).instruction_courante =
+					tampon_instruction_courante;
+			(*s_etat_processus).definitions_chainees =
+					tampon_definitions_chainees;
+			(*s_etat_processus).autorisation_empilement_programme =
+					autorisation_empilement_programme;
+
+			liberation(s_etat_processus, s_objet);
 			return;
 		}
 
-		instruction_str_fleche(s_etat_processus);
+		(*s_etat_processus).autorisation_empilement_programme = 'Y';
+		(*s_etat_processus).position_courante = 0;
+
+		if (analyse_syntaxique(s_etat_processus) == d_erreur)
+		{
+			if (indicateur_48 == d_vrai)
+			{
+				sf(s_etat_processus, 48);
+			}
+			else
+			{
+				cf(s_etat_processus, 48);
+			}
+
+			if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
+				return;
+			}
+
+			free(nom_fichier_temporaire);
+			free((*s_etat_processus).instruction_courante);
+			free((*s_etat_processus).definitions_chainees);
+			free(chaine);
+
+			(*s_etat_processus).position_courante = position_courante;
+			(*s_etat_processus).instruction_courante =
+					tampon_instruction_courante;
+			(*s_etat_processus).definitions_chainees =
+					tampon_definitions_chainees;
+			(*s_etat_processus).autorisation_empilement_programme =
+					autorisation_empilement_programme;
+
+			liberation(s_etat_processus, s_objet);
+			return;
+		}
+
+		(*s_etat_processus).position_courante = 0;
+
+		if (recherche_instruction_suivante(s_etat_processus) !=
+				d_absence_erreur)
+		{
+			if (indicateur_48 == d_vrai)
+			{
+				sf(s_etat_processus, 48);
+			}
+			else
+			{
+				cf(s_etat_processus, 48);
+			}
+
+			if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
+				return;
+			}
+
+			free(nom_fichier_temporaire);
+			free((*s_etat_processus).instruction_courante);
+			free((*s_etat_processus).definitions_chainees);
+			free(chaine);
+
+			(*s_etat_processus).position_courante = position_courante;
+			(*s_etat_processus).instruction_courante =
+					tampon_instruction_courante;
+			(*s_etat_processus).definitions_chainees =
+					tampon_definitions_chainees;
+			(*s_etat_processus).autorisation_empilement_programme =
+					autorisation_empilement_programme;
+
+			liberation(s_etat_processus, s_objet);
+			return;
+		}
+
+		(*s_etat_processus).type_en_cours = NON;
+		recherche_type(s_etat_processus);
+
+		while((*s_etat_processus).definitions_chainees
+				[(*s_etat_processus).position_courante] != d_code_fin_chaine)
+		{
+			if ((*s_etat_processus).definitions_chainees
+					[(*s_etat_processus).position_courante++] != d_code_espace)
+			{
+				(*s_etat_processus).erreur_execution = d_ex_syntaxe;
+			}
+		}
+
+		free((*s_etat_processus).instruction_courante);
+		free((*s_etat_processus).definitions_chainees);
+		free(chaine);
+
+		(*s_etat_processus).position_courante = position_courante;
+		(*s_etat_processus).instruction_courante =
+				tampon_instruction_courante;
+		(*s_etat_processus).definitions_chainees =
+				tampon_definitions_chainees;
+		(*s_etat_processus).autorisation_empilement_programme =
+				autorisation_empilement_programme;
+
+		if (indicateur_48 == d_vrai)
+		{
+			sf(s_etat_processus, 48);
+		}
+		else
+		{
+			cf(s_etat_processus, 48);
+		}
 
 		if (destruction_fichier(nom_fichier_temporaire) == d_erreur)
 		{
@@ -1215,9 +1588,9 @@ instruction_rcws(struct_processus *s_eta
 {
 	struct_objet				*s_objet_resultat;
 
-	unsigned long				i;
-	unsigned long				j;
-	unsigned long				longueur;
+	integer8					i;
+	integer8					j;
+	integer8					longueur;
 
 	(*s_etat_processus).erreur_execution = d_ex;
 
@@ -1295,10 +1668,6 @@ instruction_rcws(struct_processus *s_eta
 void
 instruction_rcls(struct_processus *s_etat_processus)
 {
-	logical1				presence_variable;
-
-	long					i;
-
 	struct_objet			*s_objet_variable;
 
 	(*s_etat_processus).erreur_execution = d_ex;
@@ -1339,48 +1708,20 @@ instruction_rcls(struct_processus *s_eta
 		}
 	}
 
-	if (recherche_variable(s_etat_processus, ds_sdat) == d_vrai)
+	if (recherche_variable_globale(s_etat_processus, ds_sdat) == d_faux)
 	{
-		i = (*s_etat_processus).position_variable_courante;
-		presence_variable = d_faux;
-
-		while(i >= 0)
-		{
-			if ((strcmp((*s_etat_processus).s_liste_variables[i].nom, ds_sdat)
-					== 0) && ((*s_etat_processus).s_liste_variables[i]
-					.niveau == 1))
-			{
-				presence_variable = d_vrai;
-				break;
-			}
-
-			i--;
-		}
-
-		(*s_etat_processus).position_variable_courante = i;
+		(*s_etat_processus).erreur_systeme = d_es;
 
-		if (presence_variable == d_faux)
+		if ((*s_etat_processus).erreur_execution == d_ex)
 		{
 			(*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
-			return;
 		}
 
-		if ((*s_etat_processus).s_liste_variables[i].objet == NULL)
-		{
-			(*s_etat_processus).erreur_execution = d_ex_variable_partagee;
-			return;
-		}
-	}
-	else
-	{
-		(*s_etat_processus).erreur_systeme = d_es;
-		(*s_etat_processus).erreur_execution = d_ex_variable_non_definie;
 		return;
 	}
 
 	if ((s_objet_variable = copie_objet(s_etat_processus,
-			((*s_etat_processus).s_liste_variables)
-			[(*s_etat_processus).position_variable_courante].objet, 'O'))
+			(*(*s_etat_processus).pointeur_variable_courante).objet, 'O'))
 			== NULL)
 	{
 		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;