--- rpl/src/instructions_s2.c	2010/01/26 15:22:44	1.1.1.1
+++ rpl/src/instructions_s2.c	2020/01/10 11:15:48	1.73
@@ -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.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"
 
 
 /*
@@ -764,7 +764,8 @@ instruction_size(struct_processus *s_eta
 		}
 
 		(*((integer8 *) (*s_objet_resultat).objet)) =
-				strlen((unsigned char *) (*s_objet_argument).objet);
+				longueur_chaine(s_etat_processus,
+				(unsigned char *) (*s_objet_argument).objet);
 	}
 
 /*
@@ -1019,15 +1020,23 @@ instruction_sst(struct_processus *s_etat
 void
 instruction_str_fleche(struct_processus *s_etat_processus)
 {
+	logical1						drapeau45;
+	logical1						presence_chaine;
+
 	struct_objet					*s_objet;
 	struct_objet					*s_sous_objet;
 
 	unsigned char					*commande;
+	unsigned char					*chaine_convertie;
+	unsigned char					*ptr_e;
+	unsigned char					*ptr_l;
 	unsigned char					*registre_definitions_chainees;
 	unsigned char					*registre_instruction_courante;
 	unsigned char					registre_interruption;
+	unsigned char					*tampon;
 
-	unsigned long					position_courante;
+	integer8						nombre_caracteres_supplementaires;
+	integer8						position_courante;
 
 	(*s_etat_processus).erreur_execution = d_ex;
 
@@ -1084,14 +1093,155 @@ instruction_str_fleche(struct_processus
 
 	if ((*s_objet).type == CHN)
 	{
+		// Comptage des caractères à protéger.
+
+		drapeau45 = test_cfsf(s_etat_processus, 45);
+		cf(s_etat_processus, 45);
+
+		tampon = formateur(s_etat_processus, 0, s_objet);
+
+		if (drapeau45 == d_vrai)
+		{
+			sf(s_etat_processus, 45);
+		}
+		else
+		{
+			cf(s_etat_processus, 45);
+		}
+
+		ptr_l = tampon;
+		presence_chaine = d_faux;
+		nombre_caracteres_supplementaires = 0;
+
+		while((*ptr_l) != d_code_fin_chaine)
+		{
+			if ((*ptr_l) == '"')
+			{
+				presence_chaine = (presence_chaine == d_faux) ? d_vrai : d_faux;
+			}
+
+			if (presence_chaine == d_vrai)
+			{
+				switch(*ptr_l)
+				{
+					case '\\':
+					case '\t':
+					case '\b':
+					case '\n':
+					{
+						nombre_caracteres_supplementaires++;
+						break;
+					}
+				}
+			}
+			else
+			{
+				switch(*ptr_l)
+				{
+					case '\n':
+					case '\b':
+					case '\t':
+					{
+						nombre_caracteres_supplementaires--;
+						break;
+					}
+				}
+			}
+
+			ptr_l++;
+		}
+
+		// Échappement des caractères et remplacement dans les chaînes
+		// de caractères incluses. Le seul caractère protégé est le '\'
+		// qui est doublé.
+
+		if ((chaine_convertie = malloc((strlen(tampon) + ((size_t)
+				nombre_caracteres_supplementaires) + 1) *
+				sizeof(unsigned char))) == NULL)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			return;
+		}
+
+		ptr_l = tampon;
+		ptr_e = chaine_convertie;
+		presence_chaine = d_faux;
+
+		while((*ptr_l) != d_code_fin_chaine)
+		{
+			if ((*ptr_l) == '"')
+			{
+				presence_chaine = (presence_chaine == d_faux) ? d_vrai : d_faux;
+			}
+
+			(*ptr_e) = (*ptr_l);
+
+			if (presence_chaine == d_vrai)
+			{
+				switch(*ptr_l)
+				{
+					case '\\':
+					{
+						(*(++ptr_e)) = '\\';
+						break;
+					}
+
+					case '\t':
+					{
+						(*ptr_e) = '\\';
+						(*(++ptr_e)) = 't';
+						break;
+					}
+
+					case '\b':
+					{
+						(*ptr_e) = '\\';
+						(*(++ptr_e)) = 'b';
+						break;
+					}
+
+					case '\n':
+					{
+						(*ptr_e) = '\\';
+						(*(++ptr_e)) = 'n';
+						break;
+					}
+				}
+			}
+			else
+			{
+				switch(*ptr_l)
+				{
+					case '\n':
+					case '\b':
+					case '\t':
+					{
+						ptr_e--;
+						break;
+					}
+				}
+			}
+
+			ptr_l++;
+			ptr_e++;
+		}
+
+		(*ptr_e) = d_code_fin_chaine;
+
 		position_courante = (*s_etat_processus).position_courante;
 		registre_definitions_chainees = (*s_etat_processus)
 				.definitions_chainees;
 		registre_instruction_courante = (*s_etat_processus)
 				.instruction_courante;
+		(*s_etat_processus).position_courante = 0;
+		(*s_etat_processus).definitions_chainees = chaine_convertie;
+		free(tampon);
 
-		(*s_etat_processus).definitions_chainees = (unsigned char *)
-				(*s_objet).objet;
+		if ((*s_etat_processus).definitions_chainees == NULL)
+		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			return;
+		}
 
 		if (analyse_syntaxique(s_etat_processus) == d_absence_erreur)
 		{
@@ -1102,15 +1252,21 @@ instruction_str_fleche(struct_processus
 				return;
 			}
 
-			sprintf(commande, "<< %s >>", (unsigned char *) (*s_objet).objet);
+			sprintf(commande, "<< %s >>", (*s_etat_processus)
+					.definitions_chainees);
 			(*s_etat_processus).instruction_courante = commande;
 
+			(*s_etat_processus).type_en_cours = NON;
 			recherche_type(s_etat_processus);
 
-			if ((*s_etat_processus).erreur_execution != d_ex)
+			if (((*s_etat_processus).erreur_execution != d_ex) ||
+					((*s_etat_processus).erreur_systeme != d_es))
 			{
 				liberation(s_etat_processus, s_objet);
 
+				free((*s_etat_processus).definitions_chainees);
+				free((*s_etat_processus).instruction_courante);
+
 				(*s_etat_processus).definitions_chainees =
 						registre_definitions_chainees;
 				(*s_etat_processus).instruction_courante =
@@ -1125,6 +1281,8 @@ instruction_str_fleche(struct_processus
 					.l_base_pile), &s_sous_objet) == d_erreur)
 			{
 				liberation(s_etat_processus, s_objet);
+				free((*s_etat_processus).definitions_chainees);
+				free((*s_etat_processus).instruction_courante);
 
 				(*s_etat_processus).definitions_chainees =
 						registre_definitions_chainees;
@@ -1143,49 +1301,43 @@ instruction_str_fleche(struct_processus
 
 			if (evaluation(s_etat_processus, s_sous_objet, 'I') == d_erreur)
 			{
+				liberation(s_etat_processus, s_sous_objet);
+				liberation(s_etat_processus, s_objet);
+
+				free((*s_etat_processus).definitions_chainees);
+				free((*s_etat_processus).instruction_courante);
+
+				(*s_etat_processus).definitions_chainees =
+						registre_definitions_chainees;
+				(*s_etat_processus).instruction_courante =
+						registre_instruction_courante;
+				(*s_etat_processus).position_courante =
+						position_courante;
+
 				(*s_etat_processus).traitement_interruptible =
 						registre_interruption;
 
 				if ((*s_etat_processus).erreur_systeme == d_es)
 				{
-					liberation(s_etat_processus, s_objet);
-
-					(*s_etat_processus).definitions_chainees =
-							registre_definitions_chainees;
-					(*s_etat_processus).instruction_courante =
-							registre_instruction_courante;
-					(*s_etat_processus).position_courante =
-							position_courante;
-
 					(*s_etat_processus).erreur_execution =
 							d_ex_expression_invalide;
-					return;
 				}
 				else
 				{
-					liberation(s_etat_processus, s_objet);
-
-					(*s_etat_processus).definitions_chainees =
-							registre_definitions_chainees;
-					(*s_etat_processus).instruction_courante =
-							registre_instruction_courante;
-					(*s_etat_processus).position_courante =
-							position_courante;
-
 					(*s_etat_processus).erreur_systeme =
 							d_es_allocation_memoire;
-					return;
 				}
-			}
 
-			(*s_etat_processus).traitement_interruptible =
-					registre_interruption;
-
-			liberation(s_etat_processus, s_sous_objet);
-			free(commande);
+				return;
+			}
 		}
 		else
 		{
+			liberation(s_etat_processus, s_objet);
+
+			free((*s_etat_processus).definitions_chainees);
+			free((*s_etat_processus).instruction_courante);
+
 			(*s_etat_processus).definitions_chainees =
 					registre_definitions_chainees;
 			(*s_etat_processus).instruction_courante =
@@ -1198,6 +1350,15 @@ instruction_str_fleche(struct_processus
 			return;
 		}
 
+
+		(*s_etat_processus).traitement_interruptible =
+				registre_interruption;
+
+		liberation(s_etat_processus, s_sous_objet);
+
+		free((*s_etat_processus).definitions_chainees);
+		free((*s_etat_processus).instruction_courante);
+
 		(*s_etat_processus).definitions_chainees =
 				registre_definitions_chainees;
 		(*s_etat_processus).instruction_courante =