--- rpl/src/instructions_n1.c	2013/03/24 23:11:30	1.46
+++ rpl/src/instructions_n1.c	2013/03/27 20:33:34	1.47
@@ -112,22 +112,37 @@ instruction_neg(struct_processus *s_etat
 
 	if ((*s_objet_argument).type == INT)
 	{
-		if ((s_objet_resultat = copie_objet(s_etat_processus,
-				s_objet_argument, 'Q')) == NULL)
+		if ((*((integer8 *) (*s_objet_argument).objet)) != INT64_MIN)
 		{
-			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
-			return;
-		}
+			if ((s_objet_resultat = copie_objet(s_etat_processus,
+					s_objet_argument, 'Q')) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
 
-		/*
-		 * Permet d'éviter les résultats du type -0. Valable pour tous
-		 * les types...
-		 */
+			/*
+			 * Permet d'éviter les résultats du type -0. Valable pour tous
+			 * les types...
+			 */
 
-		if ((*((integer8 *) (*s_objet_argument).objet)) != 0)
+			if ((*((integer8 *) (*s_objet_argument).objet)) != 0)
+			{
+				(*((integer8 *) (*s_objet_resultat).objet)) =
+						-(*((integer8 *) (*s_objet_argument).objet));
+			}
+		}
+		else
 		{
-			(*((integer8 *) (*s_objet_resultat).objet)) =
-					-(*((integer8 *) (*s_objet_argument).objet));
+			if ((s_objet_resultat = allocation(s_etat_processus, REL)) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			(*((real8 *) (*s_objet_resultat).objet)) =
+					-((real8) (*((integer8 *) (*s_objet_argument).objet)));
+
 		}
 	}
 
@@ -194,23 +209,73 @@ instruction_neg(struct_processus *s_etat
 
 	else if ((*s_objet_argument).type == VIN)
 	{
-		if ((s_objet_resultat = copie_objet(s_etat_processus,
-				s_objet_argument, 'Q')) == NULL)
+		drapeau = d_faux;
+
+		for(i = 0; i < (*((struct_vecteur *) (*s_objet_argument).objet))
+				.taille; i++)
 		{
-			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
-			return;
+			if (((integer8 *) (*((struct_vecteur *)
+					(*s_objet_argument).objet)).tableau)[i] == INT64_MIN)
+			{
+				drapeau = d_vrai;
+				break;
+			}
 		}
 
-		for(i = 0; i < (*(((struct_vecteur *) (*s_objet_argument).objet)))
-				.taille; i++)
+		if (drapeau == d_vrai)
 		{
-			if (((integer8 *) (*(((struct_vecteur *)
-					(*s_objet_argument).objet))).tableau)[i] != 0)
+			if ((s_objet_resultat = allocation(s_etat_processus, VRL)) == NULL)
 			{
-				((integer8 *) (*(((struct_vecteur *) (*s_objet_resultat)
-						.objet))).tableau)[i] = -((integer8 *)
-						(*(((struct_vecteur *)
-						(*s_objet_argument).objet))).tableau)[i];
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
+					malloc(((size_t) (*((struct_vecteur *) (*s_objet_argument)
+					.objet)).taille) * sizeof(real8))) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			for(i = 0; i < (*((struct_vecteur *) (*s_objet_argument).objet))
+					.taille; i++)
+			{
+				if (((real8 *) (*(((struct_vecteur *)
+						(*s_objet_argument).objet))).tableau)[i] != 0)
+				{
+					((real8 *) (*((struct_vecteur *) (*s_objet_resultat)
+							.objet)).tableau)[i] = -((real8) ((integer8 *)
+							(*((struct_vecteur *)
+							(*s_objet_argument).objet)).tableau)[i]);
+				}
+				else
+				{
+					((real8 *) (*((struct_vecteur *) (*s_objet_resultat)
+							.objet)).tableau)[i] = 0;
+				}
+			}
+		}
+		else
+		{
+			if ((s_objet_resultat = copie_objet(s_etat_processus,
+					s_objet_argument, 'Q')) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			for(i = 0; i < (*(((struct_vecteur *) (*s_objet_argument).objet)))
+					.taille; i++)
+			{
+				if (((integer8 *) (*(((struct_vecteur *)
+						(*s_objet_argument).objet))).tableau)[i] != 0)
+				{
+					((integer8 *) (*(((struct_vecteur *) (*s_objet_resultat)
+							.objet))).tableau)[i] = -((integer8 *)
+							(*(((struct_vecteur *)
+							(*s_objet_argument).objet))).tableau)[i];
+				}
 			}
 		}
 	}
@@ -293,26 +358,99 @@ instruction_neg(struct_processus *s_etat
 
 	else if ((*s_objet_argument).type == MIN)
 	{
-		if ((s_objet_resultat = copie_objet(s_etat_processus,
-				s_objet_argument, 'Q')) == NULL)
-		{
-			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
-			return;
-		}
+		drapeau = d_faux;
 
-		for(i = 0; i < (*(((struct_matrice *) (*s_objet_argument).objet)))
+		for(i = 0; i < (*((struct_matrice *) (*s_objet_argument).objet))
 				.nombre_lignes; i++)
 		{
-			for(j = 0; j < (*(((struct_matrice *) (*s_objet_argument).objet)))
+			for(j = 0; j < (*((struct_matrice *) (*s_objet_argument).objet))
 					.nombre_colonnes; j++)
 			{
-				if (((integer8 **) (*(((struct_matrice *) (*s_objet_argument)
-						.objet))).tableau)[i][j] != 0)
+				if (((integer8 **) (*((struct_vecteur *)
+						(*s_objet_argument).objet)).tableau)[i][j] == INT64_MIN)
+				{
+					drapeau = d_vrai;
+					break;
+				}
+			}
+
+			if (drapeau == d_vrai)
+			{
+				break;
+			}
+		}
+
+		if (drapeau == d_vrai)
+		{
+			if ((s_objet_resultat = allocation(s_etat_processus, MRL)) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
+					malloc(((size_t) (*((struct_matrice *) (*s_objet_argument)
+					.objet)).nombre_lignes) * sizeof(real8 *))) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			for(i = 0; i < (*((struct_matrice *) (*s_objet_argument).objet))
+					.nombre_lignes; i++)
+			{
+				if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat)
+						.objet)).tableau)[i] = malloc(((size_t)
+						((*((struct_matrice *) (*s_objet_argument).objet))
+						.nombre_colonnes)) * sizeof(real8))) == NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					return;
+				}
+
+				for(j = 0; j < (*((struct_matrice *) (*s_objet_argument)
+						.objet)).nombre_colonnes; j++)
+				{
+					if (((integer8 **) (*((struct_matrice *)
+							(*s_objet_argument).objet)).tableau)[i][j] != 0)
+					{
+						((real8 **) (*((struct_matrice *) (*s_objet_resultat)
+								.objet)).tableau)[i][j] = -((real8)
+								((integer8 **) (*(((struct_matrice *)
+								(*s_objet_argument).objet))).tableau)[i][j]);
+					}
+					else
+					{
+						((real8 **) (*((struct_matrice *) (*s_objet_resultat)
+								.objet)).tableau)[i][j] = 0;
+					}
+				}
+			}
+		}
+		else
+		{
+			if ((s_objet_resultat = copie_objet(s_etat_processus,
+					s_objet_argument, 'Q')) == NULL)
+			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
+				return;
+			}
+
+			for(i = 0; i < (*((struct_matrice *) (*s_objet_argument).objet))
+					.nombre_lignes; i++)
+			{
+				for(j = 0; j < (*((struct_matrice *) (*s_objet_argument)
+						.objet)).nombre_colonnes; j++)
 				{
-					((integer8 **) (*(((struct_matrice *) (*s_objet_resultat)
-							.objet))).tableau)[i][j] = -((integer8 **)
-							(*(((struct_matrice *)
-							(*s_objet_argument).objet))).tableau)[i][j];
+					if (((integer8 **) (*((struct_matrice *)
+							(*s_objet_argument).objet)).tableau)[i][j] != 0)
+					{
+						((integer8 **) (*((struct_matrice *)
+								(*s_objet_resultat).objet)).tableau)[i][j] =
+								-((integer8 **) (*((struct_matrice *)
+								(*s_objet_argument).objet)).tableau)[i][j];
+					}
 				}
 			}
 		}