--- rpl/src/instructions_f2.c	2010/01/26 15:22:44	1.1.1.1
+++ rpl/src/instructions_f2.c	2023/08/07 17:42:54	1.71
@@ -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.35
+  Copyright (C) 1989-2023 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -20,7 +20,7 @@
 */
 
 
-#include "rpl.conv.h"
+#include "rpl-conv.h"
 
 
 /*
@@ -164,12 +164,12 @@ instruction_fleche_array(struct_processu
 	struct_objet					*s_objet;
 	struct_objet					*s_objet_elementaire;
 
-	unsigned long					i;
-	unsigned long					j;
-	unsigned long					nombre_colonnes;
-	unsigned long					nombre_lignes;
-	unsigned long					nombre_dimensions;
-	unsigned long					nombre_termes;
+	integer8						i;
+	integer8						j;
+	integer8						nombre_colonnes;
+	integer8						nombre_lignes;
+	integer8						nombre_dimensions;
+	integer8						nombre_termes;
 
 	(*s_etat_processus).erreur_execution = d_ex;
 
@@ -343,7 +343,8 @@ instruction_fleche_array(struct_processu
 			}
 
 			if (((*((struct_vecteur *) (*s_objet).objet)).tableau =
-					malloc(nombre_lignes * sizeof(integer8))) == NULL)
+					malloc(((size_t) nombre_lignes) * sizeof(integer8)))
+					== NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
@@ -358,7 +359,7 @@ instruction_fleche_array(struct_processu
 			}
 
 			if (((*((struct_vecteur *) (*s_objet).objet)).tableau =
-					malloc(nombre_lignes * sizeof(real8))) == NULL)
+					malloc(((size_t) nombre_lignes) * sizeof(real8))) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
@@ -373,8 +374,8 @@ instruction_fleche_array(struct_processu
 			}
 
 			if (((*((struct_vecteur *) (*s_objet).objet)).tableau =
-					malloc(nombre_lignes * sizeof(struct_complexe16)))
-					== NULL)
+					malloc(((size_t) nombre_lignes) *
+					sizeof(struct_complexe16))) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
@@ -474,7 +475,8 @@ instruction_fleche_array(struct_processu
 			}
 
 			if (((*((struct_matrice *) (*s_objet).objet)).tableau =
-					malloc(nombre_lignes * sizeof(integer8 *))) == NULL)
+					malloc(((size_t) nombre_lignes) * sizeof(integer8 *)))
+					== NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
@@ -490,7 +492,7 @@ instruction_fleche_array(struct_processu
 			}
 
 			if (((*((struct_matrice *) (*s_objet).objet)).tableau =
-					malloc(nombre_lignes * sizeof(real8 *))) == NULL)
+					malloc(((size_t) nombre_lignes) * sizeof(real8 *))) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
@@ -506,8 +508,8 @@ instruction_fleche_array(struct_processu
 			}
 
 			if (((*((struct_matrice *) (*s_objet).objet)).tableau =
-					malloc(nombre_lignes * sizeof(struct_complexe16 *)))
-					== NULL)
+					malloc(((size_t) nombre_lignes) *
+					sizeof(struct_complexe16 *))) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
@@ -524,7 +526,8 @@ instruction_fleche_array(struct_processu
 			{
 				if ((((integer8 **) (*((struct_matrice *)
 						(*s_objet).objet)).tableau)[nombre_lignes - (i + 1)]
-						= malloc(nombre_colonnes * sizeof(integer8))) == NULL)
+						= malloc(((size_t) nombre_colonnes) *
+						sizeof(integer8))) == NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
 							d_es_allocation_memoire;
@@ -535,7 +538,8 @@ instruction_fleche_array(struct_processu
 			{
 				if ((((real8 **) (*((struct_matrice *)
 						(*s_objet).objet)).tableau)[nombre_lignes - (i + 1)]
-						= malloc(nombre_colonnes * sizeof(real8))) == NULL)
+						= malloc(((size_t) nombre_colonnes) * sizeof(real8)))
+						== NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
 							d_es_allocation_memoire;
@@ -546,8 +550,8 @@ instruction_fleche_array(struct_processu
 			{
 				if ((((struct_complexe16 **) (*((struct_matrice *)
 						(*s_objet).objet)).tableau)[nombre_lignes - (i + 1)]
-						= malloc(nombre_colonnes * sizeof(struct_complexe16)))
-						== NULL)
+						= malloc(((size_t) nombre_colonnes)
+						* sizeof(struct_complexe16))) == NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
 							d_es_allocation_memoire;
@@ -729,6 +733,12 @@ instruction_fleche_str(struct_processus
 	struct_objet					*s_objet_argument;
 	struct_objet					*s_objet_resultat;
 
+	unsigned char					*ligne;
+	unsigned char					*ptr_e;
+	unsigned char					*ptr_l;
+
+	integer8						caracteres_echappement;
+
 	(*s_etat_processus).erreur_execution = d_ex;
 
 	if ((*s_etat_processus).affichage_arguments == 'Y')
@@ -781,15 +791,95 @@ instruction_fleche_str(struct_processus
 		return;
 	}
 
-	(*s_objet_resultat).objet = (void *) formateur(s_etat_processus, 0,
-			s_objet_argument);
+	ligne = formateur(s_etat_processus, 0, s_objet_argument);
+	caracteres_echappement = 0;
+
+	// Reconstitution des caractères d'échappement
+
+	ptr_l = ligne;
+
+	while((*ptr_l) != d_code_fin_chaine)
+	{
+		switch(*ptr_l)
+		{
+			case '\"':
+			case '\b':
+			case '\n':
+			case '\t':
+			case '\\':
+			{
+				caracteres_echappement++;
+				break;
+			}
+		}
+
+		ptr_l++;
+	}
 
-	if ((*s_objet_resultat).objet == NULL)
+	if (((*s_objet_resultat).objet = malloc((strlen(ligne) + 1 +
+			((size_t) caracteres_echappement)) * sizeof(unsigned char)))
+			== NULL)
 	{
 		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 		return;
 	}
 
+	ptr_l = ligne;
+	ptr_e = (*s_objet_resultat).objet;
+
+	while((*ptr_l) != d_code_fin_chaine)
+	{
+		switch(*ptr_l)
+		{
+			case '\\':
+			{
+				(*ptr_e) = '\\';
+				(*(++ptr_e)) = '\\';
+				break;
+			}
+
+			case '\"':
+			{
+				(*ptr_e) = '\\';
+				(*(++ptr_e)) = '\"';
+				break;
+			}
+
+			case '\b':
+			{
+				(*ptr_e) = '\\';
+				(*(++ptr_e)) = 'b';
+				break;
+			}
+
+			case '\n':
+			{
+				(*ptr_e) = '\\';
+				(*(++ptr_e)) = 'n';
+				break;
+			}
+
+			case '\t':
+			{
+				(*ptr_e) = '\\';
+				(*(++ptr_e)) = 't';
+				break;
+			}
+
+			default:
+			{
+				(*ptr_e) = (*ptr_l);
+				break;
+			}
+		}
+
+		ptr_l++;
+		ptr_e++;
+	}
+
+	(*ptr_e) = d_code_fin_chaine;
+	free(ligne);
+
 	liberation(s_etat_processus, s_objet_argument);
 
 	if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
@@ -823,9 +913,9 @@ instruction_fft(struct_processus *s_etat
 	integer4					nombre_colonnes;
 	integer4					nombre_lignes;
 
-	logical1					presence_longueur_fft;
+	integer8					longueur_fft_signee;
 
-	long						longueur_fft_signee;
+	logical1					presence_longueur_fft;
 
 	struct_complexe16			*matrice_f77;
 
@@ -833,10 +923,10 @@ instruction_fft(struct_processus *s_etat
 	struct_objet				*s_objet_longueur_fft;
 	struct_objet				*s_objet_resultat;
 
-	unsigned long				i;
-	unsigned long				j;
-	unsigned long				k;
-	unsigned long				longueur_fft;
+	integer8					i;
+	integer8					j;
+	integer8					k;
+	integer8					longueur_fft;
 
 	(*s_etat_processus).erreur_execution =d_ex;
 
@@ -950,18 +1040,18 @@ instruction_fft(struct_processus *s_etat
 	{
 		if (presence_longueur_fft == d_faux)
 		{
-			longueur_fft = pow(2, (integer4) ceil(log((real8)
+			longueur_fft = (integer8) pow(2, ceil(log((real8)
 					(*((struct_vecteur *)
 					(*s_objet_argument).objet)).taille) / log((real8) 2)));
 
-			if ((longueur_fft / ((real8) (*((struct_vecteur *)
+			if ((((real8) longueur_fft) / ((real8) (*((struct_vecteur *)
 					(*s_objet_argument).objet)).taille)) == 2)
 			{
 				longueur_fft /= 2;
 			}
 		}
 
-		if ((matrice_f77 = malloc(longueur_fft *
+		if ((matrice_f77 = malloc(((size_t) longueur_fft) *
 				sizeof(struct_complexe16))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
@@ -1011,7 +1101,7 @@ instruction_fft(struct_processus *s_etat
 		}
 
 		nombre_lignes = 1;
-		nombre_colonnes = longueur_fft;
+		nombre_colonnes = (integer4) longueur_fft;
 		inverse = 0;
 
 		dft(matrice_f77, &nombre_lignes, &nombre_colonnes, &inverse, &erreur);
@@ -1048,21 +1138,21 @@ instruction_fft(struct_processus *s_etat
 	{
 		if (presence_longueur_fft == d_faux)
 		{
-			longueur_fft = pow(2, (integer4) ceil(log((real8)
+			longueur_fft = (integer8) pow(2, ceil(log((real8)
 					(*((struct_matrice *)
 					(*s_objet_argument).objet)).nombre_colonnes) /
 					log((real8) 2)));
 
-			if ((longueur_fft / ((real8) (*((struct_matrice *)
+			if ((((real8) longueur_fft) / ((real8) (*((struct_matrice *)
 					(*s_objet_argument).objet)).nombre_colonnes)) == 2)
 			{
 				longueur_fft /= 2;
 			}
 		}
 
-		if ((matrice_f77 = malloc(longueur_fft *
+		if ((matrice_f77 = malloc(((size_t) longueur_fft) * ((size_t)
 				(*((struct_matrice *) (*s_objet_argument).objet))
-				.nombre_lignes * sizeof(struct_complexe16))) == NULL)
+				.nombre_lignes) * sizeof(struct_complexe16))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
@@ -1138,9 +1228,9 @@ instruction_fft(struct_processus *s_etat
 			}
 		}
 
-		nombre_lignes = (*((struct_matrice *) (*s_objet_argument).objet))
-				.nombre_lignes;
-		nombre_colonnes = longueur_fft;
+		nombre_lignes = (integer4) (*((struct_matrice *)
+				(*s_objet_argument).objet)).nombre_lignes;
+		nombre_colonnes = (integer4) longueur_fft;
 		inverse = 0;
 
 		dft(matrice_f77, &nombre_lignes, &nombre_colonnes, &inverse, &erreur);
@@ -1168,8 +1258,9 @@ instruction_fft(struct_processus *s_etat
 				longueur_fft;
 
 		if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
-				malloc((*((struct_matrice *) (*s_objet_resultat).objet))
-				.nombre_lignes * sizeof(struct_complexe16 *))) == NULL)
+				malloc(((size_t) (*((struct_matrice *)
+				(*s_objet_resultat).objet)).nombre_lignes)
+				* sizeof(struct_complexe16 *))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
@@ -1180,8 +1271,8 @@ instruction_fft(struct_processus *s_etat
 		{
 			if ((((struct_complexe16 **) (*((struct_matrice *)
 					(*s_objet_resultat).objet)).tableau)[i] =
-					malloc((*((struct_matrice *)
-					(*s_objet_resultat).objet)).nombre_colonnes *
+					malloc(((size_t) (*((struct_matrice *)
+					(*s_objet_resultat).objet)).nombre_colonnes) *
 					sizeof(struct_complexe16))) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;