--- rpl/src/formateur_flux.c	2011/11/18 09:51:32	1.15
+++ rpl/src/formateur_flux.c	2013/02/27 14:29:01	1.31
@@ -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.12
+  Copyright (C) 1989-2013 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -244,6 +244,142 @@ 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,
+		long longueur)
+{
+	long					longueur_courante;
+	long					offset;
+
+	unsigned char			*chaine;
+	unsigned char			hexadecimal[3];
+	unsigned char			*ptr_ecriture;
+	unsigned char			*ptr_lecture;
+
+	if ((chaine = malloc((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':
+			{
+				offset = ptr_ecriture - chaine;
+
+				if ((chaine = realloc(chaine, (++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;
+					}
+				}
+
+				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, (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
@@ -268,19 +404,19 @@ validation_chaine(unsigned char *chaine)
 		{
 			if ((*(chaine + 1)) == '"')
 			{
-				// Valide
+				chaine += 2;
 			}
 			else if ((*(chaine + 1)) == 'b')
 			{
-				// Valide
+				chaine += 2;
 			}
 			else if ((*(chaine + 1)) == 'n')
 			{
-				// Valide
+				chaine += 2;
 			}
 			else if ((*(chaine + 1)) == 't')
 			{
-				// Valide
+				chaine += 2;
 			}
 			else if ((*(chaine + 1)) == 'x')
 			{
@@ -347,10 +483,12 @@ validation_chaine(unsigned char *chaine)
 				{
 					return(d_faux);
 				}
+
+				chaine += 4;
 			}
 			else if ((*(chaine + 1)) == '\\')
 			{
-				// Valide
+				chaine += 2;
 			}
 			else
 			{
@@ -360,10 +498,8 @@ validation_chaine(unsigned char *chaine)
 		}
 		else
 		{
-			// Caractère valide
+			chaine++;
 		}
-
-		chaine++;
 	}
 
 	return(d_vrai);
@@ -527,7 +663,7 @@ prochain_caractere(struct_processus *s_e
 		}
 		else if ((*(chaine + 1)) == '\\')
 		{
-			suivant = chaine + 1;
+			suivant = chaine + 2;
 		}
 		else
 		{
@@ -599,9 +735,9 @@ longueur_chaine(struct_processus *s_etat
 ================================================================================
   Routine retournant un pointeur sur le i-ème caractère d'une chaîne
 ================================================================================
-  Entrées : structure sur l'état du processus et chaîne
+  Entrées : structure sur l'état du processus, chaîne et position du caractère
 --------------------------------------------------------------------------------
-  Sorties : longueur de la chaîne
+  Sorties : pointeur sur le caractère
 --------------------------------------------------------------------------------
   Effets de bord : néant
 ================================================================================
@@ -633,4 +769,97 @@ pointeur_ieme_caractere(struct_processus
 	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);
+
+	unsigned char		*ptr;
+	unsigned char		*ptr2;
+	unsigned char		registre;
+
+	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) = registre;
+			}
+		}
+
+		ptr = ptr2;
+	}
+
+	return;
+}
+
 // vim: ts=4