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.39 and 1.40

version 1.39, 2011/06/21 15:26:29	version 1.40, 2011/06/22 12:48:30
Line 227 liste_variables_par_feuilles(struct_proc	Line 227 liste_variables_par_feuilles(struct_proc

/*	/*
================================================================================	================================================================================
	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;
	}


	/*
	================================================================================
Routine de création d'une nouvelle variable	Routine de création d'une nouvelle variable
================================================================================	================================================================================
Entrée : autorisation_creation_variable_statique vaut 'v' ou 's'.	Entrée : autorisation_creation_variable_statique vaut 'v' ou 's'.
Line 264 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 276 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 296 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 307 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 344 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 372 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);
Line 391 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 403 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 420 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 436 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 460 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) &&
Line 505 ajout_variable(struct_processus *s_etat_	Line 658 ajout_variable(struct_processus *s_etat_
}	}

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 524 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 540 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 558 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 580 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 620 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 653 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 667 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 1146 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;	(*s_etat_processus).s_arbre_variables = NULL;
break;	break;
Line 1163 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 1250 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)	if ((*variables_par_niveau).liste == NULL)
{	{
Line 1277 retrait_variable(struct_processus *s_eta	Line 1433 retrait_variable(struct_processus *s_eta
.precedent =	.precedent =
(*variables_par_niveau)	(*variables_par_niveau)
.precedent;	.precedent;
free(variables_par_niveau);	liberation_feuille(s_etat_processus,
	variables_par_niveau);
}	}

variable_supprimee = d_vrai;	variable_supprimee = d_vrai;
Line 1305 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;
}	}
Line 1485 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 1533 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);

Line 1576 liberation_arbre_variables(struct_proces	Line 1733 liberation_arbre_variables(struct_proces

l_element_suivant_liste =	l_element_suivant_liste =
(*l_element_courant_liste).suivant;	(*l_element_courant_liste).suivant;
free((*l_element_courant_liste).donnee);	liberation_variable(s_etat_processus, (struct_variable *)
free(l_element_courant_liste);	(*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;	arbre = NULL;

return;	return;

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.39
changed lines
	Added in v.1.40