Diff for /rpl/src/rpl.h between versions 1.270 and 1.310

version 1.270, 2015/06/08 14:11:44 version 1.310, 2017/07/12 15:42:43
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.22    RPL/2 (R) version 4.1.27
   Copyright (C) 1989-2015 Dr. BERTRAND Joël    Copyright (C) 1989-2017 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 64 Line 64
 #   define SA_ONSTACK   0  #   define SA_ONSTACK   0
 #endif  #endif
   
   #ifdef BROKEN_SIGSEGV
   #   undef HAVE_STACK_OVERFLOW_RECOVERY
   #   undef HAVE_SIGSEGV_RECOVERY
   #endif
   
   #define DEBUG_TRACE     uprintf("[%d/%X] %s(%d)\n", \
           getpid(), pthread_self(), __FILE__, __LINE__);
   #define TEST_ABSENCE_FICHIER(nom) \
           { int ios; struct stat *buf; ios = stat(nom, buf); \
               if (ios == 0) BUG(1, uprintf("File %s found!\n", nom)); }
   
 /*  /*
 ================================================================================  ================================================================================
Line 210 Line 220
 #   endif  #   endif
   
 #   include "sqlite3.h"  #   include "sqlite3.h"
 #   include "sigsegv.h"  
   #   ifndef BROKEN_SIGSEGV
   #       include "sigsegv.h"
   #   endif
   
 #   ifdef OS2  #   ifdef OS2
         // Bug de libsigsegv          // Bug de libsigsegv
 #       undef HAVE_STACK_OVERFLOW_RECOVERY  #       undef HAVE_STACK_OVERFLOW_RECOVERY
Line 267 Line 281
 #   define __STATIC_MUTEX_INITIALIZATION__  #   define __STATIC_MUTEX_INITIALIZATION__
 #endif  #endif
   
   
 /*  /*
 ================================================================================  ================================================================================
   Bugs spécifiques    Bugs spécifiques
Line 326  typedef struct queue_signaux Line 341  typedef struct queue_signaux
     volatile logical1           requete_arret;      volatile logical1           requete_arret;
   
     pthread_t                   thread_signaux;      pthread_t                   thread_signaux;
       pid_t                       controle;
   
     volatile struct      volatile struct
     {      {
Line 514  union semun Line 530  union semun
   
     __EXTERN__ pid_t                pid_processus_pere;      __EXTERN__ pid_t                pid_processus_pere;
   
     __EXTERN__ pthread_mutex_t      mutex_liste_threads      __EXTERN__ pthread_mutex_t      mutex_liste_threads;
                                             __STATIC_MUTEX_INITIALIZATION__;  
     __EXTERN__ pthread_mutex_t      mutex_creation_variable_partagee      __EXTERN__ pthread_mutex_t      mutex_creation_variable_partagee
                                             __STATIC_MUTEX_INITIALIZATION__;                                              __STATIC_MUTEX_INITIALIZATION__;
     __EXTERN__ pthread_mutex_t      mutex_sections_critiques;      __EXTERN__ pthread_mutex_t      mutex_sections_critiques;
Line 523  union semun Line 538  union semun
     __EXTERN__ pthread_mutex_t      mutex_sem __STATIC_MUTEX_INITIALIZATION__;      __EXTERN__ pthread_mutex_t      mutex_sem __STATIC_MUTEX_INITIALIZATION__;
   
     __EXTERN__ volatile int         routine_recursive;      __EXTERN__ volatile int         routine_recursive;
       __EXTERN__ volatile int         nombre_thread_surveillance_processus;
   
 #   define SEM_FORK                 0  #   define SEM_FORK                 0
 #   define SEM_QUEUE                1  #   define SEM_QUEUE                1
Line 590  union semun Line 606  union semun
 #   define fflush(flux) fflush((flux == stdout) ? stderr : flux)  #   define fflush(flux) fflush((flux == stdout) ? stderr : flux)
 #endif  #endif
   
 // Ajout d'un timeout sur les fonctions pipe() pour éviter une erreur  
 // système dans le cas où l'on a atteint le nombre maximale de fichiers  
 // ouverts.  
   
 #define pipe(descripteurs) \  
     ({ \  
         struct timespec temporisation; \  
         int erreur, nombre_echecs; \  
         nombre_echecs = 0; \  
         do \  
         { \  
             if ((erreur = pipe(descripteurs)) == 0) break; \  
             nombre_echecs++; \  
             temporisation.tv_sec = 0; \  
             temporisation.tv_nsec = ((long) 1000000000) * rand(); \  
             nanosleep(&temporisation, NULL); \  
         } while(nombre_echecs < 100); \  
         erreur; \  
      })  
   
 // Redéfinition de abs pour un fonctionnement en entier de type long long int  // Redéfinition de abs pour un fonctionnement en entier de type long long int
   
 #ifdef __GNUC__  #ifdef __GNUC__
Line 632  union semun Line 628  union semun
     } while(0)      } while(0)
   
 #ifdef __GLIBC__  #ifdef __GLIBC__
 #include <execinfo.h>  #   include <execinfo.h>
 #define __BACKTRACE  #   define __BACKTRACE
 #define BACKTRACE(n) \  #   define BACKTRACE(n) \
     do \      do \
     { \      { \
         void            *buffer[n]; \          void            *buffer[n]; \
Line 659  union semun Line 655  union semun
         pthread_mutex_unlock(&mutex); \          pthread_mutex_unlock(&mutex); \
     } while(0)      } while(0)
 #else  #else
 #define BACKTRACE(n) NOTICE("BACKTRACE only defined in glibc")  #   define BACKTRACE(n) NOTICE("BACKTRACE only defined in glibc")
 #endif  #endif
   
 #ifdef __BACKTRACE  #ifdef __BACKTRACE
Line 705  pid_t debug_fork(); Line 701  pid_t debug_fork();
 #endif  #endif
   
 #ifdef DEBUG_RETURN  #ifdef DEBUG_RETURN
 #define return uprintf("[%d] Return from <%s()> at line #%d " \  #   define return uprintf("[%d] Return from <%s()> at line #%d " \
         "(%s [%d])\n", (int) getpid(), __FUNCTION__, \          "(%s [%d])\n", (int) getpid(), __FUNCTION__, \
         __LINE__, strerror(errno), errno); fflush(stdout); errno = 0; return          __LINE__, strerror(errno), errno); fflush(stdout); errno = 0; return
 #endif  #endif
   
 #ifdef DEBUG_MUTEX  #ifdef DEBUG_MUTEX
 #define pthread_mutex_lock(mutex) uprintf("[%d-%llu] Mutex %s (%p) " \  #   define pthread_mutex_lock(mutex) uprintf("[%d-%llu] Mutex %s (%p) " \
         "locking at %s() " \          "locking at %s() " \
         "line #%d\n", (int) getpid(), (unsigned long long) pthread_self(), \          "line #%d\n", (int) getpid(), (unsigned long long) pthread_self(), \
         #mutex, mutex, __FUNCTION__, __LINE__), fflush(stdout), \          #mutex, mutex, __FUNCTION__, __LINE__), fflush(stdout), \
         pthread_mutex_lock(mutex)          pthread_mutex_lock(mutex)
 #define pthread_mutex_unlock(mutex) uprintf("[%d-%llu] Mutex %s (%p) " \  #   define pthread_mutex_unlock(mutex) uprintf("[%d-%llu] Mutex %s (%p) " \
         "unlocking at " \          "unlocking at " \
         "%s() line #%d\n", (int) getpid(), (unsigned long long) \          "%s() line #%d\n", (int) getpid(), (unsigned long long) \
         pthread_self(), #mutex, mutex, __FUNCTION__, __LINE__), \          pthread_self(), #mutex, mutex, __FUNCTION__, __LINE__), \
Line 772  pid_t debug_fork(); Line 768  pid_t debug_fork();
 #define d_SPH                   "Semaphore $n 'name'"  #define d_SPH                   "Semaphore $n 'name'"
 #define d_TAB                   "<[ table ]>"  #define d_TAB                   "<[ table ]>"
 #define d_MTX                   "Mutex $n"  #define d_MTX                   "Mutex $n"
   #define d_REC                   "Record /'name_1', ..., 'name_n'/"
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
Line 809  pid_t debug_fork(); Line 806  pid_t debug_fork();
 #       else  #       else
 #           define __erreur_(i) i  #           define __erreur_(i) i
 #       endif  #       endif
 #       define __erreur(i)  ({ if (strstr(__FUNCTION__, "recherche_variable") \  #       define __erreur(i)  ({ int ios; ios = errno; \
                 == NULL) ufprintf(stderr, \                  if (strstr(__FUNCTION__, "recherche_variable") \
                 "ERROR %d AT %s() FROM %s LINE %d\n", \                  == NULL) { if(ios != 0) \
                 i, __FUNCTION__, __FILE__, __LINE__); i; })                  ufprintf(stderr, "LAST ERROR: %s\n", strerror(ios)); \
                   ufprintf(stderr, "ERROR %d AT %s() FROM %s LINE %d\n", \
                   i, __FUNCTION__, __FILE__, __LINE__); BACKTRACE(16); } i; })
 #   endif  #   endif
 #else  #else
 #   define __erreur(i)  i  #   define __erreur(i)  i
 #   define __erreur_(i) i  #   define __erreur_(i) i
 #endif  #endif
   
   #ifdef DEBUG_FICHIERS
   #   define open(a, ...) \
           ({ ufprintf(stderr, "[%d] OPEN %s AT %s() FROM %s LINE %d\n", \
           getpid(), a, \
           __FUNCTION__, __FILE__, __LINE__); open(a, __VA_ARGS__); })
   #   define pipe(a) \
           ({ ufprintf(stderr, "[%d] PIPE %s AT %s() FROM %s LINE %d\n", \
           getpid(), a, \
           __FUNCTION__, __FILE__, __LINE__); pipe(a); })
   #   define shm_open(a, ...) \
           ({ ufprintf(stderr, "[%d] SHM_OPEN %s AT %s() FROM %s LINE %d\n", \
           getpid(), a, \
           __FUNCTION__, __FILE__, __LINE__); shm_open(a, __VA_ARGS__); })
   #   define shm_unlink(a) \
           ({ ufprintf(stderr, "[%d] SHM_UNLINK %s AT %s() FROM %s LINE %d\n", \
           getpid(), a, \
           __FUNCTION__, __FILE__, __LINE__); shm_unlink(a); })
   #   define sem_open(a, ...) \
           ({ ufprintf(stderr, "[%d] SEM_OPEN %s AT %s() FROM %s LINE %d\n", \
           getpid(), a, \
           __FUNCTION__, __FILE__, __LINE__); sem_open(a, __VA_ARGS__); })
   #   define sem_unlink(a) \
           ({ ufprintf(stderr, "[%d] SEM_UNLINK %s AT %s() FROM %s LINE %d\n", \
           getpid(), a, \
           __FUNCTION__, __FILE__, __LINE__); sem_unlink(a); })
   #   define close(a) \
           ({ ufprintf(stderr, "[%d] CLOSE %s AT %s() FROM %s LINE %d\n", \
           getpid(), a, \
           __FUNCTION__, __FILE__, __LINE__); close(a); })
   #endif
   
 // -1 : erreur provoquée par une bibliothèque externe  // -1 : erreur provoquée par une bibliothèque externe
 #ifndef RPLARGS  #ifndef RPLARGS
Line 985  pid_t debug_fork(); Line 1014  pid_t debug_fork();
 #   define d_ex_chiffrement_indisponible        __erreur(90)  #   define d_ex_chiffrement_indisponible        __erreur(90)
 #   define d_ex_longueur_clef_chiffrement       __erreur(91)  #   define d_ex_longueur_clef_chiffrement       __erreur(91)
 #   define d_ex_taille_message                  __erreur(92)  #   define d_ex_taille_message                  __erreur(92)
   #   define d_ex_type_externe_dup                __erreur(93)
   #   define d_ex_type_externe_drop               __erreur(94)
 #endif  #endif
   
   
Line 1013  pid_t debug_fork(); Line 1044  pid_t debug_fork();
 #define BIN __RPL_BIN  #define BIN __RPL_BIN
 #define CHN __RPL_CHN  #define CHN __RPL_CHN
 #define CPL __RPL_CPL  #define CPL __RPL_CPL
   #define EXT __RPL_EXT
 #define FCH __RPL_FCH  #define FCH __RPL_FCH
 #define FCT __RPL_FCT  #define FCT __RPL_FCT
 #define INT __RPL_INT  #define INT __RPL_INT
Line 1024  pid_t debug_fork(); Line 1056  pid_t debug_fork();
 #define NOM __RPL_NOM  #define NOM __RPL_NOM
 #define NON __RPL_NON  #define NON __RPL_NON
 #define PRC __RPL_PRC  #define PRC __RPL_PRC
   #define REC __RPL_REC
 #define REL __RPL_REL  #define REL __RPL_REL
 #define RPN __RPL_RPN  #define RPN __RPL_RPN
 #define SCK __RPL_SCK  #define SCK __RPL_SCK
Line 1037  pid_t debug_fork(); Line 1070  pid_t debug_fork();
   
 enum t_rplcas_commandes     { RPLCAS_INTEGRATION = 0, RPLCAS_LIMITE };  enum t_rplcas_commandes     { RPLCAS_INTEGRATION = 0, RPLCAS_LIMITE };
   
 enum t_type     { ADR = 0, ALG, BIN, CHN, CPL, FCH, FCT, INT, LST,  enum t_type     { ADR = 0, ALG, BIN, CHN, CPL, EXT, FCH, FCT, INT, LST,
                 MCX, MIN, MRL, MTX, NOM, NON, PRC, REL, RPN, SCK,                  MCX, MIN, MRL, MTX, NOM, NON, PRC, REC, REL, RPN, SCK,
                 SLB, SPH, SQL, TBL, VCX, VIN, VRL };                  SLB, SPH, SQL, TBL, VCX, VIN, VRL };
   
     /*      /*
Line 1061  enum t_type  { ADR = 0, ALG, BIN, CHN, C Line 1094  enum t_type  { ADR = 0, ALG, BIN, CHN, C
             Sans objet.              Sans objet.
             Type C/Fortran : complex16              Type C/Fortran : complex16
   
       EXT : type géré dans une bibliothèque externe.
   
     FCH : descripteur de fichier (struct_fichier *).      FCH : descripteur de fichier (struct_fichier *).
   
     FCT : déclaration d'une fonction et de son nombre d'arguments      FCT : déclaration d'une fonction et de son nombre d'arguments
Line 1126  enum t_type  { ADR = 0, ALG, BIN, CHN, C Line 1161  enum t_type  { ADR = 0, ALG, BIN, CHN, C
 typedef struct objet  typedef struct objet
 {  {
     enum t_type         type;      enum t_type         type;
       integer8            extension_type;
       void                *descripteur_bibliotheque;
   
     volatile long       nombre_occurrences;      volatile long       nombre_occurrences;
   
Line 1312  typedef struct connecteur_sql Line 1349  typedef struct connecteur_sql
 */  */
   
 #ifndef RPLARGS  #ifndef RPLARGS
   
   #   define                      d_BIND_TO_DEVICE        0
   #   define                      d_BROADCAST             1
   #   define                      d_DONT_ROUTE            2
   #   define                      d_KEEP_ALIVE            3
   #   define                      d_PRIORITY              4
   #   define                      d_RECEIVE_BUFFER        5
   #   define                      d_FORCE_RECEIVE_BUFFER  6
   #   define                      d_SEND_BUFFER           7
   #   define                      d_FORCE_SEND_BUFFER     8
   #   define                      d_RECEIVING_TIMEOUT     9
   #   define                      d_SENDING_TIMEOUT       10
   #   define                      d_REUSE_ADDRESS         11
   
 typedef struct socket  typedef struct socket
 {  {
     int                         domaine;      int                         domaine;
Line 1330  typedef struct socket Line 1381  typedef struct socket
     unsigned char               protection;      unsigned char               protection;
     unsigned char               type[19 + 1];      unsigned char               type[19 + 1];
   
       integer8                    options;
       int                         priorite;
       int                         buffer_reception;
       int                         buffer_emission;
       int                         timeout_emission;
       int                         timeout_reception;
   
     struct_objet                *format;      struct_objet                *format;
 } struct_socket;  } struct_socket;
 #endif  #endif
Line 1951  typedef struct processus Line 2009  typedef struct processus
     unsigned char               evaluation_forcee;                  /*Y/N*/      unsigned char               evaluation_forcee;                  /*Y/N*/
     unsigned char               instruction_valide;                 /*Y/N*/      unsigned char               instruction_valide;                 /*Y/N*/
     unsigned char               instruction_intrinseque;            /*Y/I/N*/      unsigned char               instruction_intrinseque;            /*Y/I/N*/
       unsigned char               instruction_sensible;               /*Y/N*/
     unsigned char               test_instruction;                   /*Y/N*/      unsigned char               test_instruction;                   /*Y/N*/
     unsigned char               affichage_arguments;                /*Y/N*/      unsigned char               affichage_arguments;                /*Y/N*/
     unsigned char               constante_symbolique;               /*Y/N*/      unsigned char               constante_symbolique;               /*Y/N*/
Line 2425  typedef struct processus Line 2484  typedef struct processus
             variables_tableau_noeuds_partages)              variables_tableau_noeuds_partages)
   
     CACHE2(struct_buffer, enveloppes_buffers)      CACHE2(struct_buffer, enveloppes_buffers)
     unsigned char       ***cache_buffer;      unsigned char               ***cache_buffer;
     int                 *pointeur_cache_buffer;      int                         *pointeur_cache_buffer;
 } struct_processus;  } struct_processus;
 #endif  #endif
   
Line 2446  void *rpl_malloc(struct_processus *s_eta Line 2505  void *rpl_malloc(struct_processus *s_eta
 void *rpl_realloc(struct_processus *s_etat_processus, void *ptr, size_t s);  void *rpl_realloc(struct_processus *s_etat_processus, void *ptr, size_t s);
 void rpl_free(struct_processus *s_etat_processus, void *ptr);  void rpl_free(struct_processus *s_etat_processus, void *ptr);
 void *sys_malloc(size_t s);  void *sys_malloc(size_t s);
   void *sys_realloc(void *ptr, size_t s);
 void sys_free(void *ptr);  void sys_free(void *ptr);
   
 /*  /*
Line 3105  void interruption3(int signal); Line 3165  void interruption3(int signal);
 void interruption4(int signal);  void interruption4(int signal);
 void interruption5(int signal);  void interruption5(int signal);
 void interruption6(int signal);  void interruption6(int signal);
 void interruption_depassement_pile(int urgence, stackoverflow_context_t scp);  #ifdef HAVE_SIGSEGV_RECOVERY
       void interruption_depassement_pile(int urgence,
               stackoverflow_context_t scp);
   #endif
 void inversion_matrice(struct_processus *s_etat_processus,  void inversion_matrice(struct_processus *s_etat_processus,
         struct_matrice *s_matrice);          struct_matrice *s_matrice);
 void lancement_daemon(struct_processus *s_etat_processus);  void lancement_daemon(struct_processus *s_etat_processus);
Line 3189  void liberation_queue_signaux(struct_pro Line 3252  void liberation_queue_signaux(struct_pro
 void destruction_queue_signaux(struct_processus *s_etat_processus);  void destruction_queue_signaux(struct_processus *s_etat_processus);
 int envoi_signal_contexte(struct_processus *s_etat_processus,  int envoi_signal_contexte(struct_processus *s_etat_processus,
         enum signaux_rpl signal);          enum signaux_rpl signal);
 int envoi_signal_processus(pid_t pid, enum signaux_rpl signal);  int envoi_signal_processus(pid_t pid, enum signaux_rpl signal,
           logical1 test_ouverture);
 int envoi_signal_thread(pthread_t tid, enum signaux_rpl signal);  int envoi_signal_thread(pthread_t tid, enum signaux_rpl signal);
 #endif  #endif
   
Line 3383  logical1 retrait_variable_statique(struc Line 3447  logical1 retrait_variable_statique(struc
 logical1 retrait_variables_statiques_locales(  logical1 retrait_variables_statiques_locales(
         struct_processus *s_etat_processus);          struct_processus *s_etat_processus);
 logical1 sequenceur(struct_processus *s_etat_processus);  logical1 sequenceur(struct_processus *s_etat_processus);
 logical1 sequenceur_optimise(struct_processus *s_etat_processus);  logical1 sequenceur_optimise(struct_processus *s_etat_processus,
           struct_liste_chainee *l_bibliotheques);
 #endif  #endif
   
 /*  /*

Removed from v.1.270  
changed lines
  Added in v.1.310


CVSweb interface <joel.bertrand@systella.fr>