--- rpl/src/gestion_pile_systeme.c	2013/03/05 16:26:46	1.52
+++ rpl/src/gestion_pile_systeme.c	2020/01/10 11:15:43	1.87
@@ -1,7 +1,7 @@
 /*
 ================================================================================
-  RPL/2 (R) version 4.1.13
-  Copyright (C) 1989-2013 Dr. BERTRAND Joël
+  RPL/2 (R) version 4.1.32
+  Copyright (C) 1989-2020 Dr. BERTRAND Joël
 
   This file is part of RPL/2.
 
@@ -39,9 +39,10 @@ static inline void
 estimation_taille_pile_systeme(struct_processus *s_etat_processus)
 {
 	(*s_etat_processus).estimation_taille_pile_systeme_tampon =
-			((*s_etat_processus).estimation_taille_pile_systeme_tampon *
-			((double) 0.9)) + ((*s_etat_processus)
-			.hauteur_pile_systeme * ((double) 0.1));
+			(((double) (*s_etat_processus)
+			.estimation_taille_pile_systeme_tampon) *
+			((double) 0.9)) + (((double) (*s_etat_processus)
+			.hauteur_pile_systeme) * ((double) 0.1));
 	return;
 }
 
@@ -148,6 +149,8 @@ empilement_pile_systeme(struct_processus
 			= (*s_etat_processus).creation_variables_partagees;
 	(*(*s_etat_processus).l_base_pile_systeme).evaluation_expression =
 			d_faux;
+	(*(*s_etat_processus).l_base_pile_systeme).debug_programme =
+			(*s_etat_processus).debug_programme;
 
 	(*s_etat_processus).erreur_systeme = d_es;
 	(*s_etat_processus).creation_variables_statiques = d_faux;
@@ -302,13 +305,12 @@ effacement_pile_systeme(struct_processus
 void
 trace(struct_processus *s_etat_processus, FILE *flux)
 {
-	int								candidat;
-	int								j;
-	int								nb_variables;
-
 	integer8						i;
+	integer8						j;
+	integer8						candidat;
 	integer8						candidat8;
 	integer8						delta;
+	integer8						nb_variables;
 
 	struct_liste_chainee			*l_element_expression;
 
@@ -332,8 +334,8 @@ trace(struct_processus *s_etat_processus
 
 	nb_variables = nombre_variables(s_etat_processus);
 
-	if ((tableau = malloc(nb_variables * sizeof(struct_tableau_variables)))
-			== NULL)
+	if ((tableau = malloc(((size_t) nb_variables) *
+			sizeof(struct_tableau_variables))) == NULL)
 	{
 		(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
 		return;
@@ -348,7 +350,7 @@ trace(struct_processus *s_etat_processus
 
 	while(l_element_courant != NULL)
 	{
-		fprintf(flux, "%d : address # %016Xh\n", i--, l_element_courant);
+		fprintf(flux, "%lld : address # %016Xh\n", i--, l_element_courant);
 
 		if ((*l_element_courant).creation_variables_statiques == d_vrai)
 		{
@@ -492,11 +494,10 @@ trace(struct_processus *s_etat_processus
 			}
 		}
 
-		fprintf(flux, "    Level             = %d\n",
-				(*l_element_courant).niveau_courant);
+		fprintf(flux, "    Level             = %lld\n",
+				(long long int) (*l_element_courant).niveau_courant);
 
-		if (((*l_element_courant).retour_definition == 'Y') ||
-				((*l_element_courant).origine_routine_evaluation == 'Y'))
+		if ((*l_element_courant).retour_definition == 'Y')
 		{
 			fprintf(flux, "    Return            = yes\n");
 
@@ -514,27 +515,33 @@ trace(struct_processus *s_etat_processus
 
 					for(j = 0; j < nb_variables; j++)
 					{
-						if (((*(tableau[j].objet)).type == RPN) ||
-								((*(tableau[j].objet)).type == ALG))
+						if (tableau[j].objet != NULL)
 						{
-							l_element_expression = (*(tableau[j].objet)).objet;
-
-							while(l_element_expression != NULL)
+							// Variable ni partagée ni statique
+							if (((*(tableau[j].objet)).type == RPN) ||
+									((*(tableau[j].objet)).type == ALG))
 							{
-								if (l_element_expression == (*l_element_courant)
-										.pointeur_objet_retour)
+								l_element_expression =
+										(*(tableau[j].objet)).objet;
+
+								while(l_element_expression != NULL)
 								{
-									candidat = j;
-									break;
-								}
+									if (l_element_expression ==
+											(*l_element_courant)
+											.pointeur_objet_retour)
+									{
+										candidat = j;
+										break;
+									}
 
-								l_element_expression =
-										(*l_element_expression).suivant;
-							}
+									l_element_expression =
+											(*l_element_expression).suivant;
+								}
 
-							if (candidat != -1)
-							{
-								break;
+								if (candidat != -1)
+								{
+									break;
+								}
 							}
 						}
 					}
@@ -571,6 +578,7 @@ trace(struct_processus *s_etat_processus
 				}
 				else
 				{
+					fprintf(flux, "    Come from         = compiled code\n");
 					fprintf(flux, "                      = "
 							"optimized definition\n");
 				}
@@ -595,7 +603,7 @@ trace(struct_processus *s_etat_processus
 						if ((*(tableau[j].objet)).type == ADR)
 						{
 							delta = (*l_element_courant).adresse_retour
-									- (*((unsigned long *)
+									- (*((integer8 *)
 									(*(tableau[j].objet)).objet));
 
 							if ((delta >= 0) && (delta < candidat8))
@@ -617,12 +625,16 @@ trace(struct_processus *s_etat_processus
 								"unknown definition\n");
 					}
 				}
-				else
+				else if ((*l_element_courant).niveau_courant == 0)
 				{
 					fprintf(flux, "\n");
 					fprintf(flux, "                      = RPL/2 "
 							"initialization\n");
 				}
+				else
+				{
+					fprintf(flux, "\n");
+				}
 			}
 		}
 		else
@@ -630,7 +642,8 @@ trace(struct_processus *s_etat_processus
 			fprintf(flux, "    Return            = no\n");
 		}
 
-		if ((*l_element_courant).indice_boucle != NULL)
+		if (((*l_element_courant).indice_boucle != NULL) &&
+				((*l_element_courant).type_cloture != 'A'))
 		{
 			tampon = formateur(s_etat_processus, 24,
 					(*l_element_courant).indice_boucle);
@@ -665,7 +678,6 @@ trace(struct_processus *s_etat_processus
 		l_element_courant = (*l_element_courant).suivant;
 	}
 
-	fprintf(flux, "\n");
 	funlockfile(flux);
 
 	free(tableau);