[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.26 and 1.28

version 1.26, 2011/04/21 16:00:55 version 1.28, 2011/06/08 13:35:15
Line 44  ajout_variable(struct_processus *s_etat_ Line 44  ajout_variable(struct_processus *s_etat_
 {  {
     int                         i;      int                         i;
   
     struct_arbre_variables      *l_variable_courante;  
   
     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_precedente;
   
     struct_liste_chainee        *l_nouvel_element;      struct_liste_chainee        *l_nouvel_element;
   
Line 64  ajout_variable(struct_processus *s_etat_ Line 64  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).noeud_pere = NULL;
   
         if (((*(*s_etat_processus).arbre_instructions).noeud =          if (((*(*s_etat_processus).arbre_instructions).noeud =
                 malloc((*s_etat_processus).nombre_caracteres_variables                  malloc((*s_etat_processus).nombre_caracteres_variables
Line 75  ajout_variable(struct_processus *s_etat_ Line 76  ajout_variable(struct_processus *s_etat_
   
         for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)          for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
         {          {
             (*(*s_etat_processus).s_arbre_variables).noeud[i] = NULL;              (*(*s_etat_processus).s_arbre_variables).noeuds[i] = NULL;
         }          }
     }      }
   
       l_variable_precedente = NULL;
     l_variable_courante = (*s_etat_processus).s_arbre_variables;      l_variable_courante = (*s_etat_processus).s_arbre_variables;
     ptr = (*s_variable).nom;      ptr = (*s_variable).nom;
   
Line 88  ajout_variable(struct_processus *s_etat_ Line 90  ajout_variable(struct_processus *s_etat_
                 printf("Variable=\"%s\", (*ptr)='%c'\n", (*s_variable).nom,                  printf("Variable=\"%s\", (*ptr)='%c'\n", (*s_variable).nom,
                 *ptr));                  *ptr));
   
         if ((*l_variable_courante).noeud[(*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.
   
             if (((*l_variable_courante).noeud[(*s_etat_processus)              if (((*l_variable_courante).noeuds[(*s_etat_processus)
                     .pointeurs_caracteres_variables[*ptr]] =                      .pointeurs_caracteres_variables[*ptr]] =
                     malloc(sizeof(struct_arbre_variables))) == NULL)                      malloc(sizeof(struct_arbre_variables))) == NULL)
             {              {
Line 101  ajout_variable(struct_processus *s_etat_ Line 103  ajout_variable(struct_processus *s_etat_
                 return(d_erreur);                  return(d_erreur);
             }              }
   
             (*(*l_variable_courante).noeud[(*s_etat_processus)              (*l_variable_courante).noeuds_utilises++;
               (*(*l_variable_courante).noeuds[(*s_etat_processus)
                     .pointeurs_caracteres_variables[*ptr]]).feuille = NULL;                      .pointeurs_caracteres_variables[*ptr]]).feuille = NULL;
             (*(*l_variable_courante).noeud[(*s_etat_processus)              (*(*l_variable_courante).noeuds[(*s_etat_processus)
                     .pointeurs_caracteres_variables[*ptr]]).noeuds_utilises = 0;                      .pointeurs_caracteres_variables[*ptr]]).noeuds_utilises = 0;
               (*(*l_variable_courante).noeuds[(*s_etat_processus)
                       .pointeurs_caracteres_variables[*ptr]]).noeud_pere =
                       l_variable_precedente;
   
             if (((*(*l_variable_courante).noeud[(*s_etat_processus)              if (((*(*l_variable_courante).noeuds[(*s_etat_processus)
                     .pointeurs_caracteres_variables[*ptr]]).noeud =                      .pointeurs_caracteres_variables[*ptr]]).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 117  ajout_variable(struct_processus *s_etat_ Line 123  ajout_variable(struct_processus *s_etat_
   
             for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)              for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
             {              {
                 (*(*l_variable_courante).noeud[(*s_etat_processus)                  (*(*l_variable_courante).noeuds[(*s_etat_processus)
                         .pointeurs_caracteres_variables[*ptr]]).noeud[i] = NULL;                          .pointeurs_caracteres_variables[*ptr]]).noeuds[i]
                           = NULL;
             }              }
         }          }
   
         (*l_variable_courante).noeuds_utilises++;          l_variable_precedente = l_variable_courante;
         l_variable_courante = (*l_variable_courante).noeud          l_variable_courante = (*l_variable_courante).noeuds
                 [(*s_etat_processus).pointeurs_caracteres_variables[*ptr]];                  [(*s_etat_processus).pointeurs_caracteres_variables[*ptr]];
         ptr++;          ptr++;
     }      }
Line 146  ajout_variable(struct_processus *s_etat_ Line 153  ajout_variable(struct_processus *s_etat_
                 (*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;
   
         // Allocation de la variable sur l'élément de la liste.          // Allocation de la variable sur l'élément de la liste.
   
Line 168  ajout_variable(struct_processus *s_etat_ Line 176  ajout_variable(struct_processus *s_etat_
     }      }
     else      else
     {      {
           if ((l_nouvelle_variable = malloc(sizeof(struct_liste_variables)))
                   == NULL)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return(d_erreur);
           }
   
         if ((*s_variable).niveau > 1)          if ((*s_variable).niveau > 1)
         {          {
             // Cas d'une variable locale              // Cas d'une variable locale
Line 182  ajout_variable(struct_processus *s_etat_ Line 197  ajout_variable(struct_processus *s_etat_
   
             // On ajoute la variable à la liste existante.              // On ajoute la variable à la liste existante.
   
             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_variable_courante).feuille;              (*l_nouvelle_variable).suivant = (*l_variable_courante).feuille;
             (*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_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 249  ajout_variable(struct_processus *s_etat_ Line 258  ajout_variable(struct_processus *s_etat_
             (*l_nouvelle_variable).suivant = l_variable_candidate;              (*l_nouvelle_variable).suivant = l_variable_candidate;
             (*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_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;
   
Line 287  ajout_variable(struct_processus *s_etat_ Line 297  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;
   
         (*s_etat_processus).l_liste_variables_par_niveau = l_nouvelle_variable;          (*s_etat_processus).l_liste_variables_par_niveau = l_nouvelle_variable;
     }      }
Line 307  ajout_variable(struct_processus *s_etat_ Line 318  ajout_variable(struct_processus *s_etat_
                 .l_liste_variables_par_niveau;                  .l_liste_variables_par_niveau;
         (*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;
         (*(*(*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).precedent =
Line 318  ajout_variable(struct_processus *s_etat_ Line 330  ajout_variable(struct_processus *s_etat_
     {      {
         // Création d'une variable de niveau 0 ou 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;
               return(d_erreur);
           }
   
         l_variable_candidate = (*s_etat_processus).l_liste_variables_par_niveau;          l_variable_candidate = (*s_etat_processus).l_liste_variables_par_niveau;
   
         if ((*((struct_variable *) (*(*(*(*s_etat_processus)          if ((*((struct_variable *) (*(*(*(*s_etat_processus)
Line 335  ajout_variable(struct_processus *s_etat_ Line 354  ajout_variable(struct_processus *s_etat_
         (*l_nouvelle_variable).suivant = l_variable_candidate;          (*l_nouvelle_variable).suivant = l_variable_candidate;
         (*l_nouvelle_variable).precedent = (*l_variable_candidate)          (*l_nouvelle_variable).precedent = (*l_variable_candidate)
                 .precedent;                  .precedent;
           (*l_nouvelle_variable).noeud_pere = NULL;
         (*(*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;
     }      }
Line 510  recherche_variable(struct_processus *s_e Line 530  recherche_variable(struct_processus *s_e
         return d_faux;          return d_faux;
     }      }
   
       l_variable_courante = (*s_etat_processus).s_arbre_variables;
     ptr = nom_variable;      ptr = nom_variable;
   
     while((*ptr) != d_code_fin_chaine)      while((*ptr) != d_code_fin_chaine)
Line 522  recherche_variable(struct_processus *s_e Line 543  recherche_variable(struct_processus *s_e
             return(d_erreur);              return(d_erreur);
         }          }
   
         if ((*l_variable_courante).noeud[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);              return(d_erreur);
         }          }
   
         l_variable_courante = (*l_variable_courante).noeud[pointeur];          l_variable_courante = (*l_variable_courante).noeuds[pointeur];
         ptr++;          ptr++;
     }      }
   
Line 576  recherche_variable(struct_processus *s_e Line 597  recherche_variable(struct_processus *s_e
             // Dans ce cas, on prend la variable de niveau le plus bas              // Dans ce cas, on prend la variable de niveau le plus bas
             // si ce niveau est inférieur ou égal à 1 (variable globale              // si ce niveau est inférieur ou égal à 1 (variable globale
             // ou fonction définie par l'utilisateur). Si le niveau de la              // ou fonction définie par l'utilisateur). Si le niveau de la
             // plus ancienne variable est strictement supérieur à 1, el              // plus ancienne variable est strictement supérieur à 1, il
             // s'agit d'une variable locale inaccessible.              // s'agit d'une variable locale inaccessible.
   
             if ((*(*(*(*l_variable_courante).feuille).precedent).variable)              if ((*(*(*(*l_variable_courante).feuille).precedent).variable)
Line 586  recherche_variable(struct_processus *s_e Line 607  recherche_variable(struct_processus *s_e
                         (*(*(*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;
   
                   // 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_absence_erreur);                  return(d_absence_erreur);
             }              }
         }          }
Line 612  logical1 Line 649  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)
 {  {
     logical1            erreur;      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;
   
       struct_liste_variables      *variable_a_supprimer;
       struct_liste_variables      *variables_par_niveau;
   
       unsigned long               niveau;
   
     if (recherche_variable(s_etat_processus, nom_variable) == d_vrai)      if (recherche_variable(s_etat_processus, nom_variable) == d_vrai)
     {      {
Line 625  retrait_variable(struct_processus *s_eta Line 673  retrait_variable(struct_processus *s_eta
                 // La variable obtenue est une variable locale. il faut                  // La variable obtenue est une variable locale. il faut
                 // s'assurer qu'il existe une variable de niveau 1 de même                  // s'assurer qu'il existe une variable de niveau 1 de même
                 // nom sur la feuille.                  // nom sur la feuille.
             }  
   
             if ((*s_etat_processus).position_variable_courante > 0)                  if ((*(*(*(*s_etat_processus).pointeur_feuille_courante)
             {                          .precedent).variable).niveau <= 1)
                 while(strcmp((*s_etat_processus).s_liste_variables  
                         [(*s_etat_processus).position_variable_courante]  
                         .nom, nom_variable) == 0)  
                 {                  {
                     (*s_etat_processus).position_variable_courante--;                      (*s_etat_processus).pointeur_feuille_courante =
                               (*(*s_etat_processus).pointeur_feuille_courante)
                     if ((*s_etat_processus).position_variable_courante >=                              .precedent;
                             (*s_etat_processus).nombre_variables)                      (*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).
   
               variable_a_supprimer = (*s_etat_processus)
                       .pointeur_feuille_courante;
               s_arbre_courant = (*variable_a_supprimer).noeud_pere;
   
             // (*s_etat_processus).nombre_variables est forcément              BUG((*s_arbre_courant).noeuds_utilises == 0,
             // supérieur à 1 (la décrémentation est postérieure). Ce test                      uprintf("Freed node !\n"));
             // est vrai lorsque le nombre de variables allouées est              (*s_arbre_courant).noeuds_utilises--;
             // strictement supérieur à 2.  
   
             if ((s_nouvelle_base =              while((*s_arbre_courant).noeuds_utilises == 0)
                     realloc((*s_etat_processus).s_liste_variables,  
                     (*s_etat_processus).nombre_variables_allouees *  
                     sizeof(struct_variable))) == NULL)  
             {              {
                 (*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;
             }  
                   free((*s_arbre_a_supprimer).noeuds);
                   free(s_arbre_a_supprimer);
   
                   if (s_arbre_courant == NULL)
                   {
                       break;
                   }
   
             (*s_etat_processus).s_liste_variables = s_nouvelle_base;                  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.
   
               variable_a_supprimer = (*s_etat_processus)
                       .pointeur_feuille_courante;
   
         position_supprimee = (*s_etat_processus).position_variable_courante;              (*(*(*s_etat_processus).pointeur_feuille_courante).precedent)
                       .suivant = (*(*s_etat_processus).pointeur_feuille_courante)
                       .suivant;
               (*(*(*s_etat_processus).pointeur_feuille_courante).suivant)
                       .precedent = (*(*s_etat_processus)
                       .pointeur_feuille_courante).precedent;
           }
   
         liberation(s_etat_processus, (*s_etat_processus).s_liste_variables          // Dans tous les cas, on retire la variable de la liste des variables
                 [position_supprimee].objet);          // par niveau.
         free((*s_etat_processus).s_liste_variables[position_supprimee].nom);  
   
         (*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;          while(variables_par_niveau != NULL)
                 position_courante < (*s_etat_processus).nombre_variables;  
                 position_courante++)  
         {          {
             (*s_etat_processus).s_liste_variables[position_courante] =              l_element_courant = (*variables_par_niveau).liste;
                     (*s_etat_processus).s_liste_variables  
                     [position_courante + 1];              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;
                               }
                           }
   
                           l_element_precedent = l_element_courant;
                           l_element_courant = (*l_element_courant).suivant;
                       }
                   }
               }
   
               variables_par_niveau = (*variables_par_niveau).suivant;
         }          }
   
           // 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
Line 739  retrait_variable(struct_processus *s_eta Line 868  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)
 {  {
     unsigned long                   i;      // Utilisation du champ (*s_etat_processus).liste_variables_par_niveau.
     unsigned long                   j;      // La tête de la pile contient toujours les variables de plus haut niveau
       // créées.
   
     struct_variable                 *tampon;      struct_liste_variables          *l_niveau_suivant;
   
     for(j = 0, i = 0; i < (*s_etat_processus).nombre_variables; i++)      while((*s_etat_processus).l_liste_variables_par_niveau != NULL)
     {      {
         if ((*s_etat_processus).s_liste_variables[i].niveau <=          l_niveau_suivant = (*(*s_etat_processus).l_liste_variables_par_niveau)
                 (*s_etat_processus).niveau_courant)                  .suivant;
   
           if ((*(*s_etat_processus).l_liste_variables_par_niveau).liste == NULL)
         {          {
             (*s_etat_processus).s_liste_variables[j++] =              // Si le niveau ne contient aucune variable, on le détruit.
                     (*s_etat_processus).s_liste_variables[i];              // Le pointeur sur la chaîne est déjà nul et il ne reste rien à
               // faire.
         }          }
         else          else
         {          {
             if ((*s_etat_processus).s_liste_variables[i].origine == 'P')              // Le niveau contient des variables.
   
               if ((*((struct_variable *) (*(*(*s_etat_processus)
                       .l_liste_variables_par_niveau).liste).donnee)).niveau
                       <= (*s_etat_processus).niveau_courant)
             {              {
                 if ((*s_etat_processus).s_liste_variables[i]                  // On a retiré de l'arbre des variables toutes les
                         .variable_statique.adresse != 0)                  // variables de niveau strictement supérieur au niveau
                 {                  // courant.
                     /*  
                      * 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;                  break;
                 }  
             }              }
             else  
               while((*(*s_etat_processus).l_liste_variables_par_niveau).liste
                       != NULL)
             {              {
                 if ((*s_etat_processus).s_liste_variables[i]                  // Sauvegarde des variables statiques.
                         .variable_statique.pointeur != NULL)  
                   if ((*((struct_variable *) (*(*(*s_etat_processus)
                           .l_liste_variables_par_niveau).liste).donnee)).origine
                           == 'P')
                 {                  {
                     /*                      if ((*((struct_variable *) (*(*(*s_etat_processus)
                      * Gestion des variables statiques                              .l_liste_variables_par_niveau).liste).donnee))
                      */                              .variable_statique.adresse != 0)
   
                     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                          if (recherche_variable_statique(s_etat_processus,
                                 [(*s_etat_processus)                                  (*((struct_variable *) (*(*(*s_etat_processus)
                                 .position_variable_statique_courante]                                  .l_liste_variables_par_niveau).liste).donnee))
                                 .objet = (*s_etat_processus)                                  .nom, (*((struct_variable *)
                                 .s_liste_variables[i].objet;                                  (*(*(*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
                   {
                       if ((*((struct_variable *) (*(*(*s_etat_processus)
                               .l_liste_variables_par_niveau).liste).donnee))
                               .variable_statique.pointeur != NULL)
                     {                      {
                         (*s_etat_processus).erreur_systeme =                          /*
                                 d_es_variable_introuvable;                           * Gestion des variables statiques
                         return(d_erreur);                           */
   
                           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);
                           }
   
                           (*((struct_variable *) (*(*(*s_etat_processus)
                                   .l_liste_variables_par_niveau).liste).donnee))
                                   .objet = NULL;
                     }                      }
                   }
   
                     (*s_etat_processus).s_liste_variables[i].objet = NULL;                  if (retrait_variable(s_etat_processus,
                           (*((struct_variable *) (*(*(*s_etat_processus)
                           .l_liste_variables_par_niveau).liste).donnee)).nom,
                           'L') == d_erreur)
                   {
                       return(d_erreur);
                 }                  }
             }              }
   
             free((*s_etat_processus).s_liste_variables[i].nom);  
             liberation(s_etat_processus,  
                     (*s_etat_processus).s_liste_variables[i].objet);  
         }          }
     }  
   
     (*s_etat_processus).nombre_variables = j;  
   
     if ((*s_etat_processus).nombre_variables <          free((*s_etat_processus).l_liste_variables_par_niveau);
             ((*s_etat_processus).nombre_variables_allouees / 2))          (*s_etat_processus).l_liste_variables_par_niveau = l_niveau_suivant;
     {  
         (*s_etat_processus).nombre_variables_allouees /= 2;  
   
         if ((tampon = realloc((*s_etat_processus).s_liste_variables,  
                 (*s_etat_processus).nombre_variables_allouees *  
                 sizeof(struct_variable))) == NULL)  
         {  
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;  
             return(d_erreur);  
         }  
   
         (*s_etat_processus).s_liste_variables = tampon;  
     }      }
   
     return(d_absence_erreur);      return(d_absence_erreur);
Line 865  liberation_arbre_variables(struct_proces Line 1020  liberation_arbre_variables(struct_proces
 {  {
     int                     i;      int                     i;
   
     struct_liste_chainee    *l_element_courant;      struct_liste_chainee    *l_element_courant_liste;
     struct_liste_chainee    *l_element_suivant;      struct_liste_chainee    *l_element_suivant_liste;
   
       struct_liste_variables  *l_element_courant;
       struct_liste_variables  *l_element_suivant;
   
       // 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.
   
     for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)      for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
     {      {
         if ((*arbre).noeud[i] != NULL)          if ((*arbre).noeuds[i] != NULL)
         {          {
             l_element_courant = (*arbre).l_variables;              l_element_courant = (*arbre).feuille;
   
             while(l_element_courant != NULL)              while(l_element_courant != NULL)
             {              {
                 l_element_suivant = (*l_element_courant).suivant;                  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],
                       retrait_definitions);
           }
       }
   
       // Suppression de la liste des variables par niveau.
   
                 if (retrait_definitions == d_vrai)      if (arbre == (*s_etat_processus).s_arbre_variables)
       {
           l_element_courant = (*s_etat_processus).l_liste_variables_par_niveau;
   
           while(l_element_courant != NULL)
           {
               l_element_courant_liste = (*l_element_courant).liste;
   
               while(l_element_courant_liste != NULL)
               {
                   if ((retrait_definitions == d_vrai) ||
                           ((*((struct_variable *) (*l_element_courant_liste)
                           .donnee)).niveau >= 1))
                 {                  {
                     liberation(s_etat_processus, (*((struct_variable *)                      liberation(s_etat_processus, (*((struct_variable *)
                             (*l_element_courant).donnee)).objet);                              (*l_element_courant_liste).donnee)).objet);
                     free((*((struct_variable *) (*l_element_courant)                      free((*((struct_variable *) (*l_element_courant_liste)
                             .donnee)).nom);                              .donnee)).nom);
                     free((struct_variable *) (*l_element_courant).donnee);                      free((*l_element_courant_liste).donnee);
                 }  
                 else  
                 {  
                     if ((*((struct_variable *) (*l_element_courant).donnee))  
                             .niveau >= 1)  
                     {  
                         liberation(s_etat_processus, (*((struct_variable *)  
                                 (*l_element_courant).donnee)).objet);  
                         free((*((struct_variable *) (*l_element_courant)  
                                 .donnee)).nom);  
                         free((struct_variable *) (*l_element_courant).donnee);  
                     }  
                 }                  }
   
                 free(l_element_courant);                  l_element_suivant_liste = (*l_element_courant_liste).suivant;
                 l_element_courant = l_element_suivant;                  free(l_element_courant_liste);
                   l_element_courant_liste = l_element_suivant_liste;
             }              }
   
             liberation_arbre_variables(s_etat_processus, (*arbre).noeud[i]);              l_element_suivant = (*l_element_courant).suivant;
               free(l_element_courant);
               l_element_courant = l_element_suivant;
         }          }
     }      }
   
     free((*arbre).noeud);      free((*arbre).noeuds);
     free(arbre);      free(arbre);
   
     return;      return;
 }  }
   
   
 /*  /*
 ================================================================================  ================================================================================
   Procédure de copie de l'arbre des variables    Procédure de copie de l'arbre des variables
Line 930  copie_arbre_variables(struct_processus * Line 1106  copie_arbre_variables(struct_processus *
 {  {
     // Les définitions sont partagées entre tous les threads et ne sont pas      // Les définitions sont partagées entre tous les threads et ne sont pas
     // copiées.      // 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.
   
       BUG(1, uprintf("Oops !\n"));
   
     return(d_absence_erreur);      return(d_absence_erreur);
 }  }
Removed from v.1.26  
changed lines
  Added in v.1.28

CVSweb interface <joel.bertrand@systella.fr>