rpl/src/gestion_objets.c - diff

Return to gestion_objets.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/gestion_objets.c between versions 1.41 and 1.66

version 1.41, 2010/09/14 16:21:21	version 1.66, 2011/09/14 14:34:28
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.0.19	RPL/2 (R) version 4.1.3
Copyright (C) 1989-2010 Dr. BERTRAND Joël	Copyright (C) 1989-2011 Dr. BERTRAND Joël

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

Line 57 decrementation_atomique(struct_objet *s_	Line 57 decrementation_atomique(struct_objet *s_
return((*s_objet).nombre_occurrences);	return((*s_objet).nombre_occurrences);
}	}

inline void	void
initialisation_objet(struct_objet *s_objet)	initialisation_objet(struct_objet *s_objet)
{	{
pthread_mutexattr_t attributs_mutex;	pthread_mutexattr_t attributs_mutex;
Line 111 initialisation_allocateur(struct_process	Line 111 initialisation_allocateur(struct_process
(*s_etat_processus).pointeur_vec = 0;	(*s_etat_processus).pointeur_vec = 0;
(*s_etat_processus).pointeur_maillons = 0;	(*s_etat_processus).pointeur_maillons = 0;

	(*s_etat_processus).pointeur_variables_noeud = 0;
	(*s_etat_processus).pointeur_variables_feuille = 0;
	(*s_etat_processus).pointeur_variables_variable = 0;
	(*s_etat_processus).pointeur_variables_tableau_noeuds = 0;

return;	return;
}	}

Line 143 liberation_allocateur(struct_processus *	Line 148 liberation_allocateur(struct_processus *
for(i = 0; i < (*s_etat_processus).pointeur_maillons;	for(i = 0; i < (*s_etat_processus).pointeur_maillons;
free((*s_etat_processus).maillons[i++]));	free((*s_etat_processus).maillons[i++]));

	for(i = 0; i < (*s_etat_processus).pointeur_variables_noeud;
	free((*s_etat_processus).variables_noeud[i++]));
	for(i = 0; i < (*s_etat_processus).pointeur_variables_feuille;
	free((*s_etat_processus).variables_feuille[i++]));
	for(i = 0; i < (*s_etat_processus).pointeur_variables_variable;
	free((*s_etat_processus).variables_variable[i++]));
	for(i = 0; i < (*s_etat_processus).pointeur_variables_tableau_noeuds;
	free((*s_etat_processus).variables_tableau_noeuds[i++]));

{	{
struct_liste_chainee *l_element_courant;	struct_liste_chainee *l_element_courant;
struct_liste_chainee *l_element_suivant;	struct_liste_chainee *l_element_suivant;
Line 234 allocation_maillon(struct_processus *s_e	Line 248 allocation_maillon(struct_processus *s_e

/*	/*
================================================================================	================================================================================
Routine d'allocation d'un maillon d'un objet (liste, expression...)	Routine de libération d'un maillon d'un objet (liste, expression...)
================================================================================	================================================================================
Entrées : structure sur l'état du processus et objet à afficher	Entrées : structure sur l'état du processus et objet à afficher
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Line 274 liberation_maillon(struct_processus *s_e	Line 288 liberation_maillon(struct_processus *s_e
================================================================================	================================================================================
*/	*/

void *	struct_objet *
allocation(struct_processus *s_etat_processus, enum t_type type)	allocation(struct_processus *s_etat_processus, enum t_type type)
{	{
struct_objet *s_objet;	struct_objet *s_objet;
Line 758 liberation(struct_processus *s_etat_proc	Line 772 liberation(struct_processus *s_etat_proc
{	{
logical1 drapeau;	logical1 drapeau;

sigset_t oldset;
sigset_t set;

struct_liste_chainee *l_element_courant;	struct_liste_chainee *l_element_courant;
struct_liste_chainee *l_element_suivant;	struct_liste_chainee *l_element_suivant;

Line 1130 liberation(struct_processus *s_etat_proc	Line 1141 liberation(struct_processus *s_etat_proc

case PRC :	case PRC :
{	{
sigfillset(&set);
pthread_sigmask(SIG_BLOCK, &set, &oldset);

if (pthread_mutex_lock(&(((((struct_processus_fils *)	if (pthread_mutex_lock(&(((((struct_processus_fils *)
(*s_objet).objet)).thread).mutex_nombre_references)) != 0)	(*s_objet).objet)).thread).mutex_nombre_references)) != 0)
{	{
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
Line 1166 liberation(struct_processus *s_etat_proc	Line 1171 liberation(struct_processus *s_etat_proc
if (pthread_mutex_unlock(&(((((struct_processus_fils *)	if (pthread_mutex_unlock(&(((((struct_processus_fils *)
(*s_objet).objet)).thread).mutex_nombre_references)) != 0)	(*s_objet).objet)).thread).mutex_nombre_references)) != 0)
{	{
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}

pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

if (drapeau == d_vrai)	if (drapeau == d_vrai)
{	{
pthread_mutex_destroy(&(((((struct_processus_fils *)	pthread_mutex_destroy(&(((((struct_processus_fils *)
Line 1513 struct_objet *	Line 1512 struct_objet *
copie_objet(struct_processus *s_etat_processus,	copie_objet(struct_processus *s_etat_processus,
struct_objet *s_objet, unsigned char type)	struct_objet *s_objet, unsigned char type)
{	{
sigset_t oldset;
sigset_t set;

struct_liste_chainee *l_element_base;	struct_liste_chainee *l_element_base;
struct_liste_chainee *l_element_courant;	struct_liste_chainee *l_element_courant;
struct_liste_chainee *l_element_courant_ecriture;	struct_liste_chainee *l_element_courant_ecriture;
Line 2286 copie_objet(struct_processus *s_etat_pro	Line 2282 copie_objet(struct_processus *s_etat_pro

case PRC :	case PRC :
{	{
sigfillset(&set);
pthread_sigmask(SIG_BLOCK, &set, &oldset);

if (pthread_mutex_lock(&(((((struct_processus_fils *)	if (pthread_mutex_lock(&(((((struct_processus_fils *)
(*s_objet).objet)).thread).mutex_nombre_references)) != 0)	(*s_objet).objet)).thread).mutex_nombre_references)) != 0)
{	{
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

return(NULL);	return(NULL);
}	}

Line 2304 copie_objet(struct_processus *s_etat_pro	Line 2294 copie_objet(struct_processus *s_etat_pro
if (pthread_mutex_unlock(&(((((struct_processus_fils *)	if (pthread_mutex_unlock(&(((((struct_processus_fils *)
(*s_objet).objet)).thread).mutex_nombre_references)) != 0)	(*s_objet).objet)).thread).mutex_nombre_references)) != 0)
{	{
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

return(NULL);	return(NULL);
}	}

pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

if (type != 'O')	if (type != 'O')
{	{
incrementation_atomique(s_objet);	incrementation_atomique(s_objet);
Line 2828 copie_etat_processus(struct_processus *s	Line 2812 copie_etat_processus(struct_processus *s
}	}
# endif	# endif

	initialisation_contexte_cas(s_etat_processus);

(*s_nouvel_etat_processus).var_volatile_processus_pere = 0;	(*s_nouvel_etat_processus).var_volatile_processus_pere = 0;
(*s_nouvel_etat_processus).var_volatile_processus_racine = 0;	(*s_nouvel_etat_processus).var_volatile_processus_racine = 0;
(*s_nouvel_etat_processus).fichiers_graphiques = NULL;	(*s_nouvel_etat_processus).fichiers_graphiques = NULL;
Line 2841 copie_etat_processus(struct_processus *s	Line 2827 copie_etat_processus(struct_processus *s
(*s_nouvel_etat_processus).processus_detache = d_faux;	(*s_nouvel_etat_processus).processus_detache = d_faux;
(*s_nouvel_etat_processus).evaluation_forcee = 'N';	(*s_nouvel_etat_processus).evaluation_forcee = 'N';

	(*s_nouvel_etat_processus).compteur_violation_d_acces = 0;

(*s_nouvel_etat_processus).nombre_objets_envoyes_non_lus = 0;	(*s_nouvel_etat_processus).nombre_objets_envoyes_non_lus = 0;
(*s_nouvel_etat_processus).nombre_objets_injectes = 0;	(*s_nouvel_etat_processus).nombre_objets_injectes = 0;
(*s_nouvel_etat_processus).presence_fusible = d_faux;	(*s_nouvel_etat_processus).presence_fusible = d_faux;
Line 3110 copie_etat_processus(struct_processus *s	Line 3098 copie_etat_processus(struct_processus *s
* Copie de la table des variables	* Copie de la table des variables
*/	*/

if (((*s_nouvel_etat_processus).s_liste_variables =	copie_arbre_variables(s_etat_processus, s_nouvel_etat_processus);
malloc((s_etat_processus).nombre_variables_allouees
sizeof(struct_variable))) == NULL)
{
if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
return(NULL);
}

(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);
}

for(i = 0; i < (*s_etat_processus).nombre_variables; i++)	if ((*s_nouvel_etat_processus).erreur_systeme != d_es)
{	{
if (((*s_nouvel_etat_processus).s_liste_variables[i].nom =	return(NULL);
malloc((strlen((*s_etat_processus).s_liste_variables[i].nom)
+ 1) * sizeof(unsigned char))) == NULL)
{
if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
return(NULL);
}

(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);
}

strcpy((*s_nouvel_etat_processus).s_liste_variables[i].nom,
(*s_etat_processus).s_liste_variables[i].nom);

(*s_nouvel_etat_processus).s_liste_variables[i].origine =
(*s_etat_processus).s_liste_variables[i].origine;
(*s_nouvel_etat_processus).s_liste_variables[i].niveau =
(*s_etat_processus).s_liste_variables[i].niveau;
(*s_nouvel_etat_processus).s_liste_variables[i].variable_statique =
(*s_etat_processus).s_liste_variables[i].variable_statique;
(*s_nouvel_etat_processus).s_liste_variables[i].variable_partagee =
(*s_etat_processus).s_liste_variables[i].variable_partagee;
(*s_nouvel_etat_processus).s_liste_variables[i].variable_verrouillee =
(*s_etat_processus).s_liste_variables[i].variable_verrouillee;

// Les définitions sont partagées entre tous les threads.

if ((*s_etat_processus).s_liste_variables[i].niveau == 0)
{
(*s_nouvel_etat_processus).s_liste_variables[i].objet =
(*s_etat_processus).s_liste_variables[i].objet;
}
else
{
if (((*s_nouvel_etat_processus).s_liste_variables[i].objet =
copie_objet(s_etat_processus,
(*s_etat_processus).s_liste_variables[i]
.objet, 'P')) == NULL)
{
if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)
{
(*s_etat_processus).erreur_systeme = d_es_processus;
return(NULL);
}

(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);
}
}
}	}

/*	/*
Line 3347 copie_etat_processus(struct_processus *s	Line 3272 copie_etat_processus(struct_processus *s
* Copie des différents contextes	* Copie des différents contextes
*/	*/

	(*s_nouvel_etat_processus).pointeur_signal_lecture = d_faux;
	(*s_nouvel_etat_processus).pointeur_signal_ecriture = d_faux;

(*s_nouvel_etat_processus).l_base_pile_contextes = NULL;	(*s_nouvel_etat_processus).l_base_pile_contextes = NULL;
l_element_lecture = (*s_etat_processus).l_base_pile_contextes;	l_element_lecture = (*s_etat_processus).l_base_pile_contextes;

Line 4023 debug_fork()	Line 3951 debug_fork()

if (pid == 0)	if (pid == 0)
{	{
# ifdef _BROKEN_SIGINFO	liberation_queue_signaux(s_etat_processus);
liberation_fifos_signaux(s_etat_processus);	creation_queue_signaux(s_etat_processus);
creation_fifos_signaux(s_etat_processus);
# endif

pthread_mutex_destroy(&mutex_allocation);	pthread_mutex_destroy(&mutex_allocation);
debug_memoire_initialisation();	debug_memoire_initialisation();

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.41
changed lines
	Added in v.1.66