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

Diff for /rpl/src/instructions_s9.c between versions 1.24.2.3 and 1.32

version 1.24.2.3, 2011/05/09 13:52:21 version 1.32, 2011/06/24 20:31:40
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.24    RPL/2 (R) version 4.1.0.prerelease.4
   Copyright (C) 1989-2011 Dr. BERTRAND Joël    Copyright (C) 1989-2011 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
Line 141  instruction_sort(struct_processus *s_eta Line 141  instruction_sort(struct_processus *s_eta
             return;              return;
         }          }
   
         if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)          if ((*(*s_etat_processus).pointeur_variable_courante)
                 .position_variable_courante].variable_verrouillee == d_vrai)                  .variable_verrouillee == d_vrai)
         {          {
             (*s_etat_processus).erreur_execution = d_ex_variable_verrouillee;              (*s_etat_processus).erreur_execution = d_ex_variable_verrouillee;
   
Line 152  instruction_sort(struct_processus *s_eta Line 152  instruction_sort(struct_processus *s_eta
             return;              return;
         }          }
   
         if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)          if ((*(*s_etat_processus).pointeur_variable_courante).objet == NULL)
                 .position_variable_courante].objet == NULL)  
         {          {
             if (pthread_mutex_lock(&((*(*s_etat_processus)              if (pthread_mutex_lock(&((*(*s_etat_processus)
                     .s_liste_variables_partagees).mutex)) != 0)                      .s_liste_variables_partagees).mutex)) != 0)
Line 163  instruction_sort(struct_processus *s_eta Line 162  instruction_sort(struct_processus *s_eta
             }              }
   
             if (recherche_variable_partagee(s_etat_processus,              if (recherche_variable_partagee(s_etat_processus,
                     (*s_etat_processus).s_liste_variables                      (*(*s_etat_processus).pointeur_variable_courante).nom,
                     [(*s_etat_processus).position_variable_courante].nom,                      (*(*s_etat_processus).pointeur_variable_courante)
                     (*s_etat_processus).s_liste_variables                      .variable_partagee, (*(*s_etat_processus)
                     [(*s_etat_processus).position_variable_courante]                      .pointeur_variable_courante).origine) == d_faux)
                     .variable_partagee, (*s_etat_processus).s_liste_variables  
                     [(*s_etat_processus).position_variable_courante].origine)  
                     == d_faux)  
             {              {
                 if (pthread_mutex_unlock(&((*(*s_etat_processus)                  if (pthread_mutex_unlock(&((*(*s_etat_processus)
                         .s_liste_variables_partagees).mutex)) != 0)                          .s_liste_variables_partagees).mutex)) != 0)
Line 234  instruction_sort(struct_processus *s_eta Line 230  instruction_sort(struct_processus *s_eta
         }          }
         else          else
         {          {
             if (((*(*s_etat_processus).s_liste_variables              if (((*(*(*s_etat_processus).pointeur_variable_courante).objet)
                     [(*s_etat_processus).position_variable_courante].objet)                      .type != LST) && ((*(*(*s_etat_processus)
                     .type != LST) &&                      .pointeur_variable_courante).objet).type != TBL))
                     ((*(*s_etat_processus).s_liste_variables  
                     [(*s_etat_processus).position_variable_courante].objet)  
                     .type != TBL))  
             {              {
                 (*s_etat_processus).erreur_execution =                  (*s_etat_processus).erreur_execution =
                         d_ex_erreur_type_argument;                          d_ex_erreur_type_argument;
Line 252  instruction_sort(struct_processus *s_eta Line 245  instruction_sort(struct_processus *s_eta
   
             liberation(s_etat_processus, s_objet_liste);              liberation(s_etat_processus, s_objet_liste);
   
             s_objet_liste = (*s_etat_processus).s_liste_variables              s_objet_liste = (*(*s_etat_processus).pointeur_variable_courante)
                     [(*s_etat_processus).position_variable_courante].objet;                      .objet;
   
             if ((s_objet_copie = copie_objet(s_etat_processus, s_objet_liste,              if ((s_objet_copie = copie_objet(s_etat_processus, s_objet_liste,
                     'N')) == NULL)                      'N')) == NULL)
Line 265  instruction_sort(struct_processus *s_eta Line 258  instruction_sort(struct_processus *s_eta
   
         liberation(s_etat_processus, s_objet_liste);          liberation(s_etat_processus, s_objet_liste);
         s_objet_liste = s_objet_copie;          s_objet_liste = s_objet_copie;
           (*(*s_etat_processus).pointeur_variable_courante).objet = s_objet_liste;
         (*s_etat_processus).s_liste_variables[(*s_etat_processus)  
                 .position_variable_courante].objet = s_objet_liste;  
   
         presence_nom = d_vrai;          presence_nom = d_vrai;
     }      }
     else      else
Line 663  instruction_sort(struct_processus *s_eta Line 653  instruction_sort(struct_processus *s_eta
 void  void
 instruction_save(struct_processus *s_etat_processus)  instruction_save(struct_processus *s_etat_processus)
 {  {
     logical1                            presence_variable;  
   
     long                                i;  
   
     struct_objet                        *s_objet_1;      struct_objet                        *s_objet_1;
     struct_objet                        *s_objet_2;      struct_objet                        *s_objet_2;
   
Line 738  instruction_save(struct_processus *s_eta Line 724  instruction_save(struct_processus *s_eta
         return;          return;
     }      }
   
     if (recherche_variable(s_etat_processus, (*((struct_nom *)      if (recherche_variable_globale(s_etat_processus, (*((struct_nom *)
             (*s_objet_1).objet)).nom) == d_vrai)              (*s_objet_1).objet)).nom) == d_vrai)
     {      {
         /*          /*
          * Une variable est accessible directement.           * Une variable est accessible.
          */           */
   
         if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)          if ((*(*s_etat_processus).pointeur_variable_courante)
                 .position_variable_courante].niveau == 1)                  .variable_verrouillee == d_vrai)
         {          {
             // La variable accessible directement est une variable globale.              liberation(s_etat_processus, s_objet_1);
               liberation(s_etat_processus, s_objet_2);
             if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)  
                     .position_variable_courante].variable_verrouillee == d_vrai)  
             {  
                 liberation(s_etat_processus, s_objet_1);  
                 liberation(s_etat_processus, s_objet_2);  
   
                 (*s_etat_processus).erreur_execution =  
                         d_ex_variable_verrouillee;  
                 return;  
             }  
   
             if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)  
                     .position_variable_courante].objet == NULL)  
             {  
                 liberation(s_etat_processus, s_objet_1);  
                 liberation(s_etat_processus, s_objet_2);  
   
                 (*s_etat_processus).erreur_execution = d_ex_variable_partagee;  
                 return;  
             }  
   
             liberation(s_etat_processus,  
                     (*s_etat_processus).s_liste_variables[(*s_etat_processus)  
                     .position_variable_courante].objet);  
   
             (*s_etat_processus).s_liste_variables[(*s_etat_processus)              (*s_etat_processus).erreur_execution = d_ex_variable_verrouillee;
                     .position_variable_courante].objet = s_objet_2;              return;
         }          }
         else  
         {  
             // On cherche une variable globale de même nom.  
   
             i = (*s_etat_processus).position_variable_courante;          if ((*(*s_etat_processus).pointeur_variable_courante).objet == NULL)
             presence_variable = d_faux;          {
               liberation(s_etat_processus, s_objet_1);
             while(i >= 0)              liberation(s_etat_processus, s_objet_2);
             {  
                 if ((strcmp((*s_etat_processus).s_liste_variables[i].nom,  
                         (*((struct_nom *) (*s_objet_1).objet)).nom) == 0) &&  
                         ((*s_etat_processus).s_liste_variables[i].niveau == 1))  
                 {  
                     presence_variable = d_vrai;  
                     break;  
                 }  
   
                 i--;  
             }  
   
             if (presence_variable == d_vrai)  
             {  
                 (*s_etat_processus).position_variable_courante = i;  
             }  
             else  
             {  
                 (*s_etat_processus).position_variable_courante = 0;  
             }  
   
             if (((*s_etat_processus).s_liste_variables[(*s_etat_processus)  
                     .position_variable_courante].niveau == 1) &&  
                     (presence_variable == d_vrai))  
             {  
                 // On a trouvé une variable globale correspondant au nom et  
                 // que l'on modifie.  
   
                 if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)  
                         .position_variable_courante].variable_verrouillee ==  
                         d_vrai)  
                 {  
                     liberation(s_etat_processus, s_objet_1);  
                     liberation(s_etat_processus, s_objet_2);  
   
                     (*s_etat_processus).erreur_execution =  
                             d_ex_variable_verrouillee;  
                     return;  
                 }  
   
                 if ((*s_etat_processus).s_liste_variables[(*s_etat_processus)  
                         .position_variable_courante].objet == NULL)  
                 {  
                     liberation(s_etat_processus, s_objet_1);  
                     liberation(s_etat_processus, s_objet_2);  
   
                     (*s_etat_processus).erreur_execution =  
                             d_ex_variable_partagee;  
                     return;  
                 }  
   
                 liberation(s_etat_processus,  
                         (*s_etat_processus).s_liste_variables  
                         [(*s_etat_processus).position_variable_courante].objet);  
   
                 (*s_etat_processus).s_liste_variables[(*s_etat_processus)  
                         .position_variable_courante].objet = s_objet_2;  
             }  
             else  
             {  
                 if ((s_variable.nom = malloc((strlen((*((struct_nom *)  
                         (*s_objet_1).objet)).nom) + 1) * sizeof(unsigned char)))  
                         == NULL)  
                 {  
                     (*s_etat_processus).erreur_systeme =  
                             d_es_allocation_memoire;  
                     return;  
                 }  
   
                 strcpy(s_variable.nom, (*((struct_nom *)  
                         (*s_objet_1).objet)).nom);  
                 s_variable.niveau = 1;  
   
                 /*  
                  * Le niveau 0 correspond aux définitions. Les variables  
                  * commencent à 1 car elles sont toujours incluses dans  
                  * une définition.  
                  */  
   
                 s_variable.objet = s_objet_2;  
   
                 if (creation_variable(s_etat_processus, &s_variable, 'V', 'P')              (*s_etat_processus).erreur_execution = d_ex_variable_partagee;
                         == d_erreur)              return;
                 {  
                     return;  
                 }  
             }  
         }          }
   
           liberation(s_etat_processus,
                   (*(*s_etat_processus).pointeur_variable_courante).objet);
           (*(*s_etat_processus).pointeur_variable_courante).objet = s_objet_2;
     }      }
     else      else
     {      {
Removed from v.1.24.2.3  
changed lines
  Added in v.1.32

CVSweb interface <joel.bertrand@systella.fr>