version 1.75, 2011/11/26 10:01:26
|
version 1.88, 2012/10/05 13:12:38
|
Line 1
|
Line 1
|
/* |
/* |
================================================================================ |
================================================================================ |
RPL/2 (R) version 4.1.5 |
RPL/2 (R) version 4.1.11 |
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 544 allocation(struct_processus *s_etat_proc
|
Line 544 allocation(struct_processus *s_etat_proc
|
return(NULL); |
return(NULL); |
} |
} |
|
|
|
(*((struct_mutex *) (*s_objet).objet)).tid = pthread_self(); |
break; |
break; |
} |
} |
|
|
Line 1103 liberation(struct_processus *s_etat_proc
|
Line 1104 liberation(struct_processus *s_etat_proc
|
return; |
return; |
} |
} |
|
|
|
if (pthread_mutex_trylock(&((*((struct_mutex *) |
|
(*s_objet).objet)).mutex)) == 0) |
|
{ |
|
// On a pu verrouiller le mutex. Il faut donc spécifier le tid. |
|
(*((struct_mutex *) (*s_objet).objet)).tid = pthread_self(); |
|
} |
|
|
|
if (pthread_equal(pthread_self(), |
|
(*((struct_mutex *) (*s_objet).objet)).tid) != 0) |
|
{ |
|
pthread_mutex_unlock(&((*((struct_mutex *) |
|
(*s_objet).objet)).mutex)); |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_mutex_acquis_autre_thread; |
|
return; |
|
} |
|
|
|
pthread_mutex_destroy(&((*((struct_mutex *) |
|
(*s_objet).objet)).mutex)); |
free((struct_mutex *) (*s_objet).objet); |
free((struct_mutex *) (*s_objet).objet); |
break; |
break; |
} |
} |
Line 2218 copie_objet(struct_processus *s_etat_pro
|
Line 2241 copie_objet(struct_processus *s_etat_pro
|
{ |
{ |
// La duplication d'un mutex renvoie le même objet. |
// La duplication d'un mutex renvoie le même objet. |
incrementation_atomique(s_objet); |
incrementation_atomique(s_objet); |
break; |
return(s_objet); |
} |
} |
|
|
case NOM : |
case NOM : |
Line 2260 copie_objet(struct_processus *s_etat_pro
|
Line 2283 copie_objet(struct_processus *s_etat_pro
|
return(s_objet); |
return(s_objet); |
} |
} |
|
|
|
// Un objet de type NON est un objet encapsulé dans une |
|
// structure de type struct_objet. Elle peut très bien contenir |
|
// une donnée, mais c'est à l'utilisateur de la libérer |
|
// explicitement avec un free(). |
|
|
if ((s_nouvel_objet = allocation(s_etat_processus, NON)) == NULL) |
if ((s_nouvel_objet = allocation(s_etat_processus, NON)) == NULL) |
{ |
{ |
return(NULL); |
return(NULL); |
} |
} |
|
|
(*s_nouvel_objet).objet = NULL; |
(*s_nouvel_objet).objet = (*s_objet).objet; |
break; |
break; |
} |
} |
|
|
Line 2794 copie_etat_processus(struct_processus *s
|
Line 2822 copie_etat_processus(struct_processus *s
|
|
|
pthread_mutexattr_init(&attributs_mutex); |
pthread_mutexattr_init(&attributs_mutex); |
pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL); |
pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL); |
|
(*s_nouvel_etat_processus).sections_critiques = 0; |
|
|
// Les sémaphores sont initialisés dans le nouveau thread. Il |
// Les sémaphores sont initialisés dans le nouveau thread. Il |
// s'agit d'une limitation de l'implantation de l'émulation |
// s'agit d'une limitation de l'implantation de l'émulation |
Line 3091 copie_etat_processus(struct_processus *s
|
Line 3120 copie_etat_processus(struct_processus *s
|
} |
} |
|
|
/* |
/* |
* Copie de la table des variables statiques |
|
*/ |
|
|
|
if (((*s_nouvel_etat_processus).s_liste_variables_statiques = |
|
malloc((*s_etat_processus).nombre_variables_statiques_allouees * |
|
sizeof(struct_variable_statique))) == 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_statiques; i++) |
|
{ |
|
if (((*s_nouvel_etat_processus).s_liste_variables_statiques[i].nom = |
|
malloc((strlen((*s_etat_processus).s_liste_variables_statiques |
|
[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_statiques[i].nom, |
|
(*s_etat_processus).s_liste_variables_statiques[i].nom); |
|
|
|
(*s_nouvel_etat_processus).s_liste_variables_statiques[i].origine = |
|
(*s_etat_processus).s_liste_variables_statiques[i].origine; |
|
(*s_nouvel_etat_processus).s_liste_variables_statiques[i].niveau = |
|
(*s_etat_processus).s_liste_variables_statiques[i].niveau; |
|
(*s_nouvel_etat_processus).s_liste_variables_statiques[i] |
|
.variable_statique = (*s_etat_processus) |
|
.s_liste_variables_statiques[i].variable_statique; |
|
|
|
if (((*s_nouvel_etat_processus).s_liste_variables_statiques[i].objet = |
|
copie_objet(s_etat_processus, (*s_etat_processus) |
|
.s_liste_variables_statiques[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); |
|
} |
|
} |
|
|
|
/* |
|
* Copie de la pile opérationnelle |
* Copie de la pile opérationnelle |
*/ |
*/ |
|
|