--- rpl/src/formateur_flux.c	2011/11/26 10:01:26	1.18
+++ rpl/src/formateur_flux.c	2019/02/03 14:40:32	1.58
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.5
-  Copyright (C) 1989-2011 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.31
+  Copyright (C) 1989-2019 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -37,7 +37,7 @@
 
 unsigned char *
 formateur_flux(struct_processus *s_etat_processus, unsigned char *donnees,
-		long *longueur)
+		integer8 *longueur)
 {
 	unsigned char			*chaine;
 
@@ -107,7 +107,7 @@ formateur_flux(struct_processus *s_etat_
 							case '7':
 							case '8':
 							case '9':
-								ec = (*ptr_lecture) - '0';
+								ec = (unsigned char) ((*ptr_lecture) - '0');
 								break;
 
 							case 'A':
@@ -116,7 +116,8 @@ formateur_flux(struct_processus *s_etat_
 							case 'D':
 							case 'E':
 							case 'F':
-								ec = ((*ptr_lecture) - 'A') + 10;
+								ec = (unsigned char) (((*ptr_lecture) - 'A')
+										+ 10);
 								break;
 
 							default:
@@ -125,7 +126,7 @@ formateur_flux(struct_processus *s_etat_
 								break;
 						}
 
-						ec *= 0x10;
+						ec = (unsigned char) (ec * (unsigned char) 0x10);
 						ptr_lecture++;
 
 						switch(*ptr_lecture)
@@ -140,7 +141,8 @@ formateur_flux(struct_processus *s_etat_
 							case '7':
 							case '8':
 							case '9':
-								ec += (*ptr_lecture) - '0';
+								ec = (unsigned char) (ec +
+										((*ptr_lecture) - '0'));
 								break;
 
 							case 'A':
@@ -149,7 +151,8 @@ formateur_flux(struct_processus *s_etat_
 							case 'D':
 							case 'E':
 							case 'F':
-								ec += ((*ptr_lecture) - 'A') + 10;
+								ec = (unsigned char) (ec +
+										(((*ptr_lecture) - 'A') + 10));
 								break;
 
 							default:
@@ -165,14 +168,16 @@ formateur_flux(struct_processus *s_etat_
 							{
 								printf("+++Information : "
 										"Séquence d'échappement "
-										"inconnue [%d]\n",
+										"inconnue (\\x%c%c) [%d]\n",
+										*ptr_lecture, *(ptr_lecture + 1),
 										(int) getpid());
 							}
 							else
 							{
 								printf("+++Warning : Unknown "
-										"escape code "
-										"[%d]\n", (int) getpid());
+										"escape code (\\x%c%c) [%d]\n",
+										*ptr_lecture, *(ptr_lecture + 1),
+										(int) getpid());
 							}
 						}
 					}
@@ -182,11 +187,11 @@ formateur_flux(struct_processus *s_etat_
 						{
 							printf("+++Information : "
 									"Séquence d'échappement "
-									"inconnue [%d]\n", (int) getpid());
+									"tronquée [%d]\n", (int) getpid());
 						}
 						else
 						{
-							printf("+++Warning : Unknown escape code "
+							printf("+++Warning : Truncated escape code "
 									"[%d]\n", (int) getpid());
 						}
 					}
@@ -212,15 +217,35 @@ formateur_flux(struct_processus *s_etat_
 			}
 			else
 			{
-				if ((*s_etat_processus).langue == 'F')
+				if ((*(ptr_lecture + 1)) == d_code_fin_chaine)
 				{
-					printf("+++Information : Séquence d'échappement "
-							"inconnue [%d]\n", (int) getpid());
+					if ((*s_etat_processus).langue == 'F')
+					{
+						printf("+++Information : "
+								"Séquence d'échappement "
+								"tronquée [%d]\n", (int) getpid());
+					}
+					else
+					{
+						printf("+++Warning : Truncated escape code "
+								"[%d]\n", (int) getpid());
+					}
 				}
 				else
-				{
-					printf("+++Warning : Unknown escape code "
-							"[%d]\n", (int) getpid());
+				{	
+					if ((*s_etat_processus).langue == 'F')
+					{
+						printf("+++Information : Séquence d'échappement "
+								"inconnue (%c%c) [%d]\n",
+								*ptr_lecture, *(ptr_lecture + 1),
+								(int) getpid());
+					}
+					else
+					{
+						printf("+++Warning : Unknown escape code (%c%c) "
+								"[%d]\n", *ptr_lecture, *(ptr_lecture + 1),
+								(int) getpid());
+					}
 				}
 			}
 		}
@@ -231,8 +256,8 @@ formateur_flux(struct_processus *s_etat_
 
 	(*ptr_ecriture) = d_code_fin_chaine;
 
-	if ((chaine = realloc(chaine, ((((*longueur) = ptr_ecriture - chaine)) + 1)
-			* sizeof(unsigned char))) == NULL)
+	if ((chaine = realloc(chaine, (((size_t) ((*longueur) =
+			ptr_ecriture - chaine)) + 1) * sizeof(unsigned char))) == NULL)
 	{
 		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 		return(NULL);
@@ -244,6 +269,150 @@ formateur_flux(struct_processus *s_etat_
 
 /*
 ================================================================================
+  Routine de d'analyse d'un flux
+================================================================================
+  Entrées : structure sur l'état du processus et objet à afficher
+--------------------------------------------------------------------------------
+  Sorties : chaine de caractères
+--------------------------------------------------------------------------------
+  Effets de bord : néant
+================================================================================
+*/
+
+unsigned char *
+analyse_flux(struct_processus *s_etat_processus, unsigned char *donnees,
+		integer8 longueur)
+{
+	integer8				longueur_courante;
+
+	long					offset;
+
+	unsigned char			*chaine;
+	unsigned char			hexadecimal[3];
+	unsigned char			*ptr_ecriture;
+	unsigned char			*ptr_lecture;
+
+	if ((chaine = malloc(((size_t) (longueur_courante = longueur + 1)) *
+			sizeof(unsigned char))) == NULL)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+		return(NULL);
+	}
+
+	ptr_lecture = donnees;
+	ptr_ecriture = chaine;
+
+	while(longueur > 0)
+	{
+		// Début de la séquence d'échappement
+
+		switch((*ptr_lecture))
+		{
+			case '"':
+			case '\b':
+			case '\n':
+			case '\t':
+			case '\\':
+			{
+				offset = ptr_ecriture - chaine;
+
+				if ((chaine = realloc(chaine, ((size_t) (++longueur_courante))
+						* sizeof(unsigned char))) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return(NULL);
+				}
+
+				ptr_ecriture = chaine + offset;
+				*ptr_ecriture++ = '\\';
+
+				switch((*ptr_lecture++))
+				{
+					case '"':
+					{
+						*ptr_ecriture++ = '"';
+						break;
+					}
+
+					case '\b':
+					{
+						*ptr_ecriture++ = 'b';
+						break;
+					}
+
+					case '\n':
+					{
+						*ptr_ecriture++ = 'n';
+						break;
+					}
+
+					case '\t':
+					{
+						*ptr_ecriture++ = 't';
+						break;
+					}
+
+					case '\\':
+					{
+						*ptr_ecriture++ = '\\';
+						break;
+					}
+				}
+
+				break;
+			}
+
+			case ' ':
+			{
+				*ptr_ecriture++ = *ptr_lecture++;
+				break;
+			}
+
+			default:
+			{
+				if (isgraph((*ptr_lecture)))
+				{
+					*ptr_ecriture++ = *ptr_lecture++;
+				}
+				else
+				{
+					offset = ptr_ecriture - chaine;
+
+					if ((chaine = realloc(chaine, ((size_t) (longueur_courante =
+							longueur_courante + 3)) * sizeof(unsigned char)))
+							== NULL)
+					{
+						(*s_etat_processus).erreur_systeme =
+								d_es_allocation_memoire;
+						return(NULL);
+					}
+
+					ptr_ecriture = chaine + offset;
+					*ptr_ecriture++ = '\\';
+					*ptr_ecriture++ = 'x';
+
+					sprintf(hexadecimal, "%02X", *ptr_lecture++);
+
+					*ptr_ecriture++ = hexadecimal[0];
+					*ptr_ecriture++ = hexadecimal[1];
+				}
+
+				break;
+			}
+		}
+
+		longueur--;
+	}
+
+	(*ptr_ecriture) = d_code_fin_chaine;
+
+	return(chaine);
+}
+
+
+/*
+================================================================================
   Routine testant la validité d'une chaîne de caractères
 ================================================================================
   Entrées : structure sur l'état du processus et chaîne courante
@@ -688,10 +857,10 @@ conversion_chaine(struct_processus *s_et
 {
 	int					(*fonction_1)(int);
 	int					(*fonction_2)(int);
+	int					registre;
 
 	unsigned char		*ptr;
 	unsigned char		*ptr2;
-	unsigned char		registre;
 
 	if (type == 'M')
 	{
@@ -716,7 +885,7 @@ conversion_chaine(struct_processus *s_et
 
 			if (fonction_2(registre) == (*ptr))
 			{
-				(*ptr) = registre;
+				(*ptr) = (unsigned char) registre;
 			}
 		}