version 1.37, 2011/11/26 13:05:03
|
version 1.86, 2025/04/15 10:17:54
|
Line 1
|
Line 1
|
/* |
/* |
================================================================================ |
================================================================================ |
RPL/2 (R) version 4.1.5 |
RPL/2 (R) version 4.1.36 |
Copyright (C) 1989-2011 Dr. BERTRAND Joël |
Copyright (C) 1989-2025 Dr. BERTRAND Joël |
|
|
This file is part of RPL/2. |
This file is part of RPL/2. |
|
|
Line 38
|
Line 38
|
void |
void |
instruction_mem(struct_processus *s_etat_processus) |
instruction_mem(struct_processus *s_etat_processus) |
{ |
{ |
int j; |
integer8 j; |
int nb_variables; |
integer8 nb_variables; |
|
|
struct_liste_chainee *l_element_courant; |
struct_liste_chainee *l_element_courant; |
|
|
Line 47 instruction_mem(struct_processus *s_etat
|
Line 47 instruction_mem(struct_processus *s_etat
|
|
|
struct_tableau_variables *tableau; |
struct_tableau_variables *tableau; |
|
|
unsigned long i; |
|
|
|
(*s_etat_processus).erreur_execution = d_ex; |
(*s_etat_processus).erreur_execution = d_ex; |
|
|
if ((*s_etat_processus).affichage_arguments == 'Y') |
if ((*s_etat_processus).affichage_arguments == 'Y') |
Line 144 instruction_mem(struct_processus *s_etat
|
Line 142 instruction_mem(struct_processus *s_etat
|
(*((integer8 *) (*((*((*((struct_liste_chainee *) |
(*((integer8 *) (*((*((*((struct_liste_chainee *) |
(*s_objet_resultat).objet)).suivant)).donnee)).objet)) = 0; |
(*s_objet_resultat).objet)).suivant)).donnee)).objet)) = 0; |
|
|
nb_variables = nombre_variables(s_etat_processus, |
nb_variables = nombre_variables(s_etat_processus); |
(*s_etat_processus).s_arbre_variables); |
|
|
|
if ((tableau = malloc(nb_variables * sizeof(struct_tableau_variables))) |
if ((tableau = malloc(((size_t) nb_variables) * |
== NULL) |
sizeof(struct_tableau_variables))) == NULL) |
{ |
{ |
|
liberation_mutexes_arbre_variables_partagees(s_etat_processus, |
|
(*(*s_etat_processus).s_arbre_variables_partagees)); |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
return; |
return; |
} |
} |
|
|
liste_variables(s_etat_processus, tableau, 0, |
nb_variables = liste_variables(s_etat_processus, tableau); |
(*s_etat_processus).s_arbre_variables); |
|
|
|
for(j = 0; j < nb_variables; j++) |
for(j = 0; j < nb_variables; j++) |
{ |
{ |
(*((integer8 *) (*((*((*((struct_liste_chainee *) (*s_objet_resultat) |
(*((integer8 *) (*((*((*((struct_liste_chainee *) (*s_objet_resultat) |
.objet)).suivant)).donnee)).objet)) += sizeof(unsigned char) * |
.objet)).suivant)).donnee)).objet)) += (integer8) |
strlen(tableau[j].nom); |
(sizeof(unsigned char) * strlen(tableau[j].nom)); |
(*((integer8 *) (*((*((*((struct_liste_chainee *) (*s_objet_resultat) |
(*((integer8 *) (*((*((*((struct_liste_chainee *) (*s_objet_resultat) |
.objet)).suivant)).donnee)).objet)) += occupation_memoire( |
.objet)).suivant)).donnee)).objet)) += occupation_memoire( |
tableau[j].objet); |
tableau[j].objet); |
} |
|
|
|
free(tableau); |
if(tableau[j].mutex != NULL) |
|
{ // La variable est une variable partagée. On libère le mutex. |
for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++) |
pthread_mutex_unlock(tableau[j].mutex); |
{ |
|
// Comptabilisation des empreintes mémoire des variables |
|
// statiques qui ne sont pas accessibles, les variables statiques |
|
// accessibles étant déjà comptabilitées par la boucle précédente. |
|
|
|
if ((*s_etat_processus).s_liste_variables_statiques[i].objet != NULL) |
|
{ |
|
(*((integer8 *) (*((*((*((struct_liste_chainee *) |
|
(*s_objet_resultat).objet)).suivant)).donnee)).objet)) += |
|
sizeof(unsigned char) * strlen((*s_etat_processus) |
|
.s_liste_variables_statiques[i].nom); |
|
(*((integer8 *) (*((*((*((struct_liste_chainee *) |
|
(*s_objet_resultat).objet)).suivant)).donnee)).objet)) += |
|
occupation_memoire((*s_etat_processus) |
|
.s_liste_variables_statiques[i].objet); |
|
} |
} |
} |
} |
|
|
for(i = 0; i < (*(*s_etat_processus).s_liste_variables_partagees) |
free(tableau); |
.nombre_variables; i++) |
|
{ |
|
(*((integer8 *) (*((*((*((struct_liste_chainee *) |
|
(*s_objet_resultat).objet)).suivant)).donnee)).objet)) += |
|
sizeof(unsigned char) * strlen((*(*s_etat_processus) |
|
.s_liste_variables_partagees).table[i].nom); |
|
(*((integer8 *) (*((*((*((struct_liste_chainee *) |
|
(*s_objet_resultat).objet)).suivant)).donnee)).objet)) += |
|
occupation_memoire((*(*s_etat_processus) |
|
.s_liste_variables_partagees).table[i].objet); |
|
} |
|
|
|
/* |
/* |
* Empilement du résultat |
* Empilement du résultat |
Line 610 instruction_mtxtrylock(struct_processus
|
Line 581 instruction_mtxtrylock(struct_processus
|
return; |
return; |
} |
} |
} |
} |
|
else |
(*((struct_mutex *) (*s_objet_argument).objet)).tid = pthread_self(); |
{ |
|
(*((struct_mutex *) (*s_objet_argument).objet)).tid = |
|
pthread_self(); |
|
} |
|
|
if ((*s_etat_processus).profilage == d_vrai) |
if ((*s_etat_processus).profilage == d_vrai) |
{ |
{ |
Line 635 instruction_mtxtrylock(struct_processus
|
Line 609 instruction_mtxtrylock(struct_processus
|
return; |
return; |
} |
} |
|
|
(*((integer8 *) (*s_objet_resultat).objet)) = (ios == 0) ? 0 : -1; |
(*((integer8 *) (*s_objet_resultat).objet)) = (ios == 0) ? -1 : 0; |
|
|
if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), |
if (empilement(s_etat_processus, &((*s_etat_processus).l_base_pile), |
s_objet_resultat) == d_erreur) |
s_objet_resultat) == d_erreur) |
Line 922 instruction_mtxunlock(struct_processus *
|
Line 896 instruction_mtxunlock(struct_processus *
|
{ |
{ |
liberation(s_etat_processus, s_objet_argument); |
liberation(s_etat_processus, s_objet_argument); |
|
|
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
return; |
|
} |
|
|
|
if (pthread_mutex_unlock(&((*((struct_mutex *) |
|
(*s_objet_argument).objet)).mutex)) != 0) |
|
{ |
|
liberation(s_etat_processus, s_objet_argument); |
|
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
(*s_etat_processus).erreur_systeme = d_es_processus; |
return; |
return; |
} |
} |