[BACK]Return to gestion_variables.c CVS log [TXT] [DIR] Up to [local] / rpl / src

Diff for /rpl/src/gestion_variables.c between versions 1.28 and 1.34

version 1.28, 2011/06/08 13:35:15 version 1.34, 2011/06/20 17:34:10
Line 25 Line 25
   
 /*  /*
 ================================================================================  ================================================================================
     Fonction de debug
   ================================================================================
     Entrée :
   --------------------------------------------------------------------------------
     Sortie :
   --------------------------------------------------------------------------------
     Effets de bords : néant
   ================================================================================
   */
   
   static void
   liste_variables_par_niveaux(struct_processus *s_etat_processus)
   {
       int                     c;
   
       logical1                fin;
   
       struct_liste_variables  *l;
   
       struct_liste_chainee    *e;
   
       printf("===========================================================\n");
       printf("  Liste des variables par niveaux\n");
       printf("===========================================================\n");
   
       if ((*s_etat_processus).l_liste_variables_par_niveau == NULL)
       {
           printf("===========================================================\n");
           return;
       }
   
       printf("Backward\n");
       l = (*s_etat_processus).l_liste_variables_par_niveau;
       c = 0;
       fin = d_faux;
   
       do
       {
           l = l->precedent;
           e = l->liste;
   
           while(e != NULL)
           {
               printf("%s (%p, %d) ", ((struct_variable *) e->donnee)->nom,
                       e->donnee, ((struct_variable *) e->donnee)->niveau);
               e = e->suivant;
               c++;
               if (c > 100)
               {
                   fin = d_vrai;
                   break;
               }
           }
   
           printf("\n");
   
       } while(l != (*s_etat_processus).l_liste_variables_par_niveau);
   
       printf("Forward\n");
       l = (*s_etat_processus).l_liste_variables_par_niveau;
       c = 0;
   
       do
       {
           e = l->liste;
   
           while(e != NULL)
           {
               printf("%s (%p, %d) ", ((struct_variable *) e->donnee)->nom,
                       e->donnee, ((struct_variable *) e->donnee)->niveau);
               e = e->suivant;
               c++;
               if (c > 100) exit(0);
           }
   
           printf("\n");
   
           l = l->suivant;
       } while(l != (*s_etat_processus).l_liste_variables_par_niveau);
   
       printf("===========================================================\n");
   
       if (fin == d_vrai) exit(0);
   
       return;
   }
   
   static void
   liste_variables_tas(struct_processus *s_etat_processus,
           struct_arbre_variables *arbre)
   {
       int                     c;
       int                     i;
   
       logical1                fin;
   
       struct_liste_variables  *l;
   
       fin = d_faux;
   
       if (arbre == NULL)
       {
           return;
       }
   
       printf(">>> Position :                  %d\n",
               (*arbre).indice_tableau_pere);
       printf(">>> Nombre de noeuds utilisés : %u\n",
               (*arbre).noeuds_utilises);
       printf(">>> Noeuds fils : ");
   
       for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
       {
           if ((*arbre).noeuds[i] != NULL)
           {
               printf("%d ", i);
           }
       }
   
       printf("\b\n");
   
       if ((*arbre).feuille != NULL)
       {
           printf("Feuille %p [%d]\n", (*arbre).feuille, (*arbre).noeuds_utilises);
   
           printf("  Backward\n");
   
           l = (*arbre).feuille;
           c = 0;
           fin = d_faux;
   
           do
           {
               l = l->precedent;
               c++;
               if (c > 100)
               {
                   fin = d_vrai;
                   break;
               }
               printf("    %s (%p, %d)\n", l->variable->nom, l->variable,
                       l->variable->niveau);
           } while((*arbre).feuille != l);
   
           printf("  Forward\n");
   
           l = (*arbre).feuille;
           c = 0;
   
           do
           {
               c++;
               if (c > 100) exit(0);
               printf("    %s (%p, %d)\n", l->variable->nom, l->variable,
                       l->variable->niveau);
               l = l->suivant;
           } while((*arbre).feuille != l);
       }
   
       printf("-----------------------------------------------------------\n");
   
       for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
       {
           if ((*arbre).noeuds[i] != NULL)
           {
   
               liste_variables_tas(s_etat_processus, (*arbre).noeuds[i]);
           }
       }
   
       if (fin == d_vrai) exit(0);
   
       return;
   }
   
   
   static void
   liste_variables_par_feuilles(struct_processus *s_etat_processus)
   {
       printf("===========================================================\n");
       printf("  Liste des variables sur le tas\n");
       printf("===========================================================\n");
   
       liste_variables_tas(s_etat_processus,
               (*s_etat_processus).s_arbre_variables);
   
       printf("===========================================================\n");
   
       return;
   }
   
   
   /*
   ================================================================================
   Routine de création d'une nouvelle variable    Routine de création d'une nouvelle variable
   Entrée : autorisation_creation_variable_statique vaut 'V' ou 'S'.  ================================================================================
   Dans le cas 'V', la variable est volatile.    Entrée : autorisation_creation_variable_statique vaut 'v' ou 's'.
   Dans le cas 'S', elle est statique.    dans le cas 'v', la variable est volatile.
   Entrée : autorisation_creation_variable_partagee vaut 'P' ou 'S'.    dans le cas 's', elle est statique.
   Dans le cas 'P', la variable est privée.    Entrée : autorisation_creation_variable_partagee vaut 'p' ou 's'.
   Dans le cas 'S', elle est partagée.    dans le cas 'p', la variable est privée.
     dans le cas 's', elle est partagée.
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Sortie :    Sortie :
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
Line 44  ajout_variable(struct_processus *s_etat_ Line 239  ajout_variable(struct_processus *s_etat_
 {  {
     int                         i;      int                         i;
   
       logical1                    niveau_acceptable;
   
     struct_liste_variables      *l_nouvelle_variable;      struct_liste_variables      *l_nouvelle_variable;
     struct_liste_variables      *l_variable_candidate;      struct_liste_variables      *l_variable_candidate;
   
     struct_arbre_variables      *l_variable_courante;      struct_arbre_variables      *l_variable_courante;
     struct_arbre_variables      *l_variable_precedente;      struct_arbre_variables      *l_variable_precedente;
   
Line 53  ajout_variable(struct_processus *s_etat_ Line 251  ajout_variable(struct_processus *s_etat_
   
     unsigned char               *ptr;      unsigned char               *ptr;
   
       void                        *pointeur_variable_cree;
   
     if ((*s_etat_processus).s_arbre_variables == NULL)      if ((*s_etat_processus).s_arbre_variables == NULL)
     {      {
         if (((*s_etat_processus).s_arbre_variables =          if (((*s_etat_processus).s_arbre_variables =
Line 64  ajout_variable(struct_processus *s_etat_ Line 264  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).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).noeud_pere = NULL;          (*(*s_etat_processus).s_arbre_variables).noeud_pere = NULL;
   
         if (((*(*s_etat_processus).arbre_instructions).noeud =          if (((*(*s_etat_processus).s_arbre_variables).noeuds =
                 malloc((*s_etat_processus).nombre_caracteres_variables                  malloc((*s_etat_processus).nombre_caracteres_variables
                 * sizeof(struct_arbre_variables))) == NULL)                  * sizeof(struct_arbre_variables))) == NULL)
         {          {
Line 93  ajout_variable(struct_processus *s_etat_ Line 294  ajout_variable(struct_processus *s_etat_
         if ((*l_variable_courante).noeuds[(*s_etat_processus)          if ((*l_variable_courante).noeuds[(*s_etat_processus)
                 .pointeurs_caracteres_variables[*ptr]] == NULL)                  .pointeurs_caracteres_variables[*ptr]] == NULL)
         {          {
             // Le noeud n'existe pas encore, on le crée.              // 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)              if (((*l_variable_courante).noeuds[(*s_etat_processus)
                     .pointeurs_caracteres_variables[*ptr]] =                      .pointeurs_caracteres_variables[*ptr]] =
Line 104  ajout_variable(struct_processus *s_etat_ Line 306  ajout_variable(struct_processus *s_etat_
             }              }
   
             (*l_variable_courante).noeuds_utilises++;              (*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)              (*(*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]]).noeuds_utilises = 0;                      .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)              (*(*l_variable_courante).noeuds[(*s_etat_processus)
                     .pointeurs_caracteres_variables[*ptr]]).noeud_pere =                      .pointeurs_caracteres_variables[*ptr]]).noeud_pere =
                     l_variable_precedente;                      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)              if (((*(*l_variable_courante).noeuds[(*s_etat_processus)
                     .pointeurs_caracteres_variables[*ptr]]).noeuds =                      .pointeurs_caracteres_variables[*ptr]]).noeuds =
Line 149  ajout_variable(struct_processus *s_etat_ Line 371  ajout_variable(struct_processus *s_etat_
             return(d_erreur);              return(d_erreur);
         }          }
   
           (*l_variable_courante).noeuds_utilises++;
   
         (*(*l_variable_courante).feuille).suivant =          (*(*l_variable_courante).feuille).suivant =
                 (*l_variable_courante).feuille;                  (*l_variable_courante).feuille;
         (*(*l_variable_courante).feuille).precedent =          (*(*l_variable_courante).feuille).precedent =
                 (*l_variable_courante).feuille;                  (*l_variable_courante).feuille;
         (*(*l_variable_courante).feuille).noeud_pere = l_variable_precedente;          (*(*l_variable_courante).feuille).noeud_pere = l_variable_precedente;
           (*(*l_variable_courante).feuille).noeud = l_variable_courante;
   
         // Allocation de la variable sur l'élément de la liste.          // Allocation de la variable sur l'élément de la liste.
   
Line 166  ajout_variable(struct_processus *s_etat_ Line 391  ajout_variable(struct_processus *s_etat_
   
         (*((struct_variable *) (*(*l_variable_courante).feuille).variable)) =          (*((struct_variable *) (*(*l_variable_courante).feuille).variable)) =
                 (*s_variable);                  (*s_variable);
           pointeur_variable_cree = (*(*l_variable_courante).feuille).variable;
         if (((*((struct_variable *) (*(*l_variable_courante).feuille).variable))  
                 .nom = strdup((*s_variable).nom)) == NULL)  
         {  
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
             return(d_erreur);  
         }  
     }      }
     else      else
     {      {
Line 201  ajout_variable(struct_processus *s_etat_ Line 420  ajout_variable(struct_processus *s_etat_
             (*l_nouvelle_variable).precedent = (*(*l_variable_courante).feuille)              (*l_nouvelle_variable).precedent = (*(*l_variable_courante).feuille)
                     .precedent;                      .precedent;
             (*l_nouvelle_variable).noeud_pere = l_variable_precedente;              (*l_nouvelle_variable).noeud_pere = l_variable_precedente;
               (*l_nouvelle_variable).noeud = l_variable_courante;
             (*(*(*l_variable_courante).feuille).precedent).suivant =              (*(*(*l_variable_courante).feuille).precedent).suivant =
                     l_nouvelle_variable;                      l_nouvelle_variable;
             (*(*l_variable_courante).feuille).precedent =              (*(*l_variable_courante).feuille).precedent =
Line 216  ajout_variable(struct_processus *s_etat_ Line 436  ajout_variable(struct_processus *s_etat_
   
             (*((struct_variable *) (*(*l_variable_courante).feuille).variable))              (*((struct_variable *) (*(*l_variable_courante).feuille).variable))
                     = (*s_variable);                      = (*s_variable);
               pointeur_variable_cree = (*(*l_variable_courante).feuille).variable;
             if (((*((struct_variable *) (*(*l_variable_courante).feuille)  
                     .variable)).nom = strdup((*s_variable).nom)) == NULL)  
             {  
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
                 return(d_erreur);  
             }  
         }          }
         else          else
         {          {
Line 244  ajout_variable(struct_processus *s_etat_ Line 458  ajout_variable(struct_processus *s_etat_
             } while((l_variable_candidate != (*l_variable_courante).feuille) &&              } while((l_variable_candidate != (*l_variable_courante).feuille) &&
                     ((*(*l_variable_candidate).variable).niveau <= 1));                      ((*(*l_variable_candidate).variable).niveau <= 1));
   
               BUG((*s_variable).niveau == 0,
                       uprintf("Attempt to create a level-0 variable!\n"));
   
             if ((*(*(*(*l_variable_courante).feuille).precedent).variable)              if ((*(*(*(*l_variable_courante).feuille).precedent).variable)
                     .niveau > 1)                      .niveau > 1)
             {              {
                 // Ajout inconditionnel des variables de niveaux 0 et 1                  // La variable précédente est de niveau strictement supérieur
                   // à 1. Il ne peut donc y avoir aucune variable de niveau
                   // inférieur ou égal à 1 puisque la boucle est triée.
                   // On insère donc directement la variable en queue.
             }              }
             else              else
             {              {
                   // Le niveau de la variable précédente dans la boucle est
                   // inférieur ou égal à 1.
                 l_variable_candidate = (*(*l_variable_courante).feuille)                  l_variable_candidate = (*(*l_variable_courante).feuille)
                         .precedent;                          .precedent;
             }              }
Line 259  ajout_variable(struct_processus *s_etat_ Line 481  ajout_variable(struct_processus *s_etat_
             (*l_nouvelle_variable).precedent = (*l_variable_candidate)              (*l_nouvelle_variable).precedent = (*l_variable_candidate)
                     .precedent;                      .precedent;
             (*l_nouvelle_variable).noeud_pere = l_variable_precedente;              (*l_nouvelle_variable).noeud_pere = l_variable_precedente;
               (*l_nouvelle_variable).noeud = l_variable_courante;
             (*(*l_variable_candidate).precedent).suivant = l_nouvelle_variable;              (*(*l_variable_candidate).precedent).suivant = l_nouvelle_variable;
             (*l_variable_candidate).precedent = l_nouvelle_variable;              (*l_variable_candidate).precedent = l_nouvelle_variable;
   
               // Si la variable suivant la variable que l'on vient d'insérer
               // dans la boucle est de niveau 0, la variable insérée est par
               // construction de niveau 1 et il convient de modifier le
               // pointeur de feuille pointant sur l'élément de plus haut niveau
               // de la boucle.
   
               if ((*(*(*l_nouvelle_variable).precedent).variable).niveau == 0)
               {
                   (*(*l_nouvelle_variable).noeud).feuille = l_nouvelle_variable;
               }
   
             if (((*l_nouvelle_variable).variable =              if (((*l_nouvelle_variable).variable =
                     malloc(sizeof(struct_variable))) == NULL)                      malloc(sizeof(struct_variable))) == NULL)
             {               { 
Line 270  ajout_variable(struct_processus *s_etat_ Line 504  ajout_variable(struct_processus *s_etat_
             }              }
   
             (*(*l_nouvelle_variable).variable) = (*s_variable);              (*(*l_nouvelle_variable).variable) = (*s_variable);
               pointeur_variable_cree = (*l_nouvelle_variable).variable;
             if (((*(*l_nouvelle_variable).variable).nom =  
                     strdup((*s_variable).nom)) == NULL)  
             {  
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
                 return(d_erreur);  
             }  
         }          }
     }      }
   
Line 298  ajout_variable(struct_processus *s_etat_ Line 526  ajout_variable(struct_processus *s_etat_
         (*l_nouvelle_variable).suivant = l_nouvelle_variable;          (*l_nouvelle_variable).suivant = l_nouvelle_variable;
         (*l_nouvelle_variable).precedent = l_nouvelle_variable;          (*l_nouvelle_variable).precedent = l_nouvelle_variable;
         (*l_nouvelle_variable).noeud_pere = NULL;          (*l_nouvelle_variable).noeud_pere = NULL;
           (*l_nouvelle_variable).liste = NULL;
   
         (*s_etat_processus).l_liste_variables_par_niveau = l_nouvelle_variable;          (*s_etat_processus).l_liste_variables_par_niveau = 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;
     }      }
     else if ((*s_variable).niveau > (*((struct_variable *)      else if ((*s_variable).niveau > (*((struct_variable *)
             (*(*(*s_etat_processus).l_liste_variables_par_niveau).liste)              (*(*(*s_etat_processus).l_liste_variables_par_niveau).liste)
Line 319  ajout_variable(struct_processus *s_etat_ Line 562  ajout_variable(struct_processus *s_etat_
         (*l_nouvelle_variable).precedent = (*(*s_etat_processus)          (*l_nouvelle_variable).precedent = (*(*s_etat_processus)
                 .l_liste_variables_par_niveau).precedent;                  .l_liste_variables_par_niveau).precedent;
         (*l_nouvelle_variable).noeud_pere = NULL;          (*l_nouvelle_variable).noeud_pere = NULL;
           (*l_nouvelle_variable).liste = NULL;
         (*(*(*s_etat_processus).l_liste_variables_par_niveau).precedent)          (*(*(*s_etat_processus).l_liste_variables_par_niveau).precedent)
                 .suivant = l_nouvelle_variable;                  .suivant = l_nouvelle_variable;
         (*(*s_etat_processus).l_liste_variables_par_niveau).precedent =          (*(*s_etat_processus).l_liste_variables_par_niveau)
                 l_nouvelle_variable;                  .precedent = l_nouvelle_variable;
   
         (*s_etat_processus).l_liste_variables_par_niveau = l_nouvelle_variable;          (*s_etat_processus).l_liste_variables_par_niveau = l_nouvelle_variable;
     }  
     else  
     {  
         // Création d'une variable de niveau 0 ou 1  
   
         if ((l_nouvelle_variable = malloc(sizeof(struct_liste_variables)))          // Ajout de la variable en tête de la liste
                 == NULL)  
           if ((l_nouvel_element = malloc(sizeof(struct_liste_chainee))) == 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);
         }          }
   
           (*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;
       }
       else if ((*s_variable).niveau <= 1)
       {
           // Création d'une variable de niveau 0 ou 1. Il convient de
           // chercher dans la liste si un niveau 0 ou 1 préexiste. Pour cela, on
           // regarde la position courante et les deux précédentes.
   
         l_variable_candidate = (*s_etat_processus).l_liste_variables_par_niveau;          l_variable_candidate = (*s_etat_processus).l_liste_variables_par_niveau;
           niveau_acceptable = d_faux;
   
         if ((*((struct_variable *) (*(*(*(*s_etat_processus)          for(i = 0; i <= 2; i++)
                 .l_liste_variables_par_niveau).precedent).liste).donnee))  
                 .niveau > 1)  
         {          {
             // Ajout inconditionnel des variables de niveaux 0 et 1              if ((*l_variable_candidate).liste == NULL)
               {
                   continue;
               }
   
               if ((*((struct_variable *) (*(*l_variable_candidate)
                       .liste).donnee)).niveau == (*s_variable).niveau)
               {
                   niveau_acceptable = d_vrai;
                   break;
               }
   
               l_variable_candidate = (*l_variable_candidate).precedent;
         }          }
         else  
           if (niveau_acceptable == d_faux)
         {          {
             l_variable_candidate = (*(*s_etat_processus)              if ((l_nouvelle_variable = malloc(sizeof(struct_liste_variables)))
                     .l_liste_variables_par_niveau).precedent;                      == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return(d_erreur);
               }
   
               l_variable_candidate =
                       (*(*s_etat_processus).l_liste_variables_par_niveau)
                       .precedent;
   
               // On ne peut créer qu'une variable de niveau supérieur ou égal à
               // 1 lors de l'exécution normale d'un programme. Les variables
               // de niveau 0 sont créées à l'initialisation et relèvent du
               // cas précédent car il n'existe lors de leur création aucun
               // niveau non nul.
   
               BUG((*s_variable).niveau == 0,
                       uprintf("Attempt to create a level-0 variable!\n"));
   
               (*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;
   
               l_variable_candidate = l_nouvelle_variable;
         }          }
   
         (*l_nouvelle_variable).suivant = l_variable_candidate;          // Ajout de la variable en tête de la liste l_variable_candidate.
         (*l_nouvelle_variable).precedent = (*l_variable_candidate)  
                 .precedent;  
         (*l_nouvelle_variable).noeud_pere = 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);
           }
   
     if ((l_nouvel_element = malloc(sizeof(struct_liste_chainee))) == NULL)          (*l_nouvel_element).suivant = (*l_variable_candidate).liste;
     {          (*l_nouvel_element).donnee = pointeur_variable_cree;
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;          (*l_variable_candidate).liste = l_nouvel_element;
         return(d_erreur);  
     }      }
       else
       {
           // Ajout de la variable en tête de la liste
   
     (*l_nouvel_element).suivant = (*(*s_etat_processus)          if ((l_nouvel_element = malloc(sizeof(struct_liste_chainee))) == NULL)
             .l_liste_variables_par_niveau).liste;          {
     (*l_nouvel_element).donnee = (struct_objet *) s_variable;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
     (*l_nouvelle_variable).liste = l_nouvel_element;              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);      return(d_absence_erreur);
 }  }
   
   
 logical1  logical1
 creation_variable(struct_processus *s_etat_processus,  creation_variable(struct_processus *s_etat_processus,
         struct_variable *s_variable,          struct_variable *s_variable,
Line 527  recherche_variable(struct_processus *s_e Line 828  recherche_variable(struct_processus *s_e
     if ((*s_etat_processus).s_arbre_variables == NULL)      if ((*s_etat_processus).s_arbre_variables == NULL)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_variable_introuvable;          (*s_etat_processus).erreur_systeme = d_es_variable_introuvable;
         return d_faux;          return(d_faux);
     }      }
   
     l_variable_courante = (*s_etat_processus).s_arbre_variables;      l_variable_courante = (*s_etat_processus).s_arbre_variables;
Line 540  recherche_variable(struct_processus *s_e Line 841  recherche_variable(struct_processus *s_e
         if (pointeur < 0)          if (pointeur < 0)
         {          {
             // Caractère hors de l'alphabet des variables              // Caractère hors de l'alphabet des variables
             return(d_erreur);  
               (*s_etat_processus).erreur_systeme = d_es_variable_introuvable;
               return(d_faux);
         }          }
   
         if ((*l_variable_courante).noeuds[pointeur] == NULL)          if ((*l_variable_courante).noeuds[pointeur] == NULL)
         {          {
             // Le chemin de la variable candidate n'existe pas.              // Le chemin de la variable candidate n'existe pas.
             return(d_erreur);              (*s_etat_processus).erreur_systeme = d_es_variable_introuvable;
               return(d_faux);
         }          }
   
         l_variable_courante = (*l_variable_courante).noeuds[pointeur];          l_variable_courante = (*l_variable_courante).noeuds[pointeur];
Line 564  recherche_variable(struct_processus *s_e Line 868  recherche_variable(struct_processus *s_e
         {          {
             // Problème : la pile système est vide !              // Problème : la pile système est vide !
             (*s_etat_processus).erreur_systeme = d_es_pile_vide;              (*s_etat_processus).erreur_systeme = d_es_pile_vide;
             return(d_erreur);              return(d_faux);
         }          }
   
         while((*l_element_courant).retour_definition != 'Y')          while((*l_element_courant).retour_definition != 'Y')
Line 574  recherche_variable(struct_processus *s_e Line 878  recherche_variable(struct_processus *s_e
             if (l_element_courant == NULL)              if (l_element_courant == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_pile_vide;                  (*s_etat_processus).erreur_systeme = d_es_pile_vide;
                 return(d_erreur);                  return(d_faux);
             }              }
         }          }
   
Line 589  recherche_variable(struct_processus *s_e Line 893  recherche_variable(struct_processus *s_e
                     (*(*l_variable_courante).feuille).variable;                      (*(*l_variable_courante).feuille).variable;
             (*s_etat_processus).pointeur_feuille_courante =              (*s_etat_processus).pointeur_feuille_courante =
                     (*l_variable_courante).feuille;                      (*l_variable_courante).feuille;
             return(d_absence_erreur);              return(d_vrai);
         }          }
         else          else
         {          {
Line 606  recherche_variable(struct_processus *s_e Line 910  recherche_variable(struct_processus *s_e
                 (*s_etat_processus).pointeur_variable_courante =                  (*s_etat_processus).pointeur_variable_courante =
                         (*(*(*l_variable_courante).feuille).precedent).variable;                          (*(*(*l_variable_courante).feuille).precedent).variable;
                 (*s_etat_processus).pointeur_feuille_courante =                  (*s_etat_processus).pointeur_feuille_courante =
                         (*l_variable_courante).feuille;                          (*(*l_variable_courante).feuille).precedent;
   
                 // S'il existe une variable de niveau 0 et une seconde de                  // S'il existe une variable de niveau 0 et une seconde de
                 // niveau 1, la variable de niveau 0 (fonction) est masquée                  // niveau 1, la variable de niveau 0 (fonction) est masquée
                 // par celle de niveau 1.                  // par celle de niveau 1.
   
                 if (((*(*(*l_variable_courante).feuille).variable).niveau == 0)                  if (((*(*(*(*l_variable_courante).feuille).precedent)
                         && ((*(*(*(*l_variable_courante).feuille).precedent)                          .variable).niveau == 0) && ((*(*(*(*
                           (*l_variable_courante).feuille).precedent).precedent)
                         .variable).niveau == 1))                          .variable).niveau == 1))
                 {                  {
                     (*s_etat_processus).pointeur_variable_courante =                      (*s_etat_processus).pointeur_variable_courante =
                               (*(*(*(*l_variable_courante).feuille).precedent)
                               .precedent).variable;
                       (*s_etat_processus).pointeur_feuille_courante =
                             (*(*(*l_variable_courante).feuille).precedent)                              (*(*(*l_variable_courante).feuille).precedent)
                               .precedent;
                   }
   
                   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:
               {
                   // La variable est une définition.
                   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;                              .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 =
                             (*l_variable_courante).feuille;                              (*(*(*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;
                 }                  }
   
                 return(d_absence_erreur);                  break;
             }              }
         }          }
     }      }
   
     return(d_erreur);      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(presence_variable);
 }  }
   
   
Line 650  retrait_variable(struct_processus *s_eta Line 1027  retrait_variable(struct_processus *s_eta
         unsigned char *nom_variable, unsigned char type)          unsigned char *nom_variable, unsigned char type)
 {  {
     logical1                    erreur;      logical1                    erreur;
       logical1                    variable_supprimee;
   
     struct_arbre_variables      *s_arbre_a_supprimer;      struct_arbre_variables      *s_arbre_a_supprimer;
     struct_arbre_variables      *s_arbre_courant;      struct_arbre_variables      *s_arbre_courant;
Line 742  retrait_variable(struct_processus *s_eta Line 1120  retrait_variable(struct_processus *s_eta
   
             variable_a_supprimer = (*s_etat_processus)              variable_a_supprimer = (*s_etat_processus)
                     .pointeur_feuille_courante;                      .pointeur_feuille_courante;
             s_arbre_courant = (*variable_a_supprimer).noeud_pere;              //s_arbre_courant = (*variable_a_supprimer).noeud_pere;
               s_arbre_courant = (*variable_a_supprimer).noeud;
             BUG((*s_arbre_courant).noeuds_utilises == 0,              BUG((*s_arbre_courant).noeuds_utilises == 0,
                     uprintf("Freed node !\n"));                      uprintf("Freed node !\n"));
             (*s_arbre_courant).noeuds_utilises--;              (*s_arbre_courant).noeuds_utilises--;
   
               (*((*(*variable_a_supprimer).noeud_pere).noeuds
                       [(*(*variable_a_supprimer).noeud).indice_tableau_pere]))
                       .feuille = NULL;
   
             while((*s_arbre_courant).noeuds_utilises == 0)              while((*s_arbre_courant).noeuds_utilises == 0)
             {              {
                 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;
   
                 free((*s_arbre_a_supprimer).noeuds);  
                 free(s_arbre_a_supprimer);  
   
                 if (s_arbre_courant == NULL)                  if (s_arbre_courant == NULL)
                 {                  {
                       free((*s_arbre_a_supprimer).noeuds);
                       free(s_arbre_a_supprimer);
   
                       (*s_etat_processus).s_arbre_variables = NULL;
                     break;                      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,                  BUG((*s_arbre_courant).noeuds_utilises == 0,
                         uprintf("Freed node !\n"));                          uprintf("Freed node !\n"));
                 (*s_arbre_courant).noeuds_utilises--;                  (*s_arbre_courant).noeuds_utilises--;
Line 780  retrait_variable(struct_processus *s_eta Line 1176  retrait_variable(struct_processus *s_eta
             (*(*(*s_etat_processus).pointeur_feuille_courante).suivant)              (*(*(*s_etat_processus).pointeur_feuille_courante).suivant)
                     .precedent = (*(*s_etat_processus)                      .precedent = (*(*s_etat_processus)
                     .pointeur_feuille_courante).precedent;                      .pointeur_feuille_courante).precedent;
   
               // Mise à jour du pointeur dans l'arbre des variables. Cette
               // mise à jour n'est nécessaire que dans le cas où la variable
               // supprimée est en tête de la liste.
   
               if (variable_a_supprimer == (*((*(*variable_a_supprimer).noeud_pere)
                       .noeuds[(*(*variable_a_supprimer).noeud)
                       .indice_tableau_pere])).feuille)
               {
                   (*((*(*variable_a_supprimer).noeud_pere).noeuds
                           [(*(*variable_a_supprimer).noeud).indice_tableau_pere]))
                           .feuille = (*(*((*(*variable_a_supprimer).noeud_pere)
                           .noeuds[(*(*variable_a_supprimer).noeud)
                           .indice_tableau_pere])).feuille).suivant;
               }
   
               (*s_etat_processus).pointeur_feuille_courante =
                       (*(*s_etat_processus).pointeur_feuille_courante).suivant;
               (*s_etat_processus).pointeur_variable_courante =
                       (*(*s_etat_processus).pointeur_feuille_courante).variable;
         }          }
   
         // Dans tous les cas, on retire la variable de la liste des variables          // Dans tous les cas, on retire la variable de la liste des variables
Line 787  retrait_variable(struct_processus *s_eta Line 1203  retrait_variable(struct_processus *s_eta
   
         niveau = (*(*variable_a_supprimer).variable).niveau;          niveau = (*(*variable_a_supprimer).variable).niveau;
         variables_par_niveau = (*s_etat_processus).l_liste_variables_par_niveau;          variables_par_niveau = (*s_etat_processus).l_liste_variables_par_niveau;
           variable_supprimee = d_faux;
   
         while(variables_par_niveau != NULL)          if (variables_par_niveau != NULL)
         {          {
             l_element_courant = (*variables_par_niveau).liste;              do
   
             if (l_element_courant != NULL)  
             {              {
                 if ((*((struct_variable *) (*l_element_courant).donnee)).niveau                  l_element_courant = (*variables_par_niveau).liste;
                         == niveau)  
                 {  
                     // On parcourt le bon niveau.  
   
                     l_element_precedent = NULL;  
   
                     while(l_element_courant != NULL)                  if (l_element_courant != NULL)
                   {
                       if ((*((struct_variable *) (*l_element_courant).donnee))
                               .niveau == niveau)
                     {                      {
                         // Tant que l_element_courant est non nul, il reste des                          // On parcourt le bon niveau.
                         // variables à explorer dans le niveau courant.  
   
                         if ((*l_element_courant).donnee ==                          l_element_precedent = NULL;
                                 (void *) (*variable_a_supprimer).variable)  
                           while(l_element_courant != NULL)
                         {                          {
                             // On a trouvé la variable à supprimer.                              // Tant que l_element_courant est non nul, il reste
                               // des variables à explorer dans le niveau courant.
   
                             if (l_element_precedent == NULL)                              if ((*l_element_courant).donnee ==
                             {                                      (void *) (*variable_a_supprimer).variable)
                                 (*variables_par_niveau).liste =  
                                         (*l_element_courant).suivant;  
                             }  
                             else  
                             {                              {
                                 (*l_element_precedent).suivant =                                  // On a trouvé la variable à supprimer.
                                         (*l_element_courant).suivant;  
                                   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);
   
                                   if ((*variables_par_niveau).liste == NULL)
                                   {
                                       if ((*s_etat_processus)
                                               .l_liste_variables_par_niveau
                                               == variables_par_niveau)
                                       {
                                           // On retire l'élément de la liste
                                           // pointé par
                                           // l_liste_variable_par_niveau
   
                                           (*s_etat_processus)
                                                   .l_liste_variables_par_niveau =
                                                   (*variables_par_niveau).suivant;
                                       }
   
                                       (*(*variables_par_niveau).precedent)
                                               .suivant =
                                               (*variables_par_niveau).suivant;
                                       (*(*variables_par_niveau).suivant)
                                               .precedent =
                                               (*variables_par_niveau)
                                               .precedent;
                                       free(variables_par_niveau);
                                   }
   
                                   variable_supprimee = d_vrai;
                                   break;
                             }                              }
                         }  
   
                         l_element_precedent = l_element_courant;                              l_element_precedent = l_element_courant;
                         l_element_courant = (*l_element_courant).suivant;                              l_element_courant = (*l_element_courant).suivant;
                           }
                     }                      }
                 }                  }
             }  
   
             variables_par_niveau = (*variables_par_niveau).suivant;                  if (variable_supprimee == d_vrai)
                   {
                       break;
                   }
   
                   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.          // Puis on libère le contenu de la variable.
   
         free((*(*variable_a_supprimer).variable).nom);          free((*(*variable_a_supprimer).variable).nom);
         liberation(s_etat_processus, (*(*variable_a_supprimer).variable).objet);          liberation(s_etat_processus, (*(*variable_a_supprimer).variable).objet);
           free((*variable_a_supprimer).variable);
           free(variable_a_supprimer);
   
         erreur = d_absence_erreur;          erreur = d_absence_erreur;
     }      }
Line 868  retrait_variable(struct_processus *s_eta Line 1327  retrait_variable(struct_processus *s_eta
 logical1  logical1
 retrait_variable_par_niveau(struct_processus *s_etat_processus)  retrait_variable_par_niveau(struct_processus *s_etat_processus)
 {  {
       struct_liste_variables          *l_element_a_supprimer;
   
     // Utilisation du champ (*s_etat_processus).liste_variables_par_niveau.      // Utilisation du champ (*s_etat_processus).liste_variables_par_niveau.
     // La tête de la pile contient toujours les variables de plus haut niveau      // La tête de la pile contient toujours les variables de plus haut niveau
     // créées.      // créées.
   
     struct_liste_variables          *l_niveau_suivant;  
   
     while((*s_etat_processus).l_liste_variables_par_niveau != NULL)      while((*s_etat_processus).l_liste_variables_par_niveau != NULL)
     {      {
         l_niveau_suivant = (*(*s_etat_processus).l_liste_variables_par_niveau)  
                 .suivant;  
   
         if ((*(*s_etat_processus).l_liste_variables_par_niveau).liste == NULL)          if ((*(*s_etat_processus).l_liste_variables_par_niveau).liste == NULL)
         {          {
             // Si le niveau ne contient aucune variable, on le détruit.              // Si le niveau ne contient aucune variable, on le détruit.
Line 903  retrait_variable_par_niveau(struct_proce Line 1359  retrait_variable_par_niveau(struct_proce
             while((*(*s_etat_processus).l_liste_variables_par_niveau).liste              while((*(*s_etat_processus).l_liste_variables_par_niveau).liste
                     != NULL)                      != NULL)
             {              {
                   // Nécessaire car le pointeur sur la tête de la pile
                   // peut être modifié par retrait_variable().
                 // Sauvegarde des variables statiques.                  // Sauvegarde des variables statiques.
   
                 if ((*((struct_variable *) (*(*(*s_etat_processus)                  if ((*((struct_variable *) (*(*(*s_etat_processus)
Line 990  retrait_variable_par_niveau(struct_proce Line 1448  retrait_variable_par_niveau(struct_proce
                 {                  {
                     return(d_erreur);                      return(d_erreur);
                 }                  }
   
                   if ((*((struct_variable *) (*(*(*s_etat_processus)
                           .l_liste_variables_par_niveau).liste).donnee)).niveau
                           <= (*s_etat_processus).niveau_courant)
                   {
                       // On a retiré de l'arbre des variables toutes les
                       // variables de niveau strictement supérieur au niveau
                       // courant.
   
                       return(d_absence_erreur);
                   }
             }              }
         }          }
   
         free((*s_etat_processus).l_liste_variables_par_niveau);          // On retire l'élément de la liste doublement chaînée et circulaire.
         (*s_etat_processus).l_liste_variables_par_niveau = l_niveau_suivant;  
           (*(*(*s_etat_processus).l_liste_variables_par_niveau).precedent).suivant
                   = (*(*s_etat_processus).l_liste_variables_par_niveau).suivant;
           (*(*(*s_etat_processus).l_liste_variables_par_niveau).suivant).precedent
                   = (*(*s_etat_processus).l_liste_variables_par_niveau).precedent;
   
           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);
     }      }
   
     return(d_absence_erreur);      return(d_absence_erreur);
Line 1030  liberation_arbre_variables(struct_proces Line 1509  liberation_arbre_variables(struct_proces
     // 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
     // de la liste des variables par niveau.      // de la liste des variables par niveau.
   
       if (arbre == NULL)
       {
           return;
       }
   
       l_element_courant = (*arbre).feuille;
   
       if (l_element_courant != NULL)
       {
           do
           {
               l_element_suivant = (*l_element_courant).suivant;
               free(l_element_courant);
               l_element_courant = l_element_suivant;
           } while(l_element_courant != (*arbre).feuille);
       }
   
     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)
         {          {
             l_element_courant = (*arbre).feuille;  
   
             while(l_element_courant != NULL)  
             {  
                 l_element_suivant = (*l_element_courant).suivant;  
                 free(l_element_courant);  
                 l_element_courant = l_element_suivant;  
             }  
   
             liberation_arbre_variables(s_etat_processus, (*arbre).noeuds[i],              liberation_arbre_variables(s_etat_processus, (*arbre).noeuds[i],
                     retrait_definitions);                      retrait_definitions);
         }          }
Line 1054  liberation_arbre_variables(struct_proces Line 1541  liberation_arbre_variables(struct_proces
     {      {
         l_element_courant = (*s_etat_processus).l_liste_variables_par_niveau;          l_element_courant = (*s_etat_processus).l_liste_variables_par_niveau;
   
         while(l_element_courant != NULL)          if (l_element_courant != NULL)
         {          {
             l_element_courant_liste = (*l_element_courant).liste;              do
   
             while(l_element_courant_liste != NULL)  
             {              {
                 if ((retrait_definitions == d_vrai) ||                  l_element_courant_liste = (*l_element_courant).liste;
                         ((*((struct_variable *) (*l_element_courant_liste)  
                         .donnee)).niveau >= 1))                  while(l_element_courant_liste != NULL)
                 {                  {
                     liberation(s_etat_processus, (*((struct_variable *)                      if ((retrait_definitions == d_vrai) ||
                             (*l_element_courant_liste).donnee)).objet);                              ((*((struct_variable *) (*l_element_courant_liste)
                     free((*((struct_variable *) (*l_element_courant_liste)                              .donnee)).niveau >= 1))
                             .donnee)).nom);                      {
                     free((*l_element_courant_liste).donnee);                          liberation(s_etat_processus, (*((struct_variable *)
                 }                                  (*l_element_courant_liste).donnee)).objet);
                           free((*((struct_variable *) (*l_element_courant_liste)
                                   .donnee)).nom);
                           free((*l_element_courant_liste).donnee);
                       }
   
                 l_element_suivant_liste = (*l_element_courant_liste).suivant;                      l_element_suivant_liste =
                 free(l_element_courant_liste);                              (*l_element_courant_liste).suivant;
                 l_element_courant_liste = l_element_suivant_liste;                      free(l_element_courant_liste);
             }                      l_element_courant_liste = l_element_suivant_liste;
                   }
   
             l_element_suivant = (*l_element_courant).suivant;                  l_element_suivant = (*l_element_courant).suivant;
             free(l_element_courant);                  free(l_element_courant);
             l_element_courant = l_element_suivant;                  l_element_courant = l_element_suivant;
               } while(l_element_courant != (*s_etat_processus)
                       .l_liste_variables_par_niveau);
         }          }
     }      }
   
Line 1091  liberation_arbre_variables(struct_proces Line 1583  liberation_arbre_variables(struct_proces
   
 /*  /*
 ================================================================================  ================================================================================
     Procédure renvoyant les variables dans un tableau
   ================================================================================
     Entrée :
   --------------------------------------------------------------------------------
     Sortie :
   --------------------------------------------------------------------------------
     Effets de bord : néant
   ================================================================================
   */
   
   int
   nombre_variables(struct_processus *s_etat_processus,
           struct_arbre_variables *l_element_courant)
   {
       int                     i;
       int                     n;
   
       struct_liste_variables  *l_variable;
   
       n = 0;
   
       if ((*l_element_courant).feuille != NULL)
       {
           l_variable = (*l_element_courant).feuille;
   
           do
           {
               n++;
               l_variable = (*l_variable).suivant;
           } while(l_variable != (*l_element_courant).feuille);
       }
   
       for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
       {
           if ((*l_element_courant).noeuds[i] != NULL)
           {
               n += nombre_variables(s_etat_processus,
                       (*l_element_courant).noeuds[i]);
           }
       }
   
       return(n);
   }
   
   int
   liste_variables(struct_processus *s_etat_processus,
           struct_tableau_variables *tableau, int position,
           struct_arbre_variables *l_element_courant)
   {
       int                     i;
   
       struct_liste_variables  *l_variable;
   
       if ((*l_element_courant).feuille != NULL)
       {
           l_variable = (*l_element_courant).feuille;
   
           do
           {
               tableau[position].origine = (*(*l_variable).variable).origine;
               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 =
                       (*(*l_variable).variable).variable_verrouillee;
               tableau[position].variable_statique =
                       (*(*l_variable).variable).variable_statique;
               tableau[position].variable_partagee =
                       (*(*l_variable).variable).variable_partagee;
   
               position++;
               l_variable = (*l_variable).suivant;
           } while(l_variable != (*l_element_courant).feuille);
       }
   
       for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
       {
           if ((*l_element_courant).noeuds[i] != NULL)
           {
               position = liste_variables(s_etat_processus,
                       tableau, position, (*l_element_courant).noeuds[i]);
           }
       }
   
       return(position);
   }
   
   /*
   ================================================================================
   Procédure de copie de l'arbre des variables    Procédure de copie de l'arbre des variables
 ================================================================================  ================================================================================
   Entrée :    Entrée :
Removed from v.1.28  
changed lines
  Added in v.1.34

CVSweb interface <joel.bertrand@systella.fr>