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

Diff for /rpl/src/gestion_variables_statiques.c between versions 1.2 and 1.46

version 1.2, 2010/01/27 22:22:11 version 1.46, 2013/02/26 19:56:13
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.10    RPL/2 (R) version 4.1.12
   Copyright (C) 1989-2010 Dr. BERTRAND Joël    Copyright (C) 1989-2013 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 20 Line 20
 */  */
   
   
 #include "rpl.conv.h"  #include "rpl-conv.h"
   
   
   /*
   ================================================================================
     Routine de retrait des variables statiques
   ================================================================================
     Entrée :
   --------------------------------------------------------------------------------
     Sortie :
   --------------------------------------------------------------------------------
     Effets de bords : néant
   ================================================================================
   */
   
   // Cette routine libère toutes les variables statiques de niveau non
   // nul, donc attachées à une expression et non un programme.
   
   logical1
   retrait_variables_statiques_locales(struct_processus *s_etat_processus)
   {
       struct_liste_variables_statiques    *l_element_courant;
       struct_liste_variables_statiques    *l_element_suivant;
   
       unsigned char                       registre_mode_execution;
   
       registre_mode_execution = (*s_etat_processus).mode_execution_programme;
       l_element_courant = (*s_etat_processus).l_liste_variables_statiques;
   
       while(l_element_courant != NULL)
       {
           l_element_suivant = (*l_element_courant).suivant;
   
           (*s_etat_processus).mode_execution_programme =
                   ((*(*l_element_courant).variable).origine == 'P') ? 'Y' : 'N';
   
           if ((*(*l_element_courant).variable).niveau > 0)
           {
               if (retrait_variable_statique(s_etat_processus,
                       (*(*l_element_courant).variable).nom,
                       (*(*l_element_courant).variable).variable_statique)
                       == d_erreur)
               {
                   (*s_etat_processus).mode_execution_programme =
                           registre_mode_execution;
                   return(d_erreur);
               }
           }
   
           l_element_courant = l_element_suivant;
       }
   
       (*s_etat_processus).mode_execution_programme = registre_mode_execution;
       return(d_absence_erreur);
   }
   
   
 /*  /*
Line 39  logical1 Line 93  logical1
 creation_variable_statique(struct_processus *s_etat_processus,  creation_variable_statique(struct_processus *s_etat_processus,
         struct_variable_statique *s_variable)          struct_variable_statique *s_variable)
 {  {
     struct_variable_statique            *s_nouvelle_base;      int                                     i;
   
       struct_arbre_variables                  *l_variable_courante;
   
     long                                i;      struct_liste_variables_statiques        *l_nouvel_element;
   
     (*s_etat_processus).nombre_variables_statiques++;      unsigned char                           *ptr;
   
     if ((*s_etat_processus).nombre_variables_statiques > (*s_etat_processus)      // Ajout de la variable en tête de la liste des variables statiques
             .nombre_variables_statiques_allouees)  
       if ((l_nouvel_element = malloc(sizeof(struct_liste_variables_statiques)))
               == NULL)
     {      {
         // La nouvelle variable statique ne tient pas dans la table courante.          (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
         // Il convient donc d'en augmenter la taille.          return(d_erreur);
       }
   
         if ((*s_etat_processus).nombre_variables_statiques_allouees == 0)      if (((*l_nouvel_element).variable = malloc(sizeof(
         {              struct_variable_statique))) == NULL)
             (*s_etat_processus).nombre_variables_statiques_allouees =      {
                     (*s_etat_processus).nombre_variables_statiques;          (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
         }          return(d_erreur);
         else      }
   
       (*(*l_nouvel_element).variable) = (*s_variable);
   
       (*l_nouvel_element).suivant = (*s_etat_processus)
               .l_liste_variables_statiques;
       (*l_nouvel_element).precedent = NULL;
   
       if ((*s_etat_processus).l_liste_variables_statiques != NULL)
       {
           (*(*s_etat_processus).l_liste_variables_statiques).precedent
                   = l_nouvel_element;
       }
   
       (*s_etat_processus).l_liste_variables_statiques = l_nouvel_element;
   
       // Ajout de la variable à la feuille statique de l'arbre des variables
   
       if ((*s_etat_processus).s_arbre_variables == NULL)
       {
           if (((*s_etat_processus).s_arbre_variables =
                       allocation_noeud(s_etat_processus)) == NULL)
         {          {
             while((*s_etat_processus).nombre_variables_statiques >              (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                     (*s_etat_processus).nombre_variables_statiques_allouees)              return(d_erreur);
             {  
                 (*s_etat_processus).nombre_variables_statiques_allouees *= 2;  
             }  
         }          }
   
         if ((s_nouvelle_base = realloc((*s_etat_processus)          (*(*s_etat_processus).s_arbre_variables).feuille = NULL;
                 .s_liste_variables_statiques, (*s_etat_processus)          (*(*s_etat_processus).s_arbre_variables).feuille_statique = NULL;
                 .nombre_variables_statiques_allouees *          (*(*s_etat_processus).s_arbre_variables).noeuds_utilises = 0;
                 sizeof(struct_variable_statique))) == NULL)          (*(*s_etat_processus).s_arbre_variables).indice_tableau_pere = -1;
           (*(*s_etat_processus).s_arbre_variables).noeud_pere = NULL;
   
           if (((*(*s_etat_processus).s_arbre_variables).noeuds =
                   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;
             (*s_etat_processus).nombre_variables_statiques--;  
             return(d_erreur);              return(d_erreur);
         }          }
   
         (*s_etat_processus).s_liste_variables_statiques = s_nouvelle_base;          for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
           {
               (*(*s_etat_processus).s_arbre_variables).noeuds[i] = NULL;
           }
     }      }
   
     /*      l_variable_courante = (*s_etat_processus).s_arbre_variables;
      * Positionnement de la variable statique au bon endroit      ptr = (*s_variable).nom;
      */  
   
     // Nous avons (*s_etat_processus).nombre_variables_statiques - 1 variables  
     // dans la table qui sera balayée de la fin vers le début.  
   
     if ((*s_etat_processus).nombre_variables_statiques == 1)      while((*ptr) != d_code_fin_chaine)
     {  
         (*s_etat_processus).s_liste_variables_statiques[0] = (*s_variable);  
     }  
     else  
     {      {
         for(i = (*s_etat_processus).nombre_variables_statiques - 2; i >= 0; i--)          BUG((*s_etat_processus).pointeurs_caracteres_variables[*ptr] < 0,
         {                  uprintf("Variable=\"%s\", (*ptr)='%c'\n", (*s_variable).nom,
             if (strcmp((*s_variable).nom,                  *ptr));
                     (*s_etat_processus).s_liste_variables_statiques[i].nom) < 0)  
           if ((*l_variable_courante).noeuds[(*s_etat_processus)
                   .pointeurs_caracteres_variables[*ptr]] == NULL)
           {
               // Le noeud n'existe pas encore, on le crée et on le marque
               // comme utilisé dans la structure parente.
   
               if (((*l_variable_courante).noeuds[(*s_etat_processus)
                       .pointeurs_caracteres_variables[*ptr]] =
                       allocation_noeud(s_etat_processus)) == NULL)
             {              {
                 (*s_etat_processus).s_liste_variables_statiques[i + 1] =                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                         (*s_etat_processus).s_liste_variables_statiques[i];                  return(d_erreur);
             }              }
             else  
               (*l_variable_courante).noeuds_utilises++;
   
               // La feuille est par défaut vide et aucun élément du tableau noeuds
               // (les branches qui peuvent être issues de ce nouveau noeud)
               // n'est encore utilisée.
   
               (*(*l_variable_courante).noeuds[(*s_etat_processus)
                       .pointeurs_caracteres_variables[*ptr]]).feuille = NULL;
               (*(*l_variable_courante).noeuds[(*s_etat_processus)
                       .pointeurs_caracteres_variables[*ptr]]).feuille_statique
                       = NULL;
               (*(*l_variable_courante).noeuds[(*s_etat_processus)
                       .pointeurs_caracteres_variables[*ptr]]).noeuds_utilises = 0;
   
               // Le champ noeud_pere de la structure créée pointe sur
               // la structure parente et l'indice tableau_pere correspond à la
               // position réelle dans le tableau noeuds[] de la structure parente
               // du noeud courant. Cette valeur sera utilisée lors de la
               // destruction du noeud pour annuler le pointeur contenu dans
               // le tableau noeuds[] de la structure parente.
   
               (*(*l_variable_courante).noeuds[(*s_etat_processus)
                       .pointeurs_caracteres_variables[*ptr]]).noeud_pere =
                       l_variable_courante;
               (*(*l_variable_courante).noeuds[(*s_etat_processus)
                       .pointeurs_caracteres_variables[*ptr]])
                       .indice_tableau_pere = (*s_etat_processus)
                       .pointeurs_caracteres_variables[*ptr];
   
               // Allocation du tableau noeuds[] et initialisation à zéro de
               // tous les pointeurs.
   
               if (((*(*l_variable_courante).noeuds[(*s_etat_processus)
                       .pointeurs_caracteres_variables[*ptr]]).noeuds =
                       allocation_tableau_noeuds(s_etat_processus)) == NULL)
               {
                   (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                   return(d_erreur);
               }
   
               for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++)
             {              {
                 break;                  (*(*l_variable_courante).noeuds[(*s_etat_processus)
                           .pointeurs_caracteres_variables[*ptr]]).noeuds[i]
                           = NULL;
             }              }
         }          }
   
         (*s_etat_processus).s_liste_variables_statiques[i + 1] = (*s_variable);          l_variable_courante = (*l_variable_courante).noeuds
                   [(*s_etat_processus).pointeurs_caracteres_variables[*ptr]];
           ptr++;
       }
   
       if ((l_nouvel_element = malloc(sizeof(struct_liste_variables_statiques)))
               == NULL)
       {
           (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
           return(d_erreur);
       }
   
       // Dans la feuille statique de l'arbre des variables, on ne balaie
       // les variables que dans l'ordre. Le champ 'reference' est alors utilisé
       // pour sauvegarder une référence vers la liste des variables statiques
       // pour pouvoir purger l'élément en cas de besoin.
   
       (*l_nouvel_element).suivant = (*l_variable_courante).feuille_statique;
       (*l_nouvel_element).precedent = NULL;
   
       if ((*l_nouvel_element).suivant != NULL)
       {
           (*(*l_nouvel_element).suivant).precedent = l_nouvel_element;
     }      }
   
     return d_absence_erreur;      (*l_nouvel_element).reference =
               (*s_etat_processus).l_liste_variables_statiques;
       (*l_nouvel_element).variable = (*(*s_etat_processus)
               .l_liste_variables_statiques).variable;
       (*l_variable_courante).feuille_statique = l_nouvel_element;
       (*l_nouvel_element).feuille = l_variable_courante;
   
       return(d_absence_erreur);
 }  }
   
   
Line 128  logical1 Line 284  logical1
 retrait_variable_statique(struct_processus *s_etat_processus,  retrait_variable_statique(struct_processus *s_etat_processus,
         unsigned char *nom_variable, union_position_variable position)          unsigned char *nom_variable, union_position_variable position)
 {  {
     struct_variable_statique        *s_nouvelle_base;      struct_liste_variables_statiques        *l_element_a_supprimer;
       struct_liste_variables_statiques        *l_element_liste_a_supprimer;
     logical1                        erreur;  
   
     unsigned long                   position_courante;      logical1                                erreur;
     unsigned long                   position_supprimee;  
   
     if (recherche_variable_statique(s_etat_processus, nom_variable,      if ((l_element_a_supprimer = recherche_variable_statique(s_etat_processus,
             position, ((*s_etat_processus).mode_execution_programme == 'Y')              nom_variable, position, ((*s_etat_processus)
             ? 'P' : 'E') == d_vrai)              .mode_execution_programme == 'Y') ? 'P' : 'E')) != NULL)
     {      {
         if ((*s_etat_processus).nombre_variables_statiques <          // (*s_etat_processus).pointeur_variable_statique_courante
                 ((*s_etat_processus).nombre_variables_statiques_allouees / 2))          // pointe sur la variable à éliminer. Cette variable est celle qui
           // est présente dans l'une des feuilles statiques de l'arbre des
           // variables.
   
           l_element_liste_a_supprimer = (*l_element_a_supprimer).reference;
   
           // Suppression de la liste des variables statiques
   
           if ((*l_element_liste_a_supprimer).precedent != NULL)
         {          {
             (*s_etat_processus).nombre_variables_statiques_allouees /= 2;              // L'élément à supprimer n'est pas le premier de la liste.
   
             if ((s_nouvelle_base =              (*(*l_element_liste_a_supprimer).precedent).suivant =
                     realloc((*s_etat_processus).s_liste_variables_statiques,                      (*l_element_liste_a_supprimer).suivant;
                     (*s_etat_processus).nombre_variables_statiques_allouees *  
                     sizeof(struct_variable_statique))) == NULL)              if ((*l_element_liste_a_supprimer).suivant != NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  // Il y a un élément suivant. On le chaîne.
                 return(d_erreur);                  (*(*l_element_liste_a_supprimer).suivant).precedent = NULL;
             }              }
           }
           else
           {
               // L'élement est le premier de la liste. S'il y a un élément
               // suivant, on le chaîne.
   
             (*s_etat_processus).s_liste_variables_statiques = s_nouvelle_base;              if ((*l_element_liste_a_supprimer).suivant != NULL)
               {
                   (*(*l_element_liste_a_supprimer).suivant).precedent = NULL;
               }
   
               (*s_etat_processus).l_liste_variables_statiques =
                       (*l_element_liste_a_supprimer).suivant;
         }          }
   
         position_supprimee = (*s_etat_processus)          free(l_element_liste_a_supprimer);
                 .position_variable_statique_courante;  
   
         liberation(s_etat_processus, (*s_etat_processus)          // Suppression depuis la feuille statique. Le champ 'precedent' ne sert
                 .s_liste_variables_statiques[position_supprimee].objet);          // pas car la liste est simplement chaînée.
         free((*s_etat_processus).s_liste_variables_statiques  
                 [position_supprimee].nom);          if ((*l_element_a_supprimer).precedent != NULL)
           {
               // L'élément n'est pas le premier de la liste.
   
         (*s_etat_processus).nombre_variables_statiques--;              (*(*l_element_a_supprimer).precedent).suivant =
                       (*l_element_a_supprimer).suivant;
   
         for(position_courante = position_supprimee; position_courante <              if ((*l_element_a_supprimer).suivant != NULL)
                 (*s_etat_processus).nombre_variables_statiques;              {
                 position_courante++)                  (*(*l_element_a_supprimer).suivant).precedent =
                           (*l_element_a_supprimer).precedent;
               }
               else
               {
                   (*(*l_element_a_supprimer).precedent).suivant = NULL;
               }
           }
           else
         {          {
             (*s_etat_processus).s_liste_variables_statiques[position_courante]              // L'élément est le premier de la liste.
                     = (*s_etat_processus).s_liste_variables_statiques  
                     [position_courante + 1];              if ((*l_element_a_supprimer).suivant != NULL)
               {
                   (*(*l_element_a_supprimer).suivant).precedent = NULL;
               }
   
               (*(*l_element_a_supprimer).feuille).feuille_statique
                       = (*l_element_a_supprimer).suivant;
         }          }
   
           liberation(s_etat_processus, (*(*l_element_a_supprimer).variable)
                   .objet);
           free((*(*l_element_a_supprimer).variable).nom);
           free((*l_element_a_supprimer).variable);
           free(l_element_a_supprimer);
   
         erreur = d_absence_erreur;          erreur = d_absence_erreur;
     }      }
     else      else
Line 183  retrait_variable_statique(struct_process Line 378  retrait_variable_statique(struct_process
         (*s_etat_processus).erreur_systeme = d_es_variable_introuvable;          (*s_etat_processus).erreur_systeme = d_es_variable_introuvable;
     }      }
   
     return erreur;      return(erreur);
 }  }
   
   
Line 199  retrait_variable_statique(struct_process Line 394  retrait_variable_statique(struct_process
 ================================================================================  ================================================================================
 */  */
   
 logical1  struct_liste_variables_statiques *
 recherche_variable_statique(struct_processus *s_etat_processus,  recherche_variable_statique(struct_processus *s_etat_processus,
         unsigned char *nom_variable, union_position_variable position,          unsigned char *nom_variable, union_position_variable position,
         unsigned char origine)          unsigned char origine)
 {  {
     logical1                    existence_variable;      int                                 pointeur;
   
     long                        difference;      struct_arbre_variables              *l_variable_courante;
     long                        difference_inferieure;      struct_liste_variables_statiques    *l_element_courant;
     long                        difference_superieure;  
   
     unsigned long               borne_inferieure;  
     unsigned long               borne_superieure;  
     unsigned long               moyenne;  
     unsigned long               nombre_iterations_maximal;  
     unsigned long               ordre_iteration;  
   
     if ((*s_etat_processus).nombre_variables_statiques == 0)  
     {  
         (*s_etat_processus).erreur_systeme = d_es_variable_introuvable;  
         return d_faux;  
     }  
   
     ordre_iteration = 0;      unsigned char                       *ptr;
     nombre_iterations_maximal = ((unsigned long)  
             (log((*s_etat_processus).nombre_variables_statiques) / log(2))) + 2;  
   
     borne_inferieure = 0;      l_variable_courante = (*s_etat_processus).s_arbre_variables;
     borne_superieure = (*s_etat_processus).nombre_variables_statiques - 1;      ptr = nom_variable;
   
     do      while((*ptr) != d_code_fin_chaine)
     {      {
         moyenne = (borne_inferieure + borne_superieure) / 2;          pointeur = (*s_etat_processus).pointeurs_caracteres_variables[*ptr];
         ordre_iteration++;  
   
         if ((2 * ((unsigned long) ((borne_inferieure + borne_superieure) / 2)))          if (pointeur < 0)
                 == (borne_inferieure + borne_superieure))  
         {          {
             difference = strcmp(nom_variable,              // Caractère hors de l'alphabet des variables
                     ((*s_etat_processus).s_liste_variables_statiques)  
                     [moyenne].nom);  
   
             if (difference != 0)              (*s_etat_processus).erreur_systeme = d_es_variable_introuvable;
             {              return(NULL);
                 if (difference > 0)  
                 {  
                     borne_inferieure = moyenne;  
                 }  
                 else  
                 {  
                     borne_superieure = moyenne;  
                 }  
             }  
         }          }
         else  
         {  
             difference_inferieure = strcmp(nom_variable,  
                     ((*s_etat_processus).s_liste_variables_statiques)  
                     [moyenne].nom);  
             difference_superieure = strcmp(nom_variable,  
                     ((*s_etat_processus).s_liste_variables_statiques)  
                     [moyenne + 1].nom);  
   
             if (difference_inferieure == 0)  
             {  
                 difference = 0;  
             }  
             else if (difference_superieure == 0)  
             {  
                 difference = 0;  
                 moyenne++;  
             }  
             else  
             {  
                 difference = difference_inferieure;  
   
                 if (difference > 0)          if ((*l_variable_courante).noeuds[pointeur] == NULL)
                 {          {
                     borne_inferieure = moyenne;              // Le chemin de la variable candidate n'existe pas.
                 }              (*s_etat_processus).erreur_systeme = d_es_variable_introuvable;
                 else              return(NULL);
                 {  
                     borne_superieure = moyenne;  
                 }  
             }  
         }          }
     } while((difference != 0) &&  
             (ordre_iteration <= nombre_iterations_maximal));  
   
     if (ordre_iteration > nombre_iterations_maximal)          l_variable_courante = (*l_variable_courante).noeuds[pointeur];
     {          ptr++;
         existence_variable = d_faux;  
         (*s_etat_processus).erreur_systeme = d_es_variable_introuvable;  
     }      }
     else  
       if ((*l_variable_courante).feuille_statique != NULL)
     {      {
         // Reste à rechercher la variable déclarée à la position 'position'...          // Il existe au moins une variable statique du nom requis.
   
         if (((*s_etat_processus).s_liste_variables_statiques)[moyenne]          l_element_courant = (*l_variable_courante).feuille_statique;
                 .origine == 'P')  
         {  
             if ((((*s_etat_processus).s_liste_variables_statiques)[moyenne]  
                     .variable_statique.adresse == position.adresse) &&  
                     (((*s_etat_processus).s_liste_variables_statiques)[moyenne]  
                     .origine == origine))  
             {  
                 existence_variable = d_vrai;  
             }  
             else  
             {  
                 existence_variable = d_faux;  
             }  
         }  
         else  
         {  
             if ((((*s_etat_processus).s_liste_variables_statiques)[moyenne]  
                     .variable_statique.pointeur == position.pointeur) &&  
                     (((*s_etat_processus).s_liste_variables_statiques)[moyenne]  
                     .origine == origine))  
             {  
                 existence_variable = d_vrai;  
             }  
             else  
             {  
                 existence_variable = d_faux;  
             }  
         }  
   
         if (existence_variable == d_faux)          while(l_element_courant != NULL)
         {          {
             // On rembobine.              if ((*(*l_element_courant).variable).origine == 'P')
   
             if (moyenne > 0)  
             {              {
                 while(strcmp(nom_variable, ((*s_etat_processus)                  if (((*(*l_element_courant).variable).variable_statique.adresse
                         .s_liste_variables_statiques)[moyenne - 1].nom) == 0)                          == position.adresse) &&
                           ((*(*l_element_courant).variable).origine == origine))
                 {                  {
                     moyenne--;                      (*s_etat_processus).pointeur_variable_statique_courante
                               = (*l_element_courant).variable;
                     if (moyenne == 0)                      return(l_element_courant);
                     {  
                         break;  
                     }  
                 }                  }
             }              }
               else
             // Un petit test pour voir si le premier élément du tableau  
             // peut correspondre au critère de recherche.  
   
             existence_variable = d_faux;  
   
             if (strcmp(((*s_etat_processus).s_liste_variables_statiques)  
                     [moyenne].nom, nom_variable) == 0)  
             {              {
                 if (((*s_etat_processus).s_liste_variables_statiques)                  if (((*(*l_element_courant).variable).variable_statique.pointeur
                         [moyenne].origine == 'P')                          == position.pointeur) &&
                           ((*(*l_element_courant).variable).origine == origine))
                 {                  {
                     if ((((*s_etat_processus).s_liste_variables_statiques)                      (*s_etat_processus).pointeur_variable_statique_courante
                             [moyenne].variable_statique.adresse                              = (*l_element_courant).variable;
                             == position.adresse) &&                      return(l_element_courant);
                             (((*s_etat_processus).s_liste_variables_statiques)  
                             [moyenne].origine == origine))  
                     {  
                         existence_variable = d_vrai;  
                     }  
                 }  
                 else  
                 {  
                     if ((((*s_etat_processus).s_liste_variables_statiques)  
                             [moyenne].variable_statique.pointeur  
                             == position.pointeur) &&  
                             (((*s_etat_processus).s_liste_variables_statiques)  
                             [moyenne].origine == origine))  
                     {  
                         existence_variable = d_vrai;  
                     }  
                 }                  }
             }              }
   
             // Puis on balaye dans le sens croissant.              l_element_courant = (*l_element_courant).suivant;
   
             if (((moyenne + 1) < (*s_etat_processus)  
                     .nombre_variables_statiques) &&  
                     (existence_variable == d_faux))  
             {  
                 while(strcmp(((*s_etat_processus)  
                         .s_liste_variables_statiques)[moyenne + 1].nom,  
                         nom_variable) == 0)  
                 {  
                     moyenne++;  
   
                     if (((*s_etat_processus).s_liste_variables_statiques)  
                             [moyenne].origine == 'P')  
                     {  
                         if ((((*s_etat_processus).s_liste_variables_statiques)  
                                 [moyenne].variable_statique.adresse ==  
                                 position.adresse) && (((*s_etat_processus)  
                                 .s_liste_variables_statiques)  
                                 [moyenne].origine == origine))  
                         {  
                             existence_variable = d_vrai;  
                             break;  
                         }  
                     }  
                     else  
                     {  
                         if ((((*s_etat_processus).s_liste_variables_statiques)  
                                 [moyenne].variable_statique.pointeur ==  
                                 position.pointeur) && (((*s_etat_processus)  
                                 .s_liste_variables_statiques)  
                                 [moyenne].origine == origine))  
                         {  
                             existence_variable = d_vrai;  
                             break;  
                         }  
                     }  
   
                     if ((moyenne + 1) >= (*s_etat_processus)  
                             .nombre_variables_statiques)  
                     {  
                         break;  
                     }  
                 }  
             }  
         }          }
   
         (*s_etat_processus).position_variable_statique_courante = moyenne;  
     }      }
   
     return existence_variable;      (*s_etat_processus).pointeur_variable_statique_courante = NULL;
       return(NULL);
 }  }
   
 // vim: ts=4  // vim: ts=4
Removed from v.1.2  
changed lines
  Added in v.1.46

CVSweb interface <joel.bertrand@systella.fr>