[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.37 and 1.38

version 1.37, 2011/06/21 07:45:22 version 1.38, 2011/06/21 15:03:58
Line 46  liste_variables_par_niveaux(struct_proce Line 46  liste_variables_par_niveaux(struct_proce
   
     struct_liste_chainee    *e;      struct_liste_chainee    *e;
   
     printf("===========================================================\n");      printf("=========================================================="
               "======================\n");
     printf("  Liste des variables par niveaux\n");      printf("  Liste des variables par niveaux\n");
     printf("===========================================================\n");      printf("=========================================================="
               "======================\n");
   
     if ((*s_etat_processus).l_liste_variables_par_niveau == NULL)      if ((*s_etat_processus).l_liste_variables_par_niveau == NULL)
     {      {
         printf("===========================================================\n");          printf("=========================================================="
                   "======================\n");
         return;          return;
     }      }
   
Line 68  liste_variables_par_niveaux(struct_proce Line 71  liste_variables_par_niveaux(struct_proce
   
         while(e != NULL)          while(e != NULL)
         {          {
             printf("%s (%p, %d) ", ((struct_variable *) e->donnee)->nom,              printf("%s (%p->%p, %d) ", ((struct_variable *) e->donnee)->nom,
                     e->donnee, ((struct_variable *) e->donnee)->niveau);                      e, e->donnee, ((struct_variable *) e->donnee)->niveau);
             e = e->suivant;              e = e->suivant;
             c++;              c++;
             if (c > 100)              if (c > 100)
Line 93  liste_variables_par_niveaux(struct_proce Line 96  liste_variables_par_niveaux(struct_proce
   
         while(e != NULL)          while(e != NULL)
         {          {
             printf("%s (%p, %d) ", ((struct_variable *) e->donnee)->nom,              printf("%s (%p->%p, %d) ", ((struct_variable *) e->donnee)->nom,
                     e->donnee, ((struct_variable *) e->donnee)->niveau);                      e, e->donnee, ((struct_variable *) e->donnee)->niveau);
             e = e->suivant;              e = e->suivant;
             c++;              c++;
             if (c > 100) exit(0);              if (c > 100) exit(0);
Line 105  liste_variables_par_niveaux(struct_proce Line 108  liste_variables_par_niveaux(struct_proce
         l = l->suivant;          l = l->suivant;
     } while(l != (*s_etat_processus).l_liste_variables_par_niveau);      } while(l != (*s_etat_processus).l_liste_variables_par_niveau);
   
     printf("===========================================================\n");      printf("=========================================================="
               "======================\n");
   
     if (fin == d_vrai) exit(0);      if (fin == d_vrai) exit(0);
   
Line 184  liste_variables_tas(struct_processus *s_ Line 188  liste_variables_tas(struct_processus *s_
         } while((*arbre).feuille != l);          } while((*arbre).feuille != l);
     }      }
   
     printf("-----------------------------------------------------------\n");      printf("----------------------------------------------------------"
               "----------------------\n");
   
     for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)      for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
     {      {
Line 204  liste_variables_tas(struct_processus *s_ Line 209  liste_variables_tas(struct_processus *s_
 static void  static void
 liste_variables_par_feuilles(struct_processus *s_etat_processus)  liste_variables_par_feuilles(struct_processus *s_etat_processus)
 {  {
     printf("===========================================================\n");      printf("=========================================================="
               "======================\n");
     printf("  Liste des variables sur le tas\n");      printf("  Liste des variables sur le tas\n");
     printf("===========================================================\n");      printf("=========================================================="
               "======================\n");
   
     liste_variables_tas(s_etat_processus,      liste_variables_tas(s_etat_processus,
             (*s_etat_processus).s_arbre_variables);              (*s_etat_processus).s_arbre_variables);
   
     printf("===========================================================\n");      printf("=========================================================="
               "======================\n");
   
     return;      return;
 }  }
Line 1122  retrait_variable(struct_processus *s_eta Line 1130  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;              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"));
Line 1529  liberation_arbre_variables(struct_proces Line 1536  liberation_arbre_variables(struct_proces
             free(l_element_courant);              free(l_element_courant);
             l_element_courant = l_element_suivant;              l_element_courant = l_element_suivant;
         } while(l_element_courant != (*arbre).feuille);          } while(l_element_courant != (*arbre).feuille);
   
           (*arbre).feuille = NULL;
     }      }
   
     for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)      for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
Line 1537  liberation_arbre_variables(struct_proces Line 1546  liberation_arbre_variables(struct_proces
         {          {
             liberation_arbre_variables(s_etat_processus, (*arbre).noeuds[i],              liberation_arbre_variables(s_etat_processus, (*arbre).noeuds[i],
                     retrait_definitions);                      retrait_definitions);
               (*arbre).noeuds[i] = NULL;
         }          }
     }      }
   
Line 1562  liberation_arbre_variables(struct_proces Line 1572  liberation_arbre_variables(struct_proces
                                 (*l_element_courant_liste).donnee)).objet);                                  (*l_element_courant_liste).donnee)).objet);
                         free((*((struct_variable *) (*l_element_courant_liste)                          free((*((struct_variable *) (*l_element_courant_liste)
                                 .donnee)).nom);                                  .donnee)).nom);
                         free((*l_element_courant_liste).donnee);  
                     }                      }
   
                     l_element_suivant_liste =                      l_element_suivant_liste =
                             (*l_element_courant_liste).suivant;                              (*l_element_courant_liste).suivant;
                       free((*l_element_courant_liste).donnee);
                     free(l_element_courant_liste);                      free(l_element_courant_liste);
                     l_element_courant_liste = l_element_suivant_liste;                      l_element_courant_liste = l_element_suivant_liste;
                 }                  }
Line 1581  liberation_arbre_variables(struct_proces Line 1591  liberation_arbre_variables(struct_proces
   
     free((*arbre).noeuds);      free((*arbre).noeuds);
     free(arbre);      free(arbre);
       arbre = NULL;
   
     return;      return;
 }  }
Line 1687  liste_variables(struct_processus *s_etat Line 1698  liste_variables(struct_processus *s_etat
 ================================================================================  ================================================================================
 */  */
   
 struct_arbre_variables *  void
 copie_arbre_variables(struct_processus *s_etat_processus)  copie_arbre_variables(struct_processus *s_etat_processus, struct_processus
           *s_nouvel_etat_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      // 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      // variables locales étant masquées par le processus de création de thread
     // ou de processus, elles sont inaccessibles.      // ou de processus, elles seront inaccessibles de tous les points
       // du fil d'exécution fils.
   
     BUG(1, uprintf("Oops !\n"));      // Pour copier ces variables, on récupère les variables depuis la liste par
       // niveaux (niveaux 0 et 1) et on ajoute les variables dans la nouvelle
       // structure. Les variables de niveau 0 étant non modifiables, elles
       // ne sont pas dupliquées.
   
     return(d_absence_erreur);      int                             i;
   
       struct_liste_chainee            *l_element_courant;
   
       struct_liste_variables          *l_niveau_courant;
   
       struct_variable                 s_variable;
   
       (*s_nouvel_etat_processus).s_arbre_variables = NULL;
       (*s_nouvel_etat_processus).l_liste_variables_par_niveau = NULL;
   
       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
       // 0, s'il existe est le nivau précédent la valeur courante dans la
       // boucle.
   
       if ((*((struct_variable *) (*(*l_niveau_courant).liste).donnee)).niveau
               != 0)
       {
           l_niveau_courant = (*l_niveau_courant).precedent;
       }
   
       // Les variables de niveaux 0 et 1 sont accessibles en au plus trois
       // itérations (par construction).
   
       for(i = 0; i <= 2; i++)
       {
           if ((*((struct_variable *) (*(*l_niveau_courant).liste)
                   .donnee)).niveau == 0)
           {
               l_element_courant = (*l_niveau_courant).liste;
   
               while(l_element_courant != NULL)
               {
                   if (ajout_variable(s_nouvel_etat_processus,
                           (struct_variable *) (*l_element_courant).donnee)
                           == d_erreur)
                   {
                       return;
                   }
   
                   l_element_courant = (*l_element_courant).suivant;
               }
           }
           else if ((*((struct_variable *) (*(*l_niveau_courant).liste)
                   .donnee)).niveau == 1)
           {
               l_element_courant = (*l_niveau_courant).liste;
   
               while(l_element_courant != NULL)
               {
                   s_variable = (*((struct_variable *)
                           (*l_element_courant).donnee));
   
                   if ((s_variable.nom = strdup((*((struct_variable *)
                           (*l_element_courant).donnee)).nom)) == NULL)
                   {
                       (*s_nouvel_etat_processus).erreur_systeme =
                               d_es_allocation_memoire;
                       return;
                   }
   
                   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;
               }
   
               // 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;
       }
   
       return;
 }  }
   
   
Removed from v.1.37  
changed lines
  Added in v.1.38

CVSweb interface <joel.bertrand@systella.fr>