version 1.8, 2010/05/24 10:58:30
|
version 1.31, 2011/06/17 07:55:59
|
Line 1
|
Line 1
|
/* |
/* |
================================================================================ |
================================================================================ |
RPL/2 (R) version 4.0.16 |
RPL/2 (R) version 4.1.0.prerelease.0 |
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 20
|
Line 20
|
*/ |
*/ |
|
|
|
|
#include "rpl.conv.h" |
#include "rpl-conv.h" |
|
|
|
|
/* |
/* |
Line 39
|
Line 39
|
================================================================================ |
================================================================================ |
*/ |
*/ |
|
|
logical1 |
static logical1 |
creation_variable(struct_processus *s_etat_processus, |
ajout_variable(struct_processus *s_etat_processus, struct_variable *s_variable) |
struct_variable *s_variable, |
|
unsigned char autorisation_creation_variable_statique, |
|
unsigned char autorisation_creation_variable_partagee) |
|
{ |
{ |
long i; |
int i; |
|
|
|
struct_liste_variables *l_nouvelle_variable; |
|
struct_liste_variables *l_variable_candidate; |
|
struct_arbre_variables *l_variable_courante; |
|
struct_arbre_variables *l_variable_precedente; |
|
|
|
struct_liste_chainee *l_nouvel_element; |
|
|
struct_variable *s_nouvelle_base; |
unsigned char *ptr; |
|
|
(*s_etat_processus).nombre_variables++; |
void *pointeur_variable_cree; |
|
|
if ((*s_etat_processus).nombre_variables > (*s_etat_processus) |
if ((*s_etat_processus).s_arbre_variables == NULL) |
.nombre_variables_allouees) |
{ |
|
if (((*s_etat_processus).s_arbre_variables = |
|
malloc(sizeof(struct_arbre_variables))) == NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return(d_erreur); |
|
} |
|
|
|
(*(*s_etat_processus).s_arbre_variables).feuille = NULL; |
|
(*(*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).noeud_pere = NULL; |
|
|
|
if (((*(*s_etat_processus).s_arbre_variables).noeuds = |
|
malloc((*s_etat_processus).nombre_caracteres_variables |
|
* sizeof(struct_arbre_variables))) == NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return(d_erreur); |
|
} |
|
|
|
for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++) |
|
{ |
|
(*(*s_etat_processus).s_arbre_variables).noeuds[i] = NULL; |
|
} |
|
} |
|
|
|
l_variable_precedente = NULL; |
|
l_variable_courante = (*s_etat_processus).s_arbre_variables; |
|
ptr = (*s_variable).nom; |
|
|
|
while((*ptr) != d_code_fin_chaine) |
|
{ |
|
BUG((*s_etat_processus).pointeurs_caracteres_variables[*ptr] < 0, |
|
printf("Variable=\"%s\", (*ptr)='%c'\n", (*s_variable).nom, |
|
*ptr)); |
|
|
|
if ((*l_variable_courante).noeuds[(*s_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_etat_processus) |
|
.pointeurs_caracteres_variables[*ptr]] = |
|
malloc(sizeof(struct_arbre_variables))) == NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return(d_erreur); |
|
} |
|
|
|
(*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_etat_processus) |
|
.pointeurs_caracteres_variables[*ptr]]).feuille = NULL; |
|
(*(*l_variable_courante).noeuds[(*s_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_etat_processus) |
|
.pointeurs_caracteres_variables[*ptr]]).noeud_pere = |
|
l_variable_courante; |
|
(*(*l_variable_courante).noeuds[(*s_etat_processus) |
|
.pointeurs_caracteres_variables[*ptr]]) |
|
.indice_tableau_pere = (*s_etat_processus) |
|
.pointeurs_caracteres_variables[*ptr]; |
|
|
|
// Allocation du tableau noeuds[] et initialisation à zéro de |
|
// tous les pointeurs. |
|
|
|
if (((*(*l_variable_courante).noeuds[(*s_etat_processus) |
|
.pointeurs_caracteres_variables[*ptr]]).noeuds = |
|
malloc((*s_etat_processus).nombre_caracteres_variables |
|
* sizeof(struct_arbre_variables))) == NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return(d_erreur); |
|
} |
|
|
|
for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++) |
|
{ |
|
(*(*l_variable_courante).noeuds[(*s_etat_processus) |
|
.pointeurs_caracteres_variables[*ptr]]).noeuds[i] |
|
= NULL; |
|
} |
|
} |
|
|
|
l_variable_precedente = l_variable_courante; |
|
l_variable_courante = (*l_variable_courante).noeuds |
|
[(*s_etat_processus).pointeurs_caracteres_variables[*ptr]]; |
|
ptr++; |
|
} |
|
|
|
if ((*l_variable_courante).feuille == NULL) |
|
{ |
|
// Aucune variable de même nom préexiste. On alloue le premier |
|
// élément de la liste doublement chaînée contenant toutes les |
|
// variables de même nom. Cette liste boucle en premier lieu sur |
|
// elle-même. |
|
|
|
if (((*l_variable_courante).feuille = malloc( |
|
sizeof(struct_liste_variables))) == NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return(d_erreur); |
|
} |
|
|
|
(*(*l_variable_courante).feuille).suivant = |
|
(*l_variable_courante).feuille; |
|
(*(*l_variable_courante).feuille).precedent = |
|
(*l_variable_courante).feuille; |
|
(*(*l_variable_courante).feuille).noeud_pere = l_variable_precedente; |
|
|
|
// Allocation de la variable sur l'élément de la liste. |
|
|
|
if (((*(*l_variable_courante).feuille).variable = |
|
malloc(sizeof(struct_variable))) == NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return(d_erreur); |
|
} |
|
|
|
(*((struct_variable *) (*(*l_variable_courante).feuille).variable)) = |
|
(*s_variable); |
|
pointeur_variable_cree = (*(*l_variable_courante).feuille).variable; |
|
} |
|
else |
{ |
{ |
// La nouvelle variable ne tient pas dans la table courante. Il |
if ((l_nouvelle_variable = malloc(sizeof(struct_liste_variables))) |
// faut donc en augmenter la taille. |
== NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return(d_erreur); |
|
} |
|
|
if ((*s_etat_processus).nombre_variables_allouees == 0) |
if ((*s_variable).niveau > 1) |
{ |
{ |
(*s_etat_processus).nombre_variables_allouees = |
// Cas d'une variable locale |
(*s_etat_processus).nombre_variables; |
|
|
// Si le niveau de la dernière variable de même nom est |
|
// supérieur au niveau de la variable locale que l'on veut |
|
// enregistrer dans la liste, cette liste est incohérente. |
|
|
|
BUG((*(*(*l_variable_courante).feuille).variable).niveau >= |
|
(*s_variable).niveau, |
|
printf("Variable=\"%s\"\n", (*s_variable).nom)); |
|
|
|
// On ajoute la variable à la liste existante. |
|
|
|
(*l_nouvelle_variable).suivant = (*l_variable_courante).feuille; |
|
(*l_nouvelle_variable).precedent = (*(*l_variable_courante).feuille) |
|
.precedent; |
|
(*l_nouvelle_variable).noeud_pere = l_variable_precedente; |
|
(*(*(*l_variable_courante).feuille).precedent).suivant = |
|
l_nouvelle_variable; |
|
(*(*l_variable_courante).feuille).precedent = |
|
l_nouvelle_variable; |
|
(*l_variable_courante).feuille = l_nouvelle_variable; |
|
|
|
if (((*(*l_variable_courante).feuille).variable = |
|
malloc(sizeof(struct_variable))) == NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return(d_erreur); |
|
} |
|
|
|
(*((struct_variable *) (*(*l_variable_courante).feuille).variable)) |
|
= (*s_variable); |
|
pointeur_variable_cree = (*(*l_variable_courante).feuille).variable; |
} |
} |
else |
else |
{ |
{ |
while((*s_etat_processus).nombre_variables > |
// Cas d'une variable globale (niveau 0 [définitions] ou 1 |
(*s_etat_processus).nombre_variables_allouees) |
// [variables globales]) |
|
|
|
l_variable_candidate = (*l_variable_courante).feuille; |
|
|
|
do |
{ |
{ |
(*s_etat_processus).nombre_variables_allouees *= 2; |
// S'il y a déjà une variable de même niveau, la pile |
|
// est incohérente. |
|
|
|
BUG((*(*l_variable_candidate).variable).niveau == |
|
(*s_variable).niveau, |
|
printf("Variable=\"%s\"\n", (*s_variable).nom)); |
|
|
|
l_variable_candidate = (*l_variable_candidate).precedent; |
|
} while((l_variable_candidate != (*l_variable_courante).feuille) && |
|
((*(*l_variable_candidate).variable).niveau <= 1)); |
|
|
|
if ((*(*(*(*l_variable_courante).feuille).precedent).variable) |
|
.niveau > 1) |
|
{ |
|
// Ajout inconditionnel des variables de niveaux 0 et 1 |
} |
} |
|
else |
|
{ |
|
l_variable_candidate = (*(*l_variable_courante).feuille) |
|
.precedent; |
|
} |
|
|
|
(*l_nouvelle_variable).suivant = l_variable_candidate; |
|
(*l_nouvelle_variable).precedent = (*l_variable_candidate) |
|
.precedent; |
|
(*l_nouvelle_variable).noeud_pere = l_variable_precedente; |
|
(*(*l_variable_candidate).precedent).suivant = l_nouvelle_variable; |
|
(*l_variable_candidate).precedent = l_nouvelle_variable; |
|
|
|
if (((*l_nouvelle_variable).variable = |
|
malloc(sizeof(struct_variable))) == NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return(d_erreur); |
|
} |
|
|
|
(*(*l_nouvelle_variable).variable) = (*s_variable); |
|
pointeur_variable_cree = (*l_nouvelle_variable).variable; |
} |
} |
|
} |
|
|
|
// Ajout de la variable nouvellement créée à la liste par niveaux. |
|
// Le pointeur contenu dans la structure de description du processus indique |
|
// toujours le plus haut niveau utilisé. |
|
|
if ((s_nouvelle_base = realloc((*s_etat_processus).s_liste_variables, |
if ((*s_etat_processus).l_liste_variables_par_niveau == NULL) |
(*s_etat_processus).nombre_variables_allouees * |
{ |
sizeof(struct_variable))) == NULL) |
// Le niveau courant n'existe pas. Il est créé. |
|
|
|
if ((l_nouvelle_variable = malloc(sizeof(struct_liste_variables))) |
|
== NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return(d_erreur); |
|
} |
|
|
|
(*l_nouvelle_variable).suivant = l_nouvelle_variable; |
|
(*l_nouvelle_variable).precedent = l_nouvelle_variable; |
|
(*l_nouvelle_variable).noeud_pere = NULL; |
|
(*l_nouvelle_variable).liste = NULL; |
|
|
|
(*s_etat_processus).l_liste_variables_par_niveau = l_nouvelle_variable; |
|
} |
|
else if ((*s_variable).niveau > (*((struct_variable *) |
|
(*(*(*s_etat_processus).l_liste_variables_par_niveau).liste) |
|
.donnee)).niveau) |
|
{ |
|
// Le niveau courant n'existe pas. Il est créé. |
|
|
|
if ((l_nouvelle_variable = malloc(sizeof(struct_liste_variables))) |
|
== NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return(d_erreur); |
|
} |
|
|
|
(*l_nouvelle_variable).suivant = (*s_etat_processus) |
|
.l_liste_variables_par_niveau; |
|
(*l_nouvelle_variable).precedent = (*(*s_etat_processus) |
|
.l_liste_variables_par_niveau).precedent; |
|
(*l_nouvelle_variable).noeud_pere = NULL; |
|
(*l_nouvelle_variable).liste = NULL; |
|
(*(*(*s_etat_processus).l_liste_variables_par_niveau).precedent) |
|
.suivant = l_nouvelle_variable; |
|
(*(*s_etat_processus).l_liste_variables_par_niveau).precedent = |
|
l_nouvelle_variable; |
|
|
|
(*s_etat_processus).l_liste_variables_par_niveau = l_nouvelle_variable; |
|
} |
|
else if ((*s_variable).niveau <= 1) |
|
{ |
|
// Création d'une variable de niveau 0 ou 1 |
|
|
|
if ((l_nouvelle_variable = malloc(sizeof(struct_liste_variables))) |
|
== NULL) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).nombre_variables--; |
|
return(d_erreur); |
return(d_erreur); |
} |
} |
|
|
(*s_etat_processus).s_liste_variables = s_nouvelle_base; |
l_variable_candidate = (*s_etat_processus).l_liste_variables_par_niveau; |
|
|
|
if ((*((struct_variable *) (*(*(*(*s_etat_processus) |
|
.l_liste_variables_par_niveau).precedent).liste).donnee)) |
|
.niveau <= 1) |
|
{ |
|
l_variable_candidate = (*(*s_etat_processus) |
|
.l_liste_variables_par_niveau).precedent; |
|
} |
|
|
|
(*l_nouvelle_variable).suivant = l_variable_candidate; |
|
(*l_nouvelle_variable).precedent = (*l_variable_candidate) |
|
.precedent; |
|
(*l_nouvelle_variable).noeud_pere = NULL; |
|
(*l_nouvelle_variable).liste = NULL; |
|
(*(*l_variable_candidate).precedent).suivant = l_nouvelle_variable; |
|
(*l_variable_candidate).precedent = l_nouvelle_variable; |
} |
} |
|
|
|
// Ajout de la variable en tête de la liste |
|
|
|
if ((l_nouvel_element = malloc(sizeof(struct_liste_chainee))) == NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
|
return(d_erreur); |
|
} |
|
|
|
(*l_nouvel_element).suivant = (*(*s_etat_processus) |
|
.l_liste_variables_par_niveau).liste; |
|
(*l_nouvel_element).donnee = pointeur_variable_cree; |
|
(*(*s_etat_processus).l_liste_variables_par_niveau).liste = |
|
l_nouvel_element; |
|
|
|
return(d_absence_erreur); |
|
} |
|
|
|
|
|
logical1 |
|
creation_variable(struct_processus *s_etat_processus, |
|
struct_variable *s_variable, |
|
unsigned char autorisation_creation_variable_statique, |
|
unsigned char autorisation_creation_variable_partagee) |
|
{ |
if ((*s_etat_processus).mode_execution_programme == 'Y') |
if ((*s_etat_processus).mode_execution_programme == 'Y') |
{ |
{ |
(*s_variable).origine = 'P'; |
(*s_variable).origine = 'P'; |
Line 188 creation_variable(struct_processus *s_et
|
Line 493 creation_variable(struct_processus *s_et
|
} |
} |
|
|
/* |
/* |
* Positionnement de la variable au bon endroit |
* Recherche de la feuille correspondante dans l'arbre des variables. |
|
* Si cette feuille n'existe pas, elle est créée. |
*/ |
*/ |
|
|
// Nous avons (*s_etat_processus).nombre_variables - 1 variables dans la |
if (ajout_variable(s_etat_processus, s_variable) == d_erreur) |
// table qui sera balayée de la fin vers le début. |
{ |
|
return(d_erreur); |
|
} |
|
|
|
return(d_absence_erreur); |
|
} |
|
|
|
|
|
/* |
|
================================================================================ |
|
Procédure de recherche d'une variable par son nom dans la base |
|
================================================================================ |
|
Entrée : |
|
-------------------------------------------------------------------------------- |
|
Sortie : |
|
-------------------------------------------------------------------------------- |
|
Effets de bord : néant |
|
================================================================================ |
|
*/ |
|
|
if ((*s_etat_processus).nombre_variables == 1) |
logical1 |
|
recherche_variable(struct_processus *s_etat_processus, |
|
unsigned char *nom_variable) |
|
{ |
|
int pointeur; |
|
|
|
struct_arbre_variables *l_variable_courante; |
|
struct_liste_pile_systeme *l_element_courant; |
|
|
|
unsigned char *ptr; |
|
|
|
unsigned long niveau_appel; |
|
|
|
if ((*s_etat_processus).s_arbre_variables == NULL) |
{ |
{ |
(*s_etat_processus).s_liste_variables[0] = (*s_variable); |
(*s_etat_processus).erreur_systeme = d_es_variable_introuvable; |
|
return(d_faux); |
} |
} |
else |
|
|
l_variable_courante = (*s_etat_processus).s_arbre_variables; |
|
ptr = nom_variable; |
|
|
|
while((*ptr) != d_code_fin_chaine) |
{ |
{ |
for(i = (*s_etat_processus).nombre_variables - 2; i >= 0; i--) |
pointeur = (*s_etat_processus).pointeurs_caracteres_variables[*ptr]; |
|
|
|
if (pointeur < 0) |
{ |
{ |
if (strcmp((*s_variable).nom, |
// Caractère hors de l'alphabet des variables |
(*s_etat_processus).s_liste_variables[i].nom) < 0) |
|
|
(*s_etat_processus).erreur_systeme = d_es_variable_introuvable; |
|
return(d_faux); |
|
} |
|
|
|
if ((*l_variable_courante).noeuds[pointeur] == NULL) |
|
{ |
|
// Le chemin de la variable candidate n'existe pas. |
|
(*s_etat_processus).erreur_systeme = d_es_variable_introuvable; |
|
return(d_faux); |
|
} |
|
|
|
l_variable_courante = (*l_variable_courante).noeuds[pointeur]; |
|
ptr++; |
|
} |
|
|
|
if ((*l_variable_courante).feuille != NULL) |
|
{ |
|
// Il existe une pile de variables de même nom. Le sommet de la |
|
// pile est la variable de niveau le plus haut. |
|
|
|
l_element_courant = (*s_etat_processus).l_base_pile_systeme; |
|
|
|
if (l_element_courant == NULL) |
|
{ |
|
// Problème : la pile système est vide ! |
|
(*s_etat_processus).erreur_systeme = d_es_pile_vide; |
|
return(d_faux); |
|
} |
|
|
|
while((*l_element_courant).retour_definition != 'Y') |
|
{ |
|
l_element_courant = (*l_element_courant).suivant; |
|
|
|
if (l_element_courant == NULL) |
{ |
{ |
(*s_etat_processus).s_liste_variables[i + 1] = |
(*s_etat_processus).erreur_systeme = d_es_pile_vide; |
(*s_etat_processus).s_liste_variables[i]; |
return(d_faux); |
} |
} |
else |
} |
|
|
|
niveau_appel = (*l_element_courant).niveau_courant; |
|
|
|
if (niveau_appel < (*(*(*l_variable_courante).feuille).variable).niveau) |
|
{ |
|
// Une variable locale est accessible puisque créée dans la |
|
// fonction courante. |
|
|
|
(*s_etat_processus).pointeur_variable_courante = |
|
(*(*l_variable_courante).feuille).variable; |
|
(*s_etat_processus).pointeur_feuille_courante = |
|
(*l_variable_courante).feuille; |
|
return(d_vrai); |
|
} |
|
else |
|
{ |
|
// Aucune variable locale n'est accessible depuis la fonction. |
|
// Dans ce cas, on prend la variable de niveau le plus bas |
|
// si ce niveau est inférieur ou égal à 1 (variable globale |
|
// ou fonction définie par l'utilisateur). Si le niveau de la |
|
// plus ancienne variable est strictement supérieur à 1, il |
|
// s'agit d'une variable locale inaccessible. |
|
|
|
if ((*(*(*(*l_variable_courante).feuille).precedent).variable) |
|
.niveau <= 1) |
|
{ |
|
(*s_etat_processus).pointeur_variable_courante = |
|
(*(*(*l_variable_courante).feuille).precedent).variable; |
|
(*s_etat_processus).pointeur_feuille_courante = |
|
(*l_variable_courante).feuille; |
|
|
|
// S'il existe une variable de niveau 0 et une seconde de |
|
// niveau 1, la variable de niveau 0 (fonction) est masquée |
|
// par celle de niveau 1. |
|
|
|
if (((*(*(*l_variable_courante).feuille).variable).niveau == 0) |
|
&& ((*(*(*(*l_variable_courante).feuille).precedent) |
|
.variable).niveau == 1)) |
|
{ |
|
(*s_etat_processus).pointeur_variable_courante = |
|
(*(*(*l_variable_courante).feuille).precedent) |
|
.variable; |
|
(*s_etat_processus).pointeur_feuille_courante = |
|
(*l_variable_courante).feuille; |
|
} |
|
|
|
return(d_vrai); |
|
} |
|
} |
|
} |
|
|
|
(*s_etat_processus).erreur_systeme = d_es_variable_introuvable; |
|
return(d_faux); |
|
} |
|
|
|
|
|
logical1 |
|
recherche_variable_globale(struct_processus *s_etat_processus, |
|
unsigned char *nom) |
|
{ |
|
logical1 presence_variable; |
|
|
|
presence_variable = recherche_variable(s_etat_processus, nom); |
|
|
|
if (presence_variable == d_vrai) |
|
{ |
|
switch((*(*s_etat_processus).pointeur_variable_courante).niveau) |
|
{ |
|
case 0: |
|
{ |
|
// Nous sommes en présence d'une définition et non d'une |
|
// variable. |
|
|
|
presence_variable = d_faux; |
|
break; |
|
} |
|
|
|
case 1: |
|
{ |
|
break; |
|
} |
|
|
|
default: |
{ |
{ |
|
if ((*(*(*(*s_etat_processus).pointeur_feuille_courante) |
|
.precedent).variable).niveau == 1) |
|
{ |
|
(*s_etat_processus).pointeur_feuille_courante = |
|
(*(*s_etat_processus).pointeur_feuille_courante) |
|
.precedent; |
|
(*s_etat_processus).pointeur_variable_courante = |
|
(*(*s_etat_processus).pointeur_feuille_courante) |
|
.variable; |
|
} |
|
else if ((*(*(*(*(*s_etat_processus).pointeur_feuille_courante) |
|
.precedent).precedent).variable).niveau == 1) |
|
{ |
|
(*s_etat_processus).pointeur_feuille_courante = |
|
(*(*(*s_etat_processus).pointeur_feuille_courante) |
|
.precedent).precedent; |
|
(*s_etat_processus).pointeur_variable_courante = |
|
(*(*s_etat_processus).pointeur_feuille_courante) |
|
.variable; |
|
} |
|
else |
|
{ |
|
presence_variable = d_faux; |
|
} |
|
|
break; |
break; |
} |
} |
} |
} |
|
} |
|
|
(*s_etat_processus).s_liste_variables[i + 1] = (*s_variable); |
if (presence_variable == d_vrai) |
|
{ |
|
if ((*(*s_etat_processus).pointeur_variable_courante).objet == NULL) |
|
{ |
|
// La variable n'est pas globale, elle est partagée. |
|
presence_variable = d_faux; |
|
(*s_etat_processus).erreur_execution = d_ex_variable_partagee; |
|
} |
} |
} |
|
|
return(d_absence_erreur); |
return(presence_variable); |
} |
} |
|
|
|
|
Line 238 logical1
|
Line 732 logical1
|
retrait_variable(struct_processus *s_etat_processus, |
retrait_variable(struct_processus *s_etat_processus, |
unsigned char *nom_variable, unsigned char type) |
unsigned char *nom_variable, unsigned char type) |
{ |
{ |
struct_variable *s_nouvelle_base; |
logical1 erreur; |
|
|
|
struct_arbre_variables *s_arbre_a_supprimer; |
|
struct_arbre_variables *s_arbre_courant; |
|
|
|
struct_liste_chainee *l_element_courant; |
|
struct_liste_chainee *l_element_precedent; |
|
|
logical1 erreur; |
struct_liste_variables *variable_a_supprimer; |
|
struct_liste_variables *variables_par_niveau; |
|
|
unsigned long position_courante; |
unsigned long niveau; |
unsigned long position_supprimee; |
|
|
|
if (recherche_variable(s_etat_processus, nom_variable) == d_vrai) |
if (recherche_variable(s_etat_processus, nom_variable) == d_vrai) |
{ |
{ |
|
// Une variable correspondant au nom recherché est accessible. |
|
|
if (type == 'G') |
if (type == 'G') |
{ |
{ |
if ((*s_etat_processus).position_variable_courante > 0) |
if ((*(*s_etat_processus).pointeur_variable_courante).niveau > 1) |
{ |
{ |
while(strcmp((*s_etat_processus).s_liste_variables |
// La variable obtenue est une variable locale. il faut |
[(*s_etat_processus).position_variable_courante] |
// s'assurer qu'il existe une variable de niveau 1 de même |
.nom, nom_variable) == 0) |
// nom sur la feuille. |
{ |
|
(*s_etat_processus).position_variable_courante--; |
|
|
|
if ((*s_etat_processus).position_variable_courante >= |
if ((*(*(*(*s_etat_processus).pointeur_feuille_courante) |
(*s_etat_processus).nombre_variables) |
.precedent).variable).niveau <= 1) |
|
{ |
|
(*s_etat_processus).pointeur_feuille_courante = |
|
(*(*s_etat_processus).pointeur_feuille_courante) |
|
.precedent; |
|
(*s_etat_processus).pointeur_variable_courante = |
|
(*(*s_etat_processus).pointeur_feuille_courante) |
|
.variable; |
|
|
|
// Si la variable retournée est de niveau 0, on regarde |
|
// un peu plus loin si une variable de niveau 1 existe. |
|
|
|
if (((*(*(*s_etat_processus).pointeur_feuille_courante) |
|
.variable).niveau == 0) && |
|
((*(*(*(*s_etat_processus) |
|
.pointeur_feuille_courante).precedent).variable) |
|
.niveau == 1)) |
{ |
{ |
erreur = d_erreur; |
(*s_etat_processus).pointeur_feuille_courante = |
(*s_etat_processus).erreur_execution = |
(*(*s_etat_processus).pointeur_feuille_courante) |
d_ex_variable_non_definie; |
.precedent; |
return erreur; |
(*s_etat_processus).pointeur_variable_courante = |
|
(*(*s_etat_processus).pointeur_feuille_courante) |
|
.variable; |
} |
} |
} |
} |
|
else |
|
{ |
|
// Aucune variable globale (niveau 1) n'existe. |
|
|
(*s_etat_processus).position_variable_courante++; |
erreur = d_erreur; |
} |
(*s_etat_processus).erreur_execution = |
|
d_ex_variable_non_definie; |
if ((*s_etat_processus).s_liste_variables |
return(erreur); |
[(*s_etat_processus).position_variable_courante] |
} |
.niveau != 1) |
|
{ |
|
erreur = d_erreur; |
|
(*s_etat_processus).erreur_execution = |
|
d_ex_variable_non_definie; |
|
return erreur; |
|
} |
} |
|
|
if ((*s_etat_processus).s_liste_variables |
if ((*(*s_etat_processus).pointeur_variable_courante) |
[(*s_etat_processus).position_variable_courante] |
|
.variable_verrouillee == d_vrai) |
.variable_verrouillee == d_vrai) |
{ |
{ |
erreur = d_erreur; |
erreur = d_erreur; |
(*s_etat_processus).erreur_execution = |
(*s_etat_processus).erreur_execution = |
d_ex_variable_verrouillee; |
d_ex_variable_verrouillee; |
return erreur; |
return(erreur); |
} |
} |
} |
} |
|
|
if ((*s_etat_processus).nombre_variables < |
// Suppression de la variable de la liste. |
((*s_etat_processus).nombre_variables_allouees / 2)) |
// Deux cas peuvent survenir : |
|
// 1/ les pointeurs sur la variable et la variable suivante |
|
// sont identiques et on supprime la variable ainsi que la feuille |
|
// associée ; |
|
// 2/ ces deux pointeurs sont différents et se contente de retirer |
|
// la structure décrivant la variable. |
|
|
|
if ((*s_etat_processus).pointeur_feuille_courante == |
|
(*(*s_etat_processus).pointeur_feuille_courante).suivant) |
{ |
{ |
(*s_etat_processus).nombre_variables_allouees /= 2; |
// Cas 1 : |
|
// On retire la variable du noeud en décrémentant le nombre |
|
// de feuilles de ce noeud. Si le nombre de feuilles du noeud |
|
// est nul, on retire les noeuds récursivement jusqu'à obtenir |
|
// un nombre non nul de feuilles utilisées (ou la racine des |
|
// variables). |
|
|
// (*s_etat_processus).nombre_variables est forcément |
variable_a_supprimer = (*s_etat_processus) |
// supérieur à 1 (la décrémentation est postérieure). Ce test |
.pointeur_feuille_courante; |
// est vrai lorsque le nombre de variables allouées est |
s_arbre_courant = (*variable_a_supprimer).noeud_pere; |
// strictement supérieur à 2. |
|
|
|
if ((s_nouvelle_base = |
BUG((*s_arbre_courant).noeuds_utilises == 0, |
realloc((*s_etat_processus).s_liste_variables, |
uprintf("Freed node !\n")); |
(*s_etat_processus).nombre_variables_allouees * |
(*s_arbre_courant).noeuds_utilises--; |
sizeof(struct_variable))) == NULL) |
|
|
while((*s_arbre_courant).noeuds_utilises == 0) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
s_arbre_a_supprimer = s_arbre_courant; |
return(d_erreur); |
s_arbre_courant = (*s_arbre_courant).noeud_pere; |
} |
|
|
|
(*s_etat_processus).s_liste_variables = s_nouvelle_base; |
if (s_arbre_courant == NULL) |
|
{ |
|
free((*s_arbre_a_supprimer).noeuds); |
|
free(s_arbre_a_supprimer); |
|
break; |
|
} |
|
|
|
// s_arbre_a_supprimer contient la structure de feuille qui |
|
// vient d'être libérée. Il s'agit maintenant |
|
// d'annuler le pointeur dans le tableau noeuds de la structure |
|
// pointée par noeud_pere, soit s_arbre_courant. |
|
|
|
BUG((*s_arbre_a_supprimer).indice_tableau_pere < 0, |
|
uprintf("Invalid pointer !\n")); |
|
(*s_arbre_courant).noeuds[(*s_arbre_a_supprimer) |
|
.indice_tableau_pere] = NULL; |
|
|
|
free((*s_arbre_a_supprimer).noeuds); |
|
free(s_arbre_a_supprimer); |
|
|
|
BUG((*s_arbre_courant).noeuds_utilises == 0, |
|
uprintf("Freed node !\n")); |
|
(*s_arbre_courant).noeuds_utilises--; |
|
} |
} |
} |
|
else |
|
{ |
|
// Cas 2 : |
|
// On retire la variable de la liste. |
|
|
position_supprimee = (*s_etat_processus).position_variable_courante; |
variable_a_supprimer = (*s_etat_processus) |
|
.pointeur_feuille_courante; |
|
|
liberation(s_etat_processus, (*s_etat_processus).s_liste_variables |
(*(*(*s_etat_processus).pointeur_feuille_courante).precedent) |
[position_supprimee].objet); |
.suivant = (*(*s_etat_processus).pointeur_feuille_courante) |
free((*s_etat_processus).s_liste_variables[position_supprimee].nom); |
.suivant; |
|
(*(*(*s_etat_processus).pointeur_feuille_courante).suivant) |
|
.precedent = (*(*s_etat_processus) |
|
.pointeur_feuille_courante).precedent; |
|
} |
|
|
|
// Dans tous les cas, on retire la variable de la liste des variables |
|
// par niveau. |
|
|
(*s_etat_processus).nombre_variables--; |
niveau = (*(*variable_a_supprimer).variable).niveau; |
|
variables_par_niveau = (*s_etat_processus).l_liste_variables_par_niveau; |
|
|
for(position_courante = position_supprimee; |
if (variables_par_niveau != NULL) |
position_courante < (*s_etat_processus).nombre_variables; |
|
position_courante++) |
|
{ |
{ |
(*s_etat_processus).s_liste_variables[position_courante] = |
do |
(*s_etat_processus).s_liste_variables |
{ |
[position_courante + 1]; |
l_element_courant = (*variables_par_niveau).liste; |
|
|
|
if (l_element_courant != NULL) |
|
{ |
|
if ((*((struct_variable *) (*l_element_courant).donnee)) |
|
.niveau == niveau) |
|
{ |
|
// On parcourt le bon niveau. |
|
|
|
l_element_precedent = NULL; |
|
|
|
while(l_element_courant != NULL) |
|
{ |
|
// Tant que l_element_courant est non nul, il reste |
|
// des variables à explorer dans le niveau courant. |
|
|
|
if ((*l_element_courant).donnee == |
|
(void *) (*variable_a_supprimer).variable) |
|
{ |
|
// On a trouvé la variable à supprimer. |
|
|
|
if (l_element_precedent == NULL) |
|
{ |
|
(*variables_par_niveau).liste = |
|
(*l_element_courant).suivant; |
|
} |
|
else |
|
{ |
|
(*l_element_precedent).suivant = |
|
(*l_element_courant).suivant; |
|
} |
|
|
|
free(l_element_courant); |
|
break; |
|
} |
|
|
|
l_element_precedent = l_element_courant; |
|
l_element_courant = (*l_element_courant).suivant; |
|
} |
|
} |
|
} |
|
|
|
variables_par_niveau = (*variables_par_niveau).suivant; |
|
|
|
} while(variables_par_niveau != (*s_etat_processus) |
|
.l_liste_variables_par_niveau); |
} |
} |
|
|
|
// Puis on libère le contenu de la variable. |
|
|
|
free((*(*variable_a_supprimer).variable).nom); |
|
liberation(s_etat_processus, (*(*variable_a_supprimer).variable).objet); |
|
|
erreur = d_absence_erreur; |
erreur = d_absence_erreur; |
} |
} |
else |
else |
{ |
{ |
|
// Aucune variable n'est accessible depuis le point courant du |
|
// programme. |
|
|
erreur = d_erreur; |
erreur = d_erreur; |
(*s_etat_processus).erreur_systeme = d_es_variable_introuvable; |
(*s_etat_processus).erreur_systeme = d_es_variable_introuvable; |
} |
} |
|
|
return erreur; |
return(erreur); |
} |
} |
|
|
|
|
/* |
/* |
================================================================================ |
================================================================================ |
Procédure de recherche d'une variable par son nom dans la base |
Procédure de retrait des variables de niveau strictement supérieur au |
|
niveau courant |
================================================================================ |
================================================================================ |
Entrée : |
Entrée : |
-------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
Line 355 retrait_variable(struct_processus *s_eta
|
Line 969 retrait_variable(struct_processus *s_eta
|
*/ |
*/ |
|
|
logical1 |
logical1 |
recherche_variable(struct_processus *s_etat_processus, |
retrait_variable_par_niveau(struct_processus *s_etat_processus) |
unsigned char *nom_variable) |
|
{ |
{ |
logical1 existence_variable; |
struct_liste_variables *l_element_a_supprimer; |
|
|
long difference; |
|
long difference_inferieure; |
|
long difference_superieure; |
|
|
|
struct_liste_pile_systeme *l_element_courant; |
// Utilisation du champ (*s_etat_processus).liste_variables_par_niveau. |
|
// La tête de la pile contient toujours les variables de plus haut niveau |
unsigned long borne_inferieure; |
// créées. |
unsigned long borne_superieure; |
|
unsigned long moyenne; |
|
unsigned long niveau_appel; |
|
unsigned long nombre_iterations_maximal; |
|
unsigned long ordre_iteration; |
|
|
|
if ((*s_etat_processus).nombre_variables == 0) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_variable_introuvable; |
|
return d_faux; |
|
} |
|
|
|
ordre_iteration = 0; |
while((*s_etat_processus).l_liste_variables_par_niveau != NULL) |
nombre_iterations_maximal = ((unsigned long) |
|
(log((*s_etat_processus).nombre_variables) / log(2))) + 2; |
|
|
|
borne_inferieure = 0; |
|
borne_superieure = (*s_etat_processus).nombre_variables - 1; |
|
|
|
do |
|
{ |
{ |
moyenne = (borne_inferieure + borne_superieure) / 2; |
if ((*(*s_etat_processus).l_liste_variables_par_niveau).liste == NULL) |
ordre_iteration++; |
|
|
|
if (((borne_inferieure + borne_superieure) % 2) == 0) |
|
{ |
{ |
difference = strcmp(nom_variable, |
// Si le niveau ne contient aucune variable, on le détruit. |
((*s_etat_processus).s_liste_variables)[moyenne].nom); |
// Le pointeur sur la chaîne est déjà nul et il ne reste rien à |
|
// faire. |
if (difference != 0) |
|
{ |
|
if (difference > 0) |
|
{ |
|
borne_inferieure = moyenne; |
|
} |
|
else |
|
{ |
|
borne_superieure = moyenne; |
|
} |
|
} |
|
} |
} |
else |
else |
{ |
{ |
difference_inferieure = strcmp(nom_variable, |
// Le niveau contient des variables. |
((*s_etat_processus).s_liste_variables)[moyenne].nom); |
|
difference_superieure = strcmp(nom_variable, |
|
((*s_etat_processus).s_liste_variables)[moyenne + 1].nom); |
|
|
|
if (difference_inferieure == 0) |
if ((*((struct_variable *) (*(*(*s_etat_processus) |
{ |
.l_liste_variables_par_niveau).liste).donnee)).niveau |
difference = 0; |
<= (*s_etat_processus).niveau_courant) |
} |
{ |
else if (difference_superieure == 0) |
// On a retiré de l'arbre des variables toutes les |
{ |
// variables de niveau strictement supérieur au niveau |
difference = 0; |
// courant. |
moyenne++; |
|
|
break; |
} |
} |
else |
|
|
while((*(*s_etat_processus).l_liste_variables_par_niveau).liste |
|
!= NULL) |
{ |
{ |
difference = difference_inferieure; |
// Sauvegarde des variables statiques. |
|
|
if (difference > 0) |
if ((*((struct_variable *) (*(*(*s_etat_processus) |
|
.l_liste_variables_par_niveau).liste).donnee)).origine |
|
== 'P') |
{ |
{ |
borne_inferieure = moyenne; |
if ((*((struct_variable *) (*(*(*s_etat_processus) |
|
.l_liste_variables_par_niveau).liste).donnee)) |
|
.variable_statique.adresse != 0) |
|
{ |
|
if (recherche_variable_statique(s_etat_processus, |
|
(*((struct_variable *) (*(*(*s_etat_processus) |
|
.l_liste_variables_par_niveau).liste).donnee)) |
|
.nom, (*((struct_variable *) |
|
(*(*(*s_etat_processus) |
|
.l_liste_variables_par_niveau).liste).donnee)) |
|
.variable_statique, ((*s_etat_processus) |
|
.mode_execution_programme |
|
== 'Y') ? 'P' : 'E') == d_vrai) |
|
{ |
|
(*s_etat_processus).s_liste_variables_statiques |
|
[(*s_etat_processus) |
|
.position_variable_statique_courante] |
|
.objet = (*((struct_variable *) |
|
(*(*(*s_etat_processus) |
|
.l_liste_variables_par_niveau).liste) |
|
.donnee)).objet; |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_variable_introuvable; |
|
} |
|
|
|
(*((struct_variable *) (*(*(*s_etat_processus) |
|
.l_liste_variables_par_niveau).liste).donnee)) |
|
.objet = NULL; |
|
} |
} |
} |
else |
else |
{ |
{ |
borne_superieure = moyenne; |
if ((*((struct_variable *) (*(*(*s_etat_processus) |
} |
.l_liste_variables_par_niveau).liste).donnee)) |
} |
.variable_statique.pointeur != NULL) |
} |
{ |
} while((difference != 0) && |
/* |
(ordre_iteration <= nombre_iterations_maximal)); |
* Gestion des variables statiques |
|
*/ |
|
|
|
if (recherche_variable_statique(s_etat_processus, |
|
(*((struct_variable *) (*(*(*s_etat_processus) |
|
.l_liste_variables_par_niveau).liste).donnee)) |
|
.nom, (*((struct_variable *) |
|
(*(*(*s_etat_processus) |
|
.l_liste_variables_par_niveau).liste).donnee)) |
|
.variable_statique, ((*s_etat_processus) |
|
.mode_execution_programme |
|
== 'Y') ? 'P' : 'E') == d_vrai) |
|
{ |
|
(*s_etat_processus).s_liste_variables_statiques |
|
[(*s_etat_processus) |
|
.position_variable_statique_courante] |
|
.objet = (*((struct_variable *) |
|
(*(*(*s_etat_processus) |
|
.l_liste_variables_par_niveau).liste) |
|
.donnee)).objet; |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_variable_introuvable; |
|
return(d_erreur); |
|
} |
|
|
if (ordre_iteration > nombre_iterations_maximal) |
(*((struct_variable *) (*(*(*s_etat_processus) |
{ |
.l_liste_variables_par_niveau).liste).donnee)) |
existence_variable = d_faux; |
.objet = NULL; |
(*s_etat_processus).erreur_systeme = d_es_variable_introuvable; |
} |
} |
} |
else |
|
{ |
|
if ((moyenne + 1) < (*s_etat_processus).nombre_variables) |
|
{ |
|
while(strcmp(((*s_etat_processus).s_liste_variables) |
|
[moyenne + 1].nom, nom_variable) == 0) |
|
{ |
|
moyenne++; |
|
|
|
if ((moyenne + 1) >= (*s_etat_processus).nombre_variables) |
if (retrait_variable(s_etat_processus, |
|
(*((struct_variable *) (*(*(*s_etat_processus) |
|
.l_liste_variables_par_niveau).liste).donnee)).nom, |
|
'L') == d_erreur) |
{ |
{ |
break; |
return(d_erreur); |
} |
} |
} |
} |
} |
} |
|
|
(*s_etat_processus).position_variable_courante = moyenne; |
// On retire l'élément de la liste doublement chaînée et circulaire. |
|
|
if ((*s_etat_processus).s_liste_variables[(*s_etat_processus) |
(*(*(*s_etat_processus).l_liste_variables_par_niveau).precedent).suivant |
.position_variable_courante].niveau > 1) |
= (*(*s_etat_processus).l_liste_variables_par_niveau).suivant; |
{ |
(*(*(*s_etat_processus).l_liste_variables_par_niveau).suivant).precedent |
// La variable trouvée est une variable locale. |
= (*(*s_etat_processus).l_liste_variables_par_niveau).precedent; |
// On vérifie qu'elle est accessible à la définition |
|
// courante. |
l_element_a_supprimer = (*s_etat_processus) |
|
.l_liste_variables_par_niveau; |
|
(*s_etat_processus).l_liste_variables_par_niveau = |
|
(*l_element_a_supprimer).suivant; |
|
free(l_element_a_supprimer); |
|
} |
|
|
niveau_appel = (*s_etat_processus).niveau_courant; |
return(d_absence_erreur); |
l_element_courant = (*s_etat_processus).l_base_pile_systeme; |
} |
|
|
if (l_element_courant == NULL) |
|
{ |
|
(*s_etat_processus).erreur_systeme = d_es_pile_vide; |
|
existence_variable = d_faux; |
|
|
|
return existence_variable; |
/* |
} |
================================================================================ |
|
Procédure de retrait des toutes les variables locales et globales |
|
================================================================================ |
|
Entrée : drapeau indiquant s'il faut retirer les définitions (variables |
|
de niveau 0) |
|
-------------------------------------------------------------------------------- |
|
Sortie : |
|
-------------------------------------------------------------------------------- |
|
Effets de bord : néant |
|
================================================================================ |
|
*/ |
|
|
while((*l_element_courant).retour_definition != 'Y') |
void |
{ |
liberation_arbre_variables(struct_processus *s_etat_processus, |
l_element_courant = (*l_element_courant).suivant; |
struct_arbre_variables *arbre, logical1 retrait_definitions) |
|
{ |
|
int i; |
|
|
if (l_element_courant == NULL) |
struct_liste_chainee *l_element_courant_liste; |
{ |
struct_liste_chainee *l_element_suivant_liste; |
(*s_etat_processus).erreur_systeme = d_es_pile_vide; |
|
existence_variable = d_faux; |
|
|
|
return existence_variable; |
struct_liste_variables *l_element_courant; |
} |
struct_liste_variables *l_element_suivant; |
} |
|
|
|
niveau_appel = (*l_element_courant).niveau_courant; |
// 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 |
|
// de la liste des variables par niveau. |
|
|
if (niveau_appel < (*s_etat_processus).s_liste_variables |
l_element_courant = (*arbre).feuille; |
[(*s_etat_processus).position_variable_courante].niveau) |
|
{ |
|
existence_variable = d_vrai; |
|
} |
|
else |
|
{ |
|
existence_variable = d_faux; |
|
|
|
// La variable locale n'est pas accessible. On regarde si par |
if (l_element_courant != NULL) |
// hasard il existe une variable globale. |
{ |
|
do |
|
{ |
|
l_element_suivant = (*l_element_courant).suivant; |
|
free(l_element_courant); |
|
l_element_courant = l_element_suivant; |
|
} while(l_element_courant != (*arbre).feuille); |
|
} |
|
|
while((*s_etat_processus).position_variable_courante != 0) |
for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++) |
|
{ |
|
if ((*arbre).noeuds[i] != NULL) |
|
{ |
|
liberation_arbre_variables(s_etat_processus, (*arbre).noeuds[i], |
|
retrait_definitions); |
|
} |
|
} |
|
|
|
// Suppression de la liste des variables par niveau. |
|
|
|
if (arbre == (*s_etat_processus).s_arbre_variables) |
|
{ |
|
l_element_courant = (*s_etat_processus).l_liste_variables_par_niveau; |
|
|
|
if (l_element_courant != NULL) |
|
{ |
|
do |
|
{ |
|
l_element_courant_liste = (*l_element_courant).liste; |
|
|
|
while(l_element_courant_liste != NULL) |
{ |
{ |
if (strcmp(((*s_etat_processus).s_liste_variables) |
if ((retrait_definitions == d_vrai) || |
[(*s_etat_processus).position_variable_courante - 1] .nom, nom_variable) == 0) |
((*((struct_variable *) (*l_element_courant_liste) |
|
.donnee)).niveau >= 1)) |
{ |
{ |
(*s_etat_processus).position_variable_courante--; |
liberation(s_etat_processus, (*((struct_variable *) |
} |
(*l_element_courant_liste).donnee)).objet); |
else |
free((*((struct_variable *) (*l_element_courant_liste) |
{ |
.donnee)).nom); |
if ((*s_etat_processus).s_liste_variables |
free((*l_element_courant_liste).donnee); |
[(*s_etat_processus).position_variable_courante] |
|
.niveau <= 1) |
|
{ |
|
existence_variable = d_vrai; |
|
} |
|
|
|
break; |
|
} |
} |
} |
|
|
|
if ((strcmp(((*s_etat_processus).s_liste_variables) |
l_element_suivant_liste = |
[(*s_etat_processus).position_variable_courante].nom, |
(*l_element_courant_liste).suivant; |
nom_variable) == 0) && ((*s_etat_processus) |
free(l_element_courant_liste); |
.s_liste_variables[(*s_etat_processus) |
l_element_courant_liste = l_element_suivant_liste; |
.position_variable_courante].niveau <= 1)) |
|
{ |
|
existence_variable = d_vrai; |
|
} |
} |
} |
|
} |
|
else |
|
{ |
|
// La variable trouvée est soit un pointeur sur une définition |
|
// (niveau 0), soit une variable globale (niveau 1). |
|
|
|
existence_variable = d_vrai; |
l_element_suivant = (*l_element_courant).suivant; |
|
free(l_element_courant); |
|
l_element_courant = l_element_suivant; |
|
} while(l_element_courant != (*s_etat_processus) |
|
.l_liste_variables_par_niveau); |
} |
} |
} |
} |
|
|
return existence_variable; |
free((*arbre).noeuds); |
|
free(arbre); |
|
|
|
return; |
} |
} |
|
|
|
|
/* |
/* |
================================================================================ |
================================================================================ |
Procédure de retrait des variables de niveau strictement supérieur au |
Procédure de copie de l'arbre des variables |
niveau courant |
|
================================================================================ |
================================================================================ |
Entrée : |
Entrée : |
-------------------------------------------------------------------------------- |
-------------------------------------------------------------------------------- |
Line 565 recherche_variable(struct_processus *s_e
|
Line 1219 recherche_variable(struct_processus *s_e
|
================================================================================ |
================================================================================ |
*/ |
*/ |
|
|
logical1 |
struct_arbre_variables * |
retrait_variable_par_niveau(struct_processus *s_etat_processus) |
copie_arbre_variables(struct_processus *s_etat_processus) |
{ |
{ |
unsigned long i; |
// Les définitions sont partagées entre tous les threads et ne sont pas |
unsigned long j; |
// copiées. |
|
// |
|
// NB : on ne copie que les variables de niveaux 0 et 1, les autres |
|
// variables locales étant masquées par le processus de création de thread |
|
// ou de processus, elles sont inaccessibles. |
|
|
struct_variable *tampon; |
BUG(1, uprintf("Oops !\n")); |
|
|
for(j = 0, i = 0; i < (*s_etat_processus).nombre_variables; i++) |
return(d_absence_erreur); |
{ |
} |
if ((*s_etat_processus).s_liste_variables[i].niveau <= |
|
(*s_etat_processus).niveau_courant) |
|
{ |
|
(*s_etat_processus).s_liste_variables[j++] = |
|
(*s_etat_processus).s_liste_variables[i]; |
|
} |
|
else |
|
{ |
|
if ((*s_etat_processus).s_liste_variables[i].origine == 'P') |
|
{ |
|
if ((*s_etat_processus).s_liste_variables[i] |
|
.variable_statique.adresse != 0) |
|
{ |
|
/* |
|
* Gestion des variables statiques |
|
*/ |
|
|
|
if (recherche_variable_statique(s_etat_processus, |
|
(*s_etat_processus).s_liste_variables[i] |
|
.nom, (*s_etat_processus).s_liste_variables |
|
[i].variable_statique, ((*s_etat_processus) |
|
.mode_execution_programme |
|
== 'Y') ? 'P' : 'E') == d_vrai) |
|
{ |
|
(*s_etat_processus).s_liste_variables_statiques |
|
[(*s_etat_processus) |
|
.position_variable_statique_courante] |
|
.objet = (*s_etat_processus) |
|
.s_liste_variables[i].objet; |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_variable_introuvable; |
|
} |
|
|
|
(*s_etat_processus).s_liste_variables[i].objet = NULL; |
|
} |
|
} |
|
else |
|
{ |
|
if ((*s_etat_processus).s_liste_variables[i] |
|
.variable_statique.pointeur != NULL) |
|
{ |
|
/* |
|
* Gestion des variables statiques |
|
*/ |
|
|
|
if (recherche_variable_statique(s_etat_processus, |
|
(*s_etat_processus).s_liste_variables[i] |
|
.nom, (*s_etat_processus).s_liste_variables[i] |
|
.variable_statique, ((*s_etat_processus) |
|
.mode_execution_programme |
|
== 'Y') ? 'P' : 'E') == d_vrai) |
|
{ |
|
(*s_etat_processus).s_liste_variables_statiques |
|
[(*s_etat_processus) |
|
.position_variable_statique_courante] |
|
.objet = (*s_etat_processus) |
|
.s_liste_variables[i].objet; |
|
} |
|
else |
|
{ |
|
(*s_etat_processus).erreur_systeme = |
|
d_es_variable_introuvable; |
|
} |
|
|
|
(*s_etat_processus).s_liste_variables[i].objet = NULL; |
/* |
} |
================================================================================ |
} |
Procédure d'initialisation de la table de correspondance des variables |
|
================================================================================ |
|
Entrée : |
|
-------------------------------------------------------------------------------- |
|
Sortie : |
|
-------------------------------------------------------------------------------- |
|
Effets de bord : néant |
|
================================================================================ |
|
*/ |
|
|
free((*s_etat_processus).s_liste_variables[i].nom); |
/* |
liberation(s_etat_processus, |
* Caractères autorisés dans les instructions |
(*s_etat_processus).s_liste_variables[i].objet); |
* |
} |
* A B C D E F G H I J K L M N O P Q R S T U V W X Y Z |
} |
* a b c d e f g h i j k l m n o p q r s t u v w x y z |
|
* _ |
|
* 1 2 3 4 5 6 7 8 9 0 |
|
*/ |
|
|
|
void |
|
initialisation_variables(struct_processus *s_etat_processus) |
|
{ |
|
int decalage; |
|
int i; |
|
int longueur_tableau; |
|
|
(*s_etat_processus).nombre_variables = j; |
unsigned char caractere; |
|
|
if ((*s_etat_processus).nombre_variables < |
// Récupération de la longueur d'un unsigned char |
((*s_etat_processus).nombre_variables_allouees / 2)) |
|
|
longueur_tableau = 1; |
|
decalage = 0; |
|
caractere = 1; |
|
|
|
while((1L << decalage) == (long) ((unsigned char) (caractere << decalage))) |
{ |
{ |
(*s_etat_processus).nombre_variables_allouees /= 2; |
decalage++; |
|
longueur_tableau *= 2; |
|
} |
|
|
if ((tampon = realloc((*s_etat_processus).s_liste_variables, |
if (((*s_etat_processus).pointeurs_caracteres_variables = |
(*s_etat_processus).nombre_variables_allouees * |
malloc(longueur_tableau * sizeof(int))) == NULL) |
sizeof(struct_variable))) == NULL) |
{ |
{ |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire; |
return; |
return(d_erreur); |
} |
} |
|
|
|
(*s_etat_processus).s_liste_variables = tampon; |
for(i = 0; i < longueur_tableau; i++) |
|
{ |
|
(*s_etat_processus).pointeurs_caracteres_variables[i] = -1; |
} |
} |
|
|
return(d_absence_erreur); |
(*s_etat_processus).nombre_caracteres_variables = 0; |
|
|
|
#define DECLARATION_CARACTERE(c) \ |
|
do { (*s_etat_processus).pointeurs_caracteres_variables[c] = \ |
|
(*s_etat_processus).nombre_caracteres_variables++; } while(0) |
|
|
|
DECLARATION_CARACTERE('A'); |
|
DECLARATION_CARACTERE('B'); |
|
DECLARATION_CARACTERE('C'); |
|
DECLARATION_CARACTERE('D'); |
|
DECLARATION_CARACTERE('E'); |
|
DECLARATION_CARACTERE('F'); |
|
DECLARATION_CARACTERE('G'); |
|
DECLARATION_CARACTERE('H'); |
|
DECLARATION_CARACTERE('I'); |
|
DECLARATION_CARACTERE('J'); |
|
DECLARATION_CARACTERE('K'); |
|
DECLARATION_CARACTERE('L'); |
|
DECLARATION_CARACTERE('M'); |
|
DECLARATION_CARACTERE('N'); |
|
DECLARATION_CARACTERE('O'); |
|
DECLARATION_CARACTERE('P'); |
|
DECLARATION_CARACTERE('Q'); |
|
DECLARATION_CARACTERE('R'); |
|
DECLARATION_CARACTERE('S'); |
|
DECLARATION_CARACTERE('T'); |
|
DECLARATION_CARACTERE('U'); |
|
DECLARATION_CARACTERE('V'); |
|
DECLARATION_CARACTERE('W'); |
|
DECLARATION_CARACTERE('X'); |
|
DECLARATION_CARACTERE('Y'); |
|
DECLARATION_CARACTERE('Z'); |
|
|
|
DECLARATION_CARACTERE('a'); |
|
DECLARATION_CARACTERE('b'); |
|
DECLARATION_CARACTERE('c'); |
|
DECLARATION_CARACTERE('d'); |
|
DECLARATION_CARACTERE('e'); |
|
DECLARATION_CARACTERE('f'); |
|
DECLARATION_CARACTERE('g'); |
|
DECLARATION_CARACTERE('h'); |
|
DECLARATION_CARACTERE('i'); |
|
DECLARATION_CARACTERE('j'); |
|
DECLARATION_CARACTERE('k'); |
|
DECLARATION_CARACTERE('l'); |
|
DECLARATION_CARACTERE('m'); |
|
DECLARATION_CARACTERE('n'); |
|
DECLARATION_CARACTERE('o'); |
|
DECLARATION_CARACTERE('p'); |
|
DECLARATION_CARACTERE('q'); |
|
DECLARATION_CARACTERE('r'); |
|
DECLARATION_CARACTERE('s'); |
|
DECLARATION_CARACTERE('t'); |
|
DECLARATION_CARACTERE('u'); |
|
DECLARATION_CARACTERE('v'); |
|
DECLARATION_CARACTERE('w'); |
|
DECLARATION_CARACTERE('x'); |
|
DECLARATION_CARACTERE('y'); |
|
DECLARATION_CARACTERE('z'); |
|
|
|
DECLARATION_CARACTERE('_'); |
|
|
|
DECLARATION_CARACTERE('1'); |
|
DECLARATION_CARACTERE('2'); |
|
DECLARATION_CARACTERE('3'); |
|
DECLARATION_CARACTERE('4'); |
|
DECLARATION_CARACTERE('5'); |
|
DECLARATION_CARACTERE('6'); |
|
DECLARATION_CARACTERE('7'); |
|
DECLARATION_CARACTERE('8'); |
|
DECLARATION_CARACTERE('9'); |
|
DECLARATION_CARACTERE('0'); |
|
#undef DECLARATION_CARACTERE |
|
|
|
return; |
} |
} |
|
|
// vim: ts=4 |
// vim: ts=4 |