rpl/src/gestion_variables.c - diff

Return to gestion_variables.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/gestion_variables.c between versions 1.33 and 1.52

version 1.33, 2011/06/19 17:48:27	version 1.52, 2012/03/01 10:14:04
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.0.prerelease.0	RPL/2 (R) version 4.1.7
Copyright (C) 1989-2011 Dr. BERTRAND Joël	Copyright (C) 1989-2012 Dr. BERTRAND Joël

This file is part of RPL/2.	This file is part of RPL/2.

Line 46 liste_variables_par_niveaux(struct_proce	Line 46 liste_variables_par_niveaux(struct_proce

struct_liste_chainee *e;	struct_liste_chainee *e;

printf("===========================================================\n");	printf("=========================================================="
	"======================\n");
printf(" Liste des variables par niveaux\n");	printf(" Liste des variables par niveaux\n");
printf("===========================================================\n");	printf("=========================================================="
	"======================\n");

	if ((*s_etat_processus).l_liste_variables_par_niveau == NULL)
	{
	printf("=========================================================="
	"======================\n");
	return;
	}

printf("Backward\n");	printf("Backward\n");
l = (*s_etat_processus).l_liste_variables_par_niveau;	l = (*s_etat_processus).l_liste_variables_par_niveau;
Line 62 liste_variables_par_niveaux(struct_proce	Line 71 liste_variables_par_niveaux(struct_proce

while(e != NULL)	while(e != NULL)
{	{
printf("%s (%p, %d) ", ((struct_variable *) e->donnee)->nom,	printf("%s (%p->%p, %d) ", ((struct_variable *) e->donnee)->nom,
e->donnee, ((struct_variable *) e->donnee)->niveau);	e, e->donnee, ((struct_variable *) e->donnee)->niveau);
e = e->suivant;	e = e->suivant;
c++;	c++;
if (c > 100)	if (c > 100)
Line 87 liste_variables_par_niveaux(struct_proce	Line 96 liste_variables_par_niveaux(struct_proce

while(e != NULL)	while(e != NULL)
{	{
printf("%s (%p, %d) ", ((struct_variable *) e->donnee)->nom,	printf("%s (%p->%p, %d) ", ((struct_variable *) e->donnee)->nom,
e->donnee, ((struct_variable *) e->donnee)->niveau);	e, e->donnee, ((struct_variable *) e->donnee)->niveau);
e = e->suivant;	e = e->suivant;
c++;	c++;
if (c > 100) exit(0);	if (c > 100) exit(0);
Line 99 liste_variables_par_niveaux(struct_proce	Line 108 liste_variables_par_niveaux(struct_proce
l = l->suivant;	l = l->suivant;
} while(l != (*s_etat_processus).l_liste_variables_par_niveau);	} while(l != (*s_etat_processus).l_liste_variables_par_niveau);

printf("===========================================================\n");	printf("=========================================================="
	"======================\n");

if (fin == d_vrai) exit(0);	if (fin == d_vrai) exit(0);

Line 119 liste_variables_tas(struct_processus *s_	Line 129 liste_variables_tas(struct_processus *s_

fin = d_faux;	fin = d_faux;

	if (arbre == NULL)
	{
	return;
	}

	printf(">>> Position : %d\n",
	(*arbre).indice_tableau_pere);
	printf(">>> Nombre de noeuds utilisés : %u\n",
	(*arbre).noeuds_utilises);
	printf(">>> Noeuds fils : ");

	for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
	{
	if ((*arbre).noeuds[i] != NULL)
	{
	printf("%d ", i);
	}
	}

	printf("\b\n");

if ((*arbre).feuille != NULL)	if ((*arbre).feuille != NULL)
{	{
printf("Feuille %p\n", (*arbre).feuille);	printf("Feuille %p [%d]\n", (arbre).feuille, (arbre).noeuds_utilises);

printf(" Backward\n");	printf(" Backward\n");

Line 157 liste_variables_tas(struct_processus *s_	Line 188 liste_variables_tas(struct_processus *s_
} while((*arbre).feuille != l);	} while((*arbre).feuille != l);
}	}

	printf("----------------------------------------------------------"
	"----------------------\n");

for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)	for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
{	{
if ((*arbre).noeuds[i] != NULL)	if ((*arbre).noeuds[i] != NULL)
{	{

liste_variables_tas(s_etat_processus, (*arbre).noeuds[i]);	liste_variables_tas(s_etat_processus, (*arbre).noeuds[i]);
}	}
}	}
Line 174 liste_variables_tas(struct_processus *s_	Line 209 liste_variables_tas(struct_processus *s_
static void	static void
liste_variables_par_feuilles(struct_processus *s_etat_processus)	liste_variables_par_feuilles(struct_processus *s_etat_processus)
{	{
printf("===========================================================\n");	printf("=========================================================="
	"======================\n");
printf(" Liste des variables sur le tas\n");	printf(" Liste des variables sur le tas\n");
printf("===========================================================\n");	printf("=========================================================="
	"======================\n");

liste_variables_tas(s_etat_processus,	liste_variables_tas(s_etat_processus,
(*s_etat_processus).s_arbre_variables);	(*s_etat_processus).s_arbre_variables);

printf("===========================================================\n");	printf("=========================================================="
	"======================\n");

	return;
	}


	/*
	================================================================================
	Routine de gestion du cache mémoire sur l'arbre des variables
	================================================================================
	Entrée :
	--------------------------------------------------------------------------------
	Sortie :
	--------------------------------------------------------------------------------
	Effets de bords : néant
	================================================================================
	*/

	static inline struct_arbre_variables *
	allocation_noeud(struct_processus *s_etat_processus)
	{
	struct_arbre_variables *objet;

	if ((*s_etat_processus).pointeur_variables_noeud > 0)
	{
	objet = (*s_etat_processus).variables_noeud
	[--(*s_etat_processus).pointeur_variables_noeud];
	}
	else
	{
	objet = malloc(sizeof(struct_arbre_variables));
	}

	return(objet);
	}

	static inline void
	liberation_noeud(struct_processus *s_etat_processus,
	struct_arbre_variables *objet)
	{
	if ((*s_etat_processus).pointeur_variables_noeud < TAILLE_CACHE)
	{
	(*s_etat_processus).variables_noeud
	[(*s_etat_processus).pointeur_variables_noeud++] = objet;
	}
	else
	{
	free(objet);
	}

	return;
	}

	static inline struct_arbre_variables **
	allocation_tableau_noeuds(struct_processus *s_etat_processus)
	{
	struct_arbre_variables **objet;

	if ((*s_etat_processus).pointeur_variables_tableau_noeuds > 0)
	{
	objet = (*s_etat_processus).variables_tableau_noeuds
	[--(*s_etat_processus).pointeur_variables_tableau_noeuds];
	}
	else
	{
	objet = malloc((*s_etat_processus).nombre_caracteres_variables
	* sizeof(struct_arbre_variables *));
	}

	return(objet);
	}

	static inline void
	liberation_tableau_noeuds(struct_processus *s_etat_processus,
	struct_arbre_variables **objet)
	{
	if ((*s_etat_processus).pointeur_variables_tableau_noeuds < TAILLE_CACHE)
	{
	(*s_etat_processus).variables_tableau_noeuds
	[(*s_etat_processus).pointeur_variables_tableau_noeuds++] =
	objet;
	}
	else
	{
	free(objet);
	}

	return;
	}

	static inline struct_liste_variables *
	allocation_feuille(struct_processus *s_etat_processus)
	{
	struct_liste_variables *objet;

	if ((*s_etat_processus).pointeur_variables_feuille > 0)
	{
	objet = (*s_etat_processus).variables_feuille
	[--(*s_etat_processus).pointeur_variables_feuille];
	}
	else
	{
	objet = malloc(sizeof(struct_liste_variables));
	}

	return(objet);
	}

	static inline void
	liberation_feuille(struct_processus *s_etat_processus,
	struct_liste_variables *objet)
	{
	if ((*s_etat_processus).pointeur_variables_feuille < TAILLE_CACHE)
	{
	(*s_etat_processus).variables_feuille
	[(*s_etat_processus).pointeur_variables_feuille++] = objet;
	}
	else
	{
	free(objet);
	}

	return;
	}

	static inline struct_variable *
	allocation_variable(struct_processus *s_etat_processus)
	{
	struct_variable *objet;

	if ((*s_etat_processus).pointeur_variables_variable > 0)
	{
	objet = (*s_etat_processus).variables_variable
	[--(*s_etat_processus).pointeur_variables_variable];
	}
	else
	{
	objet = malloc(sizeof(struct_variable));
	}

	return(objet);
	}

	static inline void
	liberation_variable(struct_processus *s_etat_processus,
	struct_variable *objet)
	{
	if ((*s_etat_processus).pointeur_variables_variable < TAILLE_CACHE)
	{
	(*s_etat_processus).variables_variable
	[(*s_etat_processus).pointeur_variables_variable++] = objet;
	}
	else
	{
	free(objet);
	}

return;	return;
}	}
Line 226 ajout_variable(struct_processus *s_etat_	Line 419 ajout_variable(struct_processus *s_etat_
if ((*s_etat_processus).s_arbre_variables == NULL)	if ((*s_etat_processus).s_arbre_variables == NULL)
{	{
if (((*s_etat_processus).s_arbre_variables =	if (((*s_etat_processus).s_arbre_variables =
malloc(sizeof(struct_arbre_variables))) == NULL)	allocation_noeud(s_etat_processus)) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(d_erreur);	return(d_erreur);
Line 238 ajout_variable(struct_processus *s_etat_	Line 431 ajout_variable(struct_processus *s_etat_
((s_etat_processus).s_arbre_variables).noeud_pere = NULL;	((s_etat_processus).s_arbre_variables).noeud_pere = NULL;

if ((((s_etat_processus).s_arbre_variables).noeuds =	if ((((s_etat_processus).s_arbre_variables).noeuds =
malloc((*s_etat_processus).nombre_caracteres_variables	allocation_tableau_noeuds(s_etat_processus)) == NULL)
* sizeof(struct_arbre_variables))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(d_erreur);	return(d_erreur);
Line 258 ajout_variable(struct_processus *s_etat_	Line 450 ajout_variable(struct_processus *s_etat_
while((*ptr) != d_code_fin_chaine)	while((*ptr) != d_code_fin_chaine)
{	{
BUG((s_etat_processus).pointeurs_caracteres_variables[ptr] < 0,	BUG((s_etat_processus).pointeurs_caracteres_variables[ptr] < 0,
printf("Variable=\"%s\", (ptr)='%c'\n", (s_variable).nom,	uprintf("Variable=\"%s\", (ptr)='%c'\n", (s_variable).nom,
*ptr));	*ptr));

if ((l_variable_courante).noeuds[(s_etat_processus)	if ((l_variable_courante).noeuds[(s_etat_processus)
Line 269 ajout_variable(struct_processus *s_etat_	Line 461 ajout_variable(struct_processus *s_etat_

if (((l_variable_courante).noeuds[(s_etat_processus)	if (((l_variable_courante).noeuds[(s_etat_processus)
.pointeurs_caracteres_variables[*ptr]] =	.pointeurs_caracteres_variables[*ptr]] =
malloc(sizeof(struct_arbre_variables))) == NULL)	allocation_noeud(s_etat_processus)) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(d_erreur);	return(d_erreur);
Line 306 ajout_variable(struct_processus *s_etat_	Line 498 ajout_variable(struct_processus *s_etat_

if ((((l_variable_courante).noeuds[(*s_etat_processus)	if ((((l_variable_courante).noeuds[(*s_etat_processus)
.pointeurs_caracteres_variables[*ptr]]).noeuds =	.pointeurs_caracteres_variables[*ptr]]).noeuds =
malloc((*s_etat_processus).nombre_caracteres_variables	allocation_tableau_noeuds(s_etat_processus)) == NULL)
* sizeof(struct_arbre_variables))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(d_erreur);	return(d_erreur);
Line 334 ajout_variable(struct_processus *s_etat_	Line 525 ajout_variable(struct_processus *s_etat_
// variables de même nom. Cette liste boucle en premier lieu sur	// variables de même nom. Cette liste boucle en premier lieu sur
// elle-même.	// elle-même.

if (((*l_variable_courante).feuille = malloc(	if (((*l_variable_courante).feuille = allocation_feuille(
sizeof(struct_liste_variables))) == NULL)	s_etat_processus)) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(d_erreur);	return(d_erreur);
}	}

	(*l_variable_courante).noeuds_utilises++;

((l_variable_courante).feuille).suivant =	((l_variable_courante).feuille).suivant =
(*l_variable_courante).feuille;	(*l_variable_courante).feuille;
((l_variable_courante).feuille).precedent =	((l_variable_courante).feuille).precedent =
Line 351 ajout_variable(struct_processus *s_etat_	Line 544 ajout_variable(struct_processus *s_etat_
// Allocation de la variable sur l'élément de la liste.	// Allocation de la variable sur l'élément de la liste.

if ((((l_variable_courante).feuille).variable =	if ((((l_variable_courante).feuille).variable =
malloc(sizeof(struct_variable))) == NULL)	allocation_variable(s_etat_processus)) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(d_erreur);	return(d_erreur);
Line 363 ajout_variable(struct_processus *s_etat_	Line 556 ajout_variable(struct_processus *s_etat_
}	}
else	else
{	{
if ((l_nouvelle_variable = malloc(sizeof(struct_liste_variables)))	if ((l_nouvelle_variable = allocation_feuille(s_etat_processus))
== NULL)	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 380 ajout_variable(struct_processus *s_etat_	Line 573 ajout_variable(struct_processus *s_etat_

BUG((((*l_variable_courante).feuille).variable).niveau >=	BUG((((*l_variable_courante).feuille).variable).niveau >=
(*s_variable).niveau,	(*s_variable).niveau,
printf("Variable=\"%s\"\n", (*s_variable).nom));	uprintf("Variable=\"%s\"\n", (*s_variable).nom));

// On ajoute la variable à la liste existante.	// On ajoute la variable à la liste existante.

Line 396 ajout_variable(struct_processus *s_etat_	Line 589 ajout_variable(struct_processus *s_etat_
(*l_variable_courante).feuille = l_nouvelle_variable;	(*l_variable_courante).feuille = l_nouvelle_variable;

if ((((l_variable_courante).feuille).variable =	if ((((l_variable_courante).feuille).variable =
malloc(sizeof(struct_variable))) == NULL)	allocation_variable(s_etat_processus)) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(d_erreur);	return(d_erreur);
Line 420 ajout_variable(struct_processus *s_etat_	Line 613 ajout_variable(struct_processus *s_etat_

BUG(((l_variable_candidate).variable).niveau ==	BUG(((l_variable_candidate).variable).niveau ==
(*s_variable).niveau,	(*s_variable).niveau,
printf("Variable=\"%s\"\n", (*s_variable).nom));	uprintf("Variable=\"%s\"\n", (*s_variable).nom));

l_variable_candidate = (*l_variable_candidate).precedent;	l_variable_candidate = (*l_variable_candidate).precedent;
} while((l_variable_candidate != (*l_variable_courante).feuille) &&	} while((l_variable_candidate != (*l_variable_courante).feuille) &&
(((l_variable_candidate).variable).niveau <= 1));	(((l_variable_candidate).variable).niveau <= 1));

	BUG((*s_variable).niveau == 0,
	uprintf("Attempt to create a level-0 variable!\n"));

if (((((l_variable_courante).feuille).precedent).variable)	if (((((l_variable_courante).feuille).precedent).variable)
.niveau > 1)	.niveau > 1)
{	{
// Ajout inconditionnel des variables de niveaux 0 et 1	// La variable précédente est de niveau strictement supérieur
	// à 1. Il ne peut donc y avoir aucune variable de niveau
	// inférieur ou égal à 1 puisque la boucle est triée.
	// On insère donc directement la variable en queue.
}	}
else	else
{	{
	// Le niveau de la variable précédente dans la boucle est
	// inférieur ou égal à 1.
l_variable_candidate = ((l_variable_courante).feuille)	l_variable_candidate = ((l_variable_courante).feuille)
.precedent;	.precedent;
}	}
Line 445 ajout_variable(struct_processus *s_etat_	Line 646 ajout_variable(struct_processus *s_etat_
((l_variable_candidate).precedent).suivant = l_nouvelle_variable;	((l_variable_candidate).precedent).suivant = l_nouvelle_variable;
(*l_variable_candidate).precedent = l_nouvelle_variable;	(*l_variable_candidate).precedent = l_nouvelle_variable;

	// Si la variable suivant la variable que l'on vient d'insérer
	// dans la boucle est de niveau 0, la variable insérée est par
	// construction de niveau 1 et il convient de modifier le
	// pointeur de feuille pointant sur l'élément de plus haut niveau
	// de la boucle.

	if ((((*l_nouvelle_variable).precedent).variable).niveau == 0)
	{
	((l_nouvelle_variable).noeud).feuille = l_nouvelle_variable;
	}

if (((*l_nouvelle_variable).variable =	if (((*l_nouvelle_variable).variable =
malloc(sizeof(struct_variable))) == NULL)	allocation_variable(s_etat_processus)) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(d_erreur);	return(d_erreur);
Line 465 ajout_variable(struct_processus *s_etat_	Line 677 ajout_variable(struct_processus *s_etat_
{	{
// Le niveau courant n'existe pas. Il est créé.	// Le niveau courant n'existe pas. Il est créé.

if ((l_nouvelle_variable = malloc(sizeof(struct_liste_variables)))	if ((l_nouvelle_variable = allocation_feuille(s_etat_processus))
== NULL)	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 481 ajout_variable(struct_processus *s_etat_	Line 693 ajout_variable(struct_processus *s_etat_

// Ajout de la variable en tête de la liste	// Ajout de la variable en tête de la liste

if ((l_nouvel_element = malloc(sizeof(struct_liste_chainee))) == NULL)	if ((l_nouvel_element = allocation_maillon(s_etat_processus)) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(d_erreur);	return(d_erreur);
Line 499 ajout_variable(struct_processus *s_etat_	Line 711 ajout_variable(struct_processus *s_etat_
{	{
// Le niveau courant n'existe pas. Il est créé.	// Le niveau courant n'existe pas. Il est créé.

if ((l_nouvelle_variable = malloc(sizeof(struct_liste_variables)))	if ((l_nouvelle_variable = allocation_feuille(s_etat_processus))
== NULL)	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 521 ajout_variable(struct_processus *s_etat_	Line 733 ajout_variable(struct_processus *s_etat_

// Ajout de la variable en tête de la liste	// Ajout de la variable en tête de la liste

if ((l_nouvel_element = malloc(sizeof(struct_liste_chainee))) == NULL)	if ((l_nouvel_element = allocation_maillon(s_etat_processus)) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(d_erreur);	return(d_erreur);
Line 561 ajout_variable(struct_processus *s_etat_	Line 773 ajout_variable(struct_processus *s_etat_

if (niveau_acceptable == d_faux)	if (niveau_acceptable == d_faux)
{	{
if ((l_nouvelle_variable = malloc(sizeof(struct_liste_variables)))	if ((l_nouvelle_variable = allocation_feuille(s_etat_processus))
== NULL)	== NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
Line 594 ajout_variable(struct_processus *s_etat_	Line 806 ajout_variable(struct_processus *s_etat_

// Ajout de la variable en tête de la liste l_variable_candidate.	// Ajout de la variable en tête de la liste l_variable_candidate.

if ((l_nouvel_element = malloc(sizeof(struct_liste_chainee))) == NULL)	if ((l_nouvel_element = allocation_maillon(s_etat_processus)) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(d_erreur);	return(d_erreur);
Line 608 ajout_variable(struct_processus *s_etat_	Line 820 ajout_variable(struct_processus *s_etat_
{	{
// Ajout de la variable en tête de la liste	// Ajout de la variable en tête de la liste

if ((l_nouvel_element = malloc(sizeof(struct_liste_chainee))) == NULL)	if ((l_nouvel_element = allocation_maillon(s_etat_processus)) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(d_erreur);	return(d_erreur);
Line 976 retrait_variable(struct_processus *s_eta	Line 1188 retrait_variable(struct_processus *s_eta
unsigned char *nom_variable, unsigned char type)	unsigned char *nom_variable, unsigned char type)
{	{
logical1 erreur;	logical1 erreur;
	logical1 variable_supprimee;

struct_arbre_variables *s_arbre_a_supprimer;	struct_arbre_variables *s_arbre_a_supprimer;
struct_arbre_variables *s_arbre_courant;	struct_arbre_variables *s_arbre_courant;
struct_arbre_variables *noeud_courant;

struct_liste_chainee *l_element_courant;	struct_liste_chainee *l_element_courant;
struct_liste_chainee *l_element_precedent;	struct_liste_chainee *l_element_precedent;
Line 989 retrait_variable(struct_processus *s_eta	Line 1201 retrait_variable(struct_processus *s_eta

unsigned long niveau;	unsigned long niveau;

	(*s_etat_processus).niveau_supprime = d_faux;

if (recherche_variable(s_etat_processus, nom_variable) == d_vrai)	if (recherche_variable(s_etat_processus, nom_variable) == d_vrai)
{	{
// Une variable correspondant au nom recherché est accessible.	// Une variable correspondant au nom recherché est accessible.
Line 1069 retrait_variable(struct_processus *s_eta	Line 1283 retrait_variable(struct_processus *s_eta

variable_a_supprimer = (*s_etat_processus)	variable_a_supprimer = (*s_etat_processus)
.pointeur_feuille_courante;	.pointeur_feuille_courante;
s_arbre_courant = (*variable_a_supprimer).noeud_pere;	s_arbre_courant = (*variable_a_supprimer).noeud;
noeud_courant = (*variable_a_supprimer).noeud;
(s_arbre_courant).noeuds[(noeud_courant).indice_tableau_pere]
= NULL;

BUG((*s_arbre_courant).noeuds_utilises == 0,	BUG((*s_arbre_courant).noeuds_utilises == 0,
uprintf("Freed node !\n"));	uprintf("Freed node !\n"));
(*s_arbre_courant).noeuds_utilises--;	(*s_arbre_courant).noeuds_utilises--;

	((((*variable_a_supprimer).noeud_pere).noeuds
	[((variable_a_supprimer).noeud).indice_tableau_pere]))
	.feuille = NULL;

while((*s_arbre_courant).noeuds_utilises == 0)	while((*s_arbre_courant).noeuds_utilises == 0)
{	{
s_arbre_a_supprimer = s_arbre_courant;	s_arbre_a_supprimer = s_arbre_courant;
Line 1085 retrait_variable(struct_processus *s_eta	Line 1299 retrait_variable(struct_processus *s_eta

if (s_arbre_courant == NULL)	if (s_arbre_courant == NULL)
{	{
free((*s_arbre_a_supprimer).noeuds);	liberation_tableau_noeuds(s_etat_processus,
free(s_arbre_a_supprimer);	(*s_arbre_a_supprimer).noeuds);
	liberation_noeud(s_etat_processus, s_arbre_a_supprimer);

	(*s_etat_processus).s_arbre_variables = NULL;
break;	break;
}	}

Line 1100 retrait_variable(struct_processus *s_eta	Line 1317 retrait_variable(struct_processus *s_eta
(s_arbre_courant).noeuds[(s_arbre_a_supprimer)	(s_arbre_courant).noeuds[(s_arbre_a_supprimer)
.indice_tableau_pere] = NULL;	.indice_tableau_pere] = NULL;

free((*s_arbre_a_supprimer).noeuds);	liberation_tableau_noeuds(s_etat_processus,
free(s_arbre_a_supprimer);	(*s_arbre_a_supprimer).noeuds);
	liberation_noeud(s_etat_processus, s_arbre_a_supprimer);

BUG((*s_arbre_courant).noeuds_utilises == 0,	BUG((*s_arbre_courant).noeuds_utilises == 0,
uprintf("Freed node !\n"));	uprintf("Freed node !\n"));
Line 1142 retrait_variable(struct_processus *s_eta	Line 1360 retrait_variable(struct_processus *s_eta
((s_etat_processus).pointeur_feuille_courante).suivant;	((s_etat_processus).pointeur_feuille_courante).suivant;
(*s_etat_processus).pointeur_variable_courante =	(*s_etat_processus).pointeur_variable_courante =
((s_etat_processus).pointeur_feuille_courante).variable;	((s_etat_processus).pointeur_feuille_courante).variable;

noeud_courant = NULL;
}	}

// Dans tous les cas, on retire la variable de la liste des variables	// Dans tous les cas, on retire la variable de la liste des variables
Line 1151 retrait_variable(struct_processus *s_eta	Line 1367 retrait_variable(struct_processus *s_eta

niveau = ((variable_a_supprimer).variable).niveau;	niveau = ((variable_a_supprimer).variable).niveau;
variables_par_niveau = (*s_etat_processus).l_liste_variables_par_niveau;	variables_par_niveau = (*s_etat_processus).l_liste_variables_par_niveau;
	variable_supprimee = d_faux;

if (variables_par_niveau != NULL)	if (variables_par_niveau != NULL)
{	{
Line 1188 retrait_variable(struct_processus *s_eta	Line 1405 retrait_variable(struct_processus *s_eta
(*l_element_courant).suivant;	(*l_element_courant).suivant;
}	}

free(l_element_courant);	liberation_maillon(s_etat_processus,
	l_element_courant);

	if ((*variables_par_niveau).liste == NULL)
	{
	(*s_etat_processus).niveau_supprime =
	d_vrai;

	if ((*s_etat_processus)
	.l_liste_variables_par_niveau
	== variables_par_niveau)
	{
	// On retire l'élément de la liste
	// pointé par
	// l_liste_variable_par_niveau

	(*s_etat_processus)
	.l_liste_variables_par_niveau =
	(*variables_par_niveau).suivant;
	}

	((variables_par_niveau).precedent)
	.suivant =
	(*variables_par_niveau).suivant;
	((variables_par_niveau).suivant)
	.precedent =
	(*variables_par_niveau)
	.precedent;
	liberation_feuille(s_etat_processus,
	variables_par_niveau);
	}

	variable_supprimee = d_vrai;
break;	break;
}	}

Line 1198 retrait_variable(struct_processus *s_eta	Line 1447 retrait_variable(struct_processus *s_eta
}	}
}	}

	if (variable_supprimee == d_vrai)
	{
	break;
	}

variables_par_niveau = (*variables_par_niveau).suivant;	variables_par_niveau = (*variables_par_niveau).suivant;

} while(variables_par_niveau != (*s_etat_processus)	} while(variables_par_niveau != (*s_etat_processus)
Line 1208 retrait_variable(struct_processus *s_eta	Line 1462 retrait_variable(struct_processus *s_eta

free(((variable_a_supprimer).variable).nom);	free(((variable_a_supprimer).variable).nom);
liberation(s_etat_processus, ((variable_a_supprimer).variable).objet);	liberation(s_etat_processus, ((variable_a_supprimer).variable).objet);
free((*variable_a_supprimer).variable);	liberation_variable(s_etat_processus, (*variable_a_supprimer).variable);
free(variable_a_supprimer);	liberation_feuille(s_etat_processus, variable_a_supprimer);

erreur = d_absence_erreur;	erreur = d_absence_erreur;

if (noeud_courant != NULL)
{
free((*noeud_courant).noeuds);
free(noeud_courant);
}
}	}
else	else
{	{
Line 1280 retrait_variable_par_niveau(struct_proce	Line 1528 retrait_variable_par_niveau(struct_proce
while(((s_etat_processus).l_liste_variables_par_niveau).liste	while(((s_etat_processus).l_liste_variables_par_niveau).liste
!= NULL)	!= NULL)
{	{
	// Nécessaire car le pointeur sur la tête de la pile
	// peut être modifié par retrait_variable().
// Sauvegarde des variables statiques.	// Sauvegarde des variables statiques.

if ((((struct_variable ) (((*s_etat_processus)	if ((((struct_variable ) (((*s_etat_processus)
Line 1367 retrait_variable_par_niveau(struct_proce	Line 1617 retrait_variable_par_niveau(struct_proce
{	{
return(d_erreur);	return(d_erreur);
}	}

	if ((((struct_variable ) (((*s_etat_processus)
	.l_liste_variables_par_niveau).liste).donnee)).niveau
	<= (*s_etat_processus).niveau_courant)
	{
	// On a retiré de l'arbre des variables toutes les
	// variables de niveau strictement supérieur au niveau
	// courant.

	return(d_absence_erreur);
	}
}	}
}	}

Line 1381 retrait_variable_par_niveau(struct_proce	Line 1642 retrait_variable_par_niveau(struct_proce
.l_liste_variables_par_niveau;	.l_liste_variables_par_niveau;
(*s_etat_processus).l_liste_variables_par_niveau =	(*s_etat_processus).l_liste_variables_par_niveau =
(*l_element_a_supprimer).suivant;	(*l_element_a_supprimer).suivant;
free(l_element_a_supprimer);	liberation_feuille(s_etat_processus, l_element_a_supprimer);
}	}

return(d_absence_erreur);	return(d_absence_erreur);
Line 1417 liberation_arbre_variables(struct_proces	Line 1678 liberation_arbre_variables(struct_proces
// pas détruit par cette opération, il sera détruit lors de la libération	// pas détruit par cette opération, il sera détruit lors de la libération
// de la liste des variables par niveau.	// de la liste des variables par niveau.

	if (arbre == NULL)
	{
	return;
	}

l_element_courant = (*arbre).feuille;	l_element_courant = (*arbre).feuille;

if (l_element_courant != NULL)	if (l_element_courant != NULL)
Line 1424 liberation_arbre_variables(struct_proces	Line 1690 liberation_arbre_variables(struct_proces
do	do
{	{
l_element_suivant = (*l_element_courant).suivant;	l_element_suivant = (*l_element_courant).suivant;
free(l_element_courant);	liberation_feuille(s_etat_processus, l_element_courant);
l_element_courant = l_element_suivant;	l_element_courant = l_element_suivant;
} while(l_element_courant != (*arbre).feuille);	} while(l_element_courant != (*arbre).feuille);

	(*arbre).feuille = NULL;
}	}

for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)	for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
Line 1435 liberation_arbre_variables(struct_proces	Line 1703 liberation_arbre_variables(struct_proces
{	{
liberation_arbre_variables(s_etat_processus, (*arbre).noeuds[i],	liberation_arbre_variables(s_etat_processus, (*arbre).noeuds[i],
retrait_definitions);	retrait_definitions);
	(*arbre).noeuds[i] = NULL;
}	}
}	}

Line 1460 liberation_arbre_variables(struct_proces	Line 1729 liberation_arbre_variables(struct_proces
(*l_element_courant_liste).donnee)).objet);	(*l_element_courant_liste).donnee)).objet);
free((((struct_variable ) (*l_element_courant_liste)	free((((struct_variable ) (*l_element_courant_liste)
.donnee)).nom);	.donnee)).nom);
free((*l_element_courant_liste).donnee);
}	}

l_element_suivant_liste =	l_element_suivant_liste =
(*l_element_courant_liste).suivant;	(*l_element_courant_liste).suivant;
free(l_element_courant_liste);	liberation_variable(s_etat_processus, (struct_variable *)
	(*l_element_courant_liste).donnee);
	liberation_maillon(s_etat_processus,
	l_element_courant_liste);
l_element_courant_liste = l_element_suivant_liste;	l_element_courant_liste = l_element_suivant_liste;
}	}

l_element_suivant = (*l_element_courant).suivant;	l_element_suivant = (*l_element_courant).suivant;
free(l_element_courant);	liberation_feuille(s_etat_processus, l_element_courant);
l_element_courant = l_element_suivant;	l_element_courant = l_element_suivant;
} while(l_element_courant != (*s_etat_processus)	} while(l_element_courant != (*s_etat_processus)
.l_liste_variables_par_niveau);	.l_liste_variables_par_niveau);
}	}
}	}

free((*arbre).noeuds);	liberation_tableau_noeuds(s_etat_processus, (*arbre).noeuds);
free(arbre);	liberation_noeud(s_etat_processus, arbre);
	arbre = NULL;

return;	return;
}	}
Line 1573 liste_variables(struct_processus *s_etat	Line 1845 liste_variables(struct_processus *s_etat
return(position);	return(position);
}	}


/*	/*
================================================================================	================================================================================
Procédure de copie de l'arbre des variables	Procédure de copie de l'arbre des variables
Line 1585 liste_variables(struct_processus *s_etat	Line 1858 liste_variables(struct_processus *s_etat
================================================================================	================================================================================
*/	*/

struct_arbre_variables *	void
copie_arbre_variables(struct_processus *s_etat_processus)	copie_arbre_variables(struct_processus *s_etat_processus, struct_processus
	*s_nouvel_etat_processus)
{	{
// Les définitions sont partagées entre tous les threads et ne sont pas	// Les définitions sont partagées entre tous les threads et ne sont pas
// copiées.	// copiées.
//	//
// NB : on ne copie que les variables de niveaux 0 et 1, les autres	// NB : on ne copie que les variables de niveaux 0 et 1, les autres
// variables locales étant masquées par le processus de création de thread	// variables locales étant masquées par le processus de création de thread
// ou de processus, elles sont inaccessibles.	// ou de processus, elles seront inaccessibles de tous les points
	// du fil d'exécution fils.

BUG(1, uprintf("Oops !\n"));	// Pour copier ces variables, on récupère les variables depuis la liste par
	// niveaux (niveaux 0 et 1) et on ajoute les variables dans la nouvelle
	// structure. Les variables de niveau 0 étant non modifiables, elles
	// ne sont pas dupliquées.

return(d_absence_erreur);	int i;

	logical1 niveau_0_traite;
	logical1 niveau_1_traite;

	struct_liste_chainee *l_element_courant;

	struct_liste_variables *l_niveau_courant;

	struct_variable s_variable;

	(*s_nouvel_etat_processus).s_arbre_variables = NULL;
	(*s_nouvel_etat_processus).l_liste_variables_par_niveau = NULL;

	l_niveau_courant = (*s_etat_processus).l_liste_variables_par_niveau;

	// Si la variable en tête n'est pas une variable de niveau 0, le niveau
	// 0, s'il existe est le niveau précédent la valeur courante dans la
	// boucle.

	if ((((struct_variable ) ((l_niveau_courant).liste).donnee)).niveau
	!= 0)
	{
	l_niveau_courant = (*l_niveau_courant).precedent;
	}

	// Les variables de niveaux 0 et 1 sont accessibles en au plus trois
	// itérations (par construction).

	niveau_0_traite = d_faux;
	niveau_1_traite = d_faux;

	for(i = 0; i <= 2; i++)
	{
	if ((((struct_variable ) ((l_niveau_courant).liste)
	.donnee)).niveau == 0)
	{
	if (niveau_0_traite == d_faux)
	{
	l_element_courant = (*l_niveau_courant).liste;

	while(l_element_courant != NULL)
	{
	if (ajout_variable(s_nouvel_etat_processus,
	(struct_variable ) (l_element_courant).donnee)
	== d_erreur)
	{
	return;
	}

	l_element_courant = (*l_element_courant).suivant;
	}

	niveau_0_traite = d_vrai;
	}
	}
	else if ((((struct_variable ) ((l_niveau_courant).liste)
	.donnee)).niveau == 1)
	{
	if (niveau_1_traite == d_faux)
	{
	l_element_courant = (*l_niveau_courant).liste;

	while(l_element_courant != NULL)
	{
	s_variable = (((struct_variable )
	(*l_element_courant).donnee));

	if ((s_variable.nom = strdup((((struct_variable )
	(*l_element_courant).donnee)).nom)) == NULL)
	{
	(*s_nouvel_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	return;
	}

	if ((s_variable.objet = copie_objet(s_nouvel_etat_processus,
	(((struct_variable ) (*l_element_courant).donnee))
	.objet, 'P')) == NULL)
	{
	(*s_nouvel_etat_processus).erreur_systeme =
	d_es_allocation_memoire;
	return;
	}

	if (ajout_variable(s_nouvel_etat_processus, &s_variable)
	== d_erreur)
	{
	return;
	}

	l_element_courant = (*l_element_courant).suivant;
	}

	niveau_1_traite = d_vrai;
	}

	// Les variables de niveau 0 ayant déjà été copiées, on
	// peut sortir de la boucle car toutes les variables sont
	// maintenant disponibles dans le fil d'exécution fils.

	break;
	}

	l_niveau_courant = (*l_niveau_courant).precedent;
	}

	return;
}	}

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.33
changed lines
	Added in v.1.52