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.34

version 1.33, 2011/06/19 17:48:27	version 1.34, 2011/06/20 17:34:10
Line 50 liste_variables_par_niveaux(struct_proce	Line 50 liste_variables_par_niveaux(struct_proce
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;
c = 0;	c = 0;
Line 119 liste_variables_tas(struct_processus *s_	Line 125 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 184 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 341 ajout_variable(struct_processus *s_etat_	Line 371 ajout_variable(struct_processus *s_etat_
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 426 ajout_variable(struct_processus *s_etat_	Line 458 ajout_variable(struct_processus *s_etat_
} 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 485 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)	malloc(sizeof(struct_variable))) == NULL)
{	{
Line 976 retrait_variable(struct_processus *s_eta	Line 1027 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 1069 retrait_variable(struct_processus *s_eta	Line 1120 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;	s_arbre_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 1087 retrait_variable(struct_processus *s_eta	Line 1139 retrait_variable(struct_processus *s_eta
{	{
free((*s_arbre_a_supprimer).noeuds);	free((*s_arbre_a_supprimer).noeuds);
free(s_arbre_a_supprimer);	free(s_arbre_a_supprimer);

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

Line 1142 retrait_variable(struct_processus *s_eta	Line 1196 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 1203 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 1189 retrait_variable(struct_processus *s_eta	Line 1242 retrait_variable(struct_processus *s_eta
}	}

free(l_element_courant);	free(l_element_courant);

	if ((*variables_par_niveau).liste == NULL)
	{
	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;
	free(variables_par_niveau);
	}

	variable_supprimee = d_vrai;
break;	break;
}	}

Line 1198 retrait_variable(struct_processus *s_eta	Line 1278 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 1212 retrait_variable(struct_processus *s_eta	Line 1297 retrait_variable(struct_processus *s_eta
free(variable_a_supprimer);	free(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 1359 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 1448 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 1417 liberation_arbre_variables(struct_proces	Line 1509 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)

CVSweb interface <joel.bertrand@systella.fr>

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