--- rpl/src/instructions_p1.c	2013/02/27 17:11:43	1.43
+++ rpl/src/instructions_p1.c	2013/03/20 22:24:36	1.44
@@ -43,7 +43,7 @@ instruction_pick(struct_processus *s_eta
 	struct_objet							*s_objet;
 	struct_objet							*s_nouvel_objet;
 
-	unsigned long							i;
+	integer8								i;
 
 	(*s_etat_processus).erreur_execution = d_ex;
 
@@ -140,7 +140,7 @@ instruction_pick(struct_processus *s_eta
 		return;
 	}
 
-	if ((unsigned long) (*((integer8 *) (*s_objet).objet)) > (*s_etat_processus)
+	if ((*((integer8 *) (*s_objet).objet)) > (*s_etat_processus)
 			.hauteur_pile_operationnelle)
 	{
 		liberation(s_etat_processus, s_objet);
@@ -151,7 +151,7 @@ instruction_pick(struct_processus *s_eta
 
 	l_liste = (*s_etat_processus).l_base_pile;
 
-	for(i = 1; i < (unsigned long) (*((integer8 *) (*s_objet).objet)); i++)
+	for(i = 1; i < (*((integer8 *) (*s_objet).objet)); i++)
 	{
 		l_liste = (*l_liste).suivant;
 	}
@@ -205,9 +205,9 @@ instruction_plus(struct_processus *s_eta
 	struct_objet					*s_objet_argument_2;
 	struct_objet					*s_objet_resultat;
 
-	unsigned long					i;
-	unsigned long					j;
-	unsigned long					nombre_elements;
+	integer8						i;
+	integer8						j;
+	integer8						nombre_elements;
 
 	(*s_etat_processus).erreur_execution = d_ex;
 
@@ -343,15 +343,15 @@ instruction_plus(struct_processus *s_eta
 
 		if ((*s_objet_argument_1).type == INT)
 		{
-			(*((real8 *) (*s_objet_resultat).objet)) = (*((integer8 *)
-					(*s_objet_argument_1).objet)) + (*((real8 *)
+			(*((real8 *) (*s_objet_resultat).objet)) = ((real8) (*((integer8 *)
+					(*s_objet_argument_1).objet))) + (*((real8 *)
 					(*s_objet_argument_2).objet));
 		}
 		else
 		{
 			(*((real8 *) (*s_objet_resultat).objet)) = (*((real8 *)
-					(*s_objet_argument_1).objet)) + (*((integer8 *)
-					(*s_objet_argument_2).objet));
+					(*s_objet_argument_1).objet)) + ((real8) (*((integer8 *)
+					(*s_objet_argument_2).objet)));
 		}
 	}
 
@@ -494,8 +494,8 @@ instruction_plus(struct_processus *s_eta
 				(*((struct_vecteur *) (*s_objet_argument_1).objet)).taille;
 
 		if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
-	 			malloc((*(((struct_vecteur *) (*s_objet_resultat)
-				.objet))).taille * sizeof(integer8))) == NULL)
+	 			malloc(((size_t) (*(((struct_vecteur *) (*s_objet_resultat)
+				.objet))).taille) * sizeof(integer8))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
@@ -521,8 +521,8 @@ instruction_plus(struct_processus *s_eta
 			free((*((struct_vecteur *) (*s_objet_argument_1).objet)).tableau);
 
 			if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
-					malloc((*(((struct_vecteur *) (*s_objet_resultat)
-					.objet))).taille * sizeof(real8))) == NULL)
+					malloc(((size_t) (*(((struct_vecteur *) (*s_objet_resultat)
+					.objet))).taille) * sizeof(real8))) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
@@ -574,8 +574,8 @@ instruction_plus(struct_processus *s_eta
 				(*((struct_vecteur *) (*s_objet_argument_1).objet)).taille;
 
 		if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
-	 			malloc((*(((struct_vecteur *) (*s_objet_resultat)
-				.objet))).taille * sizeof(real8))) == NULL)
+	 			malloc(((size_t) (*(((struct_vecteur *) (*s_objet_resultat)
+				.objet))).taille) * sizeof(real8))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
@@ -587,8 +587,9 @@ instruction_plus(struct_processus *s_eta
 			if ((*s_objet_argument_1).type == VIN)
 			{
 				((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
-						.tableau)[i] = ((integer8 *) (*((struct_vecteur *)
-						(*s_objet_argument_1).objet)).tableau)[i] +
+						.tableau)[i] = ((real8) ((integer8 *)
+						(*((struct_vecteur *)(*s_objet_argument_1).objet))
+						.tableau)[i]) +
 						((real8 *) (*((struct_vecteur *) (*s_objet_argument_2)
 						.objet)).tableau)[i];
 			}
@@ -597,8 +598,8 @@ instruction_plus(struct_processus *s_eta
 				((real8 *) (*((struct_vecteur *) (*s_objet_resultat).objet))
 						.tableau)[i] = ((real8 *) (*((struct_vecteur *)
 						(*s_objet_argument_1).objet)).tableau)[i] +
-						((integer8 *) (*((struct_vecteur *)
-						(*s_objet_argument_2).objet)).tableau)[i];
+						((real8) ((integer8 *) (*((struct_vecteur *)
+						(*s_objet_argument_2).objet)).tableau)[i]);
 			}
 		}
 	}
@@ -631,8 +632,8 @@ instruction_plus(struct_processus *s_eta
 				(*((struct_vecteur *) (*s_objet_argument_1).objet)).taille;
 
 		if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
-	 			malloc((*(((struct_vecteur *) (*s_objet_resultat)
-				.objet))).taille * sizeof(real8))) == NULL)
+	 			malloc(((size_t) (*(((struct_vecteur *) (*s_objet_resultat)
+				.objet))).taille) * sizeof(real8))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
@@ -679,8 +680,8 @@ instruction_plus(struct_processus *s_eta
 				(*((struct_vecteur *) (*s_objet_argument_1).objet)).taille;
 
 		if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
-	 			malloc((*(((struct_vecteur *) (*s_objet_resultat)
-				.objet))).taille * sizeof(struct_complexe16))) == NULL)
+	 			malloc(((size_t) (*(((struct_vecteur *) (*s_objet_resultat)
+				.objet))).taille) * sizeof(struct_complexe16))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
@@ -740,8 +741,8 @@ instruction_plus(struct_processus *s_eta
 				(*((struct_vecteur *) (*s_objet_argument_1).objet)).taille;
 
 		if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
-	 			malloc((*(((struct_vecteur *) (*s_objet_resultat)
-				.objet))).taille * sizeof(struct_complexe16))) == NULL)
+	 			malloc(((size_t) (*(((struct_vecteur *) (*s_objet_resultat)
+				.objet))).taille) * sizeof(struct_complexe16))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
@@ -799,8 +800,8 @@ instruction_plus(struct_processus *s_eta
 				(*((struct_vecteur *) (*s_objet_argument_1).objet)).taille;
 
 		if (((*((struct_vecteur *) (*s_objet_resultat).objet)).tableau =
-	 			malloc((*(((struct_vecteur *) (*s_objet_resultat)
-				.objet))).taille * sizeof(struct_complexe16))) == NULL)
+	 			malloc(((size_t) (*(((struct_vecteur *) (*s_objet_resultat)
+				.objet))).taille) * sizeof(struct_complexe16))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
@@ -859,8 +860,8 @@ instruction_plus(struct_processus *s_eta
 				.nombre_colonnes;
 
 		if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
-	 			malloc((*(((struct_matrice *) (*s_objet_resultat)
-				.objet))).nombre_lignes * sizeof(integer8 *))) == NULL)
+	 			malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat)
+				.objet))).nombre_lignes) * sizeof(integer8 *))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
@@ -872,9 +873,9 @@ instruction_plus(struct_processus *s_eta
 				.objet))).nombre_lignes; i++)
 		{
 			if ((((integer8 **) (*((struct_matrice *) (*s_objet_resultat)
-					.objet)).tableau)[i] = malloc((*((
+					.objet)).tableau)[i] = malloc(((size_t) (*((
 					(struct_matrice *) (*s_objet_resultat).objet)))
-					.nombre_colonnes * sizeof(integer8))) == NULL)
+					.nombre_colonnes) * sizeof(integer8))) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
@@ -908,9 +909,9 @@ instruction_plus(struct_processus *s_eta
 						(*s_objet_resultat).objet)).tableau)[i]);
 
 				if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat)
-						.objet)).tableau)[i] = malloc((*((
+						.objet)).tableau)[i] = malloc(((size_t) (*((
 						(struct_matrice *) (*s_objet_resultat).objet)))
-						.nombre_colonnes * sizeof(real8))) == NULL)
+						.nombre_colonnes) * sizeof(real8))) == NULL)
 				{
 					(*s_etat_processus).erreur_systeme =
 							d_es_allocation_memoire;
@@ -969,8 +970,8 @@ instruction_plus(struct_processus *s_eta
 				.nombre_colonnes;
 
 		if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
-	 			malloc((*(((struct_matrice *) (*s_objet_resultat)
-				.objet))).nombre_lignes * sizeof(real8 *))) == NULL)
+	 			malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat)
+				.objet))).nombre_lignes) * sizeof(real8 *))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
@@ -980,9 +981,9 @@ instruction_plus(struct_processus *s_eta
 				.objet))).nombre_lignes; i++)
 		{
 			if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat)
-					.objet)).tableau)[i] = malloc((*((
+					.objet)).tableau)[i] = malloc(((size_t) (*((
 					(struct_matrice *) (*s_objet_resultat).objet)))
-					.nombre_colonnes * sizeof(real8))) == NULL)
+					.nombre_colonnes) * sizeof(real8))) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
@@ -994,9 +995,9 @@ instruction_plus(struct_processus *s_eta
 				if ((*s_objet_argument_1).type == MIN)
 				{
 					((real8 **) (*((struct_matrice *) (*s_objet_resultat)
-							.objet)).tableau)[i][j] = ((integer8 **)
+							.objet)).tableau)[i][j] = ((real8) ((integer8 **)
 							(*((struct_matrice *) (*s_objet_argument_1).objet))
-							.tableau)[i][j] + ((real8 **) (*((struct_matrice *)
+							.tableau)[i][j]) + ((real8 **) (*((struct_matrice *)
 							(*s_objet_argument_2).objet)).tableau)[i][j];
 				}
 				else
@@ -1004,9 +1005,9 @@ instruction_plus(struct_processus *s_eta
 					((real8 **) (*((struct_matrice *) (*s_objet_resultat)
 							.objet)).tableau)[i][j] = ((real8 **)
 							(*((struct_matrice *) (*s_objet_argument_1).objet))
-							.tableau)[i][j] + ((integer8 **)
+							.tableau)[i][j] + ((real8) ((integer8 **)
 							(*((struct_matrice *) (*s_objet_argument_2)
-							.objet)).tableau)[i][j];
+							.objet)).tableau)[i][j]);
 				}
 			}
 		}
@@ -1048,8 +1049,8 @@ instruction_plus(struct_processus *s_eta
 				.nombre_colonnes;
 
 		if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
-	 			malloc((*(((struct_matrice *) (*s_objet_resultat)
-				.objet))).nombre_lignes * sizeof(real8 *))) == NULL)
+	 			malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat)
+				.objet))).nombre_lignes) * sizeof(real8 *))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
@@ -1059,9 +1060,9 @@ instruction_plus(struct_processus *s_eta
 				.objet))).nombre_lignes; i++)
 		{
 			if ((((real8 **) (*((struct_matrice *) (*s_objet_resultat)
-					.objet)).tableau)[i] = malloc((*((
+					.objet)).tableau)[i] = malloc(((size_t) (*((
 					(struct_matrice *) (*s_objet_resultat).objet)))
-					.nombre_colonnes * sizeof(real8))) == NULL)
+					.nombre_colonnes) * sizeof(real8))) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
@@ -1117,8 +1118,9 @@ instruction_plus(struct_processus *s_eta
 				.nombre_colonnes;
 
 		if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
-	 			malloc((*(((struct_matrice *) (*s_objet_resultat)
-				.objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL)
+	 			malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat)
+				.objet))).nombre_lignes) * sizeof(struct_complexe16 *)))
+				== NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
@@ -1128,9 +1130,9 @@ instruction_plus(struct_processus *s_eta
 				.objet))).nombre_lignes; i++)
 		{
 			if ((((struct_complexe16 **) (*((struct_matrice *)
-					(*s_objet_resultat).objet)).tableau)[i] = malloc((*((
-					(struct_matrice *) (*s_objet_resultat).objet)))
-					.nombre_colonnes * sizeof(struct_complexe16))) == NULL)
+					(*s_objet_resultat).objet)).tableau)[i] = malloc(((size_t)
+					(*(((struct_matrice *) (*s_objet_resultat).objet)))
+					.nombre_colonnes) * sizeof(struct_complexe16))) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
@@ -1201,8 +1203,9 @@ instruction_plus(struct_processus *s_eta
 				.nombre_colonnes;
 
 		if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
-	 			malloc((*(((struct_matrice *) (*s_objet_resultat)
-				.objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL)
+	 			malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat)
+				.objet))).nombre_lignes) * sizeof(struct_complexe16 *)))
+				== NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
@@ -1212,9 +1215,9 @@ instruction_plus(struct_processus *s_eta
 				.objet))).nombre_lignes; i++)
 		{
 			if ((((struct_complexe16 **) (*((struct_matrice *)
-					(*s_objet_resultat).objet)).tableau)[i] = malloc((*((
-					(struct_matrice *) (*s_objet_resultat).objet)))
-					.nombre_colonnes * sizeof(struct_complexe16))) == NULL)
+					(*s_objet_resultat).objet)).tableau)[i] = malloc(((size_t)
+					(*(((struct_matrice *) (*s_objet_resultat).objet)))
+					.nombre_colonnes) * sizeof(struct_complexe16))) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
@@ -1283,8 +1286,9 @@ instruction_plus(struct_processus *s_eta
 				.nombre_colonnes;
 
 		if (((*((struct_matrice *) (*s_objet_resultat).objet)).tableau =
-	 			malloc((*(((struct_matrice *) (*s_objet_resultat)
-				.objet))).nombre_lignes * sizeof(struct_complexe16 *))) == NULL)
+	 			malloc(((size_t) (*(((struct_matrice *) (*s_objet_resultat)
+				.objet))).nombre_lignes) * sizeof(struct_complexe16 *)))
+				== NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return;
@@ -1294,9 +1298,9 @@ instruction_plus(struct_processus *s_eta
 				.objet))).nombre_lignes; i++)
 		{
 			if ((((struct_complexe16 **) (*((struct_matrice *)
-					(*s_objet_resultat).objet)).tableau)[i] = malloc((*((
-					(struct_matrice *) (*s_objet_resultat).objet)))
-					.nombre_colonnes * sizeof(struct_complexe16))) == NULL)
+					(*s_objet_resultat).objet)).tableau)[i] = malloc(((size_t)
+					(*(((struct_matrice *) (*s_objet_resultat).objet)))
+					.nombre_colonnes) * sizeof(struct_complexe16))) == NULL)
 			{
 				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				return;
@@ -1360,12 +1364,13 @@ instruction_plus(struct_processus *s_eta
 		{
 			(*((logical8 *) (*s_objet_resultat).objet)) =
 					(*((logical8 *) (*s_objet_argument_1).objet))
-					+ (*((integer8 *) (*s_objet_argument_2).objet));
+					+ ((logical8) (*((integer8 *) (*s_objet_argument_2)
+					.objet)));
 		}
 		else
 		{
 			(*((logical8 *) (*s_objet_resultat).objet)) =
-					(*((integer8 *) (*s_objet_argument_1).objet))
+					((logical8) (*((integer8 *) (*s_objet_argument_1).objet)))
 					+ (*((logical8 *) (*s_objet_argument_2).objet));
 		}
 	}
@@ -2121,7 +2126,7 @@ instruction_puissance(struct_processus *
 	struct_objet				*s_objet_argument_2;
 	struct_objet				*s_objet_resultat;
 
-	unsigned long				nombre_elements;
+	integer8					nombre_elements;
 
 	(*s_etat_processus).erreur_execution = d_ex;
 
@@ -3269,7 +3274,7 @@ instruction_pourcent_t(struct_processus
 	struct_objet				*s_objet_argument_2;
 	struct_objet				*s_objet_resultat;
 
-	unsigned long				nombre_elements;
+	integer8					nombre_elements;
 
 	(*s_etat_processus).erreur_execution = d_ex;