--- rpl/src/formateur_flux.c	2011/11/17 22:21:16	1.14
+++ rpl/src/formateur_flux.c	2017/06/28 09:20:31	1.53
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.4
-  Copyright (C) 1989-2011 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.27
+  Copyright (C) 1989-2017 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,278 @@ 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
+--------------------------------------------------------------------------------
+  Sorties : pointeur sur le caractère suivant
+--------------------------------------------------------------------------------
+  Effets de bord : néant
+================================================================================
+*/
+
+logical1
+validation_chaine(unsigned char *chaine)
+{
+	if (chaine == NULL)
+	{
+		return(d_faux);
+	}
+
+	while((*chaine) != d_code_fin_chaine)
+	{
+		if ((*chaine) == '\\')
+		{
+			if ((*(chaine + 1)) == '"')
+			{
+				chaine += 2;
+			}
+			else if ((*(chaine + 1)) == 'b')
+			{
+				chaine += 2;
+			}
+			else if ((*(chaine + 1)) == 'n')
+			{
+				chaine += 2;
+			}
+			else if ((*(chaine + 1)) == 't')
+			{
+				chaine += 2;
+			}
+			else if ((*(chaine + 1)) == 'x')
+			{
+				if ((*(chaine + 2)) != d_code_fin_chaine)
+				{
+					if ((*(chaine + 3)) != d_code_fin_chaine)
+					{
+						switch(*(chaine + 2))
+						{
+							case '0':
+							case '1':
+							case '2':
+							case '3':
+							case '4':
+							case '5':
+							case '6':
+							case '7':
+							case '8':
+							case '9':
+							case 'A':
+							case 'B':
+							case 'C':
+							case 'D':
+							case 'E':
+							case 'F':
+								break;
+
+							default:
+								return(d_faux);
+								break;
+						}
+
+						switch(*(chaine + 3))
+						{
+							case '0':
+							case '1':
+							case '2':
+							case '3':
+							case '4':
+							case '5':
+							case '6':
+							case '7':
+							case '8':
+							case '9':
+							case 'A':
+							case 'B':
+							case 'C':
+							case 'D':
+							case 'E':
+							case 'F':
+								break;
+
+							default:
+								return(d_faux);
+								break;
+						}
+					}
+					else
+					{
+						return(d_faux);
+					}
+				}
+				else
+				{
+					return(d_faux);
+				}
+
+				chaine += 4;
+			}
+			else if ((*(chaine + 1)) == '\\')
+			{
+				chaine += 2;
+			}
+			else
+			{
+				// Tous les autres cas sont invalides
+				return(d_faux);
+			}
+		}
+		else
+		{
+			chaine++;
+		}
+	}
+
+	return(d_vrai);
+}
+
+
+/*
+================================================================================
   Routine permettant de trouver le caractère suivant dans une chaîne
 ================================================================================
   Entrées : structure sur l'état du processus et chaîne courante
@@ -259,6 +556,11 @@ prochain_caractere(struct_processus *s_e
 {
 	unsigned char		*suivant;
 
+	if (chaine == NULL)
+	{
+		return(NULL);
+	}
+
 	if ((*chaine) == '\\')
 	{
 		if ((*(chaine + 1)) == '"')
@@ -394,7 +696,7 @@ prochain_caractere(struct_processus *s_e
 		}
 		else if ((*(chaine + 1)) == '\\')
 		{
-			suivant = chaine + 1;
+			suivant = chaine + 2;
 		}
 		else
 		{
@@ -461,4 +763,136 @@ longueur_chaine(struct_processus *s_etat
 	return(nombre_caracteres);
 }
 
+
+/*
+================================================================================
+  Routine retournant un pointeur sur le i-ème caractère d'une chaîne
+================================================================================
+  Entrées : structure sur l'état du processus, chaîne et position du caractère
+--------------------------------------------------------------------------------
+  Sorties : pointeur sur le caractère
+--------------------------------------------------------------------------------
+  Effets de bord : néant
+================================================================================
+*/
+
+unsigned char *
+pointeur_ieme_caractere(struct_processus *s_etat_processus,
+		unsigned char *chaine, integer8 position)
+{
+	integer8			i;
+
+	unsigned char		*pointeur;
+
+	if ((pointeur = chaine) == NULL)
+	{
+		return(NULL);
+	}
+
+	for(i = 0; i < position; i++)
+	{
+		pointeur = prochain_caractere(s_etat_processus, pointeur);
+
+		if ((*pointeur) == d_code_fin_chaine)
+		{
+			return(pointeur);
+		}
+	}
+
+	return(pointeur);
+}
+
+
+/*
+================================================================================
+  Routine retournant la position du caractère en fonction du pointeur
+  dans la chaîne
+================================================================================
+  Entrées : structure sur l'état du processus, chaîne et position
+--------------------------------------------------------------------------------
+  Sorties : quantième dans la chaîne
+--------------------------------------------------------------------------------
+  Effets de bord : néant
+================================================================================
+*/
+
+integer8
+position_caractere_de_chaine(struct_processus *s_etat_processus,
+		unsigned char *chaine, unsigned char *position)
+{
+	integer8			i;
+
+	i = 1;
+
+	while(chaine != position)
+	{
+		chaine = prochain_caractere(s_etat_processus, chaine);
+		i++;
+
+		if ((*chaine) == d_code_fin_chaine)
+		{
+			return(0);
+		}
+	}
+
+	return(i);
+}
+
+
+/*
+================================================================================
+  Conversion d'une chaîne en majuscule ou en minuscule
+================================================================================
+  Entrées : chaîne et indicateur ('M' pour majuscules, 'm' pour minuscules)
+--------------------------------------------------------------------------------
+  Sorties : néant
+--------------------------------------------------------------------------------
+  Effets de bord : néant
+================================================================================
+*/
+
+void
+conversion_chaine(struct_processus *s_etat_processus,
+		unsigned char *chaine, unsigned char type)
+{
+	int					(*fonction_1)(int);
+	int					(*fonction_2)(int);
+	int					registre;
+
+	unsigned char		*ptr;
+	unsigned char		*ptr2;
+
+	if (type == 'M')
+	{
+		fonction_1 = toupper;
+		fonction_2 = tolower;
+	}
+	else
+	{
+		fonction_1 = tolower;
+		fonction_2 = toupper;
+	}
+
+	ptr = chaine;
+
+	while((*ptr) != d_code_fin_chaine)
+	{
+		ptr2 = prochain_caractere(s_etat_processus, ptr);
+
+		if ((ptr2 - ptr) == 1)
+		{
+			registre = fonction_1((*ptr));
+
+			if (fonction_2(registre) == (*ptr))
+			{
+				(*ptr) = (unsigned char) registre;
+			}
+		}
+
+		ptr = ptr2;
+	}
+
+	return;
+}
+
 // vim: ts=4