--- rpl/src/instructions_i2.c	2010/01/26 15:22:44	1.1
+++ rpl/src/instructions_i2.c	2011/11/26 10:01:29	1.34
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.0.9
-  Copyright (C) 1989-2010 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.5
+  Copyright (C) 1989-2011 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -20,7 +20,7 @@
 */
 
 
-#include "rpl.conv.h"
+#include "rpl-conv.h"
 
 
 /*
@@ -107,15 +107,15 @@ instruction_idn(struct_processus *s_etat
 
 		liberation(s_etat_processus, s_objet_argument);
 
-		if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)
-				.position_variable_courante].variable_verrouillee == d_vrai)
+		if ((*(*s_etat_processus).pointeur_variable_courante)
+				.variable_verrouillee == d_vrai)
 		{
 			(*s_etat_processus).erreur_execution = d_ex_variable_verrouillee;
 			return;
 		}
 
-		s_objet_argument = (*s_etat_processus).s_liste_variables
-				[(*s_etat_processus).position_variable_courante].objet;
+		s_objet_argument = (*(*s_etat_processus).pointeur_variable_courante)
+				.objet;
 
 		if (s_objet_argument == NULL)
 		{
@@ -127,13 +127,10 @@ instruction_idn(struct_processus *s_etat
 			}
 
 			if (recherche_variable_partagee(s_etat_processus,
-					(*s_etat_processus).s_liste_variables
-					[(*s_etat_processus).position_variable_courante].nom,
-					(*s_etat_processus).s_liste_variables
-					[(*s_etat_processus).position_variable_courante]
-					.variable_partagee, (*s_etat_processus).s_liste_variables
-					[(*s_etat_processus).position_variable_courante].origine)
-					== d_faux)
+					(*(*s_etat_processus).pointeur_variable_courante).nom,
+					(*(*s_etat_processus).pointeur_variable_courante)
+					.variable_partagee, (*(*s_etat_processus)
+					.pointeur_variable_courante).origine) == d_faux)
 			{
 				if (pthread_mutex_unlock(&((*(*s_etat_processus)
 						.s_liste_variables_partagees).mutex)) != 0)
@@ -327,8 +324,7 @@ instruction_idn(struct_processus *s_etat
 	{
 		if (variable_partagee == d_vrai)
 		{
-			(*s_etat_processus).s_liste_variables[(*s_etat_processus)
-					.position_variable_courante].objet = NULL;
+			(*(*s_etat_processus).pointeur_variable_courante).objet = NULL;
 			(*(*s_etat_processus).s_liste_variables_partagees).table
 					[(*(*s_etat_processus).s_liste_variables_partagees)
 					.position_variable].objet = s_objet_resultat;
@@ -342,8 +338,8 @@ instruction_idn(struct_processus *s_etat
 		}
 		else
 		{
-			(*s_etat_processus).s_liste_variables[(*s_etat_processus)
-					.position_variable_courante].objet = s_objet_resultat;
+			(*(*s_etat_processus).pointeur_variable_courante).objet =
+					s_objet_resultat;
 		}
 	}
 
@@ -1037,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;
 }
 
@@ -1397,17 +1481,14 @@ instruction_incr(struct_processus *s_eta
 
 		liberation(s_etat_processus, s_objet_argument);
 
-		if ((*s_etat_processus).s_liste_variables
-				[(*s_etat_processus).position_variable_courante]
+		if ((*(*s_etat_processus).pointeur_variable_courante)
 				.variable_verrouillee == d_vrai)
 		{
 			(*s_etat_processus).erreur_execution = d_ex_variable_verrouillee;
 			return;
 		}
 
-		if ((*s_etat_processus).s_liste_variables
-				[(*s_etat_processus).position_variable_courante].objet
-				== NULL)
+		if ((*(*s_etat_processus).pointeur_variable_courante).objet == NULL)
 		{
 			if (pthread_mutex_lock(&((*(*s_etat_processus)
 					.s_liste_variables_partagees).mutex)) != 0)
@@ -1417,13 +1498,10 @@ instruction_incr(struct_processus *s_eta
 			}
 
 			if (recherche_variable_partagee(s_etat_processus,
-					(*s_etat_processus).s_liste_variables
-					[(*s_etat_processus).position_variable_courante].nom,
-					(*s_etat_processus).s_liste_variables
-					[(*s_etat_processus).position_variable_courante]
-					.variable_partagee, (*s_etat_processus).s_liste_variables
-					[(*s_etat_processus).position_variable_courante]
-					.origine) == d_faux)
+					(*(*s_etat_processus).pointeur_variable_courante).nom,
+					(*(*s_etat_processus).pointeur_variable_courante)
+					.variable_partagee, (*(*s_etat_processus)
+					.pointeur_variable_courante).origine) == d_faux)
 			{
 				(*s_etat_processus).erreur_systeme = d_es;
 				(*s_etat_processus).erreur_execution =
@@ -1440,8 +1518,8 @@ instruction_incr(struct_processus *s_eta
 		}
 		else
 		{
-			s_objet_argument = (*s_etat_processus).s_liste_variables
-					[(*s_etat_processus).position_variable_courante].objet;
+			s_objet_argument = (*(*s_etat_processus).pointeur_variable_courante)
+					.objet;
 			variable_partagee = d_faux;
 		}
 
@@ -1466,8 +1544,7 @@ instruction_incr(struct_processus *s_eta
 
 		if (variable_partagee == d_vrai)
 		{
-			(*s_etat_processus).s_liste_variables[(*s_etat_processus)
-					.position_variable_courante].objet = NULL;
+			(*(*s_etat_processus).pointeur_variable_courante).objet = NULL;
 			(*(*s_etat_processus)
 					.s_liste_variables_partagees).table
 					[(*(*s_etat_processus).s_liste_variables_partagees)
@@ -1475,8 +1552,8 @@ instruction_incr(struct_processus *s_eta
 		}
 		else
 		{
-			(*s_etat_processus).s_liste_variables[(*s_etat_processus)
-					.position_variable_courante].objet = s_copie_argument;
+			(*(*s_etat_processus).pointeur_variable_courante).objet =
+					s_copie_argument;
 		}
 
 		if ((*s_copie_argument).type == INT)