--- rpl/src/gestion_objets.c	2012/12/19 09:58:23	1.93
+++ rpl/src/gestion_objets.c	2013/04/01 15:29:34	1.100
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.12
-  Copyright (C) 1989-2012 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.14
+  Copyright (C) 1989-2013 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -245,6 +245,7 @@ allocation_maillon(struct_processus *s_e
 	{
 		if ((s_maillon = malloc(sizeof(struct_liste_chainee))) == NULL)
 		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return(NULL);
 		}
 	}
@@ -318,6 +319,7 @@ allocation(struct_processus *s_etat_proc
 
 		if ((s_objet = malloc(sizeof(struct_objet))) == NULL)
 		{
+			(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 			return(NULL);
 		}
 
@@ -353,8 +355,10 @@ allocation(struct_processus *s_etat_proc
 			}
 			else
 			{
-				if (((*s_objet).objet = malloc(sizeof(unsigned long))) == NULL)
+				if (((*s_objet).objet = malloc(sizeof(integer8))) == NULL)
 				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
 					free(s_objet);
 					return(NULL);
 				}
@@ -380,6 +384,8 @@ allocation(struct_processus *s_etat_proc
 			{
 				if (((*s_objet).objet = malloc(sizeof(logical8))) == NULL)
 				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
 					free(s_objet);
 					return(NULL);
 				}
@@ -406,6 +412,8 @@ allocation(struct_processus *s_etat_proc
 				if (((*s_objet).objet = malloc(sizeof(struct_complexe16)))
 						== NULL)
 				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
 					free(s_objet);
 					return(NULL);
 				}
@@ -418,6 +426,7 @@ allocation(struct_processus *s_etat_proc
 		{
 			if (((*s_objet).objet = malloc(sizeof(struct_fichier))) == NULL)
 			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				free(s_objet);
 				return(NULL);
 			}
@@ -437,6 +446,8 @@ allocation(struct_processus *s_etat_proc
 				if (((*s_objet).objet = malloc(sizeof(struct_fonction)))
 						== NULL)
 				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
 					free(s_objet);
 					return(NULL);
 				}
@@ -460,6 +471,8 @@ allocation(struct_processus *s_etat_proc
 			{
 				if (((*s_objet).objet = malloc(sizeof(integer8))) == NULL)
 				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
 					free(s_objet);
 					return(NULL);
 				}
@@ -485,6 +498,8 @@ allocation(struct_processus *s_etat_proc
 			{
 				if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)
 				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
 					free(s_objet);
 					return(NULL);
 				}
@@ -508,6 +523,8 @@ allocation(struct_processus *s_etat_proc
 			{
 				if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)
 				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
 					free(s_objet);
 					return(NULL);
 				}
@@ -531,6 +548,8 @@ allocation(struct_processus *s_etat_proc
 			{
 				if (((*s_objet).objet = malloc(sizeof(struct_matrice))) == NULL)
 				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
 					free(s_objet);
 					return(NULL);
 				}
@@ -547,6 +566,7 @@ allocation(struct_processus *s_etat_proc
 		{
 			if (((*s_objet).objet = malloc(sizeof(struct_mutex))) == NULL)
 			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				free(s_objet);
 				return(NULL);
 			}
@@ -566,6 +586,8 @@ allocation(struct_processus *s_etat_proc
 			{
 				if (((*s_objet).objet = malloc(sizeof(struct_nom))) == NULL)
 				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
 					free(s_objet);
 					return(NULL);
 				}
@@ -585,6 +607,7 @@ allocation(struct_processus *s_etat_proc
 			if (((*s_objet).objet = malloc(sizeof(struct_processus_fils)))
 					== NULL)
 			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				free(s_objet);
 				return(NULL);
 			}
@@ -603,6 +626,8 @@ allocation(struct_processus *s_etat_proc
 			{
 				if (((*s_objet).objet = malloc(sizeof(real8))) == NULL)
 				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
 					free(s_objet);
 					return(NULL);
 				}
@@ -621,6 +646,7 @@ allocation(struct_processus *s_etat_proc
 		{
 			if (((*s_objet).objet = malloc(sizeof(struct_socket))) == NULL)
 			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				free(s_objet);
 				return(NULL);
 			}
@@ -633,6 +659,7 @@ allocation(struct_processus *s_etat_proc
 			if (((*s_objet).objet = malloc(sizeof(struct_bibliotheque)))
 					== NULL)
 			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				free(s_objet);
 				return(NULL);
 			}
@@ -644,6 +671,7 @@ allocation(struct_processus *s_etat_proc
 		{
 			if (((*s_objet).objet = malloc(sizeof(struct_semaphore))) == NULL)
 			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				free(s_objet);
 				return(NULL);
 			}
@@ -656,6 +684,7 @@ allocation(struct_processus *s_etat_proc
 			if (((*s_objet).objet = malloc(sizeof(struct_connecteur_sql)))
 					== NULL)
 			{
+				(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 				free(s_objet);
 				return(NULL);
 			}
@@ -674,6 +703,8 @@ allocation(struct_processus *s_etat_proc
 			{
 				if (((*s_objet).objet = malloc(sizeof(struct_tableau))) == NULL)
 				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
 					free(s_objet);
 					return(NULL);
 				}
@@ -695,6 +726,8 @@ allocation(struct_processus *s_etat_proc
 			{
 				if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
 				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
 					free(s_objet);
 					return(NULL);
 				}
@@ -717,6 +750,8 @@ allocation(struct_processus *s_etat_proc
 			{
 				if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
 				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
 					free(s_objet);
 					return(NULL);
 				}
@@ -739,6 +774,8 @@ allocation(struct_processus *s_etat_proc
 			{
 				if (((*s_objet).objet = malloc(sizeof(struct_vecteur))) == NULL)
 				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
 					free(s_objet);
 					return(NULL);
 				}
@@ -783,7 +820,7 @@ liberation(struct_processus *s_etat_proc
 	struct_liste_chainee				*l_element_courant;
 	struct_liste_chainee				*l_element_suivant;
 
-	unsigned long						i;
+	integer8							i;
 
 	if (s_objet == NULL)
 	{
@@ -822,7 +859,7 @@ liberation(struct_processus *s_etat_proc
 			}
 			else
 			{
-				free((unsigned long *) ((*s_objet).objet));
+				free((*s_objet).objet);
 			}
 
 			break;
@@ -1357,7 +1394,7 @@ liberation(struct_processus *s_etat_proc
 							.nombre_occurrences <= 1,
 							pthread_mutex_unlock(&((*s_objet).mutex)),
 							printf("(*((*((struct_tableau *) (*s_objet).objet))"
-							".element[%lu])).nombre_occurrences=%ld\n", i,
+							".element[%lld])).nombre_occurrences=%ld\n", i,
 							(*((*((struct_tableau *) (*s_objet).objet))
 							.elements[i])).nombre_occurrences));
 					liberation(s_etat_processus, (*((struct_tableau *)
@@ -1552,8 +1589,8 @@ copie_objet(struct_processus *s_etat_pro
 	struct_objet				*s_nouvel_objet;
 	struct_objet				*s_objet_tampon;
 
-	unsigned long				i;
-	unsigned long				j;
+	integer8					i;
+	integer8					j;
 
 	if (pthread_mutex_lock(&((*s_objet).mutex)) != 0)
 	{
@@ -1604,8 +1641,8 @@ copie_objet(struct_processus *s_etat_pro
 				return(NULL);
 			}
 
-			(*((unsigned long *) ((*s_nouvel_objet).objet))) =
-					(*((unsigned long *) ((*s_objet).objet)));
+			(*((integer8 *) ((*s_nouvel_objet).objet))) =
+					(*((integer8 *) ((*s_objet).objet)));
 			break;
 		}
 
@@ -1670,7 +1707,7 @@ copie_objet(struct_processus *s_etat_pro
 							(*l_element_courant_lecture).suivant;
 				}
 
-				(*s_nouvel_objet).objet = (void *) ((struct_liste_chainee *)
+				(*s_nouvel_objet).objet = ((struct_liste_chainee *)
 						l_element_base);
 			}
 			else // type == 'P'
@@ -1722,7 +1759,7 @@ copie_objet(struct_processus *s_etat_pro
 				return(NULL);
 			}
 
-			(*s_nouvel_objet).objet = (void *) ((unsigned char *)
+			(*s_nouvel_objet).objet = ((unsigned char *)
 					malloc((strlen((unsigned char *) ((*s_objet).objet)) + 1)
 					* sizeof(unsigned char)));
 
@@ -1816,7 +1853,7 @@ copie_objet(struct_processus *s_etat_pro
 							(*l_element_courant_lecture).suivant;
 				}
 
-				(*s_nouvel_objet).objet = (void *) ((struct_liste_chainee *)
+				(*s_nouvel_objet).objet = ((struct_liste_chainee *)
 						l_element_base);
 			}
 			else // type == 'P'
@@ -2023,7 +2060,7 @@ copie_objet(struct_processus *s_etat_pro
 							(*l_element_courant_lecture).suivant;
 				}
 
-				(*s_nouvel_objet).objet = (void *) ((struct_liste_chainee *)
+				(*s_nouvel_objet).objet = ((struct_liste_chainee *)
 						l_element_base);
 			}
 			else
@@ -2058,9 +2095,8 @@ copie_objet(struct_processus *s_etat_pro
 			}
 
 			(*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau =
-					(void **) ((integer8 **) malloc(
-					((*((struct_matrice *) ((*s_objet).objet))).nombre_lignes)
-					* sizeof(integer8 *)));
+					malloc(((size_t) ((*((struct_matrice *)
+					((*s_objet).objet))).nombre_lignes)) * sizeof(integer8 *));
 
 			if ((*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau
 					== NULL)
@@ -2082,9 +2118,9 @@ copie_objet(struct_processus *s_etat_pro
 			{
 				if ((((integer8 **) ((*((struct_matrice *)
 						((*s_nouvel_objet).objet))).tableau))[i] =
-						(void *) ((integer8 *) malloc(
+						((integer8 *) malloc(((size_t)
 						((*((struct_matrice *) ((*s_objet).objet)))
-						.nombre_colonnes) * sizeof(integer8)))) == NULL)
+						.nombre_colonnes)) * sizeof(integer8)))) == NULL)
 				{
 					for(j = 0; j < i; j++)
 					{
@@ -2125,9 +2161,9 @@ copie_objet(struct_processus *s_etat_pro
 			}
 
 			(*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau =
-					(void **) ((struct_complexe16 **) malloc(
-					((*((struct_matrice *) ((*s_objet).objet))).nombre_lignes)
-					* sizeof(struct_complexe16 *)));
+					malloc(((size_t) ((*((struct_matrice *)
+					((*s_objet).objet))).nombre_lignes))
+					* sizeof(struct_complexe16 *));
 
 			if ((*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau
 					== NULL)
@@ -2149,9 +2185,9 @@ copie_objet(struct_processus *s_etat_pro
 			{
 				if ((((struct_complexe16 **) ((*((struct_matrice *)
 						((*s_nouvel_objet).objet))).tableau))[i] =
-						(void *) ((struct_complexe16 *) malloc(
+						((struct_complexe16 *) malloc(((size_t)
 						((*((struct_matrice *) ((*s_objet).objet)))
-						.nombre_colonnes) * sizeof(struct_complexe16))))
+						.nombre_colonnes)) * sizeof(struct_complexe16))))
 						== NULL)
 				{
 					for(j = 0; j < i; j++)
@@ -2192,9 +2228,8 @@ copie_objet(struct_processus *s_etat_pro
 			}
 
 			(*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau = 
-					(void **) ((real8 **) malloc(
-					((*((struct_matrice *) ((*s_objet).objet))).nombre_lignes)
-					* sizeof(real8 *)));
+					malloc(((size_t) ((*((struct_matrice *)
+					((*s_objet).objet))).nombre_lignes)) * sizeof(real8 *));
 
 			if ((*((struct_matrice *) ((*s_nouvel_objet).objet))).tableau
 					== NULL)
@@ -2216,9 +2251,9 @@ copie_objet(struct_processus *s_etat_pro
 			{
 				if ((((real8 **) ((*((struct_matrice *)
 						((*s_nouvel_objet).objet))).tableau))[i] =
-						(void *) ((real8 *) malloc(
+						((real8 *) malloc(((size_t)
 						((*((struct_matrice *) ((*s_objet).objet)))
-						.nombre_colonnes) * sizeof(real8)))) == NULL)
+						.nombre_colonnes)) * sizeof(real8)))) == NULL)
 				{
 					for(j = 0; j < i; j++)
 					{
@@ -2588,8 +2623,9 @@ copie_objet(struct_processus *s_etat_pro
 						(*s_objet).objet)).nombre_elements;
 
 				if (((*((struct_tableau *) (*s_nouvel_objet).objet)).elements =
-						malloc((*((struct_tableau *) (*s_objet).objet))
-						.nombre_elements * sizeof(struct_objet *))) == NULL)
+						malloc(((size_t) (*((struct_tableau *)
+						(*s_objet).objet)).nombre_elements)
+						* sizeof(struct_objet *))) == NULL)
 				{
 					return(NULL);
 				}
@@ -2649,8 +2685,8 @@ copie_objet(struct_processus *s_etat_pro
 			}
 
 			(*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau = 
-					(void *) ((integer8 *) malloc(
-					((*((struct_vecteur *) ((*s_objet).objet))).taille)
+					((integer8 *) malloc(((size_t)
+					((*((struct_vecteur *) ((*s_objet).objet))).taille))
 					* sizeof(integer8)));
 
 			if ((*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau
@@ -2692,8 +2728,8 @@ copie_objet(struct_processus *s_etat_pro
 			}
 
 			(*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau = 
-					(void *) ((struct_complexe16 *) malloc(
-					((*((struct_vecteur *) ((*s_objet).objet))).taille)
+					((struct_complexe16 *) malloc(((size_t)
+					((*((struct_vecteur *) ((*s_objet).objet))).taille))
 					* sizeof(struct_complexe16)));
 
 			if ((*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau
@@ -2735,8 +2771,8 @@ copie_objet(struct_processus *s_etat_pro
 			}
 
 			(*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau = 
-					(void *) ((real8 *) malloc(
-					((*((struct_vecteur *) ((*s_objet).objet))).taille)
+					((real8 *) malloc(((size_t)
+					((*((struct_vecteur *) ((*s_objet).objet))).taille))
 					* sizeof(real8)));
 
 			if ((*((struct_vecteur *) ((*s_nouvel_objet).objet))).tableau
@@ -2799,7 +2835,7 @@ copie_etat_processus(struct_processus *s
 
 	struct_processus				*s_nouvel_etat_processus;
 
-	unsigned long					i;
+	integer8						i;
 
 	if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)
 	{
@@ -3452,7 +3488,8 @@ copie_etat_processus(struct_processus *s
 	if ((*s_etat_processus).nombre_instructions_externes != 0)
 	{
 		if (((*s_nouvel_etat_processus).s_instructions_externes =
-				malloc((*s_etat_processus).nombre_instructions_externes *
+				malloc(((size_t) (*s_etat_processus)
+				.nombre_instructions_externes) *
 				sizeof(struct_instruction_externe))) == NULL)
 		{
 			(*s_etat_processus).erreur_systeme = d_es_processus;