--- rpl/src/instructions_i2.c	2011/06/21 07:45:25	1.21
+++ rpl/src/instructions_i2.c	2011/11/17 22:47:55	1.33
@@ -1,6 +1,6 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.0.prerelease.1
+  RPL/2 (R) version 4.1.4
   Copyright (C) 1989-2011 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
@@ -1033,266 +1033,354 @@ instruction_int(struct_processus *s_etat
 
 		if ((*s_etat_processus).langue == 'F')
 		{
-			printf("(intégration numérique)\n\n");
+			printf("(intégration)\n\n");
 		}
 		else
 		{
-			printf("(numerical integration)\n\n");
+			printf("(numerical)\n\n");
 		}
 
-		printf("    3: %s, %s, %s\n", d_NOM, d_ALG, d_RPN);
+		printf("    3: %s, %s, %s, %s, %s\n", d_INT, d_REL,
+				d_NOM, d_ALG, d_RPN);
 		printf("    2: %s\n", d_LST);
 		printf("    1: %s, %s\n", d_INT, d_REL);
 		printf("->  2: %s, %s\n", d_INT, d_REL);
-		printf("    1: %s, %s\n", d_INT, d_REL);
+		printf("    1: %s, %s\n\n", d_INT, d_REL);
 
+		printf("    2: %s, %s, %s, %s\n", d_INT, d_REL, d_NOM, d_ALG);
+		printf("    1: %s\n", d_NOM);
+		printf("->  1: %s, %s, %s, %s\n", d_INT, d_REL, d_NOM, d_ALG);
 		return;
 	}
 	else if ((*s_etat_processus).test_instruction == 'Y')
 	{
-		(*s_etat_processus).nombre_arguments = 3;
+		(*s_etat_processus).nombre_arguments = -1;
 		return;
 	}
-	
-	if ((last_valide = test_cfsf(s_etat_processus, 31)) == d_vrai)
-	{
-		if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
-		{
-			return;
-		}
-	}
 
-	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
-			&s_objet_argument_1) == d_erreur)
+	if ((*s_etat_processus).l_base_pile == NULL)
 	{
 		(*s_etat_processus).erreur_execution = d_ex_manque_argument;
 		return;
 	}
 
-	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
-			&s_objet_argument_2) == d_erreur)
+	if ((*(*(*s_etat_processus).l_base_pile).donnee).type == NOM)
 	{
-		liberation(s_etat_processus, s_objet_argument_1);
+		// Intégration symbolique
 
-		(*s_etat_processus).erreur_execution = d_ex_manque_argument;
-		return;
-	}
+		if (test_cfsf(s_etat_processus, 31) == d_vrai)
+		{
+			if (empilement_pile_last(s_etat_processus, 2) == d_erreur)
+			{
+				return;
+			}
+		}
 
-	if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
-			&s_objet_argument_3) == d_erreur)
-	{
-		liberation(s_etat_processus, s_objet_argument_1);
-		liberation(s_etat_processus, s_objet_argument_2);
+		if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+				&s_objet_argument_1) == d_erreur)
+		{
+			(*s_etat_processus).erreur_execution = d_ex_manque_argument;
+			return;
+		}
 
-		(*s_etat_processus).erreur_execution = d_ex_manque_argument;
-		return;
-	}
+		if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+				&s_objet_argument_2) == d_erreur)
+		{
+			liberation(s_etat_processus, s_objet_argument_1);
 
-	if ((*s_objet_argument_1).type == INT)
-	{
-		precision = (*((integer8 *) (*s_objet_argument_1).objet));
-	}
-	else if ((*s_objet_argument_1).type == REL)
-	{
-		precision = (*((real8 *) (*s_objet_argument_1).objet));
+			(*s_etat_processus).erreur_execution = d_ex_manque_argument;
+			return;
+		}
+
+		if (((*s_objet_argument_1).type == NOM) &&
+				(((*s_objet_argument_2).type == NOM) ||
+				((*s_objet_argument_2).type == ALG) ||
+				((*s_objet_argument_2).type == REL) ||
+				((*s_objet_argument_2).type == INT)))
+		{
+			if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+					s_objet_argument_2) == d_erreur)
+			{
+				return;
+			}
+
+			if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+					s_objet_argument_1) == d_erreur)
+			{
+				return;
+			}
+
+			interface_cas(s_etat_processus, RPLCAS_INTEGRATION);
+		}
+		else
+		{
+			liberation(s_etat_processus, s_objet_argument_1);
+			liberation(s_etat_processus, s_objet_argument_2);
+
+			(*s_etat_processus).erreur_execution =
+					d_ex_erreur_type_argument;
+			return;
+		}
 	}
 	else
 	{
-		liberation(s_etat_processus, s_objet_argument_1);
-		liberation(s_etat_processus, s_objet_argument_2);
-		liberation(s_etat_processus, s_objet_argument_3);
+		// Intégration numérique
 
-		(*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
-		return;
-	}
+		if ((last_valide = test_cfsf(s_etat_processus, 31)) == d_vrai)
+		{
+			if (empilement_pile_last(s_etat_processus, 3) == d_erreur)
+			{
+				return;
+			}
+		}
 
-	if ((*s_objet_argument_2).type == LST)
-	{
-		l_element_courant = (*s_objet_argument_2).objet;
+		if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+				&s_objet_argument_1) == d_erreur)
+		{
+			(*s_etat_processus).erreur_execution = d_ex_manque_argument;
+			return;
+		}
 
-		if ((*(*l_element_courant).donnee).type != NOM)
+		if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+				&s_objet_argument_2) == d_erreur)
 		{
 			liberation(s_etat_processus, s_objet_argument_1);
-			liberation(s_etat_processus, s_objet_argument_2);
-			liberation(s_etat_processus, s_objet_argument_3);
 
-			(*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
+			(*s_etat_processus).erreur_execution = d_ex_manque_argument;
 			return;
 		}
 
-		if ((nom_variable = malloc((strlen((*((struct_nom *)
-				(*(*l_element_courant).donnee).objet)).nom)
-				+ 1) * sizeof(unsigned char))) == NULL)
+		if (depilement(s_etat_processus, &((*s_etat_processus).l_base_pile),
+				&s_objet_argument_3) == d_erreur)
 		{
-			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+			liberation(s_etat_processus, s_objet_argument_1);
+			liberation(s_etat_processus, s_objet_argument_2);
+
+			(*s_etat_processus).erreur_execution = d_ex_manque_argument;
 			return;
 		}
 
-		strcpy(nom_variable, (*((struct_nom *) (*(*l_element_courant)
-				.donnee).objet)).nom);
+		if (((*s_objet_argument_3).type != NOM) &&
+				((*s_objet_argument_3).type != ALG) &&
+				((*s_objet_argument_3).type != RPN) &&
+				((*s_objet_argument_3).type != REL) &&
+				((*s_objet_argument_3).type != INT))
+		{
+			liberation(s_etat_processus, s_objet_argument_1);
+			liberation(s_etat_processus, s_objet_argument_2);
+			liberation(s_etat_processus, s_objet_argument_3);
 
-		l_element_courant = (*l_element_courant).suivant;
+			(*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
+			return;
+		}
 
-		if ((*(*l_element_courant).donnee).type == INT)
+		if ((*s_objet_argument_1).type == INT)
 		{
-			borne_minimale = (real8) (*((integer8 *)
-					(*(*l_element_courant).donnee).objet));
+			precision = (*((integer8 *) (*s_objet_argument_1).objet));
 		}
-		else if ((*(*l_element_courant).donnee).type == REL)
+		else if ((*s_objet_argument_1).type == REL)
 		{
-			borne_minimale = (*((real8 *) (*(*l_element_courant)
-					.donnee).objet));
+			precision = (*((real8 *) (*s_objet_argument_1).objet));
 		}
 		else
 		{
-			if (evaluation(s_etat_processus, (*l_element_courant).donnee,
-					'N') == d_erreur)
+			liberation(s_etat_processus, s_objet_argument_1);
+			liberation(s_etat_processus, s_objet_argument_2);
+			liberation(s_etat_processus, s_objet_argument_3);
+
+			(*s_etat_processus).erreur_execution = d_ex_erreur_type_argument;
+			return;
+		}
+
+		if ((*s_objet_argument_2).type == LST)
+		{
+			l_element_courant = (*s_objet_argument_2).objet;
+
+			if ((*(*l_element_courant).donnee).type != NOM)
 			{
-				free(nom_variable);
 				liberation(s_etat_processus, s_objet_argument_1);
 				liberation(s_etat_processus, s_objet_argument_2);
 				liberation(s_etat_processus, s_objet_argument_3);
 
+				(*s_etat_processus).erreur_execution =
+						d_ex_erreur_type_argument;
 				return;
 			}
 
-			if (depilement(s_etat_processus, &((*s_etat_processus)
-					.l_base_pile), &s_objet_evalue) == d_erreur)
+			if ((nom_variable = malloc((strlen((*((struct_nom *)
+					(*(*l_element_courant).donnee).objet)).nom)
+					+ 1) * sizeof(unsigned char))) == NULL)
 			{
-				free(nom_variable);
-				liberation(s_etat_processus, s_objet_argument_1);
-				liberation(s_etat_processus, s_objet_argument_2);
-				liberation(s_etat_processus, s_objet_argument_3);
-
-				(*s_etat_processus).erreur_execution =
-						d_ex_manque_argument;
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
 			}
 
-			if ((*s_objet_evalue).type == INT)
+			strcpy(nom_variable, (*((struct_nom *) (*(*l_element_courant)
+					.donnee).objet)).nom);
+
+			l_element_courant = (*l_element_courant).suivant;
+
+			if ((*(*l_element_courant).donnee).type == INT)
 			{
 				borne_minimale = (real8) (*((integer8 *)
-						(*s_objet_evalue).objet));
+						(*(*l_element_courant).donnee).objet));
 			}
-			else if ((*s_objet_evalue).type == REL)
+			else if ((*(*l_element_courant).donnee).type == REL)
 			{
-				borne_minimale = (*((real8 *) (*s_objet_evalue).objet));
+				borne_minimale = (*((real8 *) (*(*l_element_courant)
+						.donnee).objet));
 			}
 			else
 			{
-				free(nom_variable);
-				
-				liberation(s_etat_processus, s_objet_evalue);
-				liberation(s_etat_processus, s_objet_argument_1);
-				liberation(s_etat_processus, s_objet_argument_2);
-				liberation(s_etat_processus, s_objet_argument_3);
-
-				(*s_etat_processus).erreur_execution =
-						d_ex_erreur_type_argument;
-				return;
-			}
+				if (evaluation(s_etat_processus, (*l_element_courant).donnee,
+						'N') == d_erreur)
+				{
+					free(nom_variable);
+					liberation(s_etat_processus, s_objet_argument_1);
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_3);
 
-			liberation(s_etat_processus, s_objet_evalue);
-		}
+					return;
+				}
 
-		l_element_courant = (*l_element_courant).suivant;
+				if (depilement(s_etat_processus, &((*s_etat_processus)
+						.l_base_pile), &s_objet_evalue) == d_erreur)
+				{
+					free(nom_variable);
+					liberation(s_etat_processus, s_objet_argument_1);
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_3);
 
-		if ((*(*l_element_courant).donnee).type == INT)
-		{
-			borne_maximale = (real8) (*((integer8 *)
-					(*(*l_element_courant).donnee).objet));
-		}
-		else if ((*(*l_element_courant).donnee).type == REL)
-		{
-			borne_maximale = (*((real8 *) (*(*l_element_courant)
-					.donnee).objet));
-		}
-		else
-		{
-			if (evaluation(s_etat_processus, (*l_element_courant).donnee,
-					'N') == d_erreur)
-			{
-				free(nom_variable);
-				liberation(s_etat_processus, s_objet_argument_1);
-				liberation(s_etat_processus, s_objet_argument_2);
-				liberation(s_etat_processus, s_objet_argument_3);
+					(*s_etat_processus).erreur_execution =
+							d_ex_manque_argument;
+					return;
+				}
 
-				return;
-			}
+				if ((*s_objet_evalue).type == INT)
+				{
+					borne_minimale = (real8) (*((integer8 *)
+							(*s_objet_evalue).objet));
+				}
+				else if ((*s_objet_evalue).type == REL)
+				{
+					borne_minimale = (*((real8 *) (*s_objet_evalue).objet));
+				}
+				else
+				{
+					free(nom_variable);
+					
+					liberation(s_etat_processus, s_objet_evalue);
+					liberation(s_etat_processus, s_objet_argument_1);
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_3);
 
-			if (depilement(s_etat_processus, &((*s_etat_processus)
-					.l_base_pile), &s_objet_evalue) == d_erreur)
-			{
-				free(nom_variable);
-				liberation(s_etat_processus, s_objet_argument_1);
-				liberation(s_etat_processus, s_objet_argument_2);
-				liberation(s_etat_processus, s_objet_argument_3);
+					(*s_etat_processus).erreur_execution =
+							d_ex_erreur_type_argument;
+					return;
+				}
 
-				(*s_etat_processus).erreur_execution =
-						d_ex_manque_argument;
-				return;
+				liberation(s_etat_processus, s_objet_evalue);
 			}
 
-			if ((*s_objet_evalue).type == INT)
+			l_element_courant = (*l_element_courant).suivant;
+
+			if ((*(*l_element_courant).donnee).type == INT)
 			{
 				borne_maximale = (real8) (*((integer8 *)
-						(*s_objet_evalue).objet));
+						(*(*l_element_courant).donnee).objet));
 			}
-			else if ((*s_objet_evalue).type == REL)
+			else if ((*(*l_element_courant).donnee).type == REL)
 			{
-				borne_maximale = (*((real8 *) (*s_objet_evalue).objet));
+				borne_maximale = (*((real8 *) (*(*l_element_courant)
+						.donnee).objet));
 			}
 			else
 			{
-				free(nom_variable);
+				if (evaluation(s_etat_processus, (*l_element_courant).donnee,
+						'N') == d_erreur)
+				{
+					free(nom_variable);
+					liberation(s_etat_processus, s_objet_argument_1);
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_3);
 
-				liberation(s_etat_processus, s_objet_evalue);
-				liberation(s_etat_processus, s_objet_argument_1);
-				liberation(s_etat_processus, s_objet_argument_2);
-				liberation(s_etat_processus, s_objet_argument_3);
+					return;
+				}
 
-				(*s_etat_processus).erreur_execution =
-						d_ex_erreur_type_argument;
-				return;
+				if (depilement(s_etat_processus, &((*s_etat_processus)
+						.l_base_pile), &s_objet_evalue) == d_erreur)
+				{
+					free(nom_variable);
+					liberation(s_etat_processus, s_objet_argument_1);
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_3);
+
+					(*s_etat_processus).erreur_execution =
+							d_ex_manque_argument;
+					return;
+				}
+
+				if ((*s_objet_evalue).type == INT)
+				{
+					borne_maximale = (real8) (*((integer8 *)
+							(*s_objet_evalue).objet));
+				}
+				else if ((*s_objet_evalue).type == REL)
+				{
+					borne_maximale = (*((real8 *) (*s_objet_evalue).objet));
+				}
+				else
+				{
+					free(nom_variable);
+
+					liberation(s_etat_processus, s_objet_evalue);
+					liberation(s_etat_processus, s_objet_argument_1);
+					liberation(s_etat_processus, s_objet_argument_2);
+					liberation(s_etat_processus, s_objet_argument_3);
+
+					(*s_etat_processus).erreur_execution =
+							d_ex_erreur_type_argument;
+					return;
+				}
+
+				liberation(s_etat_processus, s_objet_evalue);
 			}
 
-			liberation(s_etat_processus, s_objet_evalue);
-		}
+			/*
+			 * Le résultat est retourné sur la pile par la routine
+			 */
 
-		/*
-		 * Le résultat est retourné sur la pile par la routine
-		 */
+			if (last_valide == d_vrai)
+			{
+				cf(s_etat_processus, 31);
+			}
 
-		if (last_valide == d_vrai)
-		{
-			cf(s_etat_processus, 31);
-		}
+			integrale_romberg(s_etat_processus, s_objet_argument_3,
+					nom_variable, borne_minimale, borne_maximale, precision);
 
-		integrale_romberg(s_etat_processus, s_objet_argument_3, nom_variable,
-				borne_minimale, borne_maximale, precision);
+			if (last_valide == d_vrai)
+			{
+				sf(s_etat_processus, 31);
+			}
 
-		if (last_valide == d_vrai)
+			free(nom_variable);
+		}
+		else
 		{
-			sf(s_etat_processus, 31);
+			liberation(s_etat_processus, s_objet_argument_1);
+			liberation(s_etat_processus, s_objet_argument_2);
+			liberation(s_etat_processus, s_objet_argument_3);
+
+			(*s_etat_processus).erreur_execution =
+					d_ex_erreur_type_argument;
+			return;
 		}
 
-		free(nom_variable);
-	}
-	else
-	{
 		liberation(s_etat_processus, s_objet_argument_1);
 		liberation(s_etat_processus, s_objet_argument_2);
 		liberation(s_etat_processus, s_objet_argument_3);
-
-		(*s_etat_processus).erreur_execution =
-				d_ex_erreur_type_argument;
-		return;
 	}
 
-	liberation(s_etat_processus, s_objet_argument_1);
-	liberation(s_etat_processus, s_objet_argument_2);
-	liberation(s_etat_processus, s_objet_argument_3);
-
 	return;
 }