--- rpl/src/compilation.c	2014/07/26 09:58:02	1.68
+++ rpl/src/compilation.c	2014/08/04 06:58:48	1.69
@@ -19,7 +19,7 @@
 ================================================================================
 */
 
-
+#define DEBUG_ERREURS
 #include "rpl-conv.h"
 
 
@@ -1017,6 +1017,13 @@ swap(void *variable_1, void *variable_2,
 logical1
 recherche_instruction_suivante(struct_processus *s_etat_processus)
 {
+	return(recherche_instruction_suivante_recursive(s_etat_processus, 0));
+}
+
+logical1
+recherche_instruction_suivante_recursive(struct_processus *s_etat_processus,
+		integer8 recursivite)
+{
 	enum t_type					registre_type_en_cours;
 
 	logical1					drapeau_fin_objet;
@@ -1458,8 +1465,8 @@ recherche_instruction_suivante(struct_pr
 					registre_type_en_cours = (*s_etat_processus).type_en_cours;
 					(*s_etat_processus).type_en_cours = LST;
 
-					if (recherche_instruction_suivante(s_etat_processus)
-							== d_erreur)
+					if (recherche_instruction_suivante_recursive(
+							s_etat_processus, recursivite + 1) == d_erreur)
 					{
 						(*s_etat_processus).type_en_cours =
 								registre_type_en_cours;
@@ -1474,6 +1481,7 @@ recherche_instruction_suivante(struct_pr
 						return(d_erreur);
 					}
 
+					(*s_etat_processus).type_en_cours = registre_type_en_cours;
 					pointeur_caractere_courant =
 							(*s_etat_processus).definitions_chainees +
 							(*s_etat_processus).position_courante;
@@ -1585,61 +1593,78 @@ recherche_instruction_suivante(struct_pr
 						erreur_format = d_ex_syntaxe;
 					}
 
-					niveau = 1;
+					pointeur_caractere_courant++;
+					drapeau_fin_objet = d_faux;
 
-					while((niveau != 0) && ((*pointeur_caractere_courant) !=
-							d_code_fin_chaine))
+					while(((*pointeur_caractere_courant) != d_code_fin_chaine)
+							&& (erreur_format == d_absence_erreur))
 					{
-						(*s_etat_processus).position_courante =
-								pointeur_caractere_courant
-								- (*s_etat_processus).definitions_chainees;
-
-						registre_type_en_cours = (*s_etat_processus)
-								.type_en_cours;
-						(*s_etat_processus).type_en_cours = RPN;
-
-						if (recherche_instruction_suivante(s_etat_processus)
-								== d_erreur)
+						while((*pointeur_caractere_courant) == d_code_espace)
 						{
-							(*s_etat_processus).type_en_cours =
-									registre_type_en_cours;
+							pointeur_caractere_courant++;
+						}
 
-							if ((*s_etat_processus).instruction_courante
-									!= NULL)
+						if ((*pointeur_caractere_courant) == '>')
+						{
+							if ((*(++pointeur_caractere_courant)) == '>')
+							{
+								drapeau_fin_objet = d_vrai;
+							}
+							else
 							{
-								free((*s_etat_processus).instruction_courante);
-								(*s_etat_processus).instruction_courante = NULL;
+								erreur_analyse = d_ex_syntaxe;
 							}
 
-							return(d_erreur);
+							pointeur_caractere_courant++;
+							break;
 						}
 
-						(*s_etat_processus).type_en_cours =
-								registre_type_en_cours;
-						pointeur_caractere_courant =
-								(*s_etat_processus).definitions_chainees +
-								(*s_etat_processus).position_courante;
-
-						if (strcmp((*s_etat_processus).instruction_courante,
-								"<<") == 0)
-						{
-							niveau++;
-						}
-						else if (strcmp((*s_etat_processus)
-								.instruction_courante, ">>") == 0)
+						if ((erreur_format == d_absence_erreur) &&
+								(drapeau_fin_objet == d_faux))
 						{
-							niveau--;
-						}
+							(*s_etat_processus).position_courante =
+									pointeur_caractere_courant
+									- (*s_etat_processus).definitions_chainees;
+
+							registre_type_en_cours = (*s_etat_processus)
+									.type_en_cours;
+							(*s_etat_processus).type_en_cours = RPN;
+
+							if ((erreur =
+									recherche_instruction_suivante_recursive(
+									s_etat_processus, recursivite + 1))
+									!= d_absence_erreur)
+							{
+								(*s_etat_processus).type_en_cours =
+										registre_type_en_cours;
+
+								if ((*s_etat_processus).instruction_courante
+										!= NULL)
+								{
+									free((*s_etat_processus)
+											.instruction_courante);
+									(*s_etat_processus).instruction_courante
+											= NULL;
+								}
+
+								return(d_erreur);
+							}
+
+							(*s_etat_processus).type_en_cours =
+									registre_type_en_cours;
+							pointeur_caractere_courant = (*s_etat_processus)
+									.definitions_chainees + (*s_etat_processus)
+									.position_courante;
 
-						free((*s_etat_processus).instruction_courante);
+							free((*s_etat_processus).instruction_courante);
+						}
 					}
 
-					if (niveau != 0)
+					if (drapeau_fin_objet == d_faux)
 					{
 						erreur_analyse = d_ex_syntaxe;
+						drapeau_fin_objet = d_vrai;
 					}
-
-					drapeau_fin_objet = d_vrai;
 				}
 				else if ((*pointeur_caractere_courant) == '[')
 				{ // Cas <[ ]>
@@ -1686,8 +1711,10 @@ recherche_instruction_suivante(struct_pr
 									.type_en_cours;
 							(*s_etat_processus).type_en_cours = TBL;
 
-							if ((erreur = recherche_instruction_suivante(
-									s_etat_processus)) != d_absence_erreur)
+							if ((erreur =
+									recherche_instruction_suivante_recursive(
+									s_etat_processus, recursivite + 1))
+									!= d_absence_erreur)
 							{
 								(*s_etat_processus).type_en_cours =
 										registre_type_en_cours;
@@ -1725,14 +1752,43 @@ recherche_instruction_suivante(struct_pr
 			}
 		}
 
-		if ((*pointeur_caractere_courant) == caractere_fin)
+		if ((*(pointeur_caractere_courant - 1)) == caractere_fin)
 		{
+			// Cas des objets composites (LST, RPN, TBL)
+			break;
+		}
+		else if ((*pointeur_caractere_courant) == caractere_fin)
+		{
+			// Condition pour traiter les cas 123}
 			break;
 		}
 	}
 
 	pointeur_fin_instruction = pointeur_caractere_courant;
 
+	if (recursivite == 0)
+	{
+		// Si la variable récursivité est nulle, il faut que le caractère
+		// suivant l'objet soit un espace ou une fin de chaîne. Si ce n'est pas
+		// le cas, il faut retourner une erreur car les objets de type
+		// [[ 1 4 ]]3 doivent être invalides.
+
+		switch((*pointeur_fin_instruction))
+		{
+			case d_code_fin_chaine:
+			case d_code_espace:
+			{
+				break;
+			}
+
+			default:
+			{
+				(*s_etat_processus).erreur_execution = d_ex_syntaxe;
+				return(d_erreur);
+			}
+		}
+	}
+
 	(*s_etat_processus).instruction_courante = (unsigned char *)
 				malloc((((size_t) (pointeur_fin_instruction
 				- pointeur_debut_instruction)) + 1) * sizeof(unsigned char));
@@ -1764,7 +1820,6 @@ recherche_instruction_suivante(struct_pr
 		(*(*s_etat_processus).instruction_courante) = d_code_fin_chaine;
 	}
 
-uprintf("%c %s\n", caractere_fin, (*s_etat_processus).instruction_courante);
 	(*s_etat_processus).position_courante = pointeur_fin_instruction
 			- (*s_etat_processus).definitions_chainees;
 
@@ -1774,11 +1829,11 @@ uprintf("%c %s\n", caractere_fin, (*s_et
 
 /*
 ================================================================================
-  Routine mettant la chaine d'entrée en majuscule
+  Routine mettant la chaîne d'entrée en majuscule
 ================================================================================
-  Entrée : pointeur sur une chaine en minuscules.
+  Entrée : pointeur sur une chaîne en minuscules.
 --------------------------------------------------------------------------------
-  Sortie : pointeur sur la chaine en majuscules. Si le pointeur retourné
+  Sortie : pointeur sur la chaîne en majuscules. Si le pointeur retourné
 	est nul, il s'est produit une erreur. L'allocation est faite dans la
 	routine.
 --------------------------------------------------------------------------------