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

Diff for /rpl/src/rpl.c between versions 1.133 and 1.152

version 1.133, 2013/02/25 11:24:02 version 1.152, 2014/01/26 18:21:34
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.12    RPL/2 (R) version 4.1.17
   Copyright (C) 1989-2012 Dr. BERTRAND Joël    Copyright (C) 1989-2014 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 51  rplinit(int argc, char *argv[], char *en Line 51  rplinit(int argc, char *argv[], char *en
     int                                 erreur_historique;      int                                 erreur_historique;
     int                                 option_P;      int                                 option_P;
   
       integer8                            i;
   
     logical1                            core;      logical1                            core;
     logical1                            debug;      logical1                            debug;
     logical1                            erreur_fichier;      logical1                            erreur_fichier;
Line 106  rplinit(int argc, char *argv[], char *en Line 108  rplinit(int argc, char *argv[], char *en
     unsigned char                       *ptr;      unsigned char                       *ptr;
     unsigned char                       *tampon;      unsigned char                       *tampon;
   
     unsigned long                       i;  
     unsigned long                       unite_fichier;      unsigned long                       unite_fichier;
   
     void                                *l_element_courant;      void                                *l_element_courant;
Line 219  rplinit(int argc, char *argv[], char *en Line 220  rplinit(int argc, char *argv[], char *en
         return(EXIT_FAILURE);          return(EXIT_FAILURE);
     }      }
   
     if ((arg_exec = malloc((argc + 1) * sizeof(char *))) == NULL)      if ((arg_exec = malloc((((size_t) argc) + 1) * sizeof(char *))) == NULL)
     {      {
 #       ifndef SEMAPHORES_NOMMES  #       ifndef SEMAPHORES_NOMMES
         sem_post(&semaphore_gestionnaires_signaux);          sem_post(&semaphore_gestionnaires_signaux);
Line 241  rplinit(int argc, char *argv[], char *en Line 242  rplinit(int argc, char *argv[], char *en
         return(EXIT_FAILURE);          return(EXIT_FAILURE);
     }      }
   
     for(i = 0; i < (unsigned long) argc; i++)      for(i = 0; i < argc; i++)
     {      {
         arg_exec[i] = argv[i];          arg_exec[i] = argv[i];
     }      }
Line 259  rplinit(int argc, char *argv[], char *en Line 260  rplinit(int argc, char *argv[], char *en
   
     pthread_mutexattr_init(&attributs_mutex);      pthread_mutexattr_init(&attributs_mutex);
     pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);      pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
     pthread_mutex_init(&((*s_etat_processus).mutex), &attributs_mutex);      pthread_mutex_init(&((*s_etat_processus).mutex_pile_processus),
               &attributs_mutex);
       pthread_mutexattr_destroy(&attributs_mutex);
   
       pthread_mutexattr_init(&attributs_mutex);
       pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
       pthread_mutex_init(&((*s_etat_processus).mutex_interruptions),
               &attributs_mutex);
       pthread_mutexattr_destroy(&attributs_mutex);
   
       pthread_mutexattr_init(&attributs_mutex);
       pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);
       pthread_mutex_init(&((*s_etat_processus).mutex_signaux),
               &attributs_mutex);
     pthread_mutexattr_destroy(&attributs_mutex);      pthread_mutexattr_destroy(&attributs_mutex);
   
     pthread_mutexattr_init(&attributs_mutex);      pthread_mutexattr_init(&attributs_mutex);
Line 356  rplinit(int argc, char *argv[], char *en Line 370  rplinit(int argc, char *argv[], char *en
     }      }
     else      else
     {      {
 #       ifndef SEMAPHORES_NOMMES  
             sem_post(&((*s_etat_processus).semaphore_fork));  
             sem_post(&semaphore_gestionnaires_signaux);  
             sem_destroy(&semaphore_gestionnaires_signaux);  
             sem_destroy(&((*s_etat_processus).semaphore_fork));  
 #       else  
             sem_post((*s_etat_processus).semaphore_fork);  
             sem_post(semaphore_gestionnaires_signaux);  
             sem_destroy2(semaphore_gestionnaires_signaux, getpid(),  
                     SEM_SIGNAUX);  
             sem_destroy3((*s_etat_processus).semphore_fork, getpid(),  
                     pthread_self(), SEM_FORK);  
 #       endif  
   
         liberation_contexte_cas(s_etat_processus);  
         liberation_queue_signaux(s_etat_processus);  
   
         if (((*s_etat_processus).localisation = malloc((strlen(d_locale)          if (((*s_etat_processus).localisation = malloc((strlen(d_locale)
                 + 1) * sizeof(unsigned char))) == NULL)                  + 1) * sizeof(unsigned char))) == NULL)
         {          {
   #           ifndef SEMAPHORES_NOMMES
                   sem_post(&((*s_etat_processus).semaphore_fork));
                   sem_post(&semaphore_gestionnaires_signaux);
                   sem_destroy(&semaphore_gestionnaires_signaux);
                   sem_destroy(&((*s_etat_processus).semaphore_fork));
   #           else
                   sem_post((*s_etat_processus).semaphore_fork);
                   sem_post(semaphore_gestionnaires_signaux);
                   sem_destroy2(semaphore_gestionnaires_signaux, getpid(),
                           SEM_SIGNAUX);
                   sem_destroy3((*s_etat_processus).semphore_fork, getpid(),
                           pthread_self(), SEM_FORK);
   #           endif
   
               liberation_contexte_cas(s_etat_processus);
               liberation_queue_signaux(s_etat_processus);
   
             if ((*s_etat_processus).langue == 'F')              if ((*s_etat_processus).langue == 'F')
             {              {
                 uprintf("+++Système : Mémoire insuffisante\n");                  uprintf("+++Système : Mémoire insuffisante\n");
Line 430  rplinit(int argc, char *argv[], char *en Line 444  rplinit(int argc, char *argv[], char *en
         strcpy((*s_etat_processus).localisation, d_locale);          strcpy((*s_etat_processus).localisation, d_locale);
     }      }
   
     printf("+++RPL/2 (R) version %s (%s)\n", d_version_rpl,      if (resultats == NULL) // Appel direct
             ((*s_etat_processus).langue == 'F') ? d_date_rpl : d_date_en_rpl);  
   
     if ((*s_etat_processus).langue == 'F')  
     {  
         printf("+++Copyright (C) 1989 à 2012, 2013 BERTRAND Joël\n");  
     }  
     else  
     {      {
         printf("+++Copyright (C) 1989 to 2012, 2013 BERTRAND Joel\n");          printf("+++RPL/2 (R) version %s (%s)\n", d_version_rpl,
                   ((*s_etat_processus).langue == 'F')
                   ? d_date_rpl : d_date_en_rpl);
   
           if ((*s_etat_processus).langue == 'F')
           {
               printf("+++Copyright (C) 1989 à 2013, 2014 BERTRAND Joël\n");
           }
           else
           {
               printf("+++Copyright (C) 1989 to 2013, 2014 BERTRAND Joel\n");
           }
     }      }
   
     if (getenv("HOME") != NULL)      if (getenv("HOME") != NULL)
Line 2253  rplinit(int argc, char *argv[], char *en Line 2271  rplinit(int argc, char *argv[], char *en
                             }                              }
   
                             (*s_etat_processus).longueur_definitions_chainees =                              (*s_etat_processus).longueur_definitions_chainees =
                                     strlen((*s_etat_processus)                                      (integer8) strlen((*s_etat_processus)
                                     .definitions_chainees);                                      .definitions_chainees);
   
                             break;                              break;
Line 3403  rplinit(int argc, char *argv[], char *en Line 3421  rplinit(int argc, char *argv[], char *en
   
             (*s_etat_processus).liste_mutexes = NULL;              (*s_etat_processus).liste_mutexes = NULL;
             (*s_etat_processus).sections_critiques = 0;              (*s_etat_processus).sections_critiques = 0;
               (*s_etat_processus).initialisation_scheduler = d_faux;
   
             (*s_etat_processus).test_instruction = 'N';              (*s_etat_processus).test_instruction = 'N';
             (*s_etat_processus).nombre_arguments = 0;              (*s_etat_processus).nombre_arguments = 0;
Line 4482  rplinit(int argc, char *argv[], char *en Line 4501  rplinit(int argc, char *argv[], char *en
                     {                      {
                         (*s_etat_processus).erreur_systeme = d_es;                          (*s_etat_processus).erreur_systeme = d_es;
                         encart(s_etat_processus,                          encart(s_etat_processus,
                                 (unsigned long) (5 * 1000000));                                  (integer8) (5 * 1000000));
   
                         if ((*s_etat_processus).erreur_systeme != d_es)                          if ((*s_etat_processus).erreur_systeme != d_es)
                         {                          {
Line 4904  rplinit(int argc, char *argv[], char *en Line 4923  rplinit(int argc, char *argv[], char *en
                             return(EXIT_FAILURE);                              return(EXIT_FAILURE);
                         }                          }
   
                           empilement_pile_systeme(s_etat_processus);
   
                         if (evaluation(s_etat_processus, s_objet, 'E')                          if (evaluation(s_etat_processus, s_objet, 'E')
                                 == d_erreur)                                  == d_erreur)
                         {                          {
Line 5138  rplinit(int argc, char *argv[], char *en Line 5159  rplinit(int argc, char *argv[], char *en
   
                                 if (erreur == d_absence_erreur)                                  if (erreur == d_absence_erreur)
                                 {                                  {
                                     if (((*s_etat_processus).var_volatile_alarme                                      if (((*s_etat_processus)
                                             == 0) && ((*s_etat_processus)  
                                             .arret_depuis_abort == 0) &&                                              .arret_depuis_abort == 0) &&
                                             ((*s_etat_processus).at_exit                                              ((*s_etat_processus).at_exit
                                             != NULL))                                              != NULL))
                                     {                                      {
                                           // Permet de traiter ATEXIT
                                           // même après réception d'un SIGINT.
                                           (*s_etat_processus)
                                                   .var_volatile_alarme = 0;
                                           (*s_etat_processus)
                                                   .var_volatile_requete_arret = 0;
   
                                           if ((*s_etat_processus).profilage ==
                                                   d_vrai)
                                           {
                                               profilage(s_etat_processus,
                                                       "ATEXIT");
                                           }
   
                                         erreur = evaluation(s_etat_processus,                                          erreur = evaluation(s_etat_processus,
                                                 (*s_etat_processus).at_exit,                                                  (*s_etat_processus).at_exit,
                                                 'E');                                                  'E');
   
                                           if ((*s_etat_processus).profilage ==
                                                   d_vrai)
                                           {
                                               profilage(s_etat_processus, NULL);
                                           }
   
                                           if (((*s_etat_processus)
                                                   .erreur_execution != d_ex) ||
                                                   ((*s_etat_processus).exception
                                                   != d_ep) || ((*s_etat_processus)
                                                   .erreur_systeme != d_es))
                                           {
                                               printf("%s [%d]\n", message =
                                                       messages(s_etat_processus),
                                                       (int) getpid());
                                               free(message);
   
                                               if (test_cfsf(s_etat_processus, 51)
                                                       == d_faux)
                                               {
                                                   printf("%s", ds_beep);
                                               }
   
                                               if ((*s_etat_processus).core ==
                                                       d_vrai)
                                               {
                                                   printf("\n");
   
                                                   if ((*s_etat_processus).langue
                                                           == 'F')
                                                   {
                                                       printf("+++Information : Gé"
                                                               "nération du fichie"
                                                               "r rpl-core "
                                                               "[%d]\n", (int)
                                                               getpid());
                                                   }
                                                   else
                                                   {
                                                       printf("+++Information : Wr"
                                                               "iting rpl-core fil"
                                                               "e [%d]\n",
                                                               (int) getpid());
                                                   }
   
                                                   rplcore(s_etat_processus);
   
                                                   if ((*s_etat_processus).langue
                                                           == 'F')
                                                   {
                                                       printf("+++Information : Pr"
                                                               "ocessus tracé [%d]"
                                                               "\n",
                                                               (int) getpid());
                                                   }
                                                   else
                                                   {
                                                       printf("+++Information : Do"
                                                               "ne [%d]\n", (int)
                                                               getpid());
                                                   }
   
                                                   printf("\n");
                                                   fflush(stdout);
                                               }
                                           }
                                     }                                      }
                                 }                                  }
                             }                              }
Line 5159  rplinit(int argc, char *argv[], char *en Line 5260  rplinit(int argc, char *argv[], char *en
   
                                 if (erreur == d_absence_erreur)                                  if (erreur == d_absence_erreur)
                                 {                                  {
                                     if (((*s_etat_processus).var_volatile_alarme                                      if (((*s_etat_processus)
                                             == 0) && ((*s_etat_processus)  
                                             .arret_depuis_abort == 0) &&                                              .arret_depuis_abort == 0) &&
                                             ((*s_etat_processus).at_exit                                              ((*s_etat_processus).at_exit
                                             != NULL))                                              != NULL))
                                     {                                      {
                                           // Permet de traiter ATEXIT
                                           // même après réception d'un SIGINT.
                                           (*s_etat_processus)
                                                   .var_volatile_alarme = 0;
                                           (*s_etat_processus)
                                                   .var_volatile_requete_arret = 0;
   
                                           if ((*s_etat_processus).profilage ==
                                                   d_vrai)
                                           {
                                               profilage(s_etat_processus,
                                                       "ATEXIT");
                                           }
   
                                         erreur = evaluation(s_etat_processus,                                          erreur = evaluation(s_etat_processus,
                                                 (*s_etat_processus).at_exit,                                                  (*s_etat_processus).at_exit,
                                                 'E');                                                  'E');
   
                                           if ((*s_etat_processus).profilage ==
                                                   d_vrai)
                                           {
                                               profilage(s_etat_processus, NULL);
                                           }
   
                                           if (((*s_etat_processus)
                                                   .erreur_execution != d_ex) ||
                                                   ((*s_etat_processus).exception
                                                   != d_ep) || ((*s_etat_processus)
                                                   .erreur_systeme != d_es))
                                           {
                                               printf("%s [%d]\n", message =
                                                       messages(s_etat_processus),
                                                       (int) getpid());
                                               free(message);
   
                                               if (test_cfsf(s_etat_processus, 51)
                                                       == d_faux)
                                               {
                                                   printf("%s", ds_beep);
                                               }
   
                                               if ((*s_etat_processus).core ==
                                                       d_vrai)
                                               {
                                                   printf("\n");
   
                                                   if ((*s_etat_processus).langue
                                                           == 'F')
                                                   {
                                                       printf("+++Information : Gé"
                                                               "nération du fichie"
                                                               "r rpl-core "
                                                               "[%d]\n", (int)
                                                               getpid());
                                                   }
                                                   else
                                                   {
                                                       printf("+++Information : Wr"
                                                               "iting rpl-core fil"
                                                               "e [%d]\n",
                                                               (int) getpid());
                                                   }
   
                                                   rplcore(s_etat_processus);
   
                                                   if ((*s_etat_processus).langue
                                                           == 'F')
                                                   {
                                                       printf("+++Information : Pr"
                                                               "ocessus tracé [%d]"
                                                               "\n",
                                                               (int) getpid());
                                                   }
                                                   else
                                                   {
                                                       printf("+++Information : Do"
                                                               "ne [%d]\n", (int)
                                                               getpid());
                                                   }
   
                                                   printf("\n");
                                                   fflush(stdout);
                                               }
                                           }
                                     }                                      }
                                 }                                  }
                             }                              }
Line 5208  rplinit(int argc, char *argv[], char *en Line 5389  rplinit(int argc, char *argv[], char *en
                         pthread_cancel((*s_etat_processus).thread_fusible);                          pthread_cancel((*s_etat_processus).thread_fusible);
                     }                      }
   
                     pthread_mutex_lock(&((*s_etat_processus).mutex));                      pthread_mutex_lock(&((*s_etat_processus)
                               .mutex_pile_processus));
   
                     l_element_courant = (void *) (*s_etat_processus)                      l_element_courant = (void *) (*s_etat_processus)
                             .l_base_pile_processus;                              .l_base_pile_processus;
Line 5380  rplinit(int argc, char *argv[], char *en Line 5562  rplinit(int argc, char *argv[], char *en
                         l_element_courant = (void *)                          l_element_courant = (void *)
                                 (*s_etat_processus).l_base_pile_processus;                                  (*s_etat_processus).l_base_pile_processus;
   
                         for(i = 0; i < (unsigned long)                          for(i = 0; i < (*(*((struct_processus_fils *)
                                 (*(*((struct_processus_fils *)  
                                 (*(*((struct_liste_chainee *)                                  (*(*((struct_liste_chainee *)
                                 l_element_courant)).donnee).objet)).thread)                                  l_element_courant)).donnee).objet)).thread)
                                 .nombre_objets_dans_pipe; i++)                                  .nombre_objets_dans_pipe; i++)
Line 5445  rplinit(int argc, char *argv[], char *en Line 5626  rplinit(int argc, char *argv[], char *en
                                         }                                          }
 #                                   endif  #                                   endif
   
                                     pthread_mutex_unlock(                                      pthread_mutex_unlock(&((*s_etat_processus)
                                             &((*s_etat_processus).mutex));                                              .mutex_pile_processus));
                                     return(EXIT_FAILURE);                                      return(EXIT_FAILURE);
                                 }                                  }
   
Line 5508  rplinit(int argc, char *argv[], char *en Line 5689  rplinit(int argc, char *argv[], char *en
                                         }                                          }
 #                                   endif  #                                   endif
   
                                     pthread_mutex_unlock(                                      pthread_mutex_unlock(&((*s_etat_processus)
                                             &((*s_etat_processus).mutex));                                              .mutex_pile_processus));
                                     return(EXIT_FAILURE);                                      return(EXIT_FAILURE);
                                 }                                  }
                             }                              }
                         }                          }
   
                         pthread_mutex_unlock(&((*s_etat_processus).mutex));                          pthread_mutex_lock(&((*s_etat_processus)
                                   .mutex_interruptions));
   
                         if ((*s_etat_processus)                          if ((*s_etat_processus)
                                 .nombre_interruptions_non_affectees != 0)                                  .nombre_interruptions_non_affectees != 0)
Line 5524  rplinit(int argc, char *argv[], char *en Line 5706  rplinit(int argc, char *argv[], char *en
                                     s_etat_processus);                                      s_etat_processus);
                         }                          }
   
                           pthread_mutex_unlock(&((*s_etat_processus)
                                   .mutex_interruptions));
                           pthread_mutex_unlock(&((*s_etat_processus)
                                   .mutex_pile_processus));
                         nanosleep(&attente, NULL);                          nanosleep(&attente, NULL);
                         scrutation_interruptions(s_etat_processus);                          scrutation_interruptions(s_etat_processus);
                         pthread_mutex_lock(&((*s_etat_processus).mutex));                          pthread_mutex_lock(&((*s_etat_processus)
                                   .mutex_pile_processus));
                     }                      }
   
                     pthread_mutex_unlock(&((*s_etat_processus).mutex));                      pthread_mutex_unlock(&((*s_etat_processus)
                               .mutex_pile_processus));
   
                     erreur_historique = write_history(                      erreur_historique = write_history(
                             (*s_etat_processus).nom_fichier_historique);                              (*s_etat_processus).nom_fichier_historique);
Line 5721  rplinit(int argc, char *argv[], char *en Line 5909  rplinit(int argc, char *argv[], char *en
                         {                          {
                             free((*resultats));                              free((*resultats));
   
                             if (((*resultats) = malloc(((*s_etat_processus)                              if (((*resultats) = malloc(((size_t)
                                     .hauteur_pile_operationnelle + 1)                                      ((*s_etat_processus)
                                       .hauteur_pile_operationnelle + 1))
                                     * sizeof(unsigned char **))) != NULL)                                      * sizeof(unsigned char **))) != NULL)
                             {                              {
                                 (*resultats)[(*s_etat_processus)                                  (*resultats)[(*s_etat_processus)
Line 6041  rplinit(int argc, char *argv[], char *en Line 6230  rplinit(int argc, char *argv[], char *en
   
     retrait_thread(s_etat_processus);      retrait_thread(s_etat_processus);
   
     pthread_mutex_destroy(&((*s_etat_processus).mutex));      pthread_mutex_destroy(&((*s_etat_processus).mutex_pile_processus));
     pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation));      pthread_mutex_destroy(&((*s_etat_processus).mutex_allocation));
       pthread_mutex_destroy(&((*s_etat_processus).mutex_interruptions));
       pthread_mutex_destroy(&((*s_etat_processus).mutex_signaux));
     pthread_mutex_destroy(&mutex_sections_critiques);      pthread_mutex_destroy(&mutex_sections_critiques);
     pthread_mutex_destroy(&mutex_liste_variables_partagees);      pthread_mutex_destroy(&mutex_liste_variables_partagees);
   
Removed from v.1.133  
changed lines
  Added in v.1.152

CVSweb interface <joel.bertrand@systella.fr>