[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.43 and 1.91

version 1.43, 2011/06/27 09:04:55 version 1.91, 2015/02/01 22:50:00
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.0    RPL/2 (R) version 4.1.20
   Copyright (C) 1989-2011 Dr. BERTRAND Joël    Copyright (C) 1989-2015 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 237  liste_variables_par_feuilles(struct_proc Line 237  liste_variables_par_feuilles(struct_proc
 ================================================================================  ================================================================================
 */  */
   
 static inline struct_arbre_variables *  struct_arbre_variables *
 allocation_noeud(struct_processus *s_etat_processus)  allocation_noeud(struct_processus *s_etat_processus)
 {  {
     struct_arbre_variables          *objet;      struct_arbre_variables          *objet;
Line 272  liberation_noeud(struct_processus *s_eta Line 272  liberation_noeud(struct_processus *s_eta
     return;      return;
 }  }
   
 static inline struct_arbre_variables **  struct_arbre_variables **
 allocation_tableau_noeuds(struct_processus *s_etat_processus)  allocation_tableau_noeuds(struct_processus *s_etat_processus)
 {  {
     struct_arbre_variables          **objet;      struct_arbre_variables          **objet;
Line 284  allocation_tableau_noeuds(struct_process Line 284  allocation_tableau_noeuds(struct_process
     }      }
     else      else
     {      {
         objet = malloc((*s_etat_processus).nombre_caracteres_variables          objet = malloc(((size_t) (*s_etat_processus)
                   .nombre_caracteres_variables)
                 * sizeof(struct_arbre_variables *));                  * sizeof(struct_arbre_variables *));
     }      }
   
Line 426  ajout_variable(struct_processus *s_etat_ Line 427  ajout_variable(struct_processus *s_etat_
         }          }
   
         (*(*s_etat_processus).s_arbre_variables).feuille = NULL;          (*(*s_etat_processus).s_arbre_variables).feuille = NULL;
           (*(*s_etat_processus).s_arbre_variables).feuille_statique = NULL;
         (*(*s_etat_processus).s_arbre_variables).noeuds_utilises = 0;          (*(*s_etat_processus).s_arbre_variables).noeuds_utilises = 0;
         (*(*s_etat_processus).s_arbre_variables).indice_tableau_pere = -1;          (*(*s_etat_processus).s_arbre_variables).indice_tableau_pere = -1;
         (*(*s_etat_processus).s_arbre_variables).noeud_pere = NULL;          (*(*s_etat_processus).s_arbre_variables).noeud_pere = NULL;
   
         if (((*(*s_etat_processus).s_arbre_variables).noeuds =          if (((*(*s_etat_processus).s_arbre_variables).noeuds =
                     allocation_tableau_noeuds(s_etat_processus)) == NULL)                  allocation_tableau_noeuds(s_etat_processus)) == NULL)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
             return(d_erreur);              return(d_erreur);
Line 476  ajout_variable(struct_processus *s_etat_ Line 478  ajout_variable(struct_processus *s_etat_
             (*(*l_variable_courante).noeuds[(*s_etat_processus)              (*(*l_variable_courante).noeuds[(*s_etat_processus)
                     .pointeurs_caracteres_variables[*ptr]]).feuille = NULL;                      .pointeurs_caracteres_variables[*ptr]]).feuille = NULL;
             (*(*l_variable_courante).noeuds[(*s_etat_processus)              (*(*l_variable_courante).noeuds[(*s_etat_processus)
                       .pointeurs_caracteres_variables[*ptr]]).feuille_statique
                       = NULL;
               (*(*l_variable_courante).noeuds[(*s_etat_processus)
                     .pointeurs_caracteres_variables[*ptr]]).noeuds_utilises = 0;                      .pointeurs_caracteres_variables[*ptr]]).noeuds_utilises = 0;
   
             // Le champ noeud_pere de la structure créée pointe sur              // Le champ noeud_pere de la structure créée pointe sur
Line 984  recherche_variable(struct_processus *s_e Line 989  recherche_variable(struct_processus *s_e
   
     unsigned char               *ptr;      unsigned char               *ptr;
   
     unsigned long               niveau_appel;      integer8                    niveau_appel;
   
     if ((*s_etat_processus).s_arbre_variables == NULL)      if ((*s_etat_processus).s_arbre_variables == NULL)
     {      {
Line 1199  retrait_variable(struct_processus *s_eta Line 1204  retrait_variable(struct_processus *s_eta
     struct_liste_variables      *variable_a_supprimer;      struct_liste_variables      *variable_a_supprimer;
     struct_liste_variables      *variables_par_niveau;      struct_liste_variables      *variables_par_niveau;
   
     unsigned long               niveau;      integer8                    niveau;
   
     (*s_etat_processus).niveau_supprime = d_faux;      (*s_etat_processus).niveau_supprime = d_faux;
   
Line 1292  retrait_variable(struct_processus *s_eta Line 1297  retrait_variable(struct_processus *s_eta
                     [(*(*variable_a_supprimer).noeud).indice_tableau_pere]))                      [(*(*variable_a_supprimer).noeud).indice_tableau_pere]))
                     .feuille = NULL;                      .feuille = NULL;
   
             while((*s_arbre_courant).noeuds_utilises == 0)              while(((*s_arbre_courant).noeuds_utilises == 0) &&
                       ((*s_arbre_courant).feuille_statique == NULL))
             {              {
                 s_arbre_a_supprimer = s_arbre_courant;                  s_arbre_a_supprimer = s_arbre_courant;
                 s_arbre_courant = (*s_arbre_courant).noeud_pere;                  s_arbre_courant = (*s_arbre_courant).noeud_pere;
Line 1494  retrait_variable(struct_processus *s_eta Line 1500  retrait_variable(struct_processus *s_eta
 */  */
   
 logical1  logical1
 retrait_variable_par_niveau(struct_processus *s_etat_processus)  retrait_variables_par_niveau(struct_processus *s_etat_processus)
 {  {
     struct_liste_variables          *l_element_a_supprimer;      struct_liste_variables          *l_element_a_supprimer;
   
Line 1525  retrait_variable_par_niveau(struct_proce Line 1531  retrait_variable_par_niveau(struct_proce
                 break;                  break;
             }              }
   
               if (((*s_etat_processus).at_exit != NULL) &&
                       ((*s_etat_processus).niveau_courant == 0))
               {
                   // Il y a une routine ATEXIT enregistrée. On ne détruit pas
                   // les variables globales qui pourraient y être utilisées.
   
                   break;
               }
   
             while((*(*s_etat_processus).l_liste_variables_par_niveau).liste              while((*(*s_etat_processus).l_liste_variables_par_niveau).liste
                     != NULL)                      != NULL)
             {              {
Line 1548  retrait_variable_par_niveau(struct_proce Line 1563  retrait_variable_par_niveau(struct_proce
                                 .l_liste_variables_par_niveau).liste).donnee))                                  .l_liste_variables_par_niveau).liste).donnee))
                                 .variable_statique, ((*s_etat_processus)                                  .variable_statique, ((*s_etat_processus)
                                 .mode_execution_programme                                  .mode_execution_programme
                                  == 'Y') ? 'P' : 'E') == d_vrai)                                   == 'Y') ? 'P' : 'E') != NULL)
                         {                          {
                             (*s_etat_processus).s_liste_variables_statiques                              (*(*s_etat_processus)
                                     [(*s_etat_processus)                                      .pointeur_variable_statique_courante)
                                     .position_variable_statique_courante]                                      .objet = (*((struct_variable *)
                                     .objet = (*((struct_variable *)  
                                     (*(*(*s_etat_processus)                                      (*(*(*s_etat_processus)
                                     .l_liste_variables_par_niveau).liste)                                      .l_liste_variables_par_niveau).liste)
                                     .donnee)).objet;                                      .donnee)).objet;
Line 1587  retrait_variable_par_niveau(struct_proce Line 1601  retrait_variable_par_niveau(struct_proce
                                 .l_liste_variables_par_niveau).liste).donnee))                                  .l_liste_variables_par_niveau).liste).donnee))
                                 .variable_statique, ((*s_etat_processus)                                  .variable_statique, ((*s_etat_processus)
                                 .mode_execution_programme                                  .mode_execution_programme
                                  == 'Y') ? 'P' : 'E') == d_vrai)                                   == 'Y') ? 'P' : 'E') != NULL)
                         {                          {
                             (*s_etat_processus).s_liste_variables_statiques                              (*(*s_etat_processus)
                                     [(*s_etat_processus)                                      .pointeur_variable_statique_courante)
                                     .position_variable_statique_courante]  
                                     .objet = (*((struct_variable *)                                      .objet = (*((struct_variable *)
                                     (*(*(*s_etat_processus)                                      (*(*(*s_etat_processus)
                                     .l_liste_variables_par_niveau).liste)                                      .l_liste_variables_par_niveau).liste)
Line 1666  void Line 1679  void
 liberation_arbre_variables(struct_processus *s_etat_processus,  liberation_arbre_variables(struct_processus *s_etat_processus,
         struct_arbre_variables *arbre, logical1 retrait_definitions)          struct_arbre_variables *arbre, logical1 retrait_definitions)
 {  {
     int                     i;      int                                 i;
   
       struct_liste_chainee                *l_element_courant_liste;
       struct_liste_chainee                *l_element_suivant_liste;
   
     struct_liste_chainee    *l_element_courant_liste;      struct_liste_variables              *l_element_courant;
     struct_liste_chainee    *l_element_suivant_liste;      struct_liste_variables              *l_element_suivant;
   
     struct_liste_variables  *l_element_courant;      struct_liste_variables_statiques    *l_element_statique_courant;
     struct_liste_variables  *l_element_suivant;      struct_liste_variables_statiques    *l_element_statique_suivant;
   
     // Libération de l'arbre des variables. Le contenu des variables n'est      // Libération de l'arbre des variables. Le contenu des variables n'est
     // pas détruit par cette opération, il sera détruit lors de la libération      // pas détruit par cette opération, il sera détruit lors de la libération
Line 1697  liberation_arbre_variables(struct_proces Line 1713  liberation_arbre_variables(struct_proces
         (*arbre).feuille = NULL;          (*arbre).feuille = NULL;
     }      }
   
       l_element_statique_courant = (*arbre).feuille_statique;
   
       while(l_element_statique_courant != NULL)
       {
           l_element_statique_suivant = (*l_element_statique_courant).suivant;
   
           free((*(*l_element_statique_courant).variable).nom);
           liberation(s_etat_processus, (*(*l_element_statique_courant)
                   .variable).objet);
           free((*l_element_statique_courant).variable);
           free(l_element_statique_courant);
   
           l_element_statique_courant = l_element_statique_suivant;
       }
   
     for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)      for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
     {      {
         if ((*arbre).noeuds[i] != NULL)          if ((*arbre).noeuds[i] != NULL)
Line 1768  liberation_arbre_variables(struct_proces Line 1799  liberation_arbre_variables(struct_proces
 ================================================================================  ================================================================================
 */  */
   
 int  static integer8
 nombre_variables(struct_processus *s_etat_processus,  nombre_variables_locales(struct_processus *s_etat_processus,
         struct_arbre_variables *l_element_courant)          struct_arbre_variables *l_element_courant)
 {  {
     int                     i;      integer8                            i;
     int                     n;      integer8                            n;
   
       struct_liste_variables              *l_variable;
       struct_liste_variables_statiques    *l_variable_statique;
   
     struct_liste_variables  *l_variable;      if (l_element_courant == NULL)
       {
           return(0);
       }
   
     n = 0;      n = 0;
   
Line 1790  nombre_variables(struct_processus *s_eta Line 1827  nombre_variables(struct_processus *s_eta
         } while(l_variable != (*l_element_courant).feuille);          } while(l_variable != (*l_element_courant).feuille);
     }      }
   
       if ((*l_element_courant).feuille_statique != NULL)
       {
           l_variable_statique = (*l_element_courant).feuille_statique;
   
           do
           {
               // Si le pointeur est nul, la variable est accessible et a été
               // copiée dans l'arbre des variables.
   
               if ((*(*l_variable_statique).variable).objet != NULL)
               {
                   n++;
               }
   
               l_variable_statique = (*l_variable_statique).suivant;
           } while(l_variable_statique != NULL);
       }
   
     for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)      for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
     {      {
         if ((*l_element_courant).noeuds[i] != NULL)          if ((*l_element_courant).noeuds[i] != NULL)
         {          {
             n += nombre_variables(s_etat_processus,              n += nombre_variables_locales(s_etat_processus,
                     (*l_element_courant).noeuds[i]);                      (*l_element_courant).noeuds[i]);
         }          }
     }      }
Line 1802  nombre_variables(struct_processus *s_eta Line 1857  nombre_variables(struct_processus *s_eta
     return(n);      return(n);
 }  }
   
 int  
 liste_variables(struct_processus *s_etat_processus,  static integer8
         struct_tableau_variables *tableau, int position,  nombre_variables_partagees(struct_processus *s_etat_processus,
           struct_arbre_variables_partagees *l_element_courant)
   {
       integer8                            i;
       integer8                            n;
   
       struct_liste_variables_partagees    *l_variable;
   
       if (l_element_courant == NULL)
       {
           return(0);
       }
   
       // Mutex deverrouillé par liste_variables_partagees();
       if (pthread_mutex_lock(&((*l_element_courant).mutex_feuille)) != 0)
       {
           (*s_etat_processus).erreur_systeme = d_es_processus;
           return(0);
       }
   
       n = 0;
   
       if ((*l_element_courant).feuille != NULL)
       {
           l_variable = (*l_element_courant).feuille;
   
           do
           {
               n++;
               l_variable = (*l_variable).suivant;
           } while(l_variable != NULL);
       }
   
       for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
       {
           if ((*l_element_courant).noeuds[i] != NULL)
           {
               n += nombre_variables_partagees(s_etat_processus,
                       (*l_element_courant).noeuds[i]);
           }
       }
   
       return(n);
   }
   
   
   integer8
   nombre_variables(struct_processus *s_etat_processus)
   {
       return(nombre_variables_locales(s_etat_processus,
               (*s_etat_processus).s_arbre_variables)
               + nombre_variables_partagees(s_etat_processus,
               (*(*s_etat_processus).s_arbre_variables_partagees)));
   }
   
   
   void
   liberation_mutexes_arbre_variables_partagees(struct_processus *s_etat_processus,
           struct_arbre_variables_partagees *l_element_courant)
   {
       int                                 i;
   
       if (l_element_courant == NULL)
       {
           return;
       }
   
       if (pthread_mutex_trylock(&((*l_element_courant).mutex_feuille)) != 0)
       {
           (*s_etat_processus).erreur_systeme = d_es_processus;
           return;
       }
   
       if (pthread_mutex_unlock(&((*l_element_courant).mutex_feuille)) != 0)
       {
           (*s_etat_processus).erreur_systeme = d_es_processus;
           return;
       }
   
       for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
       {
           if ((*l_element_courant).noeuds[i] != NULL)
           {
               liberation_mutexes_arbre_variables_partagees(s_etat_processus,
                       (*l_element_courant).noeuds[i]);
           }
       }
   
       return;
   }
   
   
   static integer8
   liste_variables_locales(struct_processus *s_etat_processus,
           struct_tableau_variables *tableau, integer8 position,
         struct_arbre_variables *l_element_courant)          struct_arbre_variables *l_element_courant)
 {  {
     int                     i;      integer8                            i;
   
       struct_liste_variables              *l_variable;
       struct_liste_variables_statiques    *l_variable_statique;
   
     struct_liste_variables  *l_variable;      if (l_element_courant == NULL)
       {
           return(position);
       }
   
     if ((*l_element_courant).feuille != NULL)      if ((*l_element_courant).feuille != NULL)
     {      {
Line 1827  liste_variables(struct_processus *s_etat Line 1982  liste_variables(struct_processus *s_etat
                     (*(*l_variable).variable).variable_statique;                      (*(*l_variable).variable).variable_statique;
             tableau[position].variable_partagee =              tableau[position].variable_partagee =
                     (*(*l_variable).variable).variable_partagee;                      (*(*l_variable).variable).variable_partagee;
               tableau[position].variable_masquee = d_faux;
               tableau[position].mutex = NULL;
   
             position++;              position++;
   
             l_variable = (*l_variable).suivant;              l_variable = (*l_variable).suivant;
         } while(l_variable != (*l_element_courant).feuille);          } while(l_variable != (*l_element_courant).feuille);
     }      }
   
       if ((*l_element_courant).feuille_statique != NULL)
       {
           l_variable_statique = (*l_element_courant).feuille_statique;
   
           do
           {
               if ((*(*l_variable_statique).variable).objet != NULL)
               {
                   tableau[position].origine = 'E';
                   tableau[position].nom = (*(*l_variable_statique).variable).nom;
                   tableau[position].niveau =
                           (*(*l_variable_statique).variable).niveau;
                   tableau[position].objet = (*(*l_variable_statique).variable)
                           .objet;
                   tableau[position].variable_verrouillee = d_faux;
                   tableau[position].variable_statique =
                           (*(*l_variable_statique).variable).variable_statique;
                   tableau[position].variable_partagee.pointeur = NULL;
                   tableau[position].variable_masquee = d_vrai;
                   tableau[position].mutex = NULL;
   
                   position++;
               }
   
               l_variable_statique = (*l_variable_statique).suivant;
           } while(l_variable_statique != NULL);
       }
   
       for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
       {
           if ((*l_element_courant).noeuds[i] != NULL)
           {
               position = liste_variables_locales(s_etat_processus,
                       tableau, position, (*l_element_courant).noeuds[i]);
           }
       }
   
       return(position);
   }
   
   
   static integer8
   liste_variables_partagees(struct_processus *s_etat_processus,
           struct_tableau_variables *tableau, integer8 position,
           struct_arbre_variables_partagees *l_element_courant)
   {
       integer8                            i;
   
       struct_liste_variables_partagees    *l_variable;
   
       if (l_element_courant == NULL)
       {
           return(position);
       }
   
       if ((*l_element_courant).feuille != NULL)
       {
           l_variable = (*l_element_courant).feuille;
   
           do
           {
               tableau[position].origine = 'E';
               tableau[position].nom = (*(*l_variable).variable).nom;
               tableau[position].niveau = (*(*l_variable).variable).niveau;
               tableau[position].objet = (*(*l_variable).variable).objet;
               tableau[position].variable_verrouillee = d_faux;
               tableau[position].variable_partagee =
                       (*(*l_variable).variable).variable_partagee;
               tableau[position].variable_statique.pointeur = NULL;
               tableau[position].variable_masquee = d_faux;
               tableau[position].mutex = &((*(*l_variable).variable).mutex);
               pthread_mutex_lock(tableau[position].mutex);
   
               position++;
   
               l_variable = (*l_variable).suivant;
           } while(l_variable != NULL);
       }
   
     for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)      for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
     {      {
         if ((*l_element_courant).noeuds[i] != NULL)          if ((*l_element_courant).noeuds[i] != NULL)
         {          {
             position = liste_variables(s_etat_processus,              position = liste_variables_partagees(s_etat_processus,
                     tableau, position, (*l_element_courant).noeuds[i]);                      tableau, position, (*l_element_courant).noeuds[i]);
         }          }
     }      }
   
       // Mutex verrouillé par nombre_variables_partagees();
       if (pthread_mutex_unlock(&((*l_element_courant).mutex_feuille)) != 0)
       {
           (*s_etat_processus).erreur_systeme = d_es_processus;
           return(0);
       }
   
     return(position);      return(position);
 }  }
   
   
   static int
   fonction_ordre_variables(const void *argument_1, const void *argument_2)
   {
       int                         comparaison;
   
       struct_tableau_variables    *a1;
       struct_tableau_variables    *a2;
   
       a1 = (struct_tableau_variables *) argument_1;
       a2 = (struct_tableau_variables *) argument_2;
   
       comparaison = strcmp((*a1).nom, (*a2).nom);
   
       if (comparaison != 0)
       {
           return(comparaison);
       }
       else
       {
           return(((((*a1).niveau - (*a2).niveau)) > 0) ? 1 : -1);
       }
   }
   
   
   integer8
   liste_variables(struct_processus *s_etat_processus,
           struct_tableau_variables *tableau)
   {
       integer8        nombre_elements;
   
       nombre_elements = liste_variables_locales(s_etat_processus,
               tableau, 0, (*s_etat_processus).s_arbre_variables);
       nombre_elements = liste_variables_partagees(s_etat_processus,
               tableau, nombre_elements, (*(*s_etat_processus)
               .s_arbre_variables_partagees));
   
       qsort(tableau, (size_t) nombre_elements, sizeof(struct_tableau_variables),
               fonction_ordre_variables);
   
       return(nombre_elements);
   }
   
   
 /*  /*
 ================================================================================  ================================================================================
   Procédure de copie de l'arbre des variables    Procédure de copie de l'arbre des variables
Line 1874  copie_arbre_variables(struct_processus * Line 2162  copie_arbre_variables(struct_processus *
     // structure. Les variables de niveau 0 étant non modifiables, elles      // structure. Les variables de niveau 0 étant non modifiables, elles
     // ne sont pas dupliquées.      // ne sont pas dupliquées.
   
     int                             i;      int                                 i;
   
       logical1                            niveau_0_traite;
       logical1                            niveau_1_traite;
   
     struct_liste_chainee            *l_element_courant;      struct_arbre_variables              *l_variable_courante;
   
     struct_liste_variables          *l_niveau_courant;      struct_liste_chainee                *l_element_courant;
   
     struct_variable                 s_variable;      struct_liste_variables              *l_niveau_courant;
       struct_liste_variables_statiques    *l_element_statique_courant;
   
       struct_variable                     s_variable;
       struct_variable_statique            s_variable_statique;
   
       unsigned char                       *ptr;
   
     (*s_nouvel_etat_processus).s_arbre_variables = NULL;      (*s_nouvel_etat_processus).s_arbre_variables = NULL;
     (*s_nouvel_etat_processus).l_liste_variables_par_niveau = NULL;      (*s_nouvel_etat_processus).l_liste_variables_par_niveau = NULL;
Line 1888  copie_arbre_variables(struct_processus * Line 2185  copie_arbre_variables(struct_processus *
     l_niveau_courant = (*s_etat_processus).l_liste_variables_par_niveau;      l_niveau_courant = (*s_etat_processus).l_liste_variables_par_niveau;
           
     // Si la variable en tête n'est pas une variable de niveau 0, le niveau      // Si la variable en tête n'est pas une variable de niveau 0, le niveau
     // 0, s'il existe est le nivau précédent la valeur courante dans la      // 0, s'il existe est le niveau précédent la valeur courante dans la
     // boucle.      // boucle.
   
     if ((*((struct_variable *) (*(*l_niveau_courant).liste).donnee)).niveau      if ((*((struct_variable *) (*(*l_niveau_courant).liste).donnee)).niveau
Line 1900  copie_arbre_variables(struct_processus * Line 2197  copie_arbre_variables(struct_processus *
     // Les variables de niveaux 0 et 1 sont accessibles en au plus trois      // Les variables de niveaux 0 et 1 sont accessibles en au plus trois
     // itérations (par construction).      // itérations (par construction).
   
       niveau_0_traite = d_faux;
       niveau_1_traite = d_faux;
   
     for(i = 0; i <= 2; i++)      for(i = 0; i <= 2; i++)
     {      {
         if ((*((struct_variable *) (*(*l_niveau_courant).liste)          if ((*((struct_variable *) (*(*l_niveau_courant).liste)
                 .donnee)).niveau == 0)                  .donnee)).niveau == 0)
         {          {
             l_element_courant = (*l_niveau_courant).liste;              if (niveau_0_traite == d_faux)
   
             while(l_element_courant != NULL)  
             {              {
                 if (ajout_variable(s_nouvel_etat_processus,                  l_element_courant = (*l_niveau_courant).liste;
                         (struct_variable *) (*l_element_courant).donnee)  
                         == d_erreur)                  while(l_element_courant != NULL)
                 {                  {
                     return;                      if (ajout_variable(s_nouvel_etat_processus,
                               (struct_variable *) (*l_element_courant).donnee)
                               == d_erreur)
                       {
                           return;
                       }
   
                       l_element_courant = (*l_element_courant).suivant;
                 }                  }
   
                 l_element_courant = (*l_element_courant).suivant;                  niveau_0_traite = d_vrai;
             }              }
         }          }
         else if ((*((struct_variable *) (*(*l_niveau_courant).liste)          else if ((*((struct_variable *) (*(*l_niveau_courant).liste)
                 .donnee)).niveau == 1)                  .donnee)).niveau == 1)
         {          {
             l_element_courant = (*l_niveau_courant).liste;              if (niveau_1_traite == d_faux)
   
             while(l_element_courant != NULL)  
             {              {
                 s_variable = (*((struct_variable *)                  l_element_courant = (*l_niveau_courant).liste;
                         (*l_element_courant).donnee));  
   
                 if ((s_variable.nom = strdup((*((struct_variable *)                  while(l_element_courant != NULL)
                         (*l_element_courant).donnee)).nom)) == NULL)  
                 {                  {
                     (*s_nouvel_etat_processus).erreur_systeme =                      s_variable = (*((struct_variable *)
                             d_es_allocation_memoire;                              (*l_element_courant).donnee));
                     return;  
                       if ((s_variable.nom = rpl_malloc(s_nouvel_etat_processus,
                               (strlen((*((struct_variable *)
                               (*l_element_courant).donnee)).nom) + 1) *
                               sizeof(unsigned char))) == NULL)
                       {
                           (*s_nouvel_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return;
                       }
   
                       strcpy(s_variable.nom, (*((struct_variable *)
                               (*l_element_courant).donnee)).nom);
   
                       if ((s_variable.objet = copie_objet(s_nouvel_etat_processus,
                               (*((struct_variable *) (*l_element_courant).donnee))
                               .objet, 'P')) == NULL)
                       {
                           (*s_nouvel_etat_processus).erreur_systeme =
                                   d_es_allocation_memoire;
                           return;
                       }
   
                       if (ajout_variable(s_nouvel_etat_processus, &s_variable)
                               == d_erreur)
                       {
                           return;
                       }
   
                       l_element_courant = (*l_element_courant).suivant;
                 }                  }
   
                 if ((s_variable.objet = copie_objet(s_nouvel_etat_processus,                  niveau_1_traite = d_vrai;
                         (*((struct_variable *) (*l_element_courant).donnee))              }
                         .objet, 'P')) == NULL)  
               // Les variables de niveau 0 ayant déjà été copiées, on
               // peut sortir de la boucle car toutes les variables sont
               // maintenant disponibles dans le fil d'exécution fils.
   
               break;
           }
   
           l_niveau_courant = (*l_niveau_courant).precedent;
       }
   
       // Copie des variables statiques
   
       l_element_statique_courant = (*s_etat_processus)
               .l_liste_variables_statiques;
   
       while(l_element_statique_courant != NULL)
       {
           // Création des branches de l'arbre si nécessaire.
   
           if ((*s_nouvel_etat_processus).s_arbre_variables == NULL)
           {
               if (((*s_nouvel_etat_processus).s_arbre_variables =
                           allocation_noeud(s_nouvel_etat_processus)) == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               (*(*s_nouvel_etat_processus).s_arbre_variables).feuille = NULL;
               (*(*s_nouvel_etat_processus).s_arbre_variables).feuille_statique
                       = NULL;
               (*(*s_nouvel_etat_processus).s_arbre_variables).noeuds_utilises = 0;
               (*(*s_nouvel_etat_processus).s_arbre_variables).indice_tableau_pere
                       = -1;
               (*(*s_nouvel_etat_processus).s_arbre_variables).noeud_pere = NULL;
   
               if (((*(*s_nouvel_etat_processus).s_arbre_variables).noeuds =
                       allocation_tableau_noeuds(s_nouvel_etat_processus)) == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return;
               }
   
               for(i = 0; i < (*s_nouvel_etat_processus)
                       .nombre_caracteres_variables; i++)
               {
                   (*(*s_nouvel_etat_processus).s_arbre_variables).noeuds[i]
                           = NULL;
               }
           }
   
           l_variable_courante = (*s_nouvel_etat_processus).s_arbre_variables;
           ptr = (*(*l_element_statique_courant).variable).nom;
   
           while((*ptr) != d_code_fin_chaine)
           {
               BUG((*s_nouvel_etat_processus).pointeurs_caracteres_variables
                       [*ptr] < 0, uprintf("Variable=\"%s\", (*ptr)='%c'\n",
                       (*(*l_element_statique_courant).variable).nom, *ptr));
   
               if ((*l_variable_courante).noeuds[(*s_nouvel_etat_processus)
                       .pointeurs_caracteres_variables[*ptr]] == NULL)
               {
                   // Le noeud n'existe pas encore, on le crée et on le marque
                   // comme utilisé dans la structure parente.
   
                   if (((*l_variable_courante).noeuds[(*s_nouvel_etat_processus)
                           .pointeurs_caracteres_variables[*ptr]] =
                           allocation_noeud(s_nouvel_etat_processus)) == NULL)
                 {                  {
                     (*s_nouvel_etat_processus).erreur_systeme =                      (*s_etat_processus).erreur_systeme =
                             d_es_allocation_memoire;                              d_es_allocation_memoire;
                     return;                      return;
                 }                  }
   
                 if (ajout_variable(s_nouvel_etat_processus, &s_variable)                  (*l_variable_courante).noeuds_utilises++;
                         == d_erreur)  
                   // La feuille est par défaut vide et aucun élément du tableau
                   // noeuds (les branches qui peuvent être issues de ce nouveau
                   // noeud) n'est encore utilisée.
   
                   (*(*l_variable_courante).noeuds[(*s_nouvel_etat_processus)
                           .pointeurs_caracteres_variables[*ptr]]).feuille = NULL;
                   (*(*l_variable_courante).noeuds[(*s_nouvel_etat_processus)
                           .pointeurs_caracteres_variables[*ptr]]).feuille_statique
                           = NULL;
                   (*(*l_variable_courante).noeuds[(*s_nouvel_etat_processus)
                           .pointeurs_caracteres_variables[*ptr]]).noeuds_utilises
                           = 0;
   
                   // Le champ noeud_pere de la structure créée pointe sur
                   // la structure parente et l'indice tableau_pere correspond à la
                   // position réelle dans le tableau noeuds[] de la structure
                   // parente du noeud courant. Cette valeur sera utilisée lors de
                   // la destruction du noeud pour annuler le pointeur contenu dans
                   // le tableau noeuds[] de la structure parente.
   
                   (*(*l_variable_courante).noeuds[(*s_nouvel_etat_processus)
                           .pointeurs_caracteres_variables[*ptr]]).noeud_pere =
                           l_variable_courante;
                   (*(*l_variable_courante).noeuds[(*s_nouvel_etat_processus)
                           .pointeurs_caracteres_variables[*ptr]])
                           .indice_tableau_pere = (*s_nouvel_etat_processus)
                           .pointeurs_caracteres_variables[*ptr];
   
                   // Allocation du tableau noeuds[] et initialisation à zéro de
                   // tous les pointeurs.
   
                   if (((*(*l_variable_courante).noeuds[(*s_nouvel_etat_processus)
                           .pointeurs_caracteres_variables[*ptr]]).noeuds =
                           allocation_tableau_noeuds(s_nouvel_etat_processus))
                           == NULL)
                 {                  {
                       (*s_etat_processus).erreur_systeme
                               = d_es_allocation_memoire;
                     return;                      return;
                 }                  }
   
                 l_element_courant = (*l_element_courant).suivant;                  for(i = 0; i < (*s_nouvel_etat_processus)
                           .nombre_caracteres_variables; i++)
                   {
                       (*(*l_variable_courante).noeuds[(*s_nouvel_etat_processus)
                               .pointeurs_caracteres_variables[*ptr]]).noeuds[i]
                               = NULL;
                   }
             }              }
   
             // Les variables de niveau 0 ayant déjà été copiées, on              l_variable_courante = (*l_variable_courante).noeuds
             // peut sortir de la boucle car toutes les variables sont                      [(*s_nouvel_etat_processus).pointeurs_caracteres_variables
             // maintenant disponibles dans le fil d'exécution fils.                      [*ptr]];
   
             break;              ptr++;
         }          }
   
         l_niveau_courant = (*l_niveau_courant).precedent;          // Il faut copier la variable pour la dissocier de la variable
           // restant dans le thread parent.
   
           s_variable_statique = (*(*l_element_statique_courant).variable);
   
           if (copie_objet(s_etat_processus, s_variable_statique.objet, 'P')
                   == NULL)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
   
           if ((s_variable_statique.nom = rpl_malloc(s_nouvel_etat_processus,
                   (strlen((*(*l_element_statique_courant).variable).nom) + 1) *
                   sizeof(unsigned char))) == NULL)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
   
           strcpy(s_variable_statique.nom, (*(*l_element_statique_courant)
                   .variable).nom);
   
           if (creation_variable_statique(s_nouvel_etat_processus,
                   &s_variable_statique) == d_erreur)
           {
               (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
               return;
           }
   
           l_element_statique_courant = (*l_element_statique_courant).suivant;
     }      }
   
     return;      return;
Line 1982  copie_arbre_variables(struct_processus * Line 2454  copie_arbre_variables(struct_processus *
 */  */
   
 /*  /*
  * Caractères autorisés dans les instructions   * Caractères autorisés dans les variables
  *   *
  * A B C D E F G H I J K L M N O P Q R S T U V W X Y Z   * A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
  * a b c d e f g h i j k l m n o p q r s t u v w x y z   * a b c d e f g h i j k l m n o p q r s t u v w x y z
Line 2012  initialisation_variables(struct_processu Line 2484  initialisation_variables(struct_processu
     }      }
   
     if (((*s_etat_processus).pointeurs_caracteres_variables =      if (((*s_etat_processus).pointeurs_caracteres_variables =
             malloc(longueur_tableau * sizeof(int))) == NULL)              malloc(((size_t) longueur_tableau) * sizeof(int))) == NULL)
     {      {
         (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;          (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
         return;          return;
Removed from v.1.43  
changed lines
  Added in v.1.91

CVSweb interface <joel.bertrand@systella.fr>