--- rpl/src/analyse_notation_algebrique.c	2011/06/22 12:48:30	1.23
+++ rpl/src/analyse_notation_algebrique.c	2015/01/05 13:12:28	1.55
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.0.prerelease.2
-  Copyright (C) 1989-2011 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.19
+  Copyright (C) 1989-2015 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -57,8 +57,6 @@ analyse_algebrique(struct_processus *s_e
 	logical1							presence_fonction;
 	logical1							presence_liste;
 
-	long								k;
-
 	unsigned char						*chaine_arguments;
 	unsigned char						*chaine_centrale;
 	unsigned char						*chaine_droite;
@@ -76,24 +74,26 @@ analyse_algebrique(struct_processus *s_e
 	unsigned char						registre_test;
 	unsigned char						*sous_chaine_droite;
 	unsigned char						*sous_chaine_gauche;
-	unsigned char						t0;
-	unsigned char						t1;
-	unsigned char						t2;
-	unsigned char						t3;
-	unsigned char						t4;
 	unsigned char						*tampon;
 
-	unsigned long						debut_zone_algebrique;
-	unsigned long						fin_zone_algebrique;
-	unsigned long						i;
-	unsigned long						j;
-	unsigned long						longueur_chaine;
-	unsigned long						longueur_tampon;
-	unsigned long						niveau;
-	unsigned long						niveau_liste;
-	unsigned long						nombre_apostrophes;
-	unsigned long						nombre_arguments;
-	unsigned long						priorite;
+	int									t0;
+	int									t1;
+	int									t2;
+	int									t3;
+	int									t4;
+
+	integer8							debut_zone_algebrique;
+	integer8							fin_zone_algebrique;
+	integer8							i;
+	integer8							j;
+	integer8							k;
+	integer8							longueur_chaine;
+	integer8							longueur_tampon;
+	integer8							niveau;
+	integer8							niveau_liste;
+	integer8							nombre_apostrophes;
+	integer8							nombre_arguments;
+	integer8							priorite;
 
 	(*l_base_liste) = NULL;
 
@@ -106,7 +106,8 @@ analyse_algebrique(struct_processus *s_e
 	presence_liste = d_faux;
 	niveau_liste = 0;
 
-	for(i = 1, chaine_invalide = d_vrai; i < strlen(chaine_algebrique) - 1; i++)
+	for(i = 1, chaine_invalide = d_vrai; i < ((integer8)
+			strlen(chaine_algebrique)) - 1; i++)
 	{
 		if (chaine_algebrique[i] != ' ')
 		{
@@ -115,7 +116,10 @@ analyse_algebrique(struct_processus *s_e
 
 		if (chaine_algebrique[i] == '"')
 		{
-			presence_chaine = (presence_chaine == d_faux) ? d_vrai : d_faux;
+			if (chaine_algebrique[i - 1] != '\\')
+			{
+				presence_chaine = (presence_chaine == d_faux) ? d_vrai : d_faux;
+			}
 		}
 		else if (presence_chaine == d_faux)
 		{
@@ -143,7 +147,7 @@ analyse_algebrique(struct_processus *s_e
 	 * Transformation des "**" en "^ "
 	 */
 
-	for(i = 1; i < strlen(chaine_algebrique) - 1; i++)
+	for(i = 1; i < ((integer8) strlen(chaine_algebrique)) - 1; i++)
 	{
 		if (chaine_algebrique[i] == '*')
 		{
@@ -176,13 +180,30 @@ analyse_algebrique(struct_processus *s_e
 	{
 		if ((*ptr1) == '"')
 		{
-			if (presence_chaine == d_faux)
-			{
-				presence_chaine = d_vrai;
+			if (ptr1 != chaine_travail)
+			{ // Il existe un caractère précédent.
+				if ((*(ptr1 - 1)) != '\\')
+				{
+					if (presence_chaine == d_faux)
+					{
+						presence_chaine = d_vrai;
+					}
+					else
+					{
+						presence_chaine = d_faux;
+					}
+				}
 			}
 			else
-			{
-				presence_chaine = d_faux;
+			{ // Il n'existe pas de caractère précédent.
+				if (presence_chaine == d_faux)
+				{
+					presence_chaine = d_vrai;
+				}
+				else
+				{
+					presence_chaine = d_faux;
+				}
 			}
 		}
 
@@ -220,8 +241,12 @@ analyse_algebrique(struct_processus *s_e
 					for(i = 0; i < 4; (*(ptr2++)) = (*(ptr1++)), i++);
 					(*(ptr2++)) = (*ptr1);
 				}
-				else if ((strncmp(instruction_majuscule, " OR ", 4) == 0) &&
-						(strlen(instruction_majuscule) == 4))
+				else if (strcmp(instruction_majuscule, " EQV ") == 0)
+				{
+					for(i = 0; i < 4; (*(ptr2++)) = (*(ptr1++)), i++);
+					(*(ptr2++)) = (*ptr1);
+				}
+				else if ((strcmp(instruction_majuscule, " OR ") == 0))
 				{
 					for(i = 0; i < 3; (*(ptr2++)) = (*(ptr1++)), i++);
 					(*(ptr2++)) = (*ptr1);
@@ -267,8 +292,19 @@ analyse_algebrique(struct_processus *s_e
 				}
 				else if (chaine_travail[i] == '"')
 				{
-					presence_chaine = (presence_chaine == d_vrai)
-							? d_faux : d_vrai;
+					if (i > 0)
+					{
+						if (chaine_travail[i - 1] != '\\')
+						{
+							presence_chaine = (presence_chaine == d_vrai)
+									? d_faux : d_vrai;
+						}
+					}
+					else
+					{
+						presence_chaine = (presence_chaine == d_vrai)
+								? d_faux : d_vrai;
+					}
 				}
 
 				i++;
@@ -305,8 +341,19 @@ analyse_algebrique(struct_processus *s_e
 
 				if (chaine_travail[j] == '"')
 				{
-					presence_chaine = (presence_chaine == d_vrai)
-							? d_faux : d_vrai;
+					if (j > 0)
+					{
+						if (chaine_travail[j - 1] != '\\')
+						{
+							presence_chaine = (presence_chaine == d_vrai)
+									? d_faux : d_vrai;
+						}
+					}
+					else
+					{
+						presence_chaine = (presence_chaine == d_vrai)
+								? d_faux : d_vrai;
+					}
 				}
 
 				j++;
@@ -323,7 +370,8 @@ analyse_algebrique(struct_processus *s_e
 						debut_zone_algebrique + 1, fin_zone_algebrique + 1));
 				chaine_droite = purification_chaine(
 						extraction_chaine(chaine_travail,
-						fin_zone_algebrique + 2, strlen(chaine_travail)));
+						fin_zone_algebrique + 2,
+						(integer8) strlen(chaine_travail)));
 
 				free(chaine_travail);
 
@@ -352,12 +400,23 @@ analyse_algebrique(struct_processus *s_e
 				drapeau_elimination_parentheses = d_vrai;
 				presence_chaine = d_faux;
 
-				while(i < (strlen(chaine_centrale) - 1))
+				while(i < ((integer8) strlen(chaine_centrale)) - 1)
 				{
 					if (chaine_centrale[i] == '"')
 					{
-						presence_chaine = (presence_chaine == d_faux)
-								? d_vrai : d_faux;
+						if (i > 0)
+						{
+							if (chaine_centrale[i - 1] != '\\')
+							{
+								presence_chaine = (presence_chaine == d_faux)
+										? d_vrai : d_faux;
+							}
+						}
+						else
+						{
+							presence_chaine = (presence_chaine == d_faux)
+									? d_vrai : d_faux;
+						}
 
 						if (i == 1)
 						{
@@ -416,7 +475,7 @@ analyse_algebrique(struct_processus *s_e
 				{
 					if ((tampon = purification_chaine(
 							extraction_chaine(chaine_centrale, 2,
-							strlen(chaine_centrale) - 1))) == NULL)
+							((integer8) strlen(chaine_centrale)) - 1))) == NULL)
 					{
 						(*s_etat_processus).erreur_systeme =
 								d_es_allocation_memoire;
@@ -473,13 +532,13 @@ analyse_algebrique(struct_processus *s_e
 						(fin_zone_algebrique - debut_zone_algebrique > 0))
 				{
 					i = 1;
-					while((i < (strlen(chaine_centrale) - 1)) &&
+					while((i < ((integer8) strlen(chaine_centrale)) - 1) &&
 							(chaine_centrale[i] != '('))
 					{
 						i++;
 					}
 
-					j = strlen(chaine_centrale) - 1;
+					j = ((integer8) strlen(chaine_centrale)) - 1;
 					while(chaine_centrale[j] != ')')
 					{
 						j--;
@@ -512,7 +571,7 @@ analyse_algebrique(struct_processus *s_e
 									extraction_chaine(chaine_arguments, 1, i));
 							sous_chaine_droite = purification_chaine(
 									extraction_chaine(chaine_arguments, i + 2,
-									strlen(chaine_arguments)));
+									((integer8) strlen(chaine_arguments))));
 
 							free(chaine_arguments);
 
@@ -595,8 +654,8 @@ analyse_algebrique(struct_processus *s_e
 						(*s_etat_processus).instruction_valide =
 								registre_instruction_valide;
 
-						if (((unsigned long) (*s_etat_processus)
-								.nombre_arguments != nombre_arguments) &&
+						if (((*s_etat_processus).nombre_arguments !=
+								nombre_arguments) &&
 								((*s_etat_processus).nombre_arguments != -2))
 						{
 							(*s_etat_processus).erreur_execution =
@@ -727,7 +786,7 @@ analyse_algebrique(struct_processus *s_e
 		} while((drapeau_debut_zone_valide == d_vrai)
 				&& (drapeau_fin_zone_valide == d_vrai));
 
-		for(longueur_chaine = strlen(chaine_travail),
+		for(longueur_chaine = (integer8) strlen(chaine_travail),
 				i = nombre_apostrophes = 0; i < longueur_chaine;
 				nombre_apostrophes += (chaine_travail[i++] == '\'') ? 1 : 0);
 
@@ -770,7 +829,7 @@ analyse_algebrique(struct_processus *s_e
 							i + 1, j + 1));
 					chaine_droite = purification_chaine(
 							extraction_chaine(chaine_travail, j + 2,
-							strlen(chaine_travail)));
+							((integer8) strlen(chaine_travail))));
 
 					if ((chaine_gauche == NULL) || (chaine_centrale == NULL) ||
 							(chaine_droite == NULL))
@@ -782,7 +841,8 @@ analyse_algebrique(struct_processus *s_e
 
 					drapeau_elimination_parentheses = d_vrai;
 
-					if ((longueur_tampon = strlen(chaine_centrale)) != 0)
+					if ((longueur_tampon = ((integer8) strlen(chaine_centrale)))
+							!= 0)
 					{
 						niveau = 0;
 
@@ -810,9 +870,9 @@ analyse_algebrique(struct_processus *s_e
 
 						if (drapeau_elimination_parentheses == d_vrai)
 						{
-							if ((tampon = (unsigned char *) malloc(
-									((longueur_tampon = strlen(
-									chaine_centrale)) + 1) * sizeof(
+							if ((tampon = (unsigned char *) malloc(((size_t)
+									((longueur_tampon = (integer8) strlen(
+									chaine_centrale)) + 1)) * sizeof(
 									unsigned char))) == NULL)
 							{
 								(*s_etat_processus).erreur_systeme =
@@ -838,15 +898,14 @@ analyse_algebrique(struct_processus *s_e
 					}
 
 					tampon[0] = d_code_fin_chaine;
-					longueur_chaine = strlen(chaine_centrale);
+					longueur_chaine = (integer8) strlen(chaine_centrale);
+					k = ((integer8) strlen(chaine_centrale)) - 1;
 					niveau = 0;
-					k = strlen(chaine_centrale) - 1;
 					fin_boucle_extraction = d_faux;
 
-					while((k >= 0) && (fin_boucle_extraction ==
-							d_faux))
+					while((k >= 0) && (fin_boucle_extraction == d_faux))
 					{
-						t0 = ((size_t) k < strlen(chaine_centrale))
+						t0 = (k < ((integer8) strlen(chaine_centrale)))
 								? chaine_centrale[k + 1] : ' ';
 						t1 = chaine_centrale[k];
 						t2 = (k < 1) ? ' ' : chaine_centrale[k - 1];
@@ -974,8 +1033,10 @@ analyse_algebrique(struct_processus *s_e
 								drapeau_modification = d_vrai;
 							}
 							else if (((priorite == 1) && (t4 == ' ') &&
-									(t3 == 'X') && (t2 == 'O') && (t1 == 'R')
-									&& (t0 == ' ')) || ((priorite == 2) &&
+									(((t3 == 'X') && (t2 == 'O') && (t1 == 'R'))
+									|| ((t3 == 'E') && (t2 == 'Q') &&
+									(t1 == 'V'))) && (t0 == ' '))
+									|| ((priorite == 2) &&
 									(t4 == ' ') && (t3 == 'A') && (t2 == 'N')
 									&& (t1 == 'D') && (t0 == ' ')))
 							{
@@ -1095,13 +1156,13 @@ analyse_algebrique(struct_processus *s_e
 unsigned char *
 purification_chaine(unsigned char *chaine)
 {
-	long						i;
-	long						j;
+	integer8					i;
+	integer8					j;
 
 	unsigned char				*chaine_purifiee;
 
 	i = 0;
-	j = strlen(chaine) - 1;
+	j = ((integer8) strlen(chaine)) - 1;
 
 	while(chaine[i] == ' ')
 	{
@@ -1134,19 +1195,18 @@ purification_chaine(unsigned char *chain
 logical1
 test_expression_rpn(unsigned char *chaine)
 {
-	long					j;
-
-	unsigned char			t;
-	unsigned char			t0;
-	unsigned char			t1;
-	unsigned char			t2;
-	unsigned char			t3;
-	unsigned char			t4;
-
-	unsigned long			compteur;
-	unsigned long			longueur_chaine;
-	unsigned long			i;
-	unsigned long			niveau;
+	int						t;
+	int						t0;
+	int						t1;
+	int						t2;
+	int						t3;
+	int						t4;
+
+	integer8				compteur;
+	integer8				longueur_chaine;
+	integer8				i;
+	integer8				j;
+	integer8				niveau;
 
 	/*
 	 * On teste d'abord la chaîne pour vérifier qu'il n'y a pas de fonction
@@ -1155,7 +1215,8 @@ test_expression_rpn(unsigned char *chain
 
 	compteur = 0;
 
-	for(longueur_chaine = strlen(chaine), i = 1; i < longueur_chaine; i++)
+	for(longueur_chaine = ((integer8) strlen(chaine)), i = 1;
+			i < longueur_chaine; i++)
 	{
 		/*
 		 * On saute les chaînes de caractères
@@ -1164,18 +1225,18 @@ test_expression_rpn(unsigned char *chain
 		if (chaine[i - 1] == '"')
 		{
 			i++;
-			while(chaine[i - 1] != '"')
+			while(!((chaine[i - 1] == '"') && (chaine[i - 2] != '\\')))
 			{
 				i++;
 			}
 		}
 
-		j = ((long) i) - 2;
+		j = i - 2;
 		t0 = (i >= 2) ? chaine[i - 2] : '?';
 		t1 = chaine[i - 1];
 		t2 = chaine[i];
-		t3 = ((i + 1) < strlen(chaine)) ? chaine[i + 1] : '?';
-		t4 = ((i + 2) < strlen(chaine)) ? chaine[i + 2] : '?';
+		t3 = ((i + 1) < ((integer8) strlen(chaine))) ? chaine[i + 1] : '?';
+		t4 = ((i + 2) < ((integer8) strlen(chaine))) ? chaine[i + 2] : '?';
 
 		/*
 		 * Ouverture d'une parenthèse signalant une fonction
@@ -1218,6 +1279,9 @@ test_expression_rpn(unsigned char *chain
 				|| ((t0 == ' ') && ((t1 == 'A') || (t1 == 'a')) &&
 				((t2 == 'N') || (t2 == 'n')) && ((t3 == 'D') || (t3 == 'd'))
 				&& (t4 == ' ')) ||
+				((t0 == ' ') && ((t1 == 'E') || (t1 == 'e')) &&
+				((t2 == 'Q') || (t2 == 'q')) && ((t3 == 'V') || (t3 == 'v'))
+				&& (t4 == ' ')) ||
 				((t0 == ' ') && ((t1 == 'O') || (t1 == 'o')) &&
 				((t2 == 'R') || (t2 == 'r')) && (t3 == ' ')) ||
 				((t0 == ' ') && ((t1 == 'X') || (t1 == 'x')) &&
@@ -1254,13 +1318,13 @@ test_fonction(unsigned char *chaine)
 {
 	logical1				drapeau_fonction;
 
-	unsigned char			t;
+	int						t;
 
-	unsigned long			compteur;
-	unsigned long			i;
-	unsigned long			longueur_chaine;
+	integer8				compteur;
+	integer8				i;
+	integer8				longueur_chaine;
 
-	longueur_chaine = strlen(chaine);
+	longueur_chaine = (integer8) strlen(chaine);
 	i = 1;
 
 	while(((t = chaine[i]) != '(') && (i < (longueur_chaine - 1)))
@@ -1303,17 +1367,17 @@ test_fonction(unsigned char *chaine)
 
 
 unsigned char *
-extraction_chaine(unsigned char *chaine, unsigned long position_1,
-		unsigned long position_2)
+extraction_chaine(unsigned char *chaine, integer8 position_1,
+		integer8 position_2)
 {
-	long					i;
+	integer8				i;
 
 	unsigned char			*pointeur_ecriture;
 	unsigned char			*pointeur_lecture;
 	unsigned char			*sous_chaine;
 
 	if ((position_1 < 1) || (position_2 < position_1) ||
-			(position_2 > strlen(chaine)))
+			(position_2 > ((integer8) strlen(chaine))))
 	{
 		if ((sous_chaine = (unsigned char *) malloc(sizeof(unsigned char)))
 				== NULL)
@@ -1326,8 +1390,8 @@ extraction_chaine(unsigned char *chaine,
 	}
 
 	if ((sous_chaine = (unsigned char *)
-			malloc((position_2 - position_1 + 2) * sizeof(unsigned char)))
-			== NULL)
+			malloc(((size_t) (position_2 - position_1 + 2)) *
+			sizeof(unsigned char))) == NULL)
 	{
 		return(NULL);
 	}