Diff for /rpl/src/instructions_c6.c between versions 1.17 and 1.79

version 1.17, 2011/04/11 12:10:07 version 1.79, 2024/01/17 16:57:12
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.0.prerelease.0    RPL/2 (R) version 4.1.36
   Copyright (C) 1989-2011 Dr. BERTRAND Joël    Copyright (C) 1989-2024 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 38 Line 38
 void  void
 instruction_clusr(struct_processus *s_etat_processus)  instruction_clusr(struct_processus *s_etat_processus)
 {  {
     unsigned long                   i;      struct_liste_variables              *l_element_courant;
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
Line 73  instruction_clusr(struct_processus *s_et Line 73  instruction_clusr(struct_processus *s_et
         }          }
     }      }
   
     for(i = 0; i < (*s_etat_processus).nombre_variables; i++)      l_element_courant = (*s_etat_processus).l_liste_variables_par_niveau;
   
       if (l_element_courant == NULL)
     {      {
         if (((*s_etat_processus).s_liste_variables[i]).niveau == 1)          return;
       }
   
       do
       {
           if ((*l_element_courant).liste != NULL)
         {          {
             if (retrait_variable(s_etat_processus,              if ((*(*l_element_courant).liste).donnee != NULL)
                     ((*s_etat_processus).s_liste_variables[i]).nom, 'G')  
                     == d_erreur)  
             {              {
                 return;                  if ((*((struct_variable *) (*(*l_element_courant).liste)
                           .donnee)).niveau == 1)
                   {
                       while((*l_element_courant).liste != NULL)
                       {
                           if (retrait_variable(s_etat_processus,
                                   (*((struct_variable *) (*(*l_element_courant)
                                   .liste).donnee)).nom, 'G') == d_erreur)
                           {
                               return;
                           }
   
                           if ((*s_etat_processus).niveau_supprime == d_vrai)
                           {
                               // La dernière variable de niveau 1 a été
                               // supprimée. On sort donc de la boucle car
                               // (*l_element_courant).liste pointe sur
                               // un pointeur libérée par retrait_variable().
   
                               break;
                           }
                       }
   
                       break;
                   }
             }              }
         }          }
     }  
           l_element_courant = (*l_element_courant).precedent;
       } while(l_element_courant != (*s_etat_processus)
               .l_liste_variables_par_niveau);
   
     return;      return;
 }  }
Line 108  instruction_col_fleche(struct_processus Line 140  instruction_col_fleche(struct_processus
     struct_objet                *s_objet;      struct_objet                *s_objet;
     struct_objet                *s_objet_elementaire;      struct_objet                *s_objet_elementaire;
   
     unsigned long               i;      integer8                    i;
     unsigned long               j;      integer8                    j;
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
Line 174  instruction_col_fleche(struct_processus Line 206  instruction_col_fleche(struct_processus
                     .nombre_lignes;                      .nombre_lignes;
   
             if (((*((struct_matrice *) (*s_objet_elementaire).objet)).tableau =              if (((*((struct_matrice *) (*s_objet_elementaire).objet)).tableau =
                     malloc((*((struct_matrice *) (*s_objet).objet))                      malloc(((size_t) (*((struct_matrice *) (*s_objet).objet))
                     .nombre_lignes * sizeof(integer8 *))) == NULL)                      .nombre_lignes) * sizeof(integer8 *))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return;                  return;
Line 225  instruction_col_fleche(struct_processus Line 257  instruction_col_fleche(struct_processus
                     .nombre_lignes;                      .nombre_lignes;
   
             if (((*((struct_matrice *) (*s_objet_elementaire).objet)).tableau =              if (((*((struct_matrice *) (*s_objet_elementaire).objet)).tableau =
                     malloc((*((struct_matrice *) (*s_objet).objet))                      malloc(((size_t) (*((struct_matrice *) (*s_objet).objet))
                     .nombre_lignes * sizeof(real8 *))) == NULL)                      .nombre_lignes) * sizeof(real8 *))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return;                  return;
Line 276  instruction_col_fleche(struct_processus Line 308  instruction_col_fleche(struct_processus
                     .nombre_lignes;                      .nombre_lignes;
   
             if (((*((struct_matrice *) (*s_objet_elementaire).objet)).tableau =              if (((*((struct_matrice *) (*s_objet_elementaire).objet)).tableau =
                     malloc((*((struct_matrice *) (*s_objet).objet))                      malloc(((size_t) (*((struct_matrice *) (*s_objet).objet))
                     .nombre_lignes * sizeof(complex16 *))) == NULL)                      .nombre_lignes) * sizeof(complex16 *))) == NULL)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;                  (*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
                 return;                  return;
Line 558  instruction_continue(struct_processus *s Line 590  instruction_continue(struct_processus *s
   
     if ((*s_objet).type == PRC)      if ((*s_objet).type == PRC)
     {      {
         if (pthread_mutex_lock(&((*s_etat_processus).mutex)) != 0)          if (pthread_mutex_lock(&((*s_etat_processus).mutex_pile_processus))
                   != 0)
         {          {
             (*s_etat_processus).erreur_systeme = d_es_processus;              (*s_etat_processus).erreur_systeme = d_es_processus;
         }          }
Line 576  instruction_continue(struct_processus *s Line 609  instruction_continue(struct_processus *s
                             .thread).pid == (*(*((struct_processus_fils *)                              .thread).pid == (*(*((struct_processus_fils *)
                             (*(*l_element_courant).donnee).objet)).thread).pid)                              (*(*l_element_courant).donnee).objet)).thread).pid)
                     {                      {
                         if (kill((*(*((struct_processus_fils *)                          if (envoi_signal_processus(
                                 (*s_objet).objet)).thread).pid, SIGCONT) != 0)                                  (*(*((struct_processus_fils *)
                                   (*s_objet).objet)).thread).pid, rpl_sigcont,
                                   d_faux) != 0)
                         {                          {
                             // Le processus est peut-être dans l'état zombie.                              // Le processus est peut-être dans l'état zombie.
                         }                          }
Line 607  instruction_continue(struct_processus *s Line 642  instruction_continue(struct_processus *s
                                 (*(*l_element_courant).donnee).objet)).thread)                                  (*(*l_element_courant).donnee).objet)).thread)
                                 .pid))                                  .pid))
                         {                          {
                             if (pthread_kill((*(*((struct_processus_fils *)                              if (envoi_signal_thread(s_etat_processus,
                                     (*s_objet).objet)).thread).tid, SIGCONT)                                      (*(*((struct_processus_fils *)
                                       (*s_objet).objet)).thread).tid, rpl_sigcont)
                                     != 0)                                      != 0)
                             {                              {
                                 // Le thread est peut-être dans l'état zombie.                                  // Le thread est peut-être dans l'état zombie.
Line 618  instruction_continue(struct_processus *s Line 654  instruction_continue(struct_processus *s
                                     &((*(*((struct_processus_fils *)                                      &((*(*((struct_processus_fils *)
                                     (*s_objet).objet)).thread).mutex)) != 0)                                      (*s_objet).objet)).thread).mutex)) != 0)
                             {                              {
                                   pthread_mutex_unlock(&((*s_etat_processus)
                                           .mutex_pile_processus));
                                 (*s_etat_processus).erreur_systeme =                                  (*s_etat_processus).erreur_systeme =
                                         d_es_processus;                                          d_es_processus;
                                 return;                                  return;
Line 630  instruction_continue(struct_processus *s Line 668  instruction_continue(struct_processus *s
                     if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)                      if (pthread_mutex_unlock(&((*(*((struct_processus_fils *)
                             (*s_objet).objet)).thread).mutex)) != 0)                              (*s_objet).objet)).thread).mutex)) != 0)
                     {                      {
                           pthread_mutex_unlock(&((*s_etat_processus)
                                   .mutex_pile_processus));
                         (*s_etat_processus).erreur_systeme = d_es_processus;                          (*s_etat_processus).erreur_systeme = d_es_processus;
                         return;                          return;
                     }                      }
Line 638  instruction_continue(struct_processus *s Line 678  instruction_continue(struct_processus *s
                 l_element_courant = (*l_element_courant).suivant;                  l_element_courant = (*l_element_courant).suivant;
             }              }
   
             if (pthread_mutex_unlock(&((*s_etat_processus).mutex)) != 0)              if (pthread_mutex_unlock(&((*s_etat_processus)
                       .mutex_pile_processus)) != 0)
             {              {
                 (*s_etat_processus).erreur_systeme = d_es_processus;                  (*s_etat_processus).erreur_systeme = d_es_processus;
             }              }
Line 801  instruction_clrfuse(struct_processus *s_ Line 842  instruction_clrfuse(struct_processus *s_
 ================================================================================  ================================================================================
 */  */
   
 void  static struct_objet *
 instruction_crtab(struct_processus *s_etat_processus)  creation_table(struct_processus *s_etat_processus,
           struct_liste_chainee *dimensions)
 {  {
     struct_liste_chainee    *l_element_courant;      struct_objet        *s_table;
   
     struct_objet            *s_objet_argument;      integer8            i;
     struct_objet            *s_objet_resultat;  
   
     struct_objet *      if ((s_table = allocation(s_etat_processus, TBL)) == NULL)
     creation_table(struct_liste_chainee *dimensions)  
     {      {
         struct_objet        *s_table;          return(NULL);
       }
         unsigned long       i;  
   
         if ((s_table = allocation(s_etat_processus, TBL)) == NULL)  
         {  
             return(NULL);  
         }  
   
         (*((struct_tableau *) (*s_table).objet)).nombre_elements =      (*((struct_tableau *) (*s_table).objet)).nombre_elements =
                 (unsigned long) (*((integer8 *) (*(*dimensions).donnee).objet));              (*((integer8 *) (*(*dimensions).donnee).objet));
   
         dimensions = (*dimensions).suivant;      dimensions = (*dimensions).suivant;
   
         if (((*((struct_tableau *) (*s_table).objet)).elements =      if (((*((struct_tableau *) (*s_table).objet)).elements =
                 malloc((*((struct_tableau *) (*s_table).objet))              malloc(((size_t) (*((struct_tableau *) (*s_table).objet))
                 .nombre_elements * sizeof(struct_objet *))) == NULL)              .nombre_elements) * sizeof(struct_objet *))) == NULL)
         {      {
             return(NULL);          return(NULL);
         }      }
   
         if (dimensions == NULL)      if (dimensions == NULL)
       {
           for(i = 0; i < (*((struct_tableau *) (*s_table).objet))
                   .nombre_elements; i++)
         {          {
             for(i = 0; i < (*((struct_tableau *) (*s_table).objet))              if (((*((struct_tableau *) (*s_table).objet)).elements[i] =
                     .nombre_elements; i++)                      allocation(s_etat_processus, LST)) == NULL)
             {              {
                 if (((*((struct_tableau *) (*s_table).objet)).elements[i] =                  return(NULL);
                         allocation(s_etat_processus, LST)) == NULL)  
                 {  
                     return(NULL);  
                 }  
             }              }
         }          }
         else      }
       else
       {
           for(i = 0; i < (*((struct_tableau *) (*s_table).objet))
                   .nombre_elements; i++)
         {          {
             for(i = 0; i < (*((struct_tableau *) (*s_table).objet))              if (((*((struct_tableau *) (*s_table).objet)).elements[i] =
                     .nombre_elements; i++)                      creation_table(s_etat_processus, dimensions)) == NULL)
             {              {
                 if (((*((struct_tableau *) (*s_table).objet)).elements[i] =                  return(NULL);
                         creation_table(dimensions)) == NULL)  
                 {  
                     return(NULL);  
                 }  
             }              }
         }          }
   
         return(s_table);  
     }      }
   
       return(s_table);
   }
   
   void
   instruction_crtab(struct_processus *s_etat_processus)
   {
       struct_liste_chainee    *l_element_courant;
   
       struct_objet            *s_objet_argument;
       struct_objet            *s_objet_resultat;
   
     (*s_etat_processus).erreur_execution = d_ex;      (*s_etat_processus).erreur_execution = d_ex;
   
     if ((*s_etat_processus).affichage_arguments == 'Y')      if ((*s_etat_processus).affichage_arguments == 'Y')
Line 929  instruction_crtab(struct_processus *s_et Line 971  instruction_crtab(struct_processus *s_et
             l_element_courant = (*l_element_courant).suivant;              l_element_courant = (*l_element_courant).suivant;
         }          }
   
         if ((s_objet_resultat =          if ((s_objet_resultat = creation_table(s_etat_processus,
                 creation_table((*s_objet_argument).objet)) == NULL)                      (*s_objet_argument).objet)) == 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.17  
changed lines
  Added in v.1.79


CVSweb interface <joel.bertrand@systella.fr>