--- rpl/src/formateur_flux.c	2011/11/17 22:21:16	1.14
+++ rpl/src/formateur_flux.c	2011/11/19 17:53:46	1.17
@@ -244,6 +244,134 @@ formateur_flux(struct_processus *s_etat_
 
 /*
 ================================================================================
+  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 +387,11 @@ prochain_caractere(struct_processus *s_e
 {
 	unsigned char		*suivant;
 
+	if (chaine == NULL)
+	{
+		return(NULL);
+	}
+
 	if ((*chaine) == '\\')
 	{
 		if ((*(chaine + 1)) == '"')
@@ -394,7 +527,7 @@ prochain_caractere(struct_processus *s_e
 		}
 		else if ((*(chaine + 1)) == '\\')
 		{
-			suivant = chaine + 1;
+			suivant = chaine + 2;
 		}
 		else
 		{
@@ -461,4 +594,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);
+
+	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