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.29 and 1.32

version 1.29, 2011/06/09 14:48:36	version 1.32, 2011/06/17 08:47:43
Line 53 ajout_variable(struct_processus *s_etat_	Line 53 ajout_variable(struct_processus *s_etat_

unsigned char *ptr;	unsigned char *ptr;

	void *pointeur_variable_cree;

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 =
Line 64 ajout_variable(struct_processus *s_etat_	Line 66 ajout_variable(struct_processus *s_etat_

((s_etat_processus).s_arbre_variables).feuille = NULL;	((s_etat_processus).s_arbre_variables).feuille = NULL;
((s_etat_processus).s_arbre_variables).noeuds_utilises = 0;	((s_etat_processus).s_arbre_variables).noeuds_utilises = 0;
	((s_etat_processus).s_arbre_variables).indice_tableau_pere = -1;
((s_etat_processus).s_arbre_variables).noeud_pere = NULL;	((s_etat_processus).s_arbre_variables).noeud_pere = NULL;

if ((((s_etat_processus).arbre_instructions).noeud =	if ((((s_etat_processus).s_arbre_variables).noeuds =
malloc((*s_etat_processus).nombre_caracteres_variables	malloc((*s_etat_processus).nombre_caracteres_variables
* sizeof(struct_arbre_variables))) == NULL)	* sizeof(struct_arbre_variables))) == NULL)
{	{
Line 93 ajout_variable(struct_processus *s_etat_	Line 96 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]] == NULL)	.pointeurs_caracteres_variables[*ptr]] == NULL)
{	{
// Le noeud n'existe pas encore, on le crée.	// Le noeud n'existe pas encore, on le crée et on le marque
	// comme utilisé dans la structure parente.

if (((l_variable_courante).noeuds[(s_etat_processus)	if (((l_variable_courante).noeuds[(s_etat_processus)
.pointeurs_caracteres_variables[*ptr]] =	.pointeurs_caracteres_variables[*ptr]] =
Line 104 ajout_variable(struct_processus *s_etat_	Line 108 ajout_variable(struct_processus *s_etat_
}	}

(*l_variable_courante).noeuds_utilises++;	(*l_variable_courante).noeuds_utilises++;

	// La feuille est par défaut vide et aucun élément du tableau noeuds
	// (les branches qui peuvent être issues de ce nouveau noeud)
	// n'est encore utilisée.

((l_variable_courante).noeuds[(*s_etat_processus)	((l_variable_courante).noeuds[(*s_etat_processus)
.pointeurs_caracteres_variables[*ptr]]).feuille = NULL;	.pointeurs_caracteres_variables[*ptr]]).feuille = NULL;
((l_variable_courante).noeuds[(*s_etat_processus)	((l_variable_courante).noeuds[(*s_etat_processus)
.pointeurs_caracteres_variables[*ptr]]).noeuds_utilises = 0;	.pointeurs_caracteres_variables[*ptr]]).noeuds_utilises = 0;

	// Le champ noeud_pere de la structure créée pointe sur
	// la structure parente et l'indice tableau_pere correspond à la
	// position réelle dans le tableau noeuds[] de la structure parente
	// du noeud courant. Cette valeur sera utilisée lors de la
	// destruction du noeud pour annuler le pointeur contenu dans
	// le tableau noeuds[] de la structure parente.

((l_variable_courante).noeuds[(*s_etat_processus)	((l_variable_courante).noeuds[(*s_etat_processus)
.pointeurs_caracteres_variables[*ptr]]).noeud_pere =	.pointeurs_caracteres_variables[*ptr]]).noeud_pere =
l_variable_precedente;	l_variable_courante;
	((l_variable_courante).noeuds[(*s_etat_processus)
	.pointeurs_caracteres_variables[*ptr]])
	.indice_tableau_pere = (*s_etat_processus)
	.pointeurs_caracteres_variables[*ptr];

	// Allocation du tableau noeuds[] et initialisation à zéro de
	// tous les pointeurs.

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 =
Line 154 ajout_variable(struct_processus *s_etat_	Line 178 ajout_variable(struct_processus *s_etat_
((l_variable_courante).feuille).precedent =	((l_variable_courante).feuille).precedent =
(*l_variable_courante).feuille;	(*l_variable_courante).feuille;
((l_variable_courante).feuille).noeud_pere = l_variable_precedente;	((l_variable_courante).feuille).noeud_pere = l_variable_precedente;
	((l_variable_courante).feuille).noeud = l_variable_courante;

// Allocation de la variable sur l'élément de la liste.	// Allocation de la variable sur l'élément de la liste.

Line 166 ajout_variable(struct_processus *s_etat_	Line 191 ajout_variable(struct_processus *s_etat_

(((struct_variable ) ((l_variable_courante).feuille).variable)) =	(((struct_variable ) ((l_variable_courante).feuille).variable)) =
(*s_variable);	(*s_variable);
	pointeur_variable_cree = ((l_variable_courante).feuille).variable;
if (((((struct_variable ) ((l_variable_courante).feuille).variable))
.nom = strdup((*s_variable).nom)) == NULL)
{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(d_erreur);
}
}	}
else	else
{	{
Line 216 ajout_variable(struct_processus *s_etat_	Line 235 ajout_variable(struct_processus *s_etat_

(((struct_variable ) ((l_variable_courante).feuille).variable))	(((struct_variable ) ((l_variable_courante).feuille).variable))
= (*s_variable);	= (*s_variable);
	pointeur_variable_cree = ((l_variable_courante).feuille).variable;
if (((((struct_variable ) ((l_variable_courante).feuille)
.variable)).nom = strdup((*s_variable).nom)) == NULL)
{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(d_erreur);
}
}	}
else	else
{	{
Line 270 ajout_variable(struct_processus *s_etat_	Line 283 ajout_variable(struct_processus *s_etat_
}	}

((l_nouvelle_variable).variable) = (*s_variable);	((l_nouvelle_variable).variable) = (*s_variable);
	pointeur_variable_cree = (*l_nouvelle_variable).variable;
if ((((l_nouvelle_variable).variable).nom =
strdup((*s_variable).nom)) == NULL)
{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(d_erreur);
}
}	}
}	}

Line 298 ajout_variable(struct_processus *s_etat_	Line 305 ajout_variable(struct_processus *s_etat_
(*l_nouvelle_variable).suivant = l_nouvelle_variable;	(*l_nouvelle_variable).suivant = l_nouvelle_variable;
(*l_nouvelle_variable).precedent = l_nouvelle_variable;	(*l_nouvelle_variable).precedent = l_nouvelle_variable;
(*l_nouvelle_variable).noeud_pere = NULL;	(*l_nouvelle_variable).noeud_pere = NULL;
	(*l_nouvelle_variable).liste = NULL;

(*s_etat_processus).l_liste_variables_par_niveau = l_nouvelle_variable;	(*s_etat_processus).l_liste_variables_par_niveau = l_nouvelle_variable;
}	}
Line 319 ajout_variable(struct_processus *s_etat_	Line 327 ajout_variable(struct_processus *s_etat_
(l_nouvelle_variable).precedent = ((*s_etat_processus)	(l_nouvelle_variable).precedent = ((*s_etat_processus)
.l_liste_variables_par_niveau).precedent;	.l_liste_variables_par_niveau).precedent;
(*l_nouvelle_variable).noeud_pere = NULL;	(*l_nouvelle_variable).noeud_pere = NULL;
	(*l_nouvelle_variable).liste = NULL;
(((*s_etat_processus).l_liste_variables_par_niveau).precedent)	(((*s_etat_processus).l_liste_variables_par_niveau).precedent)
.suivant = l_nouvelle_variable;	.suivant = l_nouvelle_variable;
((s_etat_processus).l_liste_variables_par_niveau).precedent =	((s_etat_processus).l_liste_variables_par_niveau).precedent =
Line 326 ajout_variable(struct_processus *s_etat_	Line 335 ajout_variable(struct_processus *s_etat_

(*s_etat_processus).l_liste_variables_par_niveau = l_nouvelle_variable;	(*s_etat_processus).l_liste_variables_par_niveau = l_nouvelle_variable;
}	}
else	else if ((*s_variable).niveau <= 1)
{	{
// Création d'une variable de niveau 0 ou 1	// Création d'une variable de niveau 0 ou 1

Line 341 ajout_variable(struct_processus *s_etat_	Line 350 ajout_variable(struct_processus *s_etat_

if ((((struct_variable ) ((((s_etat_processus)	if ((((struct_variable ) ((((s_etat_processus)
.l_liste_variables_par_niveau).precedent).liste).donnee))	.l_liste_variables_par_niveau).precedent).liste).donnee))
.niveau > 1)	.niveau <= 1)
{
// Ajout inconditionnel des variables de niveaux 0 et 1
}
else
{	{
l_variable_candidate = ((s_etat_processus)	l_variable_candidate = ((s_etat_processus)
.l_liste_variables_par_niveau).precedent;	.l_liste_variables_par_niveau).precedent;
Line 355 ajout_variable(struct_processus *s_etat_	Line 360 ajout_variable(struct_processus *s_etat_
(l_nouvelle_variable).precedent = (l_variable_candidate)	(l_nouvelle_variable).precedent = (l_variable_candidate)
.precedent;	.precedent;
(*l_nouvelle_variable).noeud_pere = NULL;	(*l_nouvelle_variable).noeud_pere = NULL;
	(*l_nouvelle_variable).liste = NULL;
((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;
}	}
Line 369 ajout_variable(struct_processus *s_etat_	Line 375 ajout_variable(struct_processus *s_etat_

(l_nouvel_element).suivant = ((*s_etat_processus)	(l_nouvel_element).suivant = ((*s_etat_processus)
.l_liste_variables_par_niveau).liste;	.l_liste_variables_par_niveau).liste;
(l_nouvel_element).donnee = (struct_objet ) s_variable;	(*l_nouvel_element).donnee = pointeur_variable_cree;
(*l_nouvelle_variable).liste = l_nouvel_element;	((s_etat_processus).l_liste_variables_par_niveau).liste =
	l_nouvel_element;

return(d_absence_erreur);	return(d_absence_erreur);
}	}


logical1	logical1
creation_variable(struct_processus *s_etat_processus,	creation_variable(struct_processus *s_etat_processus,
struct_variable *s_variable,	struct_variable *s_variable,
Line 527 recherche_variable(struct_processus *s_e	Line 535 recherche_variable(struct_processus *s_e
if ((*s_etat_processus).s_arbre_variables == NULL)	if ((*s_etat_processus).s_arbre_variables == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_variable_introuvable;	(*s_etat_processus).erreur_systeme = d_es_variable_introuvable;
return d_faux;	return(d_faux);
}	}

l_variable_courante = (*s_etat_processus).s_arbre_variables;	l_variable_courante = (*s_etat_processus).s_arbre_variables;
Line 540 recherche_variable(struct_processus *s_e	Line 548 recherche_variable(struct_processus *s_e
if (pointeur < 0)	if (pointeur < 0)
{	{
// Caractère hors de l'alphabet des variables	// Caractère hors de l'alphabet des variables
return(d_erreur);
	(*s_etat_processus).erreur_systeme = d_es_variable_introuvable;
	return(d_faux);
}	}

if ((*l_variable_courante).noeuds[pointeur] == NULL)	if ((*l_variable_courante).noeuds[pointeur] == NULL)
{	{
// Le chemin de la variable candidate n'existe pas.	// Le chemin de la variable candidate n'existe pas.
return(d_erreur);	(*s_etat_processus).erreur_systeme = d_es_variable_introuvable;
	return(d_faux);
}	}

l_variable_courante = (*l_variable_courante).noeuds[pointeur];	l_variable_courante = (*l_variable_courante).noeuds[pointeur];
Line 564 recherche_variable(struct_processus *s_e	Line 575 recherche_variable(struct_processus *s_e
{	{
// Problème : la pile système est vide !	// Problème : la pile système est vide !
(*s_etat_processus).erreur_systeme = d_es_pile_vide;	(*s_etat_processus).erreur_systeme = d_es_pile_vide;
return(d_erreur);	return(d_faux);
}	}

while((*l_element_courant).retour_definition != 'Y')	while((*l_element_courant).retour_definition != 'Y')
Line 574 recherche_variable(struct_processus *s_e	Line 585 recherche_variable(struct_processus *s_e
if (l_element_courant == NULL)	if (l_element_courant == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_pile_vide;	(*s_etat_processus).erreur_systeme = d_es_pile_vide;
return(d_erreur);	return(d_faux);
}	}
}	}

Line 589 recherche_variable(struct_processus *s_e	Line 600 recherche_variable(struct_processus *s_e
((l_variable_courante).feuille).variable;	((l_variable_courante).feuille).variable;
(*s_etat_processus).pointeur_feuille_courante =	(*s_etat_processus).pointeur_feuille_courante =
(*l_variable_courante).feuille;	(*l_variable_courante).feuille;
return(d_absence_erreur);	return(d_vrai);
}	}
else	else
{	{
Line 623 recherche_variable(struct_processus *s_e	Line 634 recherche_variable(struct_processus *s_e
(*l_variable_courante).feuille;	(*l_variable_courante).feuille;
}	}

return(d_absence_erreur);	return(d_vrai);
}	}
}	}
}	}

return(d_erreur);	(*s_etat_processus).erreur_systeme = d_es_variable_introuvable;
	return(d_faux);
}	}


Line 725 retrait_variable(struct_processus *s_eta	Line 737 retrait_variable(struct_processus *s_eta

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 815 retrait_variable(struct_processus *s_eta	Line 828 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_pere;
	noeud_courant = (*variable_a_supprimer).noeud;

BUG((*s_arbre_courant).noeuds_utilises == 0,	BUG((*s_arbre_courant).noeuds_utilises == 0,
uprintf("Freed node !\n"));	uprintf("Freed node !\n"));
Line 825 retrait_variable(struct_processus *s_eta	Line 839 retrait_variable(struct_processus *s_eta
s_arbre_a_supprimer = s_arbre_courant;	s_arbre_a_supprimer = s_arbre_courant;
s_arbre_courant = (*s_arbre_courant).noeud_pere;	s_arbre_courant = (*s_arbre_courant).noeud_pere;

free((*s_arbre_a_supprimer).noeuds);
free(s_arbre_a_supprimer);

if (s_arbre_courant == NULL)	if (s_arbre_courant == NULL)
{	{
	free((*s_arbre_a_supprimer).noeuds);
	free(s_arbre_a_supprimer);
break;	break;
}	}

	// s_arbre_a_supprimer contient la structure de feuille qui
	// vient d'être libérée. Il s'agit maintenant
	// d'annuler le pointeur dans le tableau noeuds de la structure
	// pointée par noeud_pere, soit s_arbre_courant.

	BUG((*s_arbre_a_supprimer).indice_tableau_pere < 0,
	uprintf("Invalid pointer !\n"));
	(s_arbre_courant).noeuds[(s_arbre_a_supprimer)
	.indice_tableau_pere] = NULL;

	free((*s_arbre_a_supprimer).noeuds);
	free(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"));
(*s_arbre_courant).noeuds_utilises--;	(*s_arbre_courant).noeuds_utilises--;
Line 852 retrait_variable(struct_processus *s_eta	Line 878 retrait_variable(struct_processus *s_eta
(((*s_etat_processus).pointeur_feuille_courante).suivant)	(((*s_etat_processus).pointeur_feuille_courante).suivant)
.precedent = ((s_etat_processus)	.precedent = ((s_etat_processus)
.pointeur_feuille_courante).precedent;	.pointeur_feuille_courante).precedent;

	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 860 retrait_variable(struct_processus *s_eta	Line 888 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;

while(variables_par_niveau != NULL)	if (variables_par_niveau != NULL)
{	{
l_element_courant = (*variables_par_niveau).liste;	do

if (l_element_courant != NULL)
{	{
if ((((struct_variable ) (*l_element_courant).donnee)).niveau	l_element_courant = (*variables_par_niveau).liste;
== niveau)
{
// On parcourt le bon niveau.

l_element_precedent = NULL;

while(l_element_courant != NULL)	if (l_element_courant != NULL)
	{
	if ((((struct_variable ) (*l_element_courant).donnee))
	.niveau == niveau)
{	{
// Tant que l_element_courant est non nul, il reste des	// On parcourt le bon niveau.
// variables à explorer dans le niveau courant.
	l_element_precedent = NULL;

if ((*l_element_courant).donnee ==	while(l_element_courant != NULL)
(void ) (variable_a_supprimer).variable)
{	{
// On a trouvé la variable à supprimer.	// Tant que l_element_courant est non nul, il reste
	// des variables à explorer dans le niveau courant.

if (l_element_precedent == NULL)	if ((*l_element_courant).donnee ==
	(void ) (variable_a_supprimer).variable)
{	{
(*variables_par_niveau).liste =	// On a trouvé la variable à supprimer.
(*l_element_courant).suivant;
}	if (l_element_precedent == NULL)
else	{
{	(*variables_par_niveau).liste =
(*l_element_precedent).suivant =	(*l_element_courant).suivant;
(*l_element_courant).suivant;	}
	else
	{
	(*l_element_precedent).suivant =
	(*l_element_courant).suivant;
	}

	free(l_element_courant);
	break;
}	}
}

l_element_precedent = l_element_courant;	l_element_precedent = l_element_courant;
l_element_courant = (*l_element_courant).suivant;	l_element_courant = (*l_element_courant).suivant;
	}
}	}
}	}
}

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

	} while(variables_par_niveau != (*s_etat_processus)
	.l_liste_variables_par_niveau);
}	}

// Puis on libère le contenu de la variable.	// Puis on libère le contenu de la variable.

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);

erreur = d_absence_erreur;	erreur = d_absence_erreur;

	if (noeud_courant != NULL)
	{
	free((*noeud_courant).feuille);
	free((*noeud_courant).noeuds);
	free(noeud_courant);
	}
}	}
else	else
{	{
Line 940 retrait_variable(struct_processus *s_eta	Line 984 retrait_variable(struct_processus *s_eta
logical1	logical1
retrait_variable_par_niveau(struct_processus *s_etat_processus)	retrait_variable_par_niveau(struct_processus *s_etat_processus)
{	{
	struct_liste_variables *l_element_a_supprimer;

// Utilisation du champ (*s_etat_processus).liste_variables_par_niveau.	// Utilisation du champ (*s_etat_processus).liste_variables_par_niveau.
// La tête de la pile contient toujours les variables de plus haut niveau	// La tête de la pile contient toujours les variables de plus haut niveau
// créées.	// créées.

struct_liste_variables *l_niveau_suivant;

while((*s_etat_processus).l_liste_variables_par_niveau != NULL)	while((*s_etat_processus).l_liste_variables_par_niveau != NULL)
{	{
l_niveau_suivant = ((s_etat_processus).l_liste_variables_par_niveau)
.suivant;

if (((s_etat_processus).l_liste_variables_par_niveau).liste == NULL)	if (((s_etat_processus).l_liste_variables_par_niveau).liste == NULL)
{	{
// Si le niveau ne contient aucune variable, on le détruit.	// Si le niveau ne contient aucune variable, on le détruit.
Line 1065 retrait_variable_par_niveau(struct_proce	Line 1106 retrait_variable_par_niveau(struct_proce
}	}
}	}

free((*s_etat_processus).l_liste_variables_par_niveau);	// On retire l'élément de la liste doublement chaînée et circulaire.
(*s_etat_processus).l_liste_variables_par_niveau = l_niveau_suivant;
	(((*s_etat_processus).l_liste_variables_par_niveau).precedent).suivant
	= ((s_etat_processus).l_liste_variables_par_niveau).suivant;
	(((*s_etat_processus).l_liste_variables_par_niveau).suivant).precedent
	= ((s_etat_processus).l_liste_variables_par_niveau).precedent;

	l_element_a_supprimer = (*s_etat_processus)
	.l_liste_variables_par_niveau;
	(*s_etat_processus).l_liste_variables_par_niveau =
	(*l_element_a_supprimer).suivant;
	free(l_element_a_supprimer);
}	}

return(d_absence_erreur);	return(d_absence_erreur);
Line 1102 liberation_arbre_variables(struct_proces	Line 1153 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.

	l_element_courant = (*arbre).feuille;

	if (l_element_courant != NULL)
	{
	do
	{
	l_element_suivant = (*l_element_courant).suivant;
	free(l_element_courant);
	l_element_courant = l_element_suivant;
	} while(l_element_courant != (*arbre).feuille);
	}

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)
{	{
l_element_courant = (*arbre).feuille;

while(l_element_courant != NULL)
{
l_element_suivant = (*l_element_courant).suivant;
free(l_element_courant);
l_element_courant = l_element_suivant;
}

liberation_arbre_variables(s_etat_processus, (*arbre).noeuds[i],	liberation_arbre_variables(s_etat_processus, (*arbre).noeuds[i],
retrait_definitions);	retrait_definitions);
}	}
Line 1126 liberation_arbre_variables(struct_proces	Line 1180 liberation_arbre_variables(struct_proces
{	{
l_element_courant = (*s_etat_processus).l_liste_variables_par_niveau;	l_element_courant = (*s_etat_processus).l_liste_variables_par_niveau;

while(l_element_courant != NULL)	if (l_element_courant != NULL)
{	{
l_element_courant_liste = (*l_element_courant).liste;	do

while(l_element_courant_liste != NULL)
{	{
if ((retrait_definitions == d_vrai) \|\|	l_element_courant_liste = (*l_element_courant).liste;
((((struct_variable ) (*l_element_courant_liste)
.donnee)).niveau >= 1))	while(l_element_courant_liste != NULL)
{	{
liberation(s_etat_processus, (((struct_variable )	if ((retrait_definitions == d_vrai) \|\|
(*l_element_courant_liste).donnee)).objet);	((((struct_variable ) (*l_element_courant_liste)
free((((struct_variable ) (*l_element_courant_liste)	.donnee)).niveau >= 1))
.donnee)).nom);	{
free((*l_element_courant_liste).donnee);	liberation(s_etat_processus, (((struct_variable )
}	(*l_element_courant_liste).donnee)).objet);
	free((((struct_variable ) (*l_element_courant_liste)
	.donnee)).nom);
	free((*l_element_courant_liste).donnee);
	}

l_element_suivant_liste = (*l_element_courant_liste).suivant;	l_element_suivant_liste =
free(l_element_courant_liste);	(*l_element_courant_liste).suivant;
l_element_courant_liste = l_element_suivant_liste;	free(l_element_courant_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);	free(l_element_courant);
l_element_courant = l_element_suivant;	l_element_courant = l_element_suivant;
	} while(l_element_courant != (*s_etat_processus)
	.l_liste_variables_par_niveau);
}	}
}	}

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.29
changed lines
	Added in v.1.32