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

Diff for /rpl/src/rpl.h between versions 1.256 and 1.344

version 1.256, 2015/01/08 08:46:22 version 1.344, 2022/06/15 06:45:44
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.20    RPL/2 (R) version 4.1.33
   Copyright (C) 1989-2015 Dr. BERTRAND Joël    Copyright (C) 1989-2021 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 38 Line 38
 #   ifdef OpenBSD  #   ifdef OpenBSD
 #       define _BSD_SOURCE  #       define _BSD_SOURCE
 #   endif  #   endif
   
   #   ifdef FreeBSD
   #       define __BSD_VISIBLE    1
   #   endif
 #endif  #endif
   
 #ifdef OS2  #ifdef OS2
Line 60 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 78 Line 92
 #include <stdarg.h>  #include <stdarg.h>
 #include <poll.h>  #include <poll.h>
 #include <signal.h>  #include <signal.h>
   #include <sys/time.h>
   
 #ifndef RPLARGS  #ifndef RPLARGS
 #   include <sys/mman.h>  #   include <sys/mman.h>
 #   include <sys/time.h>  
 #   include <sys/resource.h>  #   include <sys/resource.h>
 #   include <sys/select.h>  #   include <sys/select.h>
 #   include <sys/socket.h>  #   include <sys/socket.h>
Line 90 Line 104
 #   include <sys/types.h>  #   include <sys/types.h>
 #   include <sys/un.h>  #   include <sys/un.h>
 #   include <sys/wait.h>  #   include <sys/wait.h>
   #   include <omp.h>
   
 #   include <arpa/inet.h>  #   include <arpa/inet.h>
 #   include <netinet/in.h>  #   include <netinet/in.h>
Line 171 Line 186
 #   include "zlib.h"  #   include "zlib.h"
   
 #   include "openssl/evp.h"  #   include "openssl/evp.h"
 #   ifndef OPENSSL_NO_MD2  #   ifndef RPLCXX
 #       include "openssl/md2.h"  #       ifndef OPENSSL_NO_MD2
 #   endif  #           include "openssl/md2.h"
 #   ifndef OPENSSL_NO_MD4  #       endif
 #       include "openssl/md4.h"  #       ifndef OPENSSL_NO_MD4
 #   endif  #           include "openssl/md4.h"
 #   ifndef OPENSSL_NO_MD5  #       endif
 #       include "openssl/md5.h"  #       ifndef OPENSSL_NO_MD5
 #   endif  #           include "openssl/md5.h"
 #   ifndef OPENSSL_NO_MDC2  #       endif
 #       include "openssl/mdc2.h"  #       ifndef OPENSSL_NO_MDC2
 #   endif  #           include "openssl/mdc2.h"
 #   ifndef OPENSSL_NO_RIPEMD  #       endif
 #       include "openssl/ripemd.h"  #       ifndef OPENSSL_NO_RIPEMD
 #   endif  #           include "openssl/ripemd.h"
 #   ifndef OPENSSL_NO_SHA  #       endif
 #       include "openssl/sha.h"  #       ifndef OPENSSL_NO_SHA
 #   endif  #           include "openssl/sha.h"
 #   ifndef OPENSSL_NO_WHIRLPOOL  #       endif
 #       include "openssl/whrlpool.h"  #       ifndef OPENSSL_NO_WHIRLPOOL
 #   endif  #           include "openssl/whrlpool.h"
 #   ifndef OPENSSL_NO_AES  #       endif
 #       include "openssl/aes.h"  #       ifndef OPENSSL_NO_AES
 #   endif  #           include "openssl/aes.h"
 #   ifndef OPENSSL_NO_CAMELLIA  #       endif
 #       include "openssl/camellia.h"  #       ifndef OPENSSL_NO_CAMELLIA
 #   endif  #           include "openssl/camellia.h"
 #   ifndef OPENSSL_NO_RC2  #       endif
 #       include "openssl/rc2.h"  #       ifndef OPENSSL_NO_RC2
 #   endif  #           include "openssl/rc2.h"
 #   ifndef OPENSSL_NO_IDEA  #       endif
 #       include "openssl/idea.h"  #       ifndef OPENSSL_NO_IDEA
   #           include "openssl/idea.h"
   #       endif
 #   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
 #   endif  #   endif
   
 #   define HAVE_INLINE  
 #   define GSL_RANGE_CHECK_OFF  #   define GSL_RANGE_CHECK_OFF
 #   include "gsl/gsl_cdf.h"  #   include "gsl/gsl_cdf.h"
 #   include "gsl/gsl_cblas.h"  #   include "gsl/gsl_cblas.h"
Line 228 Line 248
 #   include <ieeefp.h>  #   include <ieeefp.h>
 #endif  #endif
   
 // Définition spécifique à Hurd  // Définition spécifique à Hurd
 #ifndef PIPE_BUF  #ifndef PIPE_BUF
 #   define fpathconf (".", _PC_PIPE_BUF)  #   define fpathconf (".", _PC_PIPE_BUF)
 #endif  #endif
Line 251 Line 271
   
 #ifndef RPLARGS  #ifndef RPLARGS
 #   ifndef UNIX_PATH_MAX  #   ifndef UNIX_PATH_MAX
         struct sockaddr_un sizecheck;  #       pragma GCC diagnostic push
   #       pragma GCC diagnostic ignored "-Wunused-variable"
           static struct sockaddr_un sizecheck;
 #       define UNIX_PATH_MAX sizeof(sizecheck.sun_path)  #       define UNIX_PATH_MAX sizeof(sizecheck.sun_path)
   #       pragma GCC diagnostic pop
 #   endif  #   endif
 #endif  #endif
   
Line 264 Line 287
 #   define __STATIC_MUTEX_INITIALIZATION__  #   define __STATIC_MUTEX_INITIALIZATION__
 #endif  #endif
   
   
 /*  /*
 ================================================================================  ================================================================================
   Bugs spécifiques    Bugs spécifiques
 ================================================================================  ================================================================================
 */  */
   
 // Néant  // Néant
   
 /*  /*
 ================================================================================  ================================================================================
Line 292  enum signaux_rpl Line 316  enum signaux_rpl
     rpl_signull = 0,      rpl_signull = 0,
     rpl_sigint,      rpl_sigint,
     rpl_sigterm,      rpl_sigterm,
     rpl_sigstart,       // Signal envoyé par un père pour lancer son fils.      rpl_sigstart,       // Signal envoyé par un père pour lancer son fils.
     rpl_sigcont,        // Signal de redémarrage d'un processus arrêté par      rpl_sigcont,        // Signal de redémarrage d'un processus arrêté par
                         // SUSPEND                          // SUSPEND
     rpl_sigstop,        // Signal d'arrêt envoyé par l'instruction STOP ou      rpl_sigstop,        // Signal d'arrêt envoyé par l'instruction STOP ou
                         // FUSE. (FSTOP)                          // FUSE. (FSTOP)
     rpl_sigabort,       // Signal envoyé par l'instruction ABORT (à regrouper      rpl_sigabort,       // Signal envoyé par l'instruction ABORT (à regrouper
                         // avec FABORT)                          // avec FABORT)
     rpl_sigurg,         // Signal d'arrêt urgent      rpl_sigurg,         // Signal d'arrêt urgent
     rpl_siginject,      // Signal indiquant la présence d'une donnée à lire      rpl_siginject,      // Signal indiquant la présence d'une donnée à lire
                         // envoyée depuis le père                          // envoyée depuis le père
     rpl_sigalrm,        // Signal d'alarme (erreur système) depuis un fils      rpl_sigalrm,        // Signal d'alarme (erreur système) depuis un fils
     rpl_sighup,      rpl_sighup,
     rpl_sigtstp,      rpl_sigtstp,
     rpl_sigexcept,      rpl_sigexcept,
     rpl_sigmax      rpl_sigmax,
       rpl_siguser         // Base des signaux à la discrétion de l'utilisateur
 };  };
   
 #define LONGUEUR_QUEUE_SIGNAUX          1024  #define LONGUEUR_QUEUE_SIGNAUX          1024
   
 // Une structure s_queue_signaux est créée par processus (et non par thread).  // Une structure s_queue_signaux est créée par processus (et non par thread).
 // Elle est projetée dans un segment de mémoire partagée pour qu'elle soit  // Elle est projetée dans un segment de mémoire partagée pour qu'elle soit
 // accessible à la fois du père et des fils.  // accessible à la fois du père et des fils.
   
 #ifndef RPLARGS  #ifndef RPLARGS
 typedef struct queue_signaux  typedef struct queue_signaux
Line 323  typedef struct queue_signaux Line 348  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 347  __EXTERN__ int     f_queue_signaux; Line 373  __EXTERN__ int     f_queue_signaux;
 #   endif  #   endif
 #endif  #endif
   
 #ifdef OS2  
 #   define readline(s) readline_wrapper(s)  
     unsigned char *readline_wrapper(unsigned char *s);  
 #endif  
   
 #if ! defined(UNION_SEMUN) && defined(IPCS_SYSV)  #if ! defined(UNION_SEMUN) && defined(IPCS_SYSV)
 union semun  union semun
 {  {
Line 370  union semun Line 391  union semun
 #   define SIGSTKSZ         65536  #   define SIGSTKSZ         65536
 #endif  #endif
   
   
 /*  /*
 ================================================================================  ================================================================================
   SÉMAPHORES    SÉMAPHORES
 ================================================================================  ================================================================================
 */  */
   
 #ifdef IPCS_SYSV  #ifdef IPCS_SYSV
 #   ifdef DEBUG_SEMAPHORES  #   ifdef DEBUG_SEMAPHORES
   #       define sem_init(a, b, c) ({ \
                   uprintf("[%d-%llu] Semaphore %s (%p) "\
                           "initialization at %s() " \
                   "line #%d <%d>\n", (int) getpid(), (unsigned long long) \
                           pthread_self(), \
                   #a, a, __FUNCTION__, __LINE__, value), fflush(stdout); \
                   sem_init_SysV(a, b, c); })
 #       define sem_wait(a) ({ int value; sem_getvalue(a, &value); \  #       define sem_wait(a) ({ int value; sem_getvalue(a, &value); \
                 uprintf("[%d-%llu] Semaphore %s (%p) "\                  uprintf("[%d-%llu] Semaphore %s (%p) "\
                 "waiting at %s() " \                  "waiting at %s() " \
                 "line #%d\n", (int) getpid(), (unsigned long long) i\                  "line #%d <%d>\n", (int) getpid(), (unsigned long long) i\
                         pthread_self(), \                          pthread_self(), \
                 #a, a, __FUNCTION__, __LINE__), fflush(stdout); \                  #a, a, __FUNCTION__, __LINE__, value), fflush(stdout); \
                 if (value > 1) BUG(1, uprintf("Value %d\n", value)); \  
                 sem_wait_SysV(a); })                  sem_wait_SysV(a); })
 #   define sem_post(a) ({ int value; sem_getvalue(a, &value); \  #       define sem_trywait(a) ({ int value; sem_getvalue(a, &value); \
                   uprintf("[%d-%llu] Semaphore %s (%p) "\
                   "trywaiting at %s() " \
                   "line #%d <%d>\n", (int) getpid(), (unsigned long long) i\
                           pthread_self(), \
                   #a, a, __FUNCTION__, __LINE__, value), fflush(stdout); \
                   sem_trywait_SysV(a); })
   #       define sem_post(a) ({ int value; sem_getvalue(a, &value); \
                 uprintf("[%d-%llu] Semaphore %s (%p) "\                  uprintf("[%d-%llu] Semaphore %s (%p) "\
                 "posting at %s() " \                  "posting at %s() " \
                 "line #%d\n", (int) getpid(), (unsigned long long) \                  "line #%d <%d>\n", (int) getpid(), (unsigned long long) \
                         pthread_self(), \                          pthread_self(), \
                 #a, a, __FUNCTION__, __LINE__), fflush(stdout); \                  #a, a, __FUNCTION__, __LINE__, value), fflush(stdout); \
                 if (value > 0) BUG(1, uprintf("Value %d\n", value)); \  
                 sem_post_SysV(a); })                  sem_post_SysV(a); })
 #   define sem_destroy(a) ({ int value; sem_getvalue(a, &value); \  #       define sem_destroy(a) ({ int value; sem_getvalue(a, &value); \
                   uprintf("[%d-%llu] Semaphore %s (%p) "\
                   "destroying at %s() " \
                   "line #%d <%d>\n", (int) getpid(), (unsigned long long) \
                           pthread_self(), \
                   #a, a, __FUNCTION__, __LINE__, value), fflush(stdout); \
                 if (value == 0) BUG(1, uprintf("Value %d\n", value)); \                  if (value == 0) BUG(1, uprintf("Value %d\n", value)); \
                 sem_destroy_SysV(a); })                  sem_destroy_SysV(a); })
 #   else  #   else
Line 412  union semun Line 451  union semun
 #   define sem_unlink(a)        sem_unlink_SysV(a)  #   define sem_unlink(a)        sem_unlink_SysV(a)
 #else  #else
 #   ifdef DEBUG_SEMAPHORES  #   ifdef DEBUG_SEMAPHORES
   #       define sem_init(a, b, c) ({ \
                   uprintf("[%d-%llu] Semaphore %s (%p) "\
                           "initialization at %s() " \
                   "line #%d <%d>\n", (int) getpid(), (unsigned long long) \
                           pthread_self(), \
                   #a, a, __FUNCTION__, __LINE__, c), fflush(stdout); \
                   sem_init(a, b, c); })
 #       define sem_wait(a) ({ int value; sem_getvalue(a, &value); \  #       define sem_wait(a) ({ int value; sem_getvalue(a, &value); \
                 uprintf("[%d-%llu] Semaphore %s (%p) "\                  uprintf("[%d-%llu] Semaphore %s (%p) "\
                 "waiting at %s() " \                  "waiting at %s() " \
                 "line #%d\n", (int) getpid(), (unsigned long long) \                  "line #%d <%d>\n", (int) getpid(), (unsigned long long) \
                           pthread_self(), \
                   #a, a, __FUNCTION__, __LINE__, value), fflush(stdout); \
                   sem_wait(a); })
   #       define sem_trywait(a) ({ int value; sem_getvalue(a, &value); \
                   uprintf("[%d-%llu] Semaphore %s (%p) "\
                   "trywaiting at %s() " \
                   "line #%d <%d>\n", (int) getpid(), (unsigned long long) \
                         pthread_self(), \                          pthread_self(), \
                 #a, a, __FUNCTION__, __LINE__), fflush(stdout); \                  #a, a, __FUNCTION__, __LINE__, value), fflush(stdout); \
                 if (value > 1) BUG(1, uprintf("Value %d\n", value)); sem_wait(a); })                  sem_trywait(a); })
 #       define sem_post(a) ({ int value; sem_getvalue(a, &value); \  #       define sem_post(a) ({ int value; sem_getvalue(a, &value); \
                 uprintf("[%d-%llu] Semaphore %s (%p) "\                  uprintf("[%d-%llu] Semaphore %s (%p) "\
                 "posting at %s() " \                  "posting at %s() " \
                 "line #%d\n", (int) getpid(), (unsigned long long) \                  "line #%d <%d>\n", (int) getpid(), (unsigned long long) \
                         pthread_self(), \                          pthread_self(), \
                 #a, a, __FUNCTION__, __LINE__), fflush(stdout); \                  #a, a, __FUNCTION__, __LINE__, value), fflush(stdout); \
                 if (value > 0) BUG(1, uprintf("Value %d\n", value)); sem_post(a); })                  sem_post(a); })
 #       define sem_destroy(a) ({ int value; sem_getvalue(a, &value); \  #       define sem_destroy(a) ({ int value; sem_getvalue(a, &value); \
                   uprintf("[%d-%llu] Semaphore %s (%p) "\
                   "destroying at %s() " \
                   "line #%d <%d>\n", (int) getpid(), (unsigned long long) \
                           pthread_self(), \
                   #a, a, __FUNCTION__, __LINE__, value), fflush(stdout); \
                 if (value == 0) BUG(1, uprintf("Value %d\n", value)); \                  if (value == 0) BUG(1, uprintf("Value %d\n", value)); \
                 sem_destroy(a); })                  sem_destroy(a); })
 #   endif  #   endif
Line 441  union semun Line 499  union semun
   
 #ifndef RPLARGS  #ifndef RPLARGS
   
 // Signaux utilisés par défaut :  // Signaux utilisés par défaut :
 //  SIGINT  //  SIGINT
 //  SIGTSTP  //  SIGTSTP
 //  SIGCONT  //  SIGCONT
 //  SIGPIPE  //  SIGPIPE
 //  SIGUSR1 et SIGUSR2 sont utilisé par libsigsegv.  //  SIGUSR1 et SIGUSR2 sont utilisé par libsigsegv.
 //  SIGHUP  //  SIGHUP
 //  SIGALRM  //  SIGALRM
   
Line 458  union semun Line 516  union semun
   
 /*  /*
 ================================================================================  ================================================================================
   Granularité temporelle    Granularité temporelle
 ================================================================================  ================================================================================
 */  */
   
Line 515  union semun Line 573  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_sigaction;
                                             __STATIC_MUTEX_INITIALIZATION__;      __EXTERN__ pthread_mutex_t      mutex_liste_threads;
       __EXTERN__ pthread_mutex_t      mutex_liste_threads_surveillance;
     __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 524  union semun Line 583  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_threads_surveillance_processus;
   
 #   define SEM_FORK             0  #   define SEM_FORK                 0
 #   define SEM_QUEUE                1  #   define SEM_QUEUE                1
 #   define SEM_SIGNALISATION        2  #   define SEM_SIGNALISATION        2
 #   define SEM_ARRET_SIGNALISATION  3  #   define SEM_ARRET_SIGNALISATION  3
Line 538  union semun Line 598  union semun
     sem_t *sem_open2(pid_t pid, int ordre);      sem_t *sem_open2(pid_t pid, int ordre);
 #endif  #endif
   
 // Le mutex est là uniquement pour pouvoir émuler le comportement  // Le mutex est là uniquement pour pouvoir émuler le comportement
 // de sem_getvalue() sur un système comme MacOS X qui ne possède pas  // de sem_getvalue() sur un système comme MacOS X qui ne possède pas
 // cette fonction.  // cette fonction.
   
 #ifdef Darwin  #ifdef Darwin
Line 561  union semun Line 621  union semun
 ================================================================================  ================================================================================
 */  */
   
 // Par défaut, tout est redirigé vers stderr sauf indication explicite de  // Par défaut, tout est redirigé vers stderr sauf indication explicite de
 // stdout.  // stdout.
   
 #define printf(...) transliterated_fprintf(s_etat_processus, \  #define printf(...) transliterated_fprintf(s_etat_processus, \
             stderr, __VA_ARGS__)              stderr, __VA_ARGS__)
 #define fprintf(flux, ...) transliterated_fprintf(s_etat_processus, \  #define fprintf(flux, ...) transliterated_fprintf(s_etat_processus, \
             flux, __VA_ARGS__)              flux, __VA_ARGS__)
 #define uprintf(...) transliterated_fprintf(NULL, \  #define uprintf(...) std_fprintf(stderr, __VA_ARGS__)
             stderr, __VA_ARGS__)  #define ufprintf(flux, ...) std_fprintf(flux, __VA_ARGS__)
 #define ufprintf(flux, ...) transliterated_fprintf(NULL, \  
             flux, __VA_ARGS__)  
   
 #ifdef SunOS  #ifdef SunOS
 #   define fopen(...) ({ FILE *desc; \  #   define fopen(...) ({ FILE *desc; \
Line 593  union semun Line 651  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  // Redéfinition de abs pour un fonctionnement en entier de type long long int
 // 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  
   
 #ifdef __GNUC__  #ifdef __GNUC__
 #   define abs(i) ({ typeof(i) _i; _i = (i); (_i >= 0) ? _i : -_i; })  #   define abs(i) ({ typeof(i) _i; _i = (i); (_i >= 0) ? _i : -_i; })
 // typeof() est une extension de gcc, mais est présent sur d'autres compilateurs  // typeof() est une extension de gcc, mais est présent sur d'autres compilateurs
 // comme Sun Studio. Dans le cas où typeof() n'existe pas, il est possible  // comme Sun Studio. Dans le cas où typeof() n'existe pas, il est possible
 // d'utiliser la macro suivante, mais elle possède un effet de bord dû à  // d'utiliser la macro suivante, mais elle possède un effet de bord dû à
 // l'évaluation multiple de l'argument.  // l'évaluation multiple de l'argument.
 #else  #else
 #   define abs(i) (((i) >= 0) ? (i) : (-i))  #   define abs(i) (((i) >= 0) ? (i) : (-i))
 #endif  #endif
Line 635  union semun Line 673  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 653  union semun Line 691  union semun
         { \          { \
             for(i = 0; i < nb; i++) \              for(i = 0; i < nb; i++) \
                 uprintf("    %s\n", appels[i]); \                  uprintf("    %s\n", appels[i]); \
             free(appels); \              sys_free(appels); \
         } \          } \
         else \          else \
             uprintf("Nullified backtrace\n"); \              uprintf("Nullified backtrace\n"); \
Line 662  union semun Line 700  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 698  void *debug_memoire_modification(void *p Line 736  void *debug_memoire_modification(void *p
 void debug_memoire_retrait(void *ptr);  void debug_memoire_retrait(void *ptr);
 void debug_memoire_verification();  void debug_memoire_verification();
   
 pid_t debug_fork();  
   
 #define malloc(s) debug_memoire_ajout(s, __FUNCTION__, __LINE__, #s)  
 #define free(s) debug_memoire_retrait(s)  #define free(s) debug_memoire_retrait(s)
 #define realloc(s, t) debug_memoire_modification(s, t, \  #ifdef RPLCXX
             __FUNCTION__, __LINE__, #t)  #   define malloc(s) debug_memoire_ajout(s, \
 #define fork() debug_fork()                  const_cast<const unsigned char *> \
                   (reinterpret_cast<unsigned char *> \
                   (const_cast<char *>(__FUNCTION__))), __LINE__, \
                   const_cast<const unsigned char *> \
                   (reinterpret_cast<unsigned char *> \
                   (const_cast<char *>(#s))))
   #   define realloc(s, t) debug_memoire_modification(s, t, \
                   const_cast<const unsigned char *> \
                   (reinterpret_cast<unsigned char *> \
                   (const_cast<char *>(__FUNCTION__))), __LINE__, \
                   const_cast<const unsigned char *> \
                   (reinterpret_cast<unsigned char *> \
                   (const_cast<char *>(#t))))
   #else
   #   define malloc(s) debug_memoire_ajout(s, __FUNCTION__, __LINE__, \
                   (const unsigned char *) #s)
   #   define realloc(s, t) debug_memoire_modification(s, t, \
                   __FUNCTION__, __LINE__, (const unsigned char *) #t)
   #endif
   #define fork() debug_fork(s_etat_processus)
 #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__), \
         fflush(stdout), \          fflush(stdout), \
         pthread_mutex_unlock(mutex)          pthread_mutex_unlock(mutex)
   #   define pthread_mutex_trylock(mutex) uprintf("[%d-%llu] Mutex %s (%p) " \
           "trylocking at " \
           "%s() line #%d\n", (int) getpid(), (unsigned long long) \
           pthread_self(), #mutex, mutex, __FUNCTION__, __LINE__), \
           fflush(stdout), \
           pthread_mutex_trylock(mutex)
 #endif  #endif
   
   
Line 775  pid_t debug_fork(); Line 835  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 ]|"
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Paramètres du système    Paramètres du système
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 797  pid_t debug_fork(); Line 858  pid_t debug_fork();
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Erreurs système    Erreurs système
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 812  pid_t debug_fork(); Line 873  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
 #   define d_es                                 2000  #   define d_es                                 2000
 #   define d_es_allocation_memoire              __erreur(2001)  #   define d_es_allocation_memoire              __erreur(2001)
Line 889  pid_t debug_fork(); Line 982  pid_t debug_fork();
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Erreurs à l'exécution    Erreurs à l'exécution
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
 // -1 : erreur provoquée par une bibliothèque externe  // -1 : erreur provoquée par une bibliothèque externe
 #ifndef RPLARGS  #ifndef RPLARGS
 #   define d_ex                                 0  #   define d_ex                                 0
 #   define d_ex_pile_vide                       __erreur(1)  #   define d_ex_pile_vide                       __erreur(1)
Line 988  pid_t debug_fork(); Line 1081  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)
   #   define d_ex_simplification                  __erreur(95)
 #endif  #endif
   
   
Line 1016  pid_t debug_fork(); Line 1112  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 1027  pid_t debug_fork(); Line 1124  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 1038  pid_t debug_fork(); Line 1136  pid_t debug_fork();
 #define VIN __RPL_VIN  #define VIN __RPL_VIN
 #define VRL __RPL_VRL  #define VRL __RPL_VRL
   
 enum t_rplcas_commandes     { RPLCAS_INTEGRATION = 0, RPLCAS_LIMITE };  enum t_rplcas_commandes     { RPLCAS_INTEGRATION = 0, RPLCAS_LIMITE,
                               RPLCAS_SIMPLIFICATION };
   
 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 };
   
     /*      /*
     ADR : adresse sur 64 bits signés.      ADR : adresse sur 64 bits signés.
             Adresse d'une définition à interpréter.              Adresse d'une définition à interpréter.
   
     ALG : expression algébrique (struct_liste_chainee *)      ALG : expression algébrique (struct_liste_chainee *)
             La liste chaînée contient la définition convertie en notation              La liste chaînée contient la définition convertie en notation
             polonaise inversée. Ce type diffère du type 'RPN' au niveau              polonaise inversée. Ce type diffère du type 'RPN' au niveau
             du format de sortie (notation algébrique).              du format de sortie (notation algébrique).
   
     BIN : entier binaire sur 64 bits (unsigned integer8 *)      BIN : entier binaire sur 64 bits (unsigned integer8 *)
             Sans objet.              Sans objet.
             Type C/Fortran : unsigned integer8              Type C/Fortran : unsigned integer8
   
     CHN : chaine de caracteres (character*(*), unsigned char *)      CHN : chaine de caracteres (unsigned char *)
             Sans objet.              Sans objet.
   
     CPL : complexe sur 2*64 bits (complex*16, struct_complexe16 *)      CPL : complexe sur 2*64 bits (complex*16, struct_complexe16 *)
             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
             (struct_fonction *). Ce type n'est nécessaire que dans le              (struct_fonction *). Ce type n'est nécessaire que dans le
             traitement des types 'ALG' et 'RPN'.              traitement des types 'ALG' et 'RPN'.
   
     INT : entier sur 64 bits (integer*8, integer8 *)      INT : entier sur 64 bits (integer*8, integer8 *)
Line 1075  enum t_type  { ADR = 0, ALG, BIN, CHN, C Line 1176  enum t_type  { ADR = 0, ALG, BIN, CHN, C
             Type C/Fortran : integer8              Type C/Fortran : integer8
   
     LST : liste (struct_liste_chainee *)      LST : liste (struct_liste_chainee *)
             Les objets sont enregistrés sous forme de liste chaînée récursive.              Les objets sont enregistrés sous forme de liste chaînée récursive.
             Cela permet de traiter des tableaux de données hétérogènes de              Cela permet de traiter des tableaux de données hétérogènes de
             grandes dimensions. Le nombre de dimensions maximal est fixé par              grandes dimensions. Le nombre de dimensions maximal est fixé par
             la mémoire de la station.              la mémoire de la station.
   
     MCX : matrice de complexes (struct_matrice *)      MCX : matrice de complexes (struct_matrice *)
             Sans objet.              Sans objet.
Line 1098  enum t_type  { ADR = 0, ALG, BIN, CHN, C Line 1199  enum t_type  { ADR = 0, ALG, BIN, CHN, C
     PRC : processus (struct_processus_fils *)      PRC : processus (struct_processus_fils *)
             Sans objet.              Sans objet.
   
       REC : enregistrement (struct_record *)
   
     REL : reel sur 64 bits (real*8, real8 *)      REL : reel sur 64 bits (real*8, real8 *)
             Sans objet.              Sans objet.
   
     RPN : definition (struct_liste_chainee *)      RPN : definition (struct_liste_chainee *)
             Ce type diffère du type 'ALG' au niveau du format de sortie              Ce type diffère du type 'ALG' au niveau du format de sortie
             (notation polonaise inversée).              (notation polonaise inversée).
   
     SCK : socket (struct_socket *)      SCK : socket (struct_socket *)
   
     SLB : bibliothèque dynamique partagée (struct_bibliotheque *)       SLB : bibliothèque dynamique partagée (struct_bibliotheque *) 
             Sans objet.              Sans objet.
   
     SPH : sémaphore nommé (struct_semaphore *)      SPH : sémaphore nommé (struct_semaphore *)
   
     SQL : connecteur sur une base de données SQL (struct_connecteur_sql *)      SQL : connecteur sur une base de données SQL (struct_connecteur_sql *)
   
     TBL : tableau multidimensionnel d'objets (struct_tableau *).      TBL : tableau multidimensionnel d'objets (struct_tableau *).
   
Line 1129  enum t_type  { ADR = 0, ALG, BIN, CHN, C Line 1232  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 1182  typedef struct rpl_mutex Line 1287  typedef struct rpl_mutex
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Structure sémaphore    Structure sémaphore
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 1214  typedef struct marque Line 1319  typedef struct marque
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Structure bibliothèque    Structure bibliothèque
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 1315  typedef struct connecteur_sql Line 1420  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 1333  typedef struct socket Line 1452  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
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Structure liste chaînee    Structure liste chaînee
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 1364  typedef struct gestion_signaux Line 1490  typedef struct gestion_signaux
     unsigned char               masque_signaux[d_NOMBRE_SIGNAUX];      unsigned char               masque_signaux[d_NOMBRE_SIGNAUX];
   
     /*      /*
      * 'I' : signal ignoré       * 'I' : signal ignoré
      * 'Q' : signal mis en queue pour un traitement ultérieur       * 'Q' : signal mis en queue pour un traitement ultérieur
      * 'N' : traitement normal du signal       * 'N' : traitement normal du signal
      */       */
   
Line 1413  typedef struct liste_profilage2 Line 1539  typedef struct liste_profilage2
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Structure contenant les fichiers graphiques (liste chaînée)    Structure contenant les fichiers graphiques (liste chaînée)
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 1445  typedef struct nom Line 1571  typedef struct nom
 {  {
     unsigned char               *nom;      unsigned char               *nom;
     logical1                    symbole;    /* d_vrai/d_faux */      logical1                    symbole;    /* d_vrai/d_faux */
     // symbole == d_vrai signifie que le nom a été introduit dans un      // symbole == d_vrai signifie que le nom a été introduit dans un
     // calcul sans les apostrophes.      // calcul sans les apostrophes.
 } struct_nom;  } struct_nom;
   
Line 1520  typedef struct liste_pile_systeme Line 1646  typedef struct liste_pile_systeme
     logical1                    creation_variables_statiques;      logical1                    creation_variables_statiques;
     logical1                    creation_variables_partagees;      logical1                    creation_variables_partagees;
     logical1                    evaluation_expression;      logical1                    evaluation_expression;
       logical1                    debug_programme;
   
     unsigned char               clause;      unsigned char               clause;
   
Line 1527  typedef struct liste_pile_systeme Line 1654  typedef struct liste_pile_systeme
     clause :      clause :
     I : IF      I : IF
     R : IFERR      R : IFERR
     X : IFERR indiquant la présence d'une erreur.      X : IFERR indiquant la présence d'une erreur.
     T : THEN      T : THEN
     E : ELSE      E : ELSE
     Z : traitement en cours de ELSE      Z : traitement en cours de ELSE
Line 1536  typedef struct liste_pile_systeme Line 1663  typedef struct liste_pile_systeme
     W : WHILE      W : WHILE
     M : WHILE avec une clause fausse.      M : WHILE avec une clause fausse.
     S : SELECT      S : SELECT
     K : aucun cas CASE n'a encore été traité.      K : aucun cas CASE n'a encore été traité.
     C : au moins un cas de SELECT...CASE a été traité.      C : au moins un cas de SELECT...CASE a été traité.
     Q : traitement en cours d'un cas CASE.      Q : traitement en cours d'un cas CASE.
     F : traitement du cas DEFAULT      F : traitement du cas DEFAULT
     */      */
Line 1548  typedef struct liste_pile_systeme Line 1675  typedef struct liste_pile_systeme
     unsigned char               type_cloture;      unsigned char               type_cloture;
   
     /*      /*
     type clôture :      type clôture :
     C     SELECT   : END termine un test SELECT/DEFAULT/END.      C     SELECT   : END termine un test SELECT/DEFAULT/END.
     D     DO       : END termine une boucle DO/UNTIL/END.      D     DO       : END termine une boucle DO/UNTIL/END.
     I     IF       : END termine un test IF/THEN (ELSE)/END.      I     IF       : END termine un test IF/THEN (ELSE)/END.
Line 1559  typedef struct liste_pile_systeme Line 1686  typedef struct liste_pile_systeme
   
     F     FOR     : NEXT ou STEP termine une boucle avec compteur.      F     FOR     : NEXT ou STEP termine une boucle avec compteur.
     S     START   : NEXT ou STEP termine une boucle sans compteur.      S     START   : NEXT ou STEP termine une boucle sans compteur.
     L     LOOP    : boucle utilisé dans le traitement de l'instruction RETURN.      L     LOOP    : boucle utilisé dans le traitement de l'instruction RETURN.
             Elle correspond à une boucle FOR ou START mais sans son              Elle correspond à une boucle FOR ou START mais sans son
             initialisation.              initialisation.
     A     FORALL  : NEXT termine une boucle sur un objet.      A     FORALL  : NEXT termine une boucle sur un objet.
     */      */
Line 1604  typedef struct variable Line 1731  typedef struct variable
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Structure variable partagée    Structure variable partagée
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 1639  typedef struct variable_statique Line 1766  typedef struct variable_statique
     unsigned char           *nom;      unsigned char           *nom;
     unsigned char           origine;      unsigned char           origine;
   
     // Position de création de la variable statique dans le programme ou dans      // Position de création de la variable statique dans le programme ou dans
     // l'expression. 'origine' vaut 'P' pour programme ou 'E' pour expression.      // l'expression. 'origine' vaut 'P' pour programme ou 'E' pour expression.
   
     integer8                niveau;      integer8                niveau;
Line 1700  typedef struct tableau Line 1827  typedef struct tableau
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
     Structure enregistrement
   --------------------------------------------------------------------------------
   */
   
   typedef struct record
   {
       struct_objet        *noms;
       struct_objet        *donnees;
   } struct_record;
   
   
   /*
   --------------------------------------------------------------------------------
   Structure arbre    Structure arbre
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
Line 1724  typedef struct instruction_externe Line 1864  typedef struct instruction_externe
     unsigned char       *nom;      unsigned char       *nom;
     unsigned char       *nom_bibliotheque;      unsigned char       *nom_bibliotheque;
     void                *descripteur_bibliotheque;      void                *descripteur_bibliotheque;
       integer8            position_fleche;
 } struct_instruction_externe;  } struct_instruction_externe;
   
   
Line 1747  typedef struct rpl_arguments Line 1888  typedef struct rpl_arguments
 /* Traitement des erreurs                               */  /* Traitement des erreurs                               */
   
     unsigned char               *message_erreur;      unsigned char               *message_erreur;
     unsigned char               type_erreur;            /* S = système      unsigned char               type_erreur;            /* S = système
                                                            E = exécution */                                                             E = exécution */
     integer8                    erreur;      integer8                    erreur;
   
 /* Traitement des messages d'aide                       */  /* Traitement des messages d'aide                       */
Line 1765  typedef struct rpl_arguments Line 1906  typedef struct rpl_arguments
     unsigned char               test_instruction;      unsigned char               test_instruction;
   
     integer8                    nombre_arguments;      integer8                    nombre_arguments;
     // Nombre d'arguments de la fonction, positif ou nul.      // Nombre d'arguments de la fonction
       // 0       : instruction infixe
       // positif : nombre d'arguments (notation algébrique possible)
       // -1      : notation algrébrique non autorisée
   
     void                        *s_etat_processus;      void                        *s_etat_processus;
 } struct_rpl_arguments;  } struct_rpl_arguments;
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Structure d'arbre des instructions intrinsèques    Structure d'arbre des instructions intrinsèques
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 1794  typedef struct instruction Line 1938  typedef struct instruction
 typedef struct arbre_variables  typedef struct arbre_variables
 {  {
     unsigned int                        noeuds_utilises;      unsigned int                        noeuds_utilises;
                                         // Nombre de noeuds utilisés dans le                                          // Nombre de noeuds utilisés dans le
                                         // tableau **noeuds                                          // tableau **noeuds
     signed int                          indice_tableau_pere;      signed int                          indice_tableau_pere;
                                         // Position de la structure dans le                                          // Position de la structure dans le
                                         // tableau **noeuds du père                                          // tableau **noeuds du père
   
     struct arbre_variables              *noeud_pere;      struct arbre_variables              *noeud_pere;
     struct arbre_variables              **noeuds;      struct arbre_variables              **noeuds;
Line 1810  typedef struct arbre_variables Line 1954  typedef struct arbre_variables
 typedef struct arbre_variables_partagees  typedef struct arbre_variables_partagees
 {  {
     unsigned int                        noeuds_utilises;      unsigned int                        noeuds_utilises;
                                         // Nombre de noeuds utilisés dans le                                          // Nombre de noeuds utilisés dans le
                                         // tableau **noeuds                                          // tableau **noeuds
     signed int                          indice_tableau_pere;      signed int                          indice_tableau_pere;
                                         // Position de la structure dans le                                          // Position de la structure dans le
                                         // tableau **noeuds du père                                          // tableau **noeuds du père
   
     struct arbre_variables_partagees    *noeud_pere;      struct arbre_variables_partagees    *noeud_pere;
     struct arbre_variables_partagees    **noeuds;      struct arbre_variables_partagees    **noeuds;
Line 1837  typedef struct tableau_variables Line 1981  typedef struct tableau_variables
 {  {
     unsigned char           origine;      unsigned char           origine;
     unsigned char           *nom;       // pointeur sur la struct_variable      unsigned char           *nom;       // pointeur sur la struct_variable
                                         // réelle et non copie de la chaîne                                          // réelle et non copie de la chaîne
     integer8                niveau;      integer8                niveau;
   
     struct_objet            *objet;     // pointeur sur l'objet et non copie      struct_objet            *objet;     // pointeur sur l'objet et non copie
Line 1850  typedef struct tableau_variables Line 1994  typedef struct tableau_variables
     union_position_variable variable_partagee;      union_position_variable variable_partagee;
 } struct_tableau_variables;  } struct_tableau_variables;
   
 // La liste des variables est une liste doublement chaînée et circulaire.  // La liste des variables est une liste doublement chaînée et circulaire.
 typedef struct liste_variables  typedef struct liste_variables
 {  {
     union      union
     {      {
         // Utilisation dans la gestion des variables          // Utilisation dans la gestion des variables
         struct_variable                 *variable;          struct_variable                 *variable;
         // Utilisation dans la pile système (variables par niveau)          // Utilisation dans la pile système (variables par niveau)
         struct_liste_chainee            *liste;          struct_liste_chainee            *liste;
     };      };
   
Line 1867  typedef struct liste_variables Line 2011  typedef struct liste_variables
     struct liste_variables              *precedent;      struct liste_variables              *precedent;
 } struct_liste_variables;  } struct_liste_variables;
   
 // La liste des variables statiques et une liste double chaînée et non  // La liste des variables statiques et une liste double chaînée et non
 // circulaire.  // circulaire.
 typedef struct liste_variables_statiques  typedef struct liste_variables_statiques
 {  {
Line 1913  typedef struct fonction Line 2057  typedef struct fonction
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
     Structure buffer
   --------------------------------------------------------------------------------
   */
   
   typedef struct buffer
   {
       unsigned char                       *buffer;
   
       size_t                              longueur_requise;
       int                                 classe;
   } struct_buffer;
   
   
   /*
   --------------------------------------------------------------------------------
   Structure processus    Structure processus
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
Line 1939  typedef struct processus Line 2098  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 2013  typedef struct processus Line 2173  typedef struct processus
   
 /* Variables                                            */  /* Variables                                            */
   
     // La liste des variables par niveau est doublement chaînée.      // La liste des variables par niveau est doublement chaînée.
     // À tout moment, elle pointe sur le niveau le plus haut existant et      // À tout moment, elle pointe sur le niveau le plus haut existant et
     // l_liste_variable_par_niveau->precedent renvoie la liste des      // l_liste_variable_par_niveau->precedent renvoie la liste des
     // définitions. l_liste_variable_par_niveau->precedent->precedent pointe      // définitions. l_liste_variable_par_niveau->precedent->precedent pointe
     // sur la liste des variables globales.      // sur la liste des variables globales.
     //      //
     // À l'initialisation :      // À l'initialisation :
     // l_liste_variables_par_niveau->suivant == l_liste_variables_par_niveau      // l_liste_variables_par_niveau->suivant == l_liste_variables_par_niveau
     // l_liste_variables_par_niveau->precedent == l_liste_variables_par_niveau      // l_liste_variables_par_niveau->precedent == l_liste_variables_par_niveau
   
Line 2058  typedef struct processus Line 2218  typedef struct processus
   
     struct_liste_chainee        *s_sockets;      struct_liste_chainee        *s_sockets;
   
 /*  Connecteurs aux bases de données                   */  /*  Connecteurs aux bases de données                    */
   
     struct_liste_chainee        *s_connecteurs_sql;      struct_liste_chainee        *s_connecteurs_sql;
   
 /* Bibliothèques dynamiques                                */  /* Bibliothèques dynamiques                             */
   
     struct_liste_chainee        *s_bibliotheques;      struct_liste_chainee        *s_bibliotheques;
     struct_instruction_externe  *s_instructions_externes;      struct_instruction_externe  *s_instructions_externes;
Line 2264  typedef struct processus Line 2424  typedef struct processus
     unsigned char               masque_interruptions[d_NOMBRE_INTERRUPTIONS];      unsigned char               masque_interruptions[d_NOMBRE_INTERRUPTIONS];
   
     /*      /*
      * 'I' : interruption ignorée       * 'I' : interruption ignorée
      * 'Q' : interruption mise en queue pour un traitement ultérieur       * 'Q' : interruption mise en queue pour un traitement ultérieur
      * 'N' : traitement normal de l'interruption       * 'N' : traitement normal de l'interruption
      */       */
   
Line 2287  typedef struct processus Line 2447  typedef struct processus
 /* Variables volatiles                                  */  /* Variables volatiles                                  */
   
     volatile sig_atomic_t       var_volatile_alarme;      volatile sig_atomic_t       var_volatile_alarme;
     // Traitement de ctrl+C et des arrêts brutaux      // Traitement de ctrl+C et des arrêts brutaux
     volatile sig_atomic_t       var_volatile_requete_arret;      volatile sig_atomic_t       var_volatile_requete_arret;
     // Traitement de ctrl+Z      // Traitement de ctrl+Z
     volatile sig_atomic_t       var_volatile_requete_arret2;      volatile sig_atomic_t       var_volatile_requete_arret2;
Line 2314  typedef struct processus Line 2474  typedef struct processus
     integer8                    nombre_arguments;      integer8                    nombre_arguments;
   
     /*      /*
      * Il s'agit du nombre d'arguments utilisé pour l'évaluation       * Il s'agit du nombre d'arguments utilisé pour l'évaluation
      * des expressions algébriques.       * des expressions algébriques.
      * -1 : la fonction ne peut être dans un objet de type ALG.       * -1 : la fonction ne peut être dans un objet de type ALG.
      * -2 : nombre d'arguments inconnu       * -2 : nombre d'arguments inconnu
      *  0 : la fonction doit apparaître en notation infixe       *  0 : la fonction doit apparaître en notation infixe
      * >0 : la fonction apparaît comme une fonction normale       * >0 : la fonction apparaît comme une fonction normale
      */       */
   
     logical1                    lancement_interactif;      logical1                    lancement_interactif;
Line 2348  typedef struct processus Line 2508  typedef struct processus
     struct timeval              horodatage_profilage;      struct timeval              horodatage_profilage;
   
     pthread_mutex_t             mutex_allocation;      pthread_mutex_t             mutex_allocation;
       pthread_mutex_t             mutex_allocation_buffer;
     pthread_mutex_t             mutex_interruptions;      pthread_mutex_t             mutex_interruptions;
     pthread_mutex_t             mutex_pile_processus;      pthread_mutex_t             mutex_pile_processus;
     pthread_mutex_t             mutex_signaux;      pthread_mutex_t             mutex_signaux;
Line 2365  typedef struct processus Line 2526  typedef struct processus
   
     logical1                    initialisation_scheduler;      logical1                    initialisation_scheduler;
   
 /* Drapeau nécessaire à RESTART                       */  /* Drapeau nécessaire à RESTART                     */
   
     volatile logical1           requete_redemarrage;      volatile logical1           requete_redemarrage;
   
 /* Gestion optimisée de la mémoire                    */  /* Gestion optimisée de la mémoire                  */
   
     double                      estimation_taille_pile_tampon;      double                      estimation_taille_pile_tampon;
     integer8                    taille_pile_tampon;      integer8                    taille_pile_tampon;
Line 2382  typedef struct processus Line 2543  typedef struct processus
     integer8                    taille_pile_objets;      integer8                    taille_pile_objets;
     struct_objet                *pile_objets;      struct_objet                *pile_objets;
   
 #   define TAILLE_CACHE 1024  #   define TAILLE_CACHE         1024
 #   define CACHE(type, nom) \  #   define CACHE(type, nom) \
     type                        *objets_##nom[TAILLE_CACHE]; \      type                        *objets_##nom[TAILLE_CACHE]; \
     int                         pointeur_##nom;      volatile int                pointeur_##nom;
   
 #   define CACHE2(type, nom) \  #   define CACHE2(type, nom) \
     type                        *nom[TAILLE_CACHE]; \      type                        *nom[TAILLE_CACHE]; \
     int                         pointeur_##nom;      volatile int                pointeur_##nom;
   
     CACHE(integer8, adr)      CACHE(integer8, adr)
     CACHE(logical8, bin)      CACHE(logical8, bin)
Line 2398  typedef struct processus Line 2559  typedef struct processus
     CACHE(integer8, int)      CACHE(integer8, int)
     CACHE(struct_matrice, mat)      CACHE(struct_matrice, mat)
     CACHE(struct_nom, nom)      CACHE(struct_nom, nom)
       CACHE(struct_record, rec)
     CACHE(real8, rel)      CACHE(real8, rel)
     CACHE(struct_tableau, tab)      CACHE(struct_tableau, tab)
     CACHE(struct_vecteur, vec)      CACHE(struct_vecteur, vec)
Line 2408  typedef struct processus Line 2570  typedef struct processus
     CACHE2(struct_liste_variables, variables_feuille)      CACHE2(struct_liste_variables, variables_feuille)
     CACHE2(struct_variable, variables_variable)      CACHE2(struct_variable, variables_variable)
     CACHE2(struct_arbre_variables *, variables_tableau_noeuds)      CACHE2(struct_arbre_variables *, variables_tableau_noeuds)
     CACHE2(struct_arbre_variables_partagees *,variables_tableau_noeuds_partages)      CACHE2(struct_arbre_variables_partagees *,
               variables_tableau_noeuds_partages)
   
       CACHE2(struct_buffer, enveloppes_buffers)
       unsigned char               ***cache_buffer;
       int                         *pointeur_cache_buffer;
 } struct_processus;  } struct_processus;
 #endif  #endif
   
   #ifdef DEBUG_MEMOIRE
   pid_t debug_fork(struct_processus *s_etat_processus);
   #endif
   
   
   /*
   ================================================================================
     MISE EN PLACE DE L'ALLOCATEUR SPÉCIFIQUE
   ================================================================================*/
   
   #ifndef DEBUG_MEMOIRE
   #   define malloc(a)            rpl_malloc(s_etat_processus, a)
   #   define realloc(a, b)        rpl_realloc(s_etat_processus, a, b)
   #   define free(a)              rpl_free(s_etat_processus, a)
   #endif
   
   void *rpl_malloc(struct_processus *s_etat_processus, 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 *sys_malloc(size_t s);
   void *sys_realloc(void *ptr, size_t s);
   void sys_free(void *ptr);
   
   /*
    * Wrapper de readline() pour que la fonction renvoie un pointeur sur un
    * buffer alloué par rpl_malloc().
    */
   
   #define readline(s) readline_wrapper(s_etat_processus, s)
   unsigned char *readline_wrapper(struct_processus *s_etat_processus,
           unsigned char *s);
   
   
 /*  /*
 ================================================================================  ================================================================================
Line 2421  typedef struct processus Line 2620  typedef struct processus
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Procédures d'exécution des mots-clef du langage RPL/2    Procédures d'exécution des mots-clef du langage RPL/2
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 2690  void instruction_mtxtrylock(struct_proce Line 2889  void instruction_mtxtrylock(struct_proce
 void instruction_mtxunlock(struct_processus *s_etat_processus);  void instruction_mtxunlock(struct_processus *s_etat_processus);
 void instruction_multiplication(struct_processus *s_etat_processus);  void instruction_multiplication(struct_processus *s_etat_processus);
   
   void instruction_nbrcpus(struct_processus *s_etat_prorcessus);
 void instruction_ne(struct_processus *s_etat_processus);  void instruction_ne(struct_processus *s_etat_processus);
 void instruction_neg(struct_processus *s_etat_processus);  void instruction_neg(struct_processus *s_etat_processus);
 void instruction_next(struct_processus *s_etat_processus);  void instruction_next(struct_processus *s_etat_processus);
Line 2779  void instruction_rdz(struct_processus *s Line 2979  void instruction_rdz(struct_processus *s
 void instruction_re(struct_processus *s_etat_processus);  void instruction_re(struct_processus *s_etat_processus);
 void instruction_read(struct_processus *s_etat_processus);  void instruction_read(struct_processus *s_etat_processus);
 void instruction_recode(struct_processus *s_etat_processus);  void instruction_recode(struct_processus *s_etat_processus);
   void instruction_record(struct_processus *s_etat_processus);
 void instruction_recv(struct_processus *s_etat_processus);  void instruction_recv(struct_processus *s_etat_processus);
 void instruction_redraw(struct_processus *s_etat_processus);  void instruction_redraw(struct_processus *s_etat_processus);
 void instruction_regex(struct_processus *s_etat_processus);  void instruction_regex(struct_processus *s_etat_processus);
Line 2959  void instruction_yield(struct_processus Line 3160  void instruction_yield(struct_processus
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Procédures    Procédures
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 2984  void conversion_chaine(struct_processus Line 3185  void conversion_chaine(struct_processus
         unsigned char *chaine, unsigned char type);          unsigned char *chaine, unsigned char type);
 void conversion_decimal_vers_hms(real8 *angle);  void conversion_decimal_vers_hms(real8 *angle);
 void conversion_degres_vers_radians(real8 *angle);  void conversion_degres_vers_radians(real8 *angle);
 void conversion_element_tex(unsigned char **element, unsigned char *fonction);  void conversion_element_tex(struct_processus *s_etat_processus,
           unsigned char **element, unsigned char *fonction);
 void conversion_format(struct_processus *s_etat_processus,  void conversion_format(struct_processus *s_etat_processus,
         unsigned char *chaine);          unsigned char *chaine);
 void conversion_hms_vers_decimal(real8 *angle);  void conversion_hms_vers_decimal(real8 *angle);
 void conversion_majuscule_limitee(unsigned char *chaine_entree,   void conversion_majuscule_limitee(
         unsigned char *chaine_sortie, integer8 longueur);          unsigned char *chaine_entree, unsigned char *chaine_sortie,
           integer8 longueur);
 void conversion_radians_vers_degres(real8 *angle);  void conversion_radians_vers_degres(real8 *angle);
 void copie_arbre_variables(struct_processus *s_etat_processus,  void copie_arbre_variables(struct_processus *s_etat_processus,
         struct_processus *s_nouvel_etat_processus);          struct_processus *s_nouvel_etat_processus);
Line 3058  void interruption3(int signal); Line 3261  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 3142  void liberation_queue_signaux(struct_pro Line 3348  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,
 int envoi_signal_thread(pthread_t tid, enum signaux_rpl signal);          logical1 test_ouverture);
   int envoi_signal_thread(struct_processus *s_etat_processus,
           pthread_t tid, enum signaux_rpl signal);
 #endif  #endif
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Fonctions de sommation de vecteur dans perte de précision    Fonctions de sommation de vecteur dans perte de précision
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 3180  real8 correlation_statistique(struct_mat Line 3388  real8 correlation_statistique(struct_mat
 real8 covariance_statistique(struct_matrice *s_matrice,  real8 covariance_statistique(struct_matrice *s_matrice,
         integer8 colonne_1, integer8 colonne_2,          integer8 colonne_1, integer8 colonne_2,
         unsigned char type, logical1 *erreur);          unsigned char type, logical1 *erreur);
 struct_vecteur *ecart_type_statistique(struct_matrice *s_matrice,  struct_vecteur *ecart_type_statistique(struct_processus *s_etat_processus,
         unsigned char type);          struct_matrice *s_matrice, unsigned char type);
 struct_vecteur *moyenne_statistique(struct_matrice *s_matrice);  struct_vecteur *moyenne_statistique(struct_processus *s_etat_processus,
 struct_vecteur *sommation_colonne_statistique(struct_matrice *s_matrice,          struct_matrice *s_matrice);
   struct_vecteur *sommation_colonne_statistique(
           struct_processus *s_etat_processus, struct_matrice *s_matrice,
         integer8 colonne);          integer8 colonne);
 struct_vecteur *sommation_produits_colonnes_statistiques(struct_matrice  struct_vecteur *sommation_produits_colonnes_statistiques(
           struct_processus *s_etat_processus, struct_matrice
         *s_matrice, integer8 colonne_1, integer8 colonne_2);          *s_matrice, integer8 colonne_1, integer8 colonne_2);
 struct_vecteur *sommation_statistique(struct_matrice *s_matrice);  struct_vecteur *sommation_statistique(struct_processus *s_etat_processus,
 struct_vecteur *variance_statistique(struct_matrice *s_matrice,          struct_matrice *s_matrice);
         unsigned char type);  struct_vecteur *variance_statistique(struct_processus *s_etat_processus,
           struct_matrice *s_matrice, unsigned char type);
 #endif  #endif
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Gestion des bibliothèques    Gestion des bibliothèques
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 3223  struct_liste_chainee *sauvegarde_argumen Line 3435  struct_liste_chainee *sauvegarde_argumen
 #ifndef RPLARGS  #ifndef RPLARGS
 unsigned char *analyse_algebrique(struct_processus *s_etat_processus,  unsigned char *analyse_algebrique(struct_processus *s_etat_processus,
         unsigned char *chaine_algebrique, struct_liste_chainee **l_base_liste);          unsigned char *chaine_algebrique, struct_liste_chainee **l_base_liste);
   #endif
 unsigned char *analyse_flux(struct_processus *s_etat_processus,  unsigned char *analyse_flux(struct_processus *s_etat_processus,
         unsigned char *flux, integer8 longueur);          unsigned char *flux, integer8 longueur);
 unsigned char *chiffrement(const EVP_CIPHER *type_chiffrement,  #ifndef RPLARGS
   unsigned char *chiffrement(struct_processus *s_etat_processus,
           const EVP_CIPHER *type_chiffrement,
         logical1 encodage, unsigned char *message, integer8 longueur_message,          logical1 encodage, unsigned char *message, integer8 longueur_message,
         unsigned char *clef, integer8 longueur_clef,          unsigned char *clef, integer8 longueur_clef,
         unsigned char *vecteur_initialisation,          unsigned char *vecteur_initialisation,
         integer8 *longueur_message_chiffre);          integer8 *longueur_message_chiffre);
 unsigned char *compactage(unsigned char *chaine);  unsigned char *compactage(struct_processus *s_etat_processus,
 unsigned char *conversion_majuscule(unsigned char *chaine);          unsigned char *chaine);
   unsigned char *conversion_majuscule(struct_processus *s_etat_processus,
           unsigned char *chaine);
 unsigned char *creation_nom_fichier(struct_processus *s_etat_processus,  unsigned char *creation_nom_fichier(struct_processus *s_etat_processus,
         unsigned char *chemin);          unsigned char *chemin);
 unsigned char *date_compilation();  unsigned char *date_compilation(struct_processus *s_etat_processus);
 unsigned char *extraction_chaine(unsigned char *chaine, integer8 i, integer8 j);  unsigned char *extraction_chaine(struct_processus *s_etat_processus,
           unsigned char *chaine, integer8 i, integer8 j);
 unsigned char *formateur(struct_processus *s_etat_processus, long offset,  unsigned char *formateur(struct_processus *s_etat_processus, long offset,
         struct_objet *s_objet);          struct_objet *s_objet);
 unsigned char *formateur_fichier(struct_processus *s_etat_processus,  unsigned char *formateur_fichier(struct_processus *s_etat_processus,
Line 3243  unsigned char *formateur_fichier(struct_ Line 3461  unsigned char *formateur_fichier(struct_
         integer8 longueur, integer8 longueur_champ, unsigned char format,          integer8 longueur, integer8 longueur_champ, unsigned char format,
         unsigned char type, integer8 *longueur_effective, integer8 *recursivite,          unsigned char type, integer8 *longueur_effective, integer8 *recursivite,
         logical1 export_fichier);          logical1 export_fichier);
   #endif
 unsigned char *formateur_flux(struct_processus *s_etat_processus,  unsigned char *formateur_flux(struct_processus *s_etat_processus,
         unsigned char *donnees, integer8 *longueur);          unsigned char *donnees, integer8 *longueur);
   #ifndef RPLARGS
 unsigned char *formateur_fichier_nombre(struct_processus *s_etat_processus,  unsigned char *formateur_fichier_nombre(struct_processus *s_etat_processus,
         void *valeur_numerique, unsigned char type,          void *valeur_numerique, unsigned char type,
         integer8 longueur, integer8 longueur_champ, unsigned char format);          integer8 longueur, integer8 longueur_champ, unsigned char format);
Line 3261  unsigned char *formateur_reel(struct_pro Line 3481  unsigned char *formateur_reel(struct_pro
 unsigned char *messages(struct_processus *s_etat_processus);  unsigned char *messages(struct_processus *s_etat_processus);
 unsigned char *pointeur_ieme_caractere(struct_processus *s_etat_processus,  unsigned char *pointeur_ieme_caractere(struct_processus *s_etat_processus,
         unsigned char *chaine, integer8 position);          unsigned char *chaine, integer8 position);
 unsigned char *purification_chaine(unsigned char *chaine);  unsigned char *purification_chaine(struct_processus *s_etat_processus,
           unsigned char *chaine);
 unsigned char *recherche_chemin_fichiers_temporaires(struct_processus  unsigned char *recherche_chemin_fichiers_temporaires(struct_processus
         *s_etat_processus);          *s_etat_processus);
 unsigned char *reencodage(struct_processus *s_etat_processus,  unsigned char *reencodage(struct_processus *s_etat_processus,
Line 3327  logical1 retrait_variable_statique(struc Line 3548  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
   
 /*  /*
Line 3365  logical1 validation_chaine(unsigned char Line 3587  logical1 validation_chaine(unsigned char
 #ifndef RPLARGS  #ifndef RPLARGS
 ssize_t read_atomic(struct_processus *s_etat_processus,  ssize_t read_atomic(struct_processus *s_etat_processus,
         int fd, void *buf, size_t count);          int fd, void *buf, size_t count);
   ssize_t read_atomic_signal(struct_processus *s_etat_processus,
           int fd, void *buf, size_t count);
 ssize_t write_atomic(struct_processus *s_etat_processus,  ssize_t write_atomic(struct_processus *s_etat_processus,
         int fd, void *buf, size_t count);          int fd, void *buf, size_t count);
 #endif  #endif
Line 3375  ssize_t write_atomic(struct_processus *s Line 3599  ssize_t write_atomic(struct_processus *s
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
 int alsprintf(unsigned char **strp, const char *fmt, ...);  int alsprintf(struct_processus *s_etat_processus,
           unsigned char **strp, const char *fmt, ...);
   #ifndef RPLARGS
   int association_etat_processus_readline();
   #endif
 int interruption_violation_access(void *adresse_fautive, int gravite);  int interruption_violation_access(void *adresse_fautive, int gravite);
 #ifndef RPLARGS  #ifndef RPLARGS
   int initialisation_etat_processus_readline();
   int liberation_etat_processus_readline();
 integer8 liste_variables(struct_processus *s_etat_processus,  integer8 liste_variables(struct_processus *s_etat_processus,
         struct_tableau_variables *tableau);          struct_tableau_variables *tableau);
 integer8 nombre_variables(struct_processus *s_etat_processus);  integer8 nombre_variables(struct_processus *s_etat_processus);
 int readline_analyse_syntaxique(int count, int key);  int readline_analyse_syntaxique(int count, int key);
 int readline_effacement(int count, int key);  int readline_effacement(int count, int key);
 #endif  #endif
   int std_fprintf(file *flux, const char *format, ...);
 int tex_fprintf(struct_processus *s_etat_processus,  int tex_fprintf(struct_processus *s_etat_processus,
         file *flux, const char *format, ...);          file *flux, const char *format, ...);
 int transliterated_fprintf(struct_processus *s_etat_processus, file *flux,  int transliterated_fprintf(struct_processus *s_etat_processus, file *flux,
         const char *format, ...);          const char *format, ...);
 int valsprintf(unsigned char **strp, const char *fmt, va_list ap);  int valsprintf(struct_processus *s_etat_processus,
           unsigned char **strp, const char *fmt, va_list ap);
 int wrapper_instruction_intrinseque(void (*fonction)(),  int wrapper_instruction_intrinseque(void (*fonction)(),
         struct_rpl_arguments *rpl_arguments);          struct_rpl_arguments *rpl_arguments);
   
Line 3404  unsigned char longueur_entiers_binaires( Line 3636  unsigned char longueur_entiers_binaires(
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Fonctions retournant un INTEGER*8 (valeur binaire non signée)    Fonctions retournant un INTEGER*8 (valeur binaire non signée)
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 3428  integer8 position_caractere_de_chaine(st Line 3660  integer8 position_caractere_de_chaine(st
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Fonctions renvoyant une liste chaînée (pointeur sur *struct_liste_chainee)    Fonctions renvoyant une liste chaînée (pointeur sur *struct_liste_chainee)
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 3439  struct_liste_chainee *analyse_rpn(struct Line 3671  struct_liste_chainee *analyse_rpn(struct
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
     Allocateur de buffers à cache
   --------------------------------------------------------------------------------
   */
   
   void initialisation_allocateur_buffer(struct_processus *s_etat_processus);
   void liberation_allocateur_buffer(struct_processus *s_etat_pocessus);
   struct_buffer *allocation_buffer(struct_processus *s_etat_processus,
           size_t longueur);
   void liberation_buffer(struct_processus *s_etat_processus,
           struct_buffer *buffer);
   
   /*
   --------------------------------------------------------------------------------
   Fonctions renvoyant une copie de la structure de description des processus    Fonctions renvoyant une copie de la structure de description des processus
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
Line 3501  struct_liste_variables_partagees *recher Line 3746  struct_liste_variables_partagees *recher
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Fonctions gérant la complétion automatique    Fonctions gérant la complétion automatique
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 3513  char **completion_matches(); Line 3758  char **completion_matches();
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Arithmétique    Arithmétique
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 3557  void f77soustractionrc_(real8 *ra, compl Line 3802  void f77soustractionrc_(real8 *ra, compl
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Trigonométrie complexe    Trigonométrie complexe
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 3654  void zgeev_(unsigned char *calcul_vp_gau Line 3899  void zgeev_(unsigned char *calcul_vp_gau
         integer4 *erreur, integer4 longueur_1, integer4 longueur_2);          integer4 *erreur, integer4 longueur_1, integer4 longueur_2);
   
     /*      /*
      * Valeurs propres généralisées       * Valeurs propres généralisées
      */       */
   
 void zggev_(unsigned char *calcul_vp_gauches, unsigned char *calcul_vp_droits,  void zggev_(unsigned char *calcul_vp_gauches, unsigned char *calcul_vp_droits,
Line 3667  void zggev_(unsigned char *calcul_vp_gau Line 3912  void zggev_(unsigned char *calcul_vp_gau
         integer4 *erreur, integer4 longueur_1, integer4 longueur_2);          integer4 *erreur, integer4 longueur_1, integer4 longueur_2);
   
     /*      /*
      * Moindres carrés       * Moindres carrés
      */       */
   
 void dgelsd_(integer4 *nombre_lignes_a, integer4 *nombre_colonnes_a,  void dgelsd_(integer4 *nombre_lignes_a, integer4 *nombre_colonnes_a,
Line 3682  void zgelsd_(integer4 *nombre_lignes_a, Line 3927  void zgelsd_(integer4 *nombre_lignes_a,
         real8 *rwork, integer4 *iwork, integer4 *info);          real8 *rwork, integer4 *iwork, integer4 *info);
   
     /*      /*
      * Moindres carrés généralisé       * Moindres carrés généralisé
      */       */
   
     /*      /*
      * Décomposition en valeurs singulières       * Décomposition en valeurs singulières
      */       */
   
 void dgesvd_(unsigned char *jobu, unsigned char *jobvh,  void dgesvd_(unsigned char *jobu, unsigned char *jobvh,
Line 3743  void zgees_(unsigned char *calcul_vecteu Line 3988  void zgees_(unsigned char *calcul_vecteu
         real8 *rwork, logical4 *bwork, integer4 *info,          real8 *rwork, logical4 *bwork, integer4 *info,
         integer4 l1, integer4 l2);          integer4 l1, integer4 l2);
   
         /* Déterminant et rang */          /* Déterminant et rang */
 void dgecon_(unsigned char *norm, integer4 *n, real8 *a, integer4 *lda,  void dgecon_(unsigned char *norm, integer4 *n, real8 *a, integer4 *lda,
         real8 *anorm, real8 *rcond, real8 *work, integer4 *iwork,          real8 *anorm, real8 *rcond, real8 *work, integer4 *iwork,
         integer4 *info, integer4 l1);          integer4 *info, integer4 l1);
Line 3764  void zgelsy_(integer4 *m, integer4 *n, i Line 4009  void zgelsy_(integer4 *m, integer4 *n, i
 #endif  #endif
   
 /*  /*
  * Fonction testant la requête d'arrêt (nécessaire pour tester le   * Fonction testant la requête d'arrêt (nécessaire pour tester le
  * drapeau depuis une bibliothèque).   * drapeau depuis une bibliothèque).
  */   */
   
 int test_arret(struct_processus *s_etat_processus);  int test_arret(struct_processus *s_etat_processus);
Removed from v.1.256  
changed lines
  Added in v.1.344

CVSweb interface <joel.bertrand@systella.fr>