--- rpl/src/gestion_objets.c	2017/07/17 21:38:07	1.136
+++ rpl/src/gestion_objets.c	2022/09/07 13:40:31	1.150
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.27
-  Copyright (C) 1989-2017 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.34
+  Copyright (C) 1989-2021 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -106,6 +106,7 @@ initialisation_allocateur(struct_process
 	(*s_etat_processus).pointeur_int = 0;
 	(*s_etat_processus).pointeur_mat = 0;
 	(*s_etat_processus).pointeur_nom = 0;
+	(*s_etat_processus).pointeur_rec = 0;
 	(*s_etat_processus).pointeur_rel = 0;
 	(*s_etat_processus).pointeur_tab = 0;
 	(*s_etat_processus).pointeur_vec = 0;
@@ -141,6 +142,8 @@ liberation_allocateur(struct_processus *
 			free((*s_etat_processus).objets_mat[i++]));
 	for(i = 0; i < (*s_etat_processus).pointeur_nom;
 			free((*s_etat_processus).objets_nom[i++]));
+	for(i = 0; i < (*s_etat_processus).pointeur_rec;
+			free((*s_etat_processus).objets_rec[i++]));
 	for(i = 0; i < (*s_etat_processus).pointeur_rel;
 			free((*s_etat_processus).objets_rel[i++]));
 	for(i = 0; i < (*s_etat_processus).pointeur_tab;
@@ -623,6 +626,28 @@ allocation(struct_processus *s_etat_proc
 			break;
 		}
 
+		case REC :
+		{
+			if ((*s_etat_processus).pointeur_rec > 0)
+			{
+				(*s_objet).objet = (*s_etat_processus).objets_rec
+						[--(*s_etat_processus).pointeur_rec];
+			}
+			else
+			{
+				if (((*s_objet).objet = malloc(sizeof(struct_record)))
+						== NULL)
+				{
+					(*s_etat_processus).erreur_systeme =
+							d_es_allocation_memoire;
+					free(s_objet);
+					return(NULL);
+				}
+			}
+
+			break;
+		}
+
 		case REL :
 		{
 			if ((*s_etat_processus).pointeur_rel > 0)
@@ -1273,6 +1298,31 @@ liberation(struct_processus *s_etat_proc
 			break;
 		}
 
+		case REC :
+		{
+			liberation(s_etat_processus,
+					(*((struct_record *) (*s_objet).objet)).noms);
+			liberation(s_etat_processus,
+					(*((struct_record *) (*s_objet).objet)).donnees);
+
+			if (decrementation_atomique(s_objet) > 0)
+			{
+				return;
+			}
+
+			if ((*s_etat_processus).pointeur_rec < TAILLE_CACHE)
+			{
+				(*s_etat_processus).objets_rec
+						[(*s_etat_processus).pointeur_rec++] = (*s_objet).objet;
+			}
+			else
+			{
+				free((struct_record *) ((*s_objet).objet));
+			}
+
+			break;
+		}
+
 		case REL :
 		{
 			if (decrementation_atomique(s_objet) > 0)
@@ -2434,6 +2484,46 @@ copie_objet(struct_processus *s_etat_pro
 			break;
 		}
 
+		case REC :
+		{
+			if (type != 'P')
+			{
+				if ((s_nouvel_objet = allocation(s_etat_processus, REC))
+						== NULL)
+				{
+					return(NULL);
+				}
+
+				if (((*((struct_record *) (*s_nouvel_objet).objet)).noms =
+						copie_objet(s_etat_processus, (*((struct_record *)
+						(*s_objet).objet)).noms, 'P')) == NULL)
+				{
+					return(NULL);
+				}
+
+				if (((*((struct_record *) (*s_nouvel_objet).objet)).donnees =
+						copie_objet(s_etat_processus, (*((struct_record *)
+						(*s_objet).objet)).donnees, type)) == NULL)
+				{
+					return(NULL);
+				}
+			}
+			else
+			{
+				incrementation_atomique(s_objet);
+				(*((struct_record *) (*s_objet).objet)).noms =
+						copie_objet(s_etat_processus, (*((struct_record *)
+						(*s_objet).objet)).noms, 'P');
+				(*((struct_record *) (*s_objet).objet)).donnees =
+						copie_objet(s_etat_processus, (*((struct_record *)
+						(*s_objet).objet)).donnees, 'P');
+
+				return(s_objet);
+			}
+
+			break;
+		}
+
 		case REL :
 		{
 			if (type != 'O')
@@ -2984,8 +3074,33 @@ copie_etat_processus(struct_processus *s
 		return(NULL);
 	}
 
+
+	if (pthread_mutex_lock(&((*s_etat_processus).mutex_interruptions)) != 0)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_processus;
+		return(NULL);
+	}
+
+	if (pthread_mutex_lock(&((*s_etat_processus).mutex_signaux)) != 0)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_processus;
+		return(NULL);
+	}
+
 	(*s_nouvel_etat_processus) = (*s_etat_processus);
 
+	if (pthread_mutex_unlock(&((*s_etat_processus).mutex_signaux)) != 0)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_processus;
+		return(NULL);
+	}
+
+	if (pthread_mutex_unlock(&((*s_etat_processus).mutex_interruptions)) != 0)
+	{
+		(*s_etat_processus).erreur_systeme = d_es_processus;
+		return(NULL);
+	}
+
 	// On réinitialise les allocateurs.
 
 	pthread_mutexattr_init(&attributs_mutex);
@@ -3851,6 +3966,13 @@ debug_memoire_ajout(size_t taille, const
 			sizeof(unsigned char))) == NULL)
 	{
 		pthread_mutex_unlock(&mutex_allocation);
+
+		uprintf("[%d-%llu] ILLEGAL POINTER (malloc) $%016X\n",
+				getpid(), (unsigned long long) pthread_self(), NULL);
+#		ifdef __BACKTRACE
+			BACKTRACE(PROFONDEUR_PILE);
+#		endif
+
 		return(NULL);
 	}
 
@@ -3911,8 +4033,9 @@ debug_memoire_modification(void *pointeu
 			{
 				pthread_mutex_unlock(&mutex_allocation);
 
-				uprintf("[%d-%llu] ILLEGAL POINTER (realloc)\n",
-						getpid(), (unsigned long long) pthread_self());
+				uprintf("[%d-%llu] ILLEGAL POINTER (realloc) $%016X\n",
+						getpid(), (unsigned long long) pthread_self(),
+						pointeur);
 #				ifdef __BACKTRACE
 					BACKTRACE(PROFONDEUR_PILE);
 #				endif
@@ -4008,8 +4131,8 @@ debug_memoire_retrait(void *pointeur)
 
 	if (element_courant == NULL)
 	{
-		uprintf("[%d-%llu] ILLEGAL POINTER (free)\n",
-				getpid(), (unsigned long long) pthread_self());
+		uprintf("[%d-%llu] ILLEGAL POINTER (free) $%016X\n",
+				getpid(), (unsigned long long) pthread_self(), pointeur);
 #		ifdef __BACKTRACE
 			BACKTRACE(PROFONDEUR_PILE);
 #		endif
@@ -4126,7 +4249,7 @@ debug_memoire_verification()
 }
 
 pid_t
-debug_fork()
+debug_fork(struct_processus *s_etat_processus)
 {
 	pid_t	pid;