version 1.53, 2012/03/31 12:15:22
|
version 1.72, 2013/03/23 16:14:39
|
Line 1
|
Line 1
|
/* |
/* |
================================================================================ |
================================================================================ |
RPL/2 (R) version 4.1.7 |
RPL/2 (R) version 4.1.13 |
Copyright (C) 1989-2012 Dr. BERTRAND Joël |
Copyright (C) 1989-2013 Dr. BERTRAND Joël |
|
|
This file is part of RPL/2. |
This file is part of RPL/2. |
|
|
Line 237 liste_variables_par_feuilles(struct_proc
|
Line 237 liste_variables_par_feuilles(struct_proc
|
================================================================================ |
================================================================================ |
*/ |
*/ |
|
|
static inline struct_arbre_variables * |
struct_arbre_variables * |
allocation_noeud(struct_processus *s_etat_processus) |
allocation_noeud(struct_processus *s_etat_processus) |
{ |
{ |
struct_arbre_variables *objet; |
struct_arbre_variables *objet; |
Line 272 liberation_noeud(struct_processus *s_eta
|
Line 272 liberation_noeud(struct_processus *s_eta
|
return; |
return; |
} |
} |
|
|
static inline struct_arbre_variables ** |
struct_arbre_variables ** |
allocation_tableau_noeuds(struct_processus *s_etat_processus) |
allocation_tableau_noeuds(struct_processus *s_etat_processus) |
{ |
{ |
struct_arbre_variables **objet; |
struct_arbre_variables **objet; |
Line 284 allocation_tableau_noeuds(struct_process
|
Line 284 allocation_tableau_noeuds(struct_process
|
} |
} |
else |
else |
{ |
{ |
objet = malloc((*s_etat_processus).nombre_caracteres_variables |
objet = malloc(((size_t) (*s_etat_processus) |
|
.nombre_caracteres_variables) |
* sizeof(struct_arbre_variables *)); |
* sizeof(struct_arbre_variables *)); |
} |
} |
|
|
Line 426 ajout_variable(struct_processus *s_etat_
|
Line 427 ajout_variable(struct_processus *s_etat_
|
} |
} |
|
|
(*(*s_etat_processus).s_arbre_variables).feuille = NULL; |
(*(*s_etat_processus).s_arbre_variables).feuille = NULL; |
|
(*(*s_etat_processus).s_arbre_variables).feuille_statique = NULL; |
(*(*s_etat_processus).s_arbre_variables).noeuds_utilises = 0; |
(*(*s_etat_processus).s_arbre_variables).noeuds_utilises = 0; |
(*(*s_etat_processus).s_arbre_variables).indice_tableau_pere = -1; |
(*(*s_etat_processus).s_arbre_variables).indice_tableau_pere = -1; |
(*(*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 = |
allocation_tableau_noeuds(s_etat_processus)) == NULL) |
allocation_tableau_noeuds(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 476 ajout_variable(struct_processus *s_etat_
|
Line 478 ajout_variable(struct_processus *s_etat_
|
(*(*l_variable_courante).noeuds[(*s_etat_processus) |
(*(*l_variable_courante).noeuds[(*s_etat_processus) |
.pointeurs_caracteres_variables[*ptr]]).feuille = NULL; |
.pointeurs_caracteres_variables[*ptr]]).feuille = NULL; |
(*(*l_variable_courante).noeuds[(*s_etat_processus) |
(*(*l_variable_courante).noeuds[(*s_etat_processus) |
|
.pointeurs_caracteres_variables[*ptr]]).feuille_statique |
|
= NULL; |
|
(*(*l_variable_courante).noeuds[(*s_etat_processus) |
.pointeurs_caracteres_variables[*ptr]]).noeuds_utilises = 0; |
.pointeurs_caracteres_variables[*ptr]]).noeuds_utilises = 0; |
|
|
// Le champ noeud_pere de la structure créée pointe sur |
// Le champ noeud_pere de la structure créée pointe sur |
Line 984 recherche_variable(struct_processus *s_e
|
Line 989 recherche_variable(struct_processus *s_e
|
|
|
unsigned char *ptr; |
unsigned char *ptr; |
|
|
unsigned long niveau_appel; |
integer8 niveau_appel; |
|
|
if ((*s_etat_processus).s_arbre_variables == NULL) |
if ((*s_etat_processus).s_arbre_variables == NULL) |
{ |
{ |
Line 1199 retrait_variable(struct_processus *s_eta
|
Line 1204 retrait_variable(struct_processus *s_eta
|
struct_liste_variables *variable_a_supprimer; |
struct_liste_variables *variable_a_supprimer; |
struct_liste_variables *variables_par_niveau; |
struct_liste_variables *variables_par_niveau; |
|
|
unsigned long niveau; |
integer8 niveau; |
|
|
(*s_etat_processus).niveau_supprime = d_faux; |
(*s_etat_processus).niveau_supprime = d_faux; |
|
|
Line 1292 retrait_variable(struct_processus *s_eta
|
Line 1297 retrait_variable(struct_processus *s_eta
|
[(*(*variable_a_supprimer).noeud).indice_tableau_pere])) |
[(*(*variable_a_supprimer).noeud).indice_tableau_pere])) |
.feuille = NULL; |
.feuille = NULL; |
|
|
while((*s_arbre_courant).noeuds_utilises == 0) |
while(((*s_arbre_courant).noeuds_utilises == 0) && |
|
((*s_arbre_courant).feuille_statique == NULL)) |
{ |
{ |
s_arbre_a_supprimer = s_arbre_courant; |
s_arbre_a_supprimer = s_arbre_courant; |
s_arbre_courant = (*s_arbre_courant).noeud_pere; |
s_arbre_courant = (*s_arbre_courant).noeud_pere; |
Line 1494 retrait_variable(struct_processus *s_eta
|
Line 1500 retrait_variable(struct_processus *s_eta
|
*/ |
*/ |
|
|
logical1 |
logical1 |
retrait_variable_par_niveau(struct_processus *s_etat_processus) |
retrait_variables_par_niveau(struct_processus *s_etat_processus) |
{ |
{ |
struct_liste_variables *l_element_a_supprimer; |
struct_liste_variables *l_element_a_supprimer; |
|
|
Line 1548 retrait_variable_par_niveau(struct_proce
|
Line 1554 retrait_variable_par_niveau(struct_proce
|
.l_liste_variables_par_niveau).liste).donnee)) |
.l_liste_variables_par_niveau).liste).donnee)) |
.variable_statique, ((*s_etat_processus) |
.variable_statique, ((*s_etat_processus) |
.mode_execution_programme |
.mode_execution_programme |
== 'Y') ? 'P' : 'E') == d_vrai) |
== 'Y') ? 'P' : 'E') != NULL) |
{ |
{ |
(*s_etat_processus).s_liste_variables_statiques |
(*(*s_etat_processus) |
[(*s_etat_processus) |
.pointeur_variable_statique_courante) |
.position_variable_statique_courante] |
.objet = (*((struct_variable *) |
.objet = (*((struct_variable *) |
|
(*(*(*s_etat_processus) |
(*(*(*s_etat_processus) |
.l_liste_variables_par_niveau).liste) |
.l_liste_variables_par_niveau).liste) |
.donnee)).objet; |
.donnee)).objet; |
Line 1587 retrait_variable_par_niveau(struct_proce
|
Line 1592 retrait_variable_par_niveau(struct_proce
|
.l_liste_variables_par_niveau).liste).donnee)) |
.l_liste_variables_par_niveau).liste).donnee)) |
.variable_statique, ((*s_etat_processus) |
.variable_statique, ((*s_etat_processus) |
.mode_execution_programme |
.mode_execution_programme |
== 'Y') ? 'P' : 'E') == d_vrai) |
== 'Y') ? 'P' : 'E') != NULL) |
{ |
{ |
(*s_etat_processus).s_liste_variables_statiques |
(*(*s_etat_processus) |
[(*s_etat_processus) |
.pointeur_variable_statique_courante) |
.position_variable_statique_courante] |
|
.objet = (*((struct_variable *) |
.objet = (*((struct_variable *) |
(*(*(*s_etat_processus) |
(*(*(*s_etat_processus) |
.l_liste_variables_par_niveau).liste) |
.l_liste_variables_par_niveau).liste) |
Line 1666 void
|
Line 1670 void
|
liberation_arbre_variables(struct_processus *s_etat_processus, |
liberation_arbre_variables(struct_processus *s_etat_processus, |
struct_arbre_variables *arbre, logical1 retrait_definitions) |
struct_arbre_variables *arbre, logical1 retrait_definitions) |
{ |
{ |
int i; |
int i; |
|
|
struct_liste_chainee *l_element_courant_liste; |
struct_liste_chainee *l_element_courant_liste; |
struct_liste_chainee *l_element_suivant_liste; |
struct_liste_chainee *l_element_suivant_liste; |
|
|
struct_liste_variables *l_element_courant; |
struct_liste_variables *l_element_courant; |
struct_liste_variables *l_element_suivant; |
struct_liste_variables *l_element_suivant; |
|
|
|
struct_liste_variables_statiques *l_element_statique_courant; |
|
struct_liste_variables_statiques *l_element_statique_suivant; |
|
|
// Libération de l'arbre des variables. Le contenu des variables n'est |
// Libération de l'arbre des variables. Le contenu des variables n'est |
// 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 |
Line 1697 liberation_arbre_variables(struct_proces
|
Line 1704 liberation_arbre_variables(struct_proces
|
(*arbre).feuille = NULL; |
(*arbre).feuille = NULL; |
} |
} |
|
|
|
l_element_statique_courant = (*arbre).feuille_statique; |
|
|
|
while(l_element_statique_courant != NULL) |
|
{ |
|
l_element_statique_suivant = (*l_element_statique_courant).suivant; |
|
|
|
free((*(*l_element_statique_courant).variable).nom); |
|
liberation(s_etat_processus, (*(*l_element_statique_courant) |
|
.variable).objet); |
|
free((*l_element_statique_courant).variable); |
|
free(l_element_statique_courant); |
|
|
|
l_element_statique_courant = l_element_statique_suivant; |
|
} |
|
|
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) |
Line 1768 liberation_arbre_variables(struct_proces
|
Line 1790 liberation_arbre_variables(struct_proces
|
================================================================================ |
================================================================================ |
*/ |
*/ |
|
|
int |
static integer8 |
nombre_variables(struct_processus *s_etat_processus, |
nombre_variables_locales(struct_processus *s_etat_processus, |
struct_arbre_variables *l_element_courant) |
struct_arbre_variables *l_element_courant) |
{ |
{ |
int i; |
integer8 i; |
int n; |
integer8 n; |
|
|
|
struct_liste_variables *l_variable; |
|
struct_liste_variables_statiques *l_variable_statique; |
|
|
struct_liste_variables *l_variable; |
if (l_element_courant == NULL) |
|
{ |
|
return(0); |
|
} |
|
|
n = 0; |
n = 0; |
|
|
Line 1790 nombre_variables(struct_processus *s_eta
|
Line 1818 nombre_variables(struct_processus *s_eta
|
} while(l_variable != (*l_element_courant).feuille); |
} while(l_variable != (*l_element_courant).feuille); |
} |
} |
|
|
|
if ((*l_element_courant).feuille_statique != NULL) |
|
{ |
|
l_variable_statique = (*l_element_courant).feuille_statique; |
|
|
|
do |
|
{ |
|
// Si le pointeur est nul, la variable est accessible et a été |
|
// copiée dans l'arbre des variables. |
|
|
|
if ((*(*l_variable_statique).variable).objet != NULL) |
|
{ |
|
n++; |
|
} |
|
|
|
l_variable_statique = (*l_variable_statique).suivant; |
|
} while(l_variable_statique != NULL); |
|
} |
|
|
for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++) |
for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++) |
{ |
{ |
if ((*l_element_courant).noeuds[i] != NULL) |
if ((*l_element_courant).noeuds[i] != NULL) |
{ |
{ |
n += nombre_variables(s_etat_processus, |
n += nombre_variables_locales(s_etat_processus, |
(*l_element_courant).noeuds[i]); |
(*l_element_courant).noeuds[i]); |
} |
} |
} |
} |
Line 1803 nombre_variables(struct_processus *s_eta
|
Line 1849 nombre_variables(struct_processus *s_eta
|
} |
} |
|
|
|
|
int |
static integer8 |
liste_variables(struct_processus *s_etat_processus, |
nombre_variables_partagees(struct_processus *s_etat_processus, |
struct_tableau_variables *tableau, int position, |
struct_arbre_variables_partagees *l_element_courant) |
|
{ |
|
integer8 i; |
|
integer8 n; |
|
|
|
struct_liste_variables_partagees *l_variable; |
|
|
|
if (l_element_courant == NULL) |
|
{ |
|
return(0); |
|
} |
|
|
|
if (pthread_mutex_lock(&((*l_element_courant).mutex_feuille)) != 0) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
return(0); |
|
} |
|
|
|
n = 0; |
|
|
|
if ((*l_element_courant).feuille != NULL) |
|
{ |
|
l_variable = (*l_element_courant).feuille; |
|
|
|
do |
|
{ |
|
n++; |
|
l_variable = (*l_variable).suivant; |
|
} while(l_variable != NULL); |
|
} |
|
|
|
for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++) |
|
{ |
|
if ((*l_element_courant).noeuds[i] != NULL) |
|
{ |
|
n += nombre_variables_partagees(s_etat_processus, |
|
(*l_element_courant).noeuds[i]); |
|
} |
|
} |
|
|
|
return(n); |
|
} |
|
|
|
|
|
integer8 |
|
nombre_variables(struct_processus *s_etat_processus) |
|
{ |
|
return(nombre_variables_locales(s_etat_processus, |
|
(*s_etat_processus).s_arbre_variables) |
|
+ nombre_variables_partagees(s_etat_processus, |
|
(*(*s_etat_processus).s_arbre_variables_partagees))); |
|
} |
|
|
|
|
|
void |
|
liberation_mutexes_arbre_variables_partagees(struct_processus *s_etat_processus, |
|
struct_arbre_variables_partagees *l_element_courant) |
|
{ |
|
int i; |
|
|
|
if (l_element_courant == NULL) |
|
{ |
|
return; |
|
} |
|
|
|
if (pthread_mutex_trylock(&((*l_element_courant).mutex_feuille)) != 0) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
return; |
|
} |
|
|
|
if (pthread_mutex_unlock(&((*l_element_courant).mutex_feuille)) != 0) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
return; |
|
} |
|
|
|
for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++) |
|
{ |
|
if ((*l_element_courant).noeuds[i] != NULL) |
|
{ |
|
liberation_mutexes_arbre_variables_partagees(s_etat_processus, |
|
(*l_element_courant).noeuds[i]); |
|
} |
|
} |
|
|
|
return; |
|
} |
|
|
|
|
|
static integer8 |
|
liste_variables_locales(struct_processus *s_etat_processus, |
|
struct_tableau_variables *tableau, integer8 position, |
struct_arbre_variables *l_element_courant) |
struct_arbre_variables *l_element_courant) |
{ |
{ |
int i; |
integer8 i; |
|
|
struct_liste_variables *l_variable; |
struct_liste_variables *l_variable; |
|
struct_liste_variables_statiques *l_variable_statique; |
|
|
|
if (l_element_courant == NULL) |
|
{ |
|
return(position); |
|
} |
|
|
if ((*l_element_courant).feuille != NULL) |
if ((*l_element_courant).feuille != NULL) |
{ |
{ |
Line 1828 liste_variables(struct_processus *s_etat
|
Line 1972 liste_variables(struct_processus *s_etat
|
(*(*l_variable).variable).variable_statique; |
(*(*l_variable).variable).variable_statique; |
tableau[position].variable_partagee = |
tableau[position].variable_partagee = |
(*(*l_variable).variable).variable_partagee; |
(*(*l_variable).variable).variable_partagee; |
|
tableau[position].variable_masquee = d_faux; |
|
tableau[position].mutex = NULL; |
|
|
position++; |
position++; |
|
|
l_variable = (*l_variable).suivant; |
l_variable = (*l_variable).suivant; |
} while(l_variable != (*l_element_courant).feuille); |
} while(l_variable != (*l_element_courant).feuille); |
} |
} |
|
|
|
if ((*l_element_courant).feuille_statique != NULL) |
|
{ |
|
l_variable_statique = (*l_element_courant).feuille_statique; |
|
|
|
do |
|
{ |
|
if ((*(*l_variable_statique).variable).objet != NULL) |
|
{ |
|
tableau[position].origine = 'E'; |
|
tableau[position].nom = (*(*l_variable_statique).variable).nom; |
|
tableau[position].niveau = |
|
(*(*l_variable_statique).variable).niveau; |
|
tableau[position].objet = (*(*l_variable_statique).variable) |
|
.objet; |
|
tableau[position].variable_verrouillee = d_faux; |
|
tableau[position].variable_statique = |
|
(*(*l_variable_statique).variable).variable_statique; |
|
tableau[position].variable_partagee.pointeur = NULL; |
|
tableau[position].variable_masquee = d_vrai; |
|
|
|
position++; |
|
} |
|
|
|
l_variable_statique = (*l_variable_statique).suivant; |
|
} while(l_variable_statique != NULL); |
|
} |
|
|
for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++) |
for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++) |
{ |
{ |
if ((*l_element_courant).noeuds[i] != NULL) |
if ((*l_element_courant).noeuds[i] != NULL) |
{ |
{ |
position = liste_variables(s_etat_processus, |
position = liste_variables_locales(s_etat_processus, |
tableau, position, (*l_element_courant).noeuds[i]); |
tableau, position, (*l_element_courant).noeuds[i]); |
} |
} |
} |
} |
Line 1847 liste_variables(struct_processus *s_etat
|
Line 2021 liste_variables(struct_processus *s_etat
|
} |
} |
|
|
|
|
|
static integer8 |
|
liste_variables_partagees(struct_processus *s_etat_processus, |
|
struct_tableau_variables *tableau, integer8 position, |
|
struct_arbre_variables_partagees *l_element_courant) |
|
{ |
|
integer8 i; |
|
|
|
struct_liste_variables_partagees *l_variable; |
|
|
|
if (l_element_courant == NULL) |
|
{ |
|
return(position); |
|
} |
|
|
|
// mutex_liste_variables_partagees |
|
// et (*l_variable_courante).mutex_feuille |
|
if ((*l_element_courant).feuille != NULL) |
|
{ |
|
l_variable = (*l_element_courant).feuille; |
|
|
|
do |
|
{ |
|
tableau[position].origine = 'E'; |
|
tableau[position].nom = (*(*l_variable).variable).nom; |
|
tableau[position].niveau = (*(*l_variable).variable).niveau; |
|
tableau[position].objet = (*(*l_variable).variable).objet; |
|
tableau[position].variable_verrouillee = d_faux; |
|
tableau[position].variable_partagee = |
|
(*(*l_variable).variable).variable_partagee; |
|
tableau[position].variable_partagee.pointeur = NULL; |
|
tableau[position].variable_masquee = d_faux; |
|
tableau[position].mutex = &((*(*l_variable).variable).mutex); |
|
|
|
position++; |
|
|
|
l_variable = (*l_variable).suivant; |
|
} while(l_variable != NULL); |
|
} |
|
|
|
for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++) |
|
{ |
|
if ((*l_element_courant).noeuds[i] != NULL) |
|
{ |
|
position = liste_variables_partagees(s_etat_processus, |
|
tableau, position, (*l_element_courant).noeuds[i]); |
|
} |
|
} |
|
|
|
if (pthread_mutex_unlock(&((*l_element_courant).mutex_feuille)) != 0) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_processus; |
|
return(0); |
|
} |
|
|
|
return(position); |
|
} |
|
|
|
|
|
static int |
|
fonction_ordre_variables(const void *argument_1, const void *argument_2) |
|
{ |
|
int comparaison; |
|
|
|
struct_tableau_variables *a1; |
|
struct_tableau_variables *a2; |
|
|
|
a1 = (struct_tableau_variables *) argument_1; |
|
a2 = (struct_tableau_variables *) argument_2; |
|
|
|
comparaison = strcmp((*a1).nom, (*a2).nom); |
|
|
|
if (comparaison != 0) |
|
{ |
|
return(comparaison); |
|
} |
|
else |
|
{ |
|
return(((((*a1).niveau - (*a2).niveau)) > 0) ? 1 : -1); |
|
} |
|
} |
|
|
|
|
|
integer8 |
|
liste_variables(struct_processus *s_etat_processus, |
|
struct_tableau_variables *tableau) |
|
{ |
|
integer8 nombre_elements; |
|
|
|
nombre_elements = liste_variables_locales(s_etat_processus, |
|
tableau, 0, (*s_etat_processus).s_arbre_variables); |
|
nombre_elements = liste_variables_partagees(s_etat_processus, |
|
tableau, nombre_elements, (*(*s_etat_processus) |
|
.s_arbre_variables_partagees)); |
|
|
|
qsort(tableau, (size_t) nombre_elements, sizeof(struct_tableau_variables), |
|
fonction_ordre_variables); |
|
|
|
return(nombre_elements); |
|
} |
|
|
|
|
/* |
/* |
================================================================================ |
================================================================================ |
Procédure de copie de l'arbre des variables |
Procédure de copie de l'arbre des variables |
Line 1876 copie_arbre_variables(struct_processus *
|
Line 2151 copie_arbre_variables(struct_processus *
|
// structure. Les variables de niveau 0 étant non modifiables, elles |
// structure. Les variables de niveau 0 étant non modifiables, elles |
// ne sont pas dupliquées. |
// ne sont pas dupliquées. |
|
|
int i; |
int i; |
|
|
|
logical1 niveau_0_traite; |
|
logical1 niveau_1_traite; |
|
|
logical1 niveau_0_traite; |
struct_arbre_variables *l_variable_courante; |
logical1 niveau_1_traite; |
|
|
|
struct_liste_chainee *l_element_courant; |
struct_liste_chainee *l_element_courant; |
|
|
struct_liste_variables *l_niveau_courant; |
struct_liste_variables *l_niveau_courant; |
|
struct_liste_variables_statiques *l_element_statique_courant; |
|
|
struct_variable s_variable; |
struct_variable s_variable; |
|
struct_variable_statique s_variable_statique; |
|
|
|
unsigned char *ptr; |
|
|
(*s_nouvel_etat_processus).s_arbre_variables = NULL; |
(*s_nouvel_etat_processus).s_arbre_variables = NULL; |
(*s_nouvel_etat_processus).l_liste_variables_par_niveau = NULL; |
(*s_nouvel_etat_processus).l_liste_variables_par_niveau = NULL; |
Line 1983 copie_arbre_variables(struct_processus *
|
Line 2264 copie_arbre_variables(struct_processus *
|
l_niveau_courant = (*l_niveau_courant).precedent; |
l_niveau_courant = (*l_niveau_courant).precedent; |
} |
} |
|
|
|
// Copie des variables statiques |
|
|
|
l_element_statique_courant = (*s_etat_processus) |
|
.l_liste_variables_statiques; |
|
|
|
while(l_element_statique_courant != NULL) |
|
{ |
|
// Création des branches de l'arbre si nécessaire. |
|
|
|
if ((*s_nouvel_etat_processus).s_arbre_variables == NULL) |
|
{ |
|
if (((*s_nouvel_etat_processus).s_arbre_variables = |
|
allocation_noeud(s_nouvel_etat_processus)) == NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return; |
|
} |
|
|
|
(*(*s_nouvel_etat_processus).s_arbre_variables).feuille = NULL; |
|
(*(*s_nouvel_etat_processus).s_arbre_variables).feuille_statique |
|
= NULL; |
|
(*(*s_nouvel_etat_processus).s_arbre_variables).noeuds_utilises = 0; |
|
(*(*s_nouvel_etat_processus).s_arbre_variables).indice_tableau_pere |
|
= -1; |
|
(*(*s_nouvel_etat_processus).s_arbre_variables).noeud_pere = NULL; |
|
|
|
if (((*(*s_nouvel_etat_processus).s_arbre_variables).noeuds = |
|
allocation_tableau_noeuds(s_nouvel_etat_processus)) == NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return; |
|
} |
|
|
|
for(i = 0; i < (*s_nouvel_etat_processus) |
|
.nombre_caracteres_variables; i++) |
|
{ |
|
(*(*s_nouvel_etat_processus).s_arbre_variables).noeuds[i] |
|
= NULL; |
|
} |
|
} |
|
|
|
l_variable_courante = (*s_nouvel_etat_processus).s_arbre_variables; |
|
ptr = (*(*l_element_statique_courant).variable).nom; |
|
|
|
while((*ptr) != d_code_fin_chaine) |
|
{ |
|
BUG((*s_nouvel_etat_processus).pointeurs_caracteres_variables |
|
[*ptr] < 0, uprintf("Variable=\"%s\", (*ptr)='%c'\n", |
|
(*(*l_element_statique_courant).variable).nom, *ptr)); |
|
|
|
if ((*l_variable_courante).noeuds[(*s_nouvel_etat_processus) |
|
.pointeurs_caracteres_variables[*ptr]] == NULL) |
|
{ |
|
// Le noeud n'existe pas encore, on le crée et on le marque |
|
// comme utilisé dans la structure parente. |
|
|
|
if (((*l_variable_courante).noeuds[(*s_nouvel_etat_processus) |
|
.pointeurs_caracteres_variables[*ptr]] = |
|
allocation_noeud(s_nouvel_etat_processus)) == NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_allocation_memoire; |
|
return; |
|
} |
|
|
|
(*l_variable_courante).noeuds_utilises++; |
|
|
|
// La feuille est par défaut vide et aucun élément du tableau |
|
// noeuds (les branches qui peuvent être issues de ce nouveau |
|
// noeud) n'est encore utilisée. |
|
|
|
(*(*l_variable_courante).noeuds[(*s_nouvel_etat_processus) |
|
.pointeurs_caracteres_variables[*ptr]]).feuille = NULL; |
|
(*(*l_variable_courante).noeuds[(*s_nouvel_etat_processus) |
|
.pointeurs_caracteres_variables[*ptr]]).feuille_statique |
|
= NULL; |
|
(*(*l_variable_courante).noeuds[(*s_nouvel_etat_processus) |
|
.pointeurs_caracteres_variables[*ptr]]).noeuds_utilises |
|
= 0; |
|
|
|
// Le champ noeud_pere de la structure créée pointe sur |
|
// la structure parente et l'indice tableau_pere correspond à la |
|
// position réelle dans le tableau noeuds[] de la structure |
|
// parente du noeud courant. Cette valeur sera utilisée lors de |
|
// la destruction du noeud pour annuler le pointeur contenu dans |
|
// le tableau noeuds[] de la structure parente. |
|
|
|
(*(*l_variable_courante).noeuds[(*s_nouvel_etat_processus) |
|
.pointeurs_caracteres_variables[*ptr]]).noeud_pere = |
|
l_variable_courante; |
|
(*(*l_variable_courante).noeuds[(*s_nouvel_etat_processus) |
|
.pointeurs_caracteres_variables[*ptr]]) |
|
.indice_tableau_pere = (*s_nouvel_etat_processus) |
|
.pointeurs_caracteres_variables[*ptr]; |
|
|
|
// Allocation du tableau noeuds[] et initialisation à zéro de |
|
// tous les pointeurs. |
|
|
|
if (((*(*l_variable_courante).noeuds[(*s_nouvel_etat_processus) |
|
.pointeurs_caracteres_variables[*ptr]]).noeuds = |
|
allocation_tableau_noeuds(s_nouvel_etat_processus)) |
|
== NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme |
|
= d_es_allocation_memoire; |
|
return; |
|
} |
|
|
|
for(i = 0; i < (*s_nouvel_etat_processus) |
|
.nombre_caracteres_variables; i++) |
|
{ |
|
(*(*l_variable_courante).noeuds[(*s_nouvel_etat_processus) |
|
.pointeurs_caracteres_variables[*ptr]]).noeuds[i] |
|
= NULL; |
|
} |
|
} |
|
|
|
l_variable_courante = (*l_variable_courante).noeuds |
|
[(*s_nouvel_etat_processus).pointeurs_caracteres_variables |
|
[*ptr]]; |
|
|
|
ptr++; |
|
} |
|
|
|
// Il faut copier la variable pour la dissocier de la variable |
|
// restant dans le thread parent. |
|
|
|
s_variable_statique = (*(*l_element_statique_courant).variable); |
|
|
|
if (copie_objet(s_etat_processus, s_variable_statique.objet, 'P') |
|
== NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return; |
|
} |
|
|
|
if ((s_variable_statique.nom = malloc((strlen( |
|
(*(*l_element_statique_courant).variable).nom) + 1) * |
|
sizeof(unsigned char))) == NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return; |
|
} |
|
|
|
strcpy(s_variable_statique.nom, (*(*l_element_statique_courant) |
|
.variable).nom); |
|
|
|
if (creation_variable_statique(s_nouvel_etat_processus, |
|
&s_variable_statique) == d_erreur) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return; |
|
} |
|
|
|
l_element_statique_courant = (*l_element_statique_courant).suivant; |
|
} |
|
|
return; |
return; |
} |
} |
|
|
Line 2030 initialisation_variables(struct_processu
|
Line 2468 initialisation_variables(struct_processu
|
} |
} |
|
|
if (((*s_etat_processus).pointeurs_caracteres_variables = |
if (((*s_etat_processus).pointeurs_caracteres_variables = |
malloc(longueur_tableau * sizeof(int))) == NULL) |
malloc(((size_t) longueur_tableau) * sizeof(int))) == NULL) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
return; |
return; |