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

Diff for /rpl/src/rpl.h between versions 1.20 and 1.176

version 1.20, 2010/04/07 13:33:23 version 1.176, 2012/09/29 17:53:02
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.13    RPL/2 (R) version 4.1.10
   Copyright (C) 1989-2010 Dr. BERTRAND Joël    Copyright (C) 1989-2012 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 23 Line 23
 #ifndef INCLUSION_RPL  #ifndef INCLUSION_RPL
 #define INCLUSION_RPL  #define INCLUSION_RPL
   
 #define _GNU_SOURCE  #ifndef __RPLCAS
   #   define _GNU_SOURCE
   #   define _XOPEN_SOURCE        700
   #endif
   
 #define _REENTRANT  #define _REENTRANT
   
   #ifndef __RPLCAS
   #   ifdef Darwin
   #       define  _DARWIN_C_SOURCE
   #   endif
   
   #   ifdef OpenBSD
   #       define _BSD_SOURCE
   #   endif
   #endif
   
   #ifdef OS2
   #   ifndef __RPLCAS
   #       define _BSD_SOURCE
   #   endif
   
   #   include <types.h>
       enum { SHUT_RD = 0, SHUT_WR, SHUT_RDWR };
   #   define SHUT_RD      SHUT_RD
   #   define SHUT_WR      SHUT_WR
   #   define SHUT_RDWR    SHUT_RDWR
   
   #   include "getaddrinfo-conv.h"
   
   #   define sched_yield(arg)
   #endif
   
   
 /*  /*
 ================================================================================  ================================================================================
Line 41 Line 71
 #include <syslog.h>  #include <syslog.h>
 #include <errno.h>  #include <errno.h>
 #include <stdarg.h>  #include <stdarg.h>
   #include <poll.h>
   
 #ifndef RPLARGS  #ifndef RPLARGS
   #   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>
 #   include <sys/stat.h>  #   include <sys/stat.h>
 #   include <sys/time.h>  
 #   include <sys/timeb.h>  #   include <sys/timeb.h>
 #   include <sys/types.h>  #   include <sys/types.h>
 #   include <sys/un.h>  #   include <sys/un.h>
Line 60 Line 92
 #   include <dlfcn.h>  #   include <dlfcn.h>
 #   include <fcntl.h>  #   include <fcntl.h>
 #   include <pthread.h>  #   include <pthread.h>
   #   include <regex.h>
   
   #   ifdef OS2
   #       undef pthread_mutexattr_settype
   #       define pthread_mutexattr_settype(a, b)
   #   endif
   
 #   include <pwd.h>  #   include <pwd.h>
 #   include <semaphore.h>  #   ifdef SHARED_MEMORY
   #       include <sys/shm.h>
   #   endif
   
   #   ifndef IPCS_SYSV
   #       include <semaphore.h>
   #   else
   #       include <sys/ipc.h>
   #       include <sys/sem.h>
   
   #       ifdef OS2
   #           define INCL_DOSSEMAPHORES
   #           define INCL_DOSMEMMGR
   #           define INCL_DOSERRORS
   #           include <os2.h>
   
               typedef struct _OS2SEM
               {
                   HMTX    hmtx;
                   HEV     hev;
                   ULONG   shared;
                   ULONG   *cnt;
                   ULONG   *nopened;
                   ULONG   allocated;
               } sem_t;
   #       else // IPCS_SYSV
               typedef struct
               {
                   int             sem;
                   int             alloue;
                   unsigned char   *path;
                   pid_t           pid;
                   pthread_t       tid;
               } sem_t;
   #       endif
   
   #       ifndef SEM_FAILED
   #           define SEM_FAILED   NULL
   #       endif
   
           sem_t *sem_open_SysV(const char *nom, int oflag, ...);
           int sem_init_SysV(sem_t *sem, int shared, unsigned int value);
           int sem_close_SysV(sem_t *sem);
           int sem_wait_SysV(sem_t *sem);
           int sem_trywait_SysV(sem_t *sem);
           int sem_timedwait_SysV(sem_t *sem, struct timespec *ts);
           int sem_post_SysV(sem_t *sem);
           int sem_getvalue_SysV(sem_t *sem, int *value);
           int sem_unlink_SysV(char *nom);
           int sem_destroy_SysV(sem_t *sem);
   #   endif
   
 #   include <setjmp.h>  #   include <setjmp.h>
 #   include <signal.h>  #   include <signal.h>
 #   include <termios.h>  #   include <termios.h>
Line 76 Line 166
   
 #   include "openssl/evp.h"  #   include "openssl/evp.h"
 #   include "sqlite3.h"  #   include "sqlite3.h"
   #   include "sigsegv.h"
   #   ifdef OS2
           // Bug de libsigsegv
   #       undef HAVE_STACK_OVERFLOW_RECOVERY
   #   endif
   
 #   define HAVE_INLINE  #   define HAVE_INLINE
 #   define GSL_RANGE_CHECK_OFF  #   define GSL_RANGE_CHECK_OFF
Line 93 Line 188
 #   include <ieeefp.h>  #   include <ieeefp.h>
 #endif  #endif
   
   // Définition spécifique à Hurd
   #ifndef PIPE_BUF
   #   define fpathconf (".", _PC_PIPE_BUF)
   #endif
   
 #ifdef MYSQL_SUPPORT  #ifdef MYSQL_SUPPORT
 #   include <mysql.h>  #   include <mysql.h>
 #   define mysqlclose(arg)      mysql_close(arg.mysql)  #   define mysqlclose(arg)      mysql_close(arg.mysql)
Line 107 Line 207
 #   define postgresqlclose(arg)  #   define postgresqlclose(arg)
 #endif  #endif
   
 #ifdef LIBRPL  #include "librplprototypes.h"
 #   include "librplprototypes.h"  
   #ifndef RPLARGS
   #   ifndef UNIX_PATH_MAX
           struct sockaddr_un sizecheck;
   #       define UNIX_PATH_MAX sizeof(sizecheck.sun_path)
   #   endif
   #endif
   
   #ifdef MAIN_RPL
   #   define __EXTERN__
   #   define __STATIC_MUTEX_INITIALIZATION__ = PTHREAD_MUTEX_INITIALIZER
   #else
   #   define __EXTERN__                       extern
   #   define __STATIC_MUTEX_INITIALIZATION__
 #endif  #endif
   
 /*  /*
 ================================================================================  ================================================================================
     Bugs spécifiques
   ================================================================================
   */
   
   // Néant
   
   /*
   ================================================================================
     TYPES
   ================================================================================
   */
   
   typedef FILE                    file;
   typedef unsigned char           t_8_bits;
   
   #ifndef RPLARGS
   #   include "rpltypes-conv.h"
   #else
   #   include "rpltypes.h"
   #endif
   
   enum signaux_rpl
   {
       rpl_signull = 0,
       rpl_sigint,
       rpl_sigterm,
       rpl_sigstart,       // Signal envoyé par un père pour lancer son fils.
       rpl_sigcont,        // Signal de redémarrage d'un processus arrêté par
                           // SUSPEND
       rpl_sigstop,        // Signal d'arrêt envoyé par l'instruction STOP ou
                           // FUSE. (FSTOP)
       rpl_sigabort,       // Signal envoyé par l'instruction ABORT (à regrouper
                           // avec FABORT)
       rpl_sigurg,         // Signal d'arrêt urgent
       rpl_siginject,      // Signal indiquant la présence d'une donnée à lire
                           // envoyée depuis le père
       rpl_sigalrm,        // Signal d'alarme (erreur système) depuis un fils
       rpl_sighup,
       rpl_sigtstp,
       rpl_sigexcept,
       rpl_sigmax
   };
   
   #define LONGUEUR_QUEUE_SIGNAUX          1024
   
   // 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
   // accessible à la fois du père et des fils.
   
   #ifndef RPLARGS
   typedef struct queue_signaux
   {
   #   ifndef IPCS_SYSV
   #       ifndef SEMAPHORES_NOMMES
               sem_t               semaphore;
               sem_t               signalisation;
   #       endif
   #   else
           sem_t                   semaphore;
           sem_t                   signalisation;
   #   endif
   
       volatile int                pointeur_lecture;
       volatile int                pointeur_ecriture;
       pthread_t                   thread_signaux;
       volatile logical1           requete_arret;
   
       volatile struct
       {
           pid_t                   pid;
           enum signaux_rpl        signal;
       }                           queue[LONGUEUR_QUEUE_SIGNAUX];
   } struct_queue_signaux;
   
   __EXTERN__ struct_queue_signaux     *s_queue_signaux;
   __EXTERN__ int                      f_queue_signaux;
   
   #   ifdef SEMAPHORES_NOMMES
           __EXTERN__ sem_t            *semaphore_queue_signaux;
           __EXTERN__ sem_t            *semaphore_signalisation;
   #   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)
   union semun
   {
       int                 val;
       struct semid_ds     *buf;
       unsigned short      *array;
       struct seminfo      *__buf;
   };
   #endif
   
   #ifndef RTLD_LOCAL
   #   define RTLD_LOCAL       0
   #endif
   
   #ifndef SIGSTKSZ
   #   define SIGSTKSZ         65536
   #endif
   
   /*
   ================================================================================
     SÉMAPHORES
   ================================================================================
   */
   
   #ifdef IPCS_SYSV
   #   define sem_init(a, b, c)    sem_init_SysV(a, b, c)
   #   define sem_destroy(a)       sem_destroy_SysV(a)
   #   define sem_wait(a)          sem_wait_SysV(a)
   #   define sem_trywait(a)       sem_trywait_SysV(a)
   #   define sem_timedwait(a, b)  sem_timedwait_SysV(a, b)
   #   define sem_post(a)          sem_post_SysV(a)
   #   define sem_getvalue(a, b)   sem_getvalue_SysV(a, b)
   #   define sem_open(...)        sem_open_SysV(__VA_ARGS__)
   #   define sem_close(a)         sem_close_SysV(a)
   #   define sem_unlink(a)        sem_unlink_SysV(a)
   #endif
   
   
   /*
   ================================================================================
   SIGNAUX    SIGNAUX
 ================================================================================  ================================================================================
 */  */
   
 #ifndef RPLARGS  #ifndef RPLARGS
 #   define SIGFSTOP                 SIGUSR1  
 #   define SIGSTART                 SIGUSR2  // Signaux utilisés par défaut :
 #   define SIGINJECT                SIGQUIT  //  SIGINT
 #   define SIGABORT                 SIGPROF  //  SIGTSTP
   //  SIGCONT
   //  SIGPIPE
   //  SIGUSR1 et SIGUSR2 sont utilisé par libsigsegv.
   //  SIGHUP
   //  SIGALRM
   
   #   define SIGTEST                  255
   
   //  Nombre d'interruptions disponibles
 #   define d_NOMBRE_INTERRUPTIONS   64  #   define d_NOMBRE_INTERRUPTIONS   64
 #endif  #endif
   
 /*  /*
 ================================================================================  ================================================================================
   Granularité temporelle    Granularité temporelle
 ================================================================================  ================================================================================
 */  */
   
Line 162 Line 412
   
 /*  /*
 ================================================================================  ================================================================================
   TYPES  
 ================================================================================  
 */  
   
 typedef FILE                    file;  
 typedef unsigned char           t_8_bits;  
   
 #ifndef RPLARGS  
 #   include "rpltypes.conv.h"  
 #else  
 #   include "rpltypes.h"  
 #endif  
   
 /*  
 ================================================================================  
   Variables globales    Variables globales
 ================================================================================  ================================================================================
 */  */
   
 #ifndef RPLARGS  #ifndef RPLARGS
 #   ifndef MAIN_RPL  #   ifdef SEMAPHORES_NOMMES
     extern jmp_buf                  contexte;  #       define LONGUEUR_NOM_SEMAPHORE   64
     extern jmp_buf                  contexte_initial;  #   endif
   
     extern pthread_key_t            semaphore_fork_processus_courant;  #   ifdef SEMAPHORES_NOMMES
   #       define __PTR__      *
     extern sem_t                    semaphore_liste_threads;  
     extern sem_t                    semaphore_gestionnaires_signaux;  
     extern sem_t                    semaphore_gestionnaires_signaux_atomique;  
 #   else  #   else
     jmp_buf                         contexte;  #       define __PTR__
     jmp_buf                         contexte_initial;  #   endif
   
       __EXTERN__ jmp_buf              contexte_ecriture;
       __EXTERN__ jmp_buf              contexte_impression;
       __EXTERN__ jmp_buf              contexte_initial;
       __EXTERN__ jmp_buf              contexte_processus;
       __EXTERN__ jmp_buf              contexte_thread;
   
       __EXTERN__ volatile int         signal_test;
   
     pthread_key_t                   semaphore_fork_processus_courant;      __EXTERN__ pid_t                pid_processus_pere;
   
     sem_t                           semaphore_liste_threads;  #   ifdef SEMAPHORES_NOMMES
     sem_t                           semaphore_gestionnaires_signaux;      __EXTERN__ pthread_mutex_t      mutex_sem __STATIC_MUTEX_INITIALIZATION__;
     sem_t                           semaphore_gestionnaires_signaux_atomique;  
 #   endif  #   endif
   
       __EXTERN__ pthread_mutex_t      mutex_liste_threads
                                               __STATIC_MUTEX_INITIALIZATION__;
       __EXTERN__ pthread_mutex_t      mutex_gestionnaires_signaux_atomique
                                               __STATIC_MUTEX_INITIALIZATION__;
       __EXTERN__ pthread_mutex_t      mutex_sections_critiques;
   
       __EXTERN__ sem_t __PTR__        semaphore_gestionnaires_signaux;
   
       __EXTERN__ volatile int         routine_recursive;
   #endif
   
   #ifdef SEMAPHORES_NOMMES
   #define SEM_FORK            0
   #define SEM_QUEUE           1
   #define SEM_SIGNAUX         2
   #define SEM_SIGNALISATION   3
   sem_t *sem_init2(unsigned int valeur, pid_t pid, int ordre);
   sem_t *sem_init3(unsigned int valeur, pid_t pid, pthread_t tid, int ordre);
   int sem_destroy2(sem_t *semaphore_p, pid_t pid, int ordre);
   int sem_destroy3(sem_t *semaphore_p, pid_t pid, pthread_t tid, int ordre);
   int sem_getvalue2(sem_t *semaphore, int *valeur);
   sem_t *sem_open2(pid_t pid, int ordre);
   
   // 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
   // cette fonction.
   
   #define sem_getvalue(semaphore, value) sem_getvalue2(semaphore, value)
   #define sem_post(semaphore) \
           ({ int r; pthread_mutex_lock(&mutex_sem); \
           r = sem_post(semaphore), pthread_mutex_unlock(&mutex_sem); r; })
   #define sem_wait(semaphore) \
           ({ int r; pthread_mutex_lock(&mutex_sem); \
           r = sem_wait(semaphore), pthread_mutex_unlock(&mutex_sem); r; })
   #define sem_trywait(semaphore) \
           ({ int r; pthread_mutex_lock(&mutex_sem); \
           r = sem_trywait(semaphore), pthread_mutex_unlock(&mutex_sem); r; })
 #endif  #endif
   
 /*  /*
Line 209  typedef unsigned char   t_8_bits; Line 486  typedef unsigned char   t_8_bits;
 ================================================================================  ================================================================================
 */  */
   
 // 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, \
Line 221  typedef unsigned char   t_8_bits; Line 498  typedef unsigned char   t_8_bits;
 #define ufprintf(flux, ...) transliterated_fprintf(NULL, \  #define ufprintf(flux, ...) transliterated_fprintf(NULL, \
             flux, __VA_ARGS__)              flux, __VA_ARGS__)
   
 // Tous les messages pour DISP, INPUT et les E/S par readline sont sur stderr.  
 // Cela évite aux messages envoyés par les gestionnaires de signaux d'être  
 // indéfiniment bloqués.  
   
 #ifdef SunOS  #ifdef SunOS
 #   define fopen(...) ({ FILE *desc; \  #   define fopen(...) ({ FILE *desc; \
             while((desc = fopen(__VA_ARGS__)) == NULL) \              while((desc = fopen(__VA_ARGS__)) == NULL) \
             { if ((errno != EINTR) && (errno != 0)) break; } desc; })              { if ((errno != EINTR) && (errno != 0)) break; } desc; })
   #   define freopen(...) ({ FILE *desc; \
               while((desc = freopen(__VA_ARGS__)) == NULL) \
               { if ((errno != EINTR) && (errno != 0)) break; } desc; })
 #   define fclose(...) ({ int ios; \  #   define fclose(...) ({ int ios; \
             while((ios = fclose(__VA_ARGS__)) != 0) \              while((ios = fclose(__VA_ARGS__)) != 0) \
             { if ((errno != EINTR) && (errno != 0)) break; } ios; })              { if ((errno != EINTR) && (errno != 0)) break; } ios; })
 #   define fread(...) ({ int ios; \  
             while((ios = fread(__VA_ARGS__)) < 0) \  
             { if ((errno != EINTR) && (errno != 0)) break; } ios; })  
 #   define fflush(flux) ({ int ios; \  #   define fflush(flux) ({ int ios; \
             while((ios = fflush((flux == stdout) ? stderr : flux)) != 0) \              while((ios = fflush((flux == stdout) ? stderr : flux)) != 0) \
             { if ((errno != EINTR) && (errno != 0)) break; } ios; })              { if ((errno != EINTR) && (errno != 0)) break; } ios; })
Line 245  typedef unsigned char   t_8_bits; Line 518  typedef unsigned char   t_8_bits;
 #   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  // 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  // système dans le cas où l'on a atteint le nombre maximale de fichiers
 // ouverts.  // ouverts.
   
 #define pipe(descripteurs) \  #define pipe(descripteurs) \
Line 265  typedef unsigned char   t_8_bits; Line 538  typedef unsigned char   t_8_bits;
         erreur; \          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
   
 #if 1  #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
   
 #define BUG(b, ...) \  
         do { if (b) { uprintf("[%d] BUG! <%s()> at line #%d of %s\n", \  
         (int) getpid(), __FUNCTION__, __LINE__, __FILE__); \  
         __VA_ARGS__; fflush(stdout); \  
         pthread_kill(pthread_self(), SIGBUS); }} while(0)  
   
 #define NOTICE(m) \  #define NOTICE(m) \
     do \      do \
     { \      { \
Line 294  typedef unsigned char   t_8_bits; Line 561  typedef unsigned char   t_8_bits;
   
 #ifdef __GLIBC__  #ifdef __GLIBC__
 #include <execinfo.h>  #include <execinfo.h>
   #define __BACKTRACE
 #define BACKTRACE(n) \  #define BACKTRACE(n) \
     do \      do \
     { \      { \
Line 309  typedef unsigned char   t_8_bits; Line 577  typedef unsigned char   t_8_bits;
         if (appels != NULL) \          if (appels != NULL) \
         { \          { \
             for(i = 0; i < nb; i++) \              for(i = 0; i < nb; i++) \
                 uprintf("%s\n", appels[i]); \                  uprintf("    %s\n", appels[i]); \
             free(appels); \              free(appels); \
         } \          } \
         else \          else \
Line 322  typedef unsigned char   t_8_bits; Line 590  typedef unsigned char   t_8_bits;
 #define BACKTRACE(n) NOTICE("BACKTRACE only defined in glibc")  #define BACKTRACE(n) NOTICE("BACKTRACE only defined in glibc")
 #endif  #endif
   
   #ifdef __BACKTRACE
   #   define BUG(b, ...) \
               do { if (b) { uprintf("[%d] BUG! <%s()> at line #%d of %s\n", \
               (int) getpid(), __FUNCTION__, __LINE__, __FILE__); \
               __VA_ARGS__; fflush(stdout); \
               BACKTRACE(64); \
               pthread_kill(pthread_self(), SIGBUS); }} while(0)
   #else
   #   define BUG(b, ...) \
               do { if (b) { uprintf("[%d] BUG! <%s()> at line #%d of %s\n", \
               (int) getpid(), __FUNCTION__, __LINE__, __FILE__); \
               __VA_ARGS__; fflush(stdout); \
               pthread_kill(pthread_self(), SIGBUS); }} while(0)
   #endif
   
   
 /*  /*
 ================================================================================  ================================================================================
Line 330  typedef unsigned char   t_8_bits; Line 613  typedef unsigned char   t_8_bits;
 */  */
   
 #ifdef DEBUG_MEMOIRE  #ifdef DEBUG_MEMOIRE
   void analyse_post_mortem();
 void *debug_memoire_ajout(size_t taille, const unsigned char *fonction,  void *debug_memoire_ajout(size_t taille, const unsigned char *fonction,
         unsigned long ligne, const unsigned char *argument);          unsigned long ligne, const unsigned char *argument);
   void debug_memoire_initialisation();
 void *debug_memoire_modification(void *pointeur, size_t taille,  void *debug_memoire_modification(void *pointeur, size_t taille,
         const unsigned char *fonction, unsigned long ligne,          const unsigned char *fonction, unsigned long ligne,
         const unsigned char *argument);          const unsigned char *argument);
 void debug_memoire_retrait(void *ptr);  void debug_memoire_retrait(void *ptr);
   void debug_memoire_verification();
   
   pid_t debug_fork();
   
 #define malloc(s) debug_memoire_ajout(s, __FUNCTION__, __LINE__, #s)  #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, \  #define realloc(s, t) debug_memoire_modification(s, t, \
             __FUNCTION__, __LINE__, #t)              __FUNCTION__, __LINE__, #t)
   #define fork() debug_fork()
 #endif  #endif
   
 #ifdef DEBUG_RETURN  #ifdef DEBUG_RETURN
Line 380  void debug_memoire_retrait(void *ptr); Line 669  void debug_memoire_retrait(void *ptr);
         if (value == 0) BUG(1, uprintf("Value %d\n", value)); sem_destroy(a); })          if (value == 0) BUG(1, uprintf("Value %d\n", value)); sem_destroy(a); })
 #endif  #endif
   
 #ifdef DEBUG_MALLOC  
 #define malloc(taille) ({ size_t s = taille; void *p; \  
         p = malloc(taille); if (p != NULL) memset(p, 0, s); \  
         /*uprintf("[%d-%llu] Allocating %p (%d bytes) at %s() line #%d\n", \  
         (int) getpid(), (unsigned long long) pthread_self(), p, \  
         (int) s, __FUNCTION__, __LINE__); fflush(stdout); */ p; })  
 #endif  
   
 #ifdef DEBUG_FREE  
 #define free(ptr) ({ void *p = ptr; \  
         /*uprintf("[%d-%llu] Freeing %p (%d bytes) at %s() line #%d\n", \  
         (int) getpid(), (unsigned long long) pthread_self(), p, \  
         (int) sizeof(p), __FUNCTION__, __LINE__); fflush(stdout); */ \  
         if (p != NULL) memset(p, 0, sizeof(p)); free(p); })  
 #endif  
   
 /*  /*
 ================================================================================  ================================================================================
Line 414  void debug_memoire_retrait(void *ptr); Line 688  void debug_memoire_retrait(void *ptr);
 #define d_absence_erreur        ((logical1) d_faux)  #define d_absence_erreur        ((logical1) d_faux)
 #define d_erreur                ((logical1) d_vrai)  #define d_erreur                ((logical1) d_vrai)
   
 #define d_code_fin_chaine       '\0'  #define d_code_fin_chaine                   '\0'
 #define d_code_espace           ' '  #define d_code_espace                       ' '
 #define d_code_retour_chariot   '\n'  #define d_code_retour_chariot               '\n'
 #define d_code_tabulation       '\t'  #define d_code_tabulation                   '\t'
   #define d_longueur_maximale_instruction     16
   
 #define d_INT                   "integer"  #define d_INT                   "integer"
 #define d_REL                   "real"  #define d_REL                   "real"
Line 445  void debug_memoire_retrait(void *ptr); Line 720  void debug_memoire_retrait(void *ptr);
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Paramètres du système    Paramètres du système
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 464  void debug_memoire_retrait(void *ptr); Line 739  void debug_memoire_retrait(void *ptr);
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Erreurs système    Erreurs système
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
 #define __erreur    { uprintf("%s() / %d\n", __FUNCTION__, __LINE__); } while(0)  #ifdef DEBUG_ERREURS
   #   ifdef MESSAGES
   #       define __erreur(i)  i
   #       define __erreur_(i) i
   #   else
   #       undef _ERREURS_VARIABLES
   #       ifdef _ERREURS_VARIABLES
   #           define __erreur_(i) __erreur(i)
   #       else
   #           define __erreur_(i) i
   #       endif
   #       define __erreur(i)  ({ if (strstr(__FUNCTION__, "recherche_variable") \
                   == NULL) ufprintf(stderr, \
                   "ERROR %d AT %s() FROM %s LINE %d\n", \
                   i, __FUNCTION__, __FILE__, __LINE__); i; })
   #   endif
   #else
   #   define __erreur(i)  i
   #   define __erreur_(i) i
   #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              2001  #   define d_es_allocation_memoire              __erreur(2001)
 #   define d_es_variable_introuvable            2002  #   define d_es_variable_introuvable            __erreur_(2002)
 #   define d_es_pile_vide                       2003  #   define d_es_pile_vide                       __erreur(2003)
 #   define d_es_end_incoherent                  2004  #   define d_es_end_incoherent                  __erreur(2004)
 #   define d_es_peripherique_stdin              2005  #   define d_es_peripherique_stdin              __erreur(2005)
 #   define d_es_erreur_fichier                  2006  #   define d_es_erreur_fichier                  __erreur(2006)
 #   define d_es_execution_bibliotheque          2007  #   define d_es_execution_bibliotheque          __erreur(2007)
 #   define d_es_signal                          2008  #   define d_es_signal                          __erreur(2008)
 #   define d_es_processus                       2009  #   define d_es_processus                       __erreur(2009)
 #   define d_es_pile_operationnelle_vide        2010  #   define d_es_pile_operationnelle_vide        __erreur(2010)
 #   define d_es_nombre_max_descripteurs         2011  #   define d_es_nombre_max_descripteurs         __erreur(2011)
 #   define d_es_interruption_invalide           2012  #   define d_es_interruption_invalide           __erreur(2012)
 #   define d_es_contexte                        2013  #   define d_es_contexte                        __erreur(2013)
 #   define d_es_somme_controle                  2014  #   define d_es_somme_controle                  __erreur(2014)
 #   define d_es_nom_implicite                   2015  #   define d_es_semaphore                       __erreur(2015)
   #   define d_es_mutex_acquis_autre_thread       __erreur(2016)
 #endif  #endif
   
 /*  /*
Line 498  void debug_memoire_retrait(void *ptr); Line 794  void debug_memoire_retrait(void *ptr);
   
 #ifndef RPLARGS  #ifndef RPLARGS
 #   define d_ep                                 1000  #   define d_ep                                 1000
 #   define d_ep_division_par_zero               1001  #   define d_ep_division_par_zero               __erreur(1001)
 #   define d_ep_matrice_non_inversible          1002  #   define d_ep_matrice_non_inversible          __erreur(1002)
 #   define d_ep_resultat_indefini               1003  #   define d_ep_resultat_indefini               __erreur(1003)
 #   define d_ep_underflow                       1004  #   define d_ep_underflow                       __erreur(1004)
 #   define d_ep_overflow                        1005  #   define d_ep_overflow                        __erreur(1005)
 #   define d_ep_domaine_definition              1006  #   define d_ep_domaine_definition              __erreur(1006)
 #   define d_ep_perte_precision                 1007  #   define d_ep_perte_precision                 __erreur(1007)
 #   define d_ep_decomposition_QR                1008  #   define d_ep_decomposition_QR                __erreur(1008)
 #   define d_ep_matrice_non_definie_positive    1009  #   define d_ep_matrice_non_definie_positive    __erreur(1009)
 #   define d_ep_decomposition_QZ                1010  #   define d_ep_decomposition_QZ                __erreur(1010)
 #   define d_ep_decomposition_SVD               1011  #   define d_ep_decomposition_SVD               __erreur(1011)
 #endif  #endif
   
 /*  /*
Line 519  void debug_memoire_retrait(void *ptr); Line 815  void debug_memoire_retrait(void *ptr);
   
 #ifndef RPLARGS  #ifndef RPLARGS
 #   define d_ec                                 3000  #   define d_ec                                 3000
 #   define d_ec_niveau_definition_negatif       3001  #   define d_ec_niveau_definition_negatif       __erreur(3001)
 #   define d_ec_nom_definition_invalide         3002  #   define d_ec_nom_definition_invalide         __erreur(3002)
 #   define d_ec_erreur_boucle_definie           3003  #   define d_ec_erreur_boucle_definie           __erreur(3003)
 #   define d_ec_erreur_instruction_end          3004  #   define d_ec_erreur_instruction_end          __erreur(3004)
 #   define d_ec_erreur_instruction_until        3005  #   define d_ec_erreur_instruction_until        __erreur(3005)
 #   define d_ec_source_incoherent               3006  #   define d_ec_source_incoherent               __erreur(3006)
 #   define d_ec_erreur_instruction_while        3007  #   define d_ec_erreur_instruction_while        __erreur(3007)
 #   define d_ec_erreur_instruction_then         3008  #   define d_ec_erreur_instruction_then         __erreur(3008)
 #   define d_ec_erreur_instruction_else         3009  #   define d_ec_erreur_instruction_else         __erreur(3009)
 #   define d_ec_erreur_instruction_elseif       3010  #   define d_ec_erreur_instruction_elseif       __erreur(3010)
 #   define d_ec_erreur_instruction_select       3011  #   define d_ec_erreur_instruction_select       __erreur(3011)
 #   define d_ec_erreur_instruction_case         3012  #   define d_ec_erreur_instruction_case         __erreur(3012)
 #endif  #endif
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   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                       1  #   define d_ex_pile_vide                       __erreur(1)
 #   define d_ex_manque_argument                 2  #   define d_ex_manque_argument                 __erreur(2)
 #   define d_ex_argument_invalide               3  #   define d_ex_argument_invalide               __erreur(3)
 #   define d_ex_erreur_type_argument            4  #   define d_ex_erreur_type_argument            __erreur(4)
 #   define d_ex_nom_reserve                     5  #   define d_ex_nom_reserve                     __erreur(5)
 #   define d_ex_nombre_arguments                6  #   define d_ex_nombre_arguments                __erreur(6)
 #   define d_ex_dimensions_invalides            7  #   define d_ex_dimensions_invalides            __erreur(7)
 #   define d_ex_expression_invalide             8  #   define d_ex_expression_invalide             __erreur(8)
 #   define d_ex_absence_graphique_courant       9  #   define d_ex_absence_graphique_courant       __erreur(9)
 #   define d_ex_erreur_traitement_condition     10  #   define d_ex_erreur_traitement_condition     __erreur(10)
 #   define d_ex_erreur_traitement_boucle        11  #   define d_ex_erreur_traitement_boucle        __erreur(11)
 #   define d_ex_variable_non_definie            12  #   define d_ex_variable_non_definie            __erreur_(12)
 #   define d_ex_drapeau_inexistant              13  #   define d_ex_drapeau_inexistant              __erreur(13)
 #   define d_ex_nom_invalide                    14  #   define d_ex_nom_invalide                    __erreur(14)
 #   define d_ex_element_inexistant              15  #   define d_ex_element_inexistant              __erreur(15)
 #   define d_ex_absence_variable                16  #   define d_ex_absence_variable                __erreur(16)
 #   define d_ex_erreur_evaluation               17  #   define d_ex_erreur_evaluation               __erreur(17)
 #   define d_ex_semaphore                       18  #   define d_ex_semaphore                       __erreur(18)
 #   define d_ex_longueur_fft                    19  #   define d_ex_longueur_fft                    __erreur(19)
 #   define d_ex_queue_impression                20  #   define d_ex_queue_impression                __erreur(20)
 #   define d_ex_type_trace_invalide             21  #   define d_ex_type_trace_invalide             __erreur(21)
 #   define d_ex_erreur_fichier                  22  #   define d_ex_erreur_fichier                  __erreur(22)
 #   define d_ex_absence_equation                23  #   define d_ex_absence_equation                __erreur(23)
 #   define d_ex_erreur_bibliotheque             24  #   define d_ex_erreur_bibliotheque             __erreur(24)
 #   define d_ex_execution_bibliotheque          25  #   define d_ex_execution_bibliotheque          __erreur(25)
 #   define d_ex_stop                            26  #   define d_ex_stop                            __erreur(26)
 #   define d_ex_matrice_statistique_invalide    27  #   define d_ex_matrice_statistique_invalide    __erreur(27)
 #   define d_ex_dimensions_matrice_statistique  28  #   define d_ex_dimensions_matrice_statistique  __erreur(28)
 #   define d_ex_absence_observations            29  #   define d_ex_absence_observations            __erreur(29)
 #   define d_ex_statistiques_echantillon        30  #   define d_ex_statistiques_echantillon        __erreur(30)
 #   define d_ex_observations_inexistantes       31  #   define d_ex_observations_inexistantes       __erreur(31)
 #   define d_ex_syntaxe                         32  #   define d_ex_syntaxe                         __erreur(32)
 #   define d_ex_cycle_hors_boucle               33  #   define d_ex_cycle_hors_boucle               __erreur(33)
 #   define d_ex_conversion_unite                34  #   define d_ex_conversion_unite                __erreur(34)
 #   define d_ex_erreur_parametre_fichier        35  #   define d_ex_erreur_parametre_fichier        __erreur(35)
 #   define d_ex_erreur_acces_fichier            36  #   define d_ex_erreur_acces_fichier            __erreur(36)
 #   define d_ex_erreur_requete_fichier          37  #   define d_ex_erreur_requete_fichier          __erreur(37)
 #   define d_ex_erreur_format_fichier           38  #   define d_ex_erreur_format_fichier           __erreur(38)
 #   define d_ex_fichier_verrouille              39  #   define d_ex_fichier_verrouille              __erreur(39)
 #   define d_ex_verrou_indefini                 40  #   define d_ex_verrou_indefini                 __erreur(40)
 #   define d_ex_fin_de_fichier_atteinte         41  #   define d_ex_fin_de_fichier_atteinte         __erreur(41)
 #   define d_ex_debut_de_fichier_atteint        42  #   define d_ex_debut_de_fichier_atteint        __erreur(42)
 #   define d_ex_erreur_type_fichier             43  #   define d_ex_erreur_type_fichier             __erreur(43)
 #   define d_ex_fichier_vide                    44  #   define d_ex_fichier_vide                    __erreur(44)
 #   define d_ex_dimensions_differentes          45  #   define d_ex_dimensions_differentes          __erreur(45)
 #   define d_ex_routines_mathematiques          46  #   define d_ex_routines_mathematiques          __erreur(46)
 #   define d_ex_exit_hors_boucle                47  #   define d_ex_exit_hors_boucle                __erreur(47)
 #   define d_ex_longueur_dft                    48  #   define d_ex_longueur_dft                    __erreur(48)
 #   define d_ex_contexte                        49  #   define d_ex_contexte                        __erreur(49)
 #   define d_ex_processus                       50  #   define d_ex_processus                       __erreur(50)
 #   define d_ex_image_processus                 51  #   define d_ex_image_processus                 __erreur(51)
 #   define d_ex_erreur_sql                      52  #   define d_ex_erreur_sql                      __erreur(52)
 #   define d_ex_variable_verrouillee            53  #   define d_ex_variable_verrouillee            __erreur(53)
 #   define d_ex_variable_volatile               54  #   define d_ex_variable_volatile               __erreur(54)
 #   define d_ex_erreur_processus                55  #   define d_ex_erreur_processus                __erreur(55)
 #   define d_ex_erreur_impression               56  #   define d_ex_erreur_impression               __erreur(56)
 #   define d_ex_nombre_arguments_fonction       57  #   define d_ex_nombre_arguments_fonction       __erreur(57)
 #   define d_ex_fonction_indisponible           58  #   define d_ex_fonction_indisponible           __erreur(58)
 #   define d_ex_bibliotheque_chargee            59  #   define d_ex_bibliotheque_chargee            __erreur(59)
 #   define d_ex_aucun_symbole                   60  #   define d_ex_aucun_symbole                   __erreur(60)
 #   define d_ex_definition_ambigue              61  #   define d_ex_definition_ambigue              __erreur(61)
 #   define d_ex_fichier_hors_contexte           62  #   define d_ex_fichier_hors_contexte           __erreur(62)
 #   define d_ex_socket_en_ecoute                63  #   define d_ex_socket_en_ecoute                __erreur(63)
 #   define d_ex_interruption_invalide           64  #   define d_ex_interruption_invalide           __erreur(64)
 #   define d_ex_erreur_transcodage              65  #   define d_ex_erreur_transcodage              __erreur(65)
 #   define d_ex_absence_processus_pere          66  #   define d_ex_absence_processus_pere          __erreur(66)
 #   define d_ex_creation_variable               67  #   define d_ex_creation_variable               __erreur(67)
 #   define d_ex_fusible                         68  #   define d_ex_fusible                         __erreur(68)
 #   define d_ex_iswi_hors_interruption          69  #   define d_ex_iswi_hors_interruption          __erreur(69)
 #   define d_ex_daemon                          70  #   define d_ex_daemon                          __erreur(70)
 #   define d_ex_mutex                           71  #   define d_ex_mutex                           __erreur(71)
 #   define d_ex_variable_statique_partagee      72  #   define d_ex_variable_statique_partagee      __erreur(72)
 #   define d_ex_variable_partagee               73  #   define d_ex_variable_partagee               __erreur(73)
 #   define d_ex_graphique_memorise              74  #   define d_ex_graphique_memorise              __erreur(74)
 #   define d_ex_matrice_non_diagonale           75  #   define d_ex_matrice_non_diagonale           __erreur(75)
 #   define d_ex_locales                         76  #   define d_ex_locales                         __erreur(76)
 #   define d_ex_representation                  77  #   define d_ex_representation                  __erreur(77)
 #   define d_ex_erreur_profilage                78  #   define d_ex_erreur_profilage                __erreur(78)
 #   define d_ex_enregistrement_inexistant       79  #   define d_ex_enregistrement_inexistant       __erreur(79)
 #   define d_ex_clef_inexistante                80  #   define d_ex_clef_inexistante                __erreur(80)
   #   define d_ex_nom_implicite                   __erreur(81)
   #   define d_ex_version_bibliotheque            __erreur(82)
   #   define d_ex_creation_variable_globale       __erreur(83)
   #   define d_ex_erreur_interne_rplcas           __erreur(84)
   #   define d_ex_fichier_corrompu                __erreur(85)
   #   define d_ex_mutex_acquis_autre_thread       __erreur(86)
   #   define d_ex_expression_reguliere            __erreur(87)
   #   define d_ex_instruction_indisponible        __erreur(88)
 #endif  #endif
   
   
Line 637  void debug_memoire_retrait(void *ptr); Line 941  void debug_memoire_retrait(void *ptr);
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
   #ifdef MIN
   #   undef MIN
   #endif
   
   #ifdef MAX
   #   undef MAX
   #endif
   
   #define ADR __RPL_ADR
   #define ALG __RPL_ALG
   #define BIN __RPL_BIN
   #define CHN __RPL_CHN
   #define CPL __RPL_CPL
   #define FCH __RPL_FCH
   #define FCT __RPL_FCT
   #define INT __RPL_INT
   #define LST __RPL_LST
   #define MCX __RPL_MCX
   #define MIN __RPL_MIN
   #define MRL __RPL_MRL
   #define MTX __RPL_MTX
   #define NOM __RPL_NOM
   #define NON __RPL_NON
   #define PRC __RPL_PRC
   #define REL __RPL_REL
   #define RPN __RPL_RPN
   #define SCK __RPL_SCK
   #define SLB __RPL_SLB
   #define SPH __RPL_SPH
   #define SQL __RPL_SQL
   #define TBL __RPL_TBL
   #define VCX __RPL_VCX
   #define VIN __RPL_VIN
   #define VRL __RPL_VRL
   
   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, FCH, FCT, INT, LST,
                 MCX, MIN, MRL, MTX, NOM, NON, PRC, REL, RPN, SCK,                  MCX, MIN, MRL, MTX, NOM, NON, PRC, REL, RPN, SCK,
                 SLB, SPH, SQL, TBL, VCX, VIN, VRL };                  SLB, SPH, SQL, TBL, VCX, VIN, VRL };
   
     /*      /*
     ADR : adresse sur 32 bits (au moins) non signés (unsigned long)      ADR : adresse sur 32 bits (au moins) non signés (unsigned long)
             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.
Line 663  enum t_type  { ADR = 0, ALG, BIN, CHN, C Line 1004  enum t_type  { ADR = 0, ALG, BIN, CHN, C
   
     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 672  enum t_type  { ADR = 0, ALG, BIN, CHN, C Line 1013  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 699  enum t_type  { ADR = 0, ALG, BIN, CHN, C Line 1040  enum t_type  { ADR = 0, ALG, BIN, CHN, C
             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 772  typedef struct fichier Line 1113  typedef struct fichier
 typedef struct rpl_mutex  typedef struct rpl_mutex
 {  {
     pthread_mutex_t     mutex;      pthread_mutex_t     mutex;
       pthread_t           tid;
 } struct_mutex;  } struct_mutex;
 #endif  #endif
   
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Structure sémaphore    Structure sémaphore
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 810  typedef struct marque Line 1152  typedef struct marque
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Structure bibliothèque    Structure bibliothèque
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 845  typedef struct descripteur_fichier Line 1187  typedef struct descripteur_fichier
     pid_t                       pid;      pid_t                       pid;
     pthread_t                   tid;      pthread_t                   tid;
   
     file                        *descripteur_c;      union
     sqlite3                     *descripteur_sqlite;      {
           file                    *descripteur_c;
           sqlite3                 *descripteur_sqlite;
       };
 } struct_descripteur_fichier;  } struct_descripteur_fichier;
 #endif  #endif
   
Line 927  typedef struct socket Line 1272  typedef struct socket
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Structure liste chaînee    Structure liste chaînee
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 941  typedef struct liste_chainee Line 1286  typedef struct liste_chainee
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
     Structure de gestion des signaux en provenance de rplsignal
   --------------------------------------------------------------------------------
   */
   
   #define d_NOMBRE_SIGNAUX                64
   
   typedef struct gestion_signaux
   {
       unsigned char               masque_signaux[d_NOMBRE_SIGNAUX];
   
       /*
        * 'I' : signal ignoré
        * 'Q' : signal mis en queue pour un traitement ultérieur
        * 'N' : traitement normal du signal
        */
   
       integer8                    queue_signaux[d_NOMBRE_SIGNAUX];
       integer8                    nombre_signaux_en_queue;
       struct_objet                *corps_signaux[d_NOMBRE_SIGNAUX];
   
       pthread_mutex_t             mutex;
   } struct_gestion_signaux;
   
   #ifndef MAIN_RPL
   #   define __STATIC_GESTION_SIGNAUX__
   #else
   #   define __STATIC_GESTION_SIGNAUX__ = { .mutex = PTHREAD_MUTEX_INITIALIZER }
   #endif
   
   __EXTERN__ volatile struct_gestion_signaux signaux_externes
           __STATIC_GESTION_SIGNAUX__;
   
   
   /*
   --------------------------------------------------------------------------------
   Structure liste profilage    Structure liste profilage
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
Line 966  typedef struct liste_profilage2 Line 1346  typedef struct liste_profilage2
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Structure contenant les fichiers graphiques (liste chaînée)    Structure contenant les fichiers graphiques (liste chaînée)
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 998  typedef struct nom Line 1378  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 1023  typedef struct descripteur_thread Line 1403  typedef struct descripteur_thread
     pthread_t                   thread_pere;      pthread_t                   thread_pere;
   
     pthread_mutex_t             mutex;      pthread_mutex_t             mutex;
       pthread_mutex_t             mutex_nombre_references;
   
     volatile logical1           thread_actif;      volatile logical1           thread_actif;
   
     int                         pipe_erreurs[2];      int                         pipe_erreurs[2];
Line 1040  typedef struct descripteur_thread Line 1422  typedef struct descripteur_thread
     logical1                    processus_detache;      logical1                    processus_detache;
     logical1                    destruction_objet;      logical1                    destruction_objet;
   
     sigset_t                    oldset;  
     sigset_t                    set;  
   
     volatile signed long        nombre_references;      volatile signed long        nombre_references;
 } struct_descripteur_thread;  } struct_descripteur_thread;
   
Line 1081  typedef struct liste_pile_systeme Line 1460  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 1090  typedef struct liste_pile_systeme Line 1469  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 1102  typedef struct liste_pile_systeme Line 1481  typedef struct liste_pile_systeme
     unsigned char               type_cloture;      unsigned char               type_cloture;
   
     /*      /*
     type clôture :      type clôture :
     C     CASE  : END termine un test SELECT/CASE/THEN/END/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.
     J     IFERR : END termine un test IFERR/THEN (ELSE)/END.      J     IFERR    : END termine un test IFERR/THEN (ELSE)/END.
     W     WHILE : END termine une boucle WHILE/REPEAT/END.      K     CASE     : END termine un test CASE/THEN/END
       W     WHILE    : END termine une boucle WHILE/REPEAT/END.
     F     FOR   : NEXT ou STEP termine une boucle avec compteur.      Q     CRITICAL : END termine une section critique CRITICAL/END
     S     START : NEXT ou STEP termine une boucle sans compteur.  
     L     LOOP  : boucle utilisé dans le traitement de l'instruction RETURN.      F     FOR     : NEXT ou STEP termine une boucle avec compteur.
             Elle correspond à une boucle FOR ou START mais sans son      S     START   : NEXT ou STEP termine une boucle sans compteur.
       L     LOOP    : boucle utilisé dans le traitement de l'instruction RETURN.
               Elle correspond à une boucle FOR ou START mais sans son
             initialisation.              initialisation.
       A     FORALL  : NEXT termine une boucle sur un objet.
     */      */
   
     unsigned long               adresse_retour;      unsigned long               adresse_retour;
     unsigned long               niveau_courant;      unsigned long               niveau_courant;
       struct_objet                *pointeur_adresse_retour;
 } struct_liste_pile_systeme;  } struct_liste_pile_systeme;
 #endif  #endif
   
Line 1154  typedef struct variable Line 1537  typedef struct variable
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Structure variable partagée    Structure variable partagée
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 1199  typedef struct variable_statique Line 1582  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.
   
     unsigned long           niveau;      unsigned long           niveau;
Line 1307  typedef struct rpl_arguments Line 1690  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 1330  typedef struct rpl_arguments Line 1713  typedef struct rpl_arguments
     void                        *s_etat_processus;      void                        *s_etat_processus;
 } struct_rpl_arguments;  } struct_rpl_arguments;
   
   /*
   --------------------------------------------------------------------------------
     Structure d'arbre des instructions intrinsèques
   --------------------------------------------------------------------------------
   */
   
   #ifndef RPLARGS
   typedef struct instruction
   {
       struct instruction      **noeuds;
       void                    (*feuille)(struct processus *);
   } struct_instruction;
   #endif
   
   /*
   --------------------------------------------------------------------------------
     Structure d'arbre des variables variable globales et locales
   --------------------------------------------------------------------------------
   */
   
   #ifndef RPLARGS
   typedef struct arbre_variables
   {
       unsigned int            noeuds_utilises;
       signed int              indice_tableau_pere;
       struct arbre_variables  *noeud_pere;
       struct arbre_variables  **noeuds;
       struct liste_variables  *feuille;
   } struct_arbre_variables;
   
   typedef struct tableau_variables
   {
       unsigned char           origine;
       unsigned char           *nom;       // pointeur sur la struct_variable
                                           // réelle et non copie de la chaîne
       unsigned long           niveau;
   
       struct_objet            *objet;     // pointeur sur l'objet et non copie
                                           // de l'objet.
   
       logical1                variable_verrouillee;
       union_position_variable variable_statique;
       union_position_variable variable_partagee;
   } struct_tableau_variables;
   
   typedef struct liste_variables
   {
       union
       {
           // Utilisation dans la gestion des variables
           struct_variable                 *variable;
           // Utilisation dans la pile système (variables par niveau)
           struct_liste_chainee            *liste;
       };
   
       struct arbre_variables              *noeud_pere;
       struct arbre_variables              *noeud;
       struct liste_variables              *suivant;
       struct liste_variables              *precedent;
   } struct_liste_variables;
   
   #endif
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
Line 1367  typedef struct processus Line 1812  typedef struct processus
     unsigned char               mode_interactif;                    /*Y/N*/      unsigned char               mode_interactif;                    /*Y/N*/
     unsigned char               mode_evaluation_expression;         /*Y/N*/      unsigned char               mode_evaluation_expression;         /*Y/N*/
     unsigned char               traitement_cycle_exit;              /*N/E/C*/      unsigned char               traitement_cycle_exit;              /*N/E/C*/
       unsigned char               recherche_type;                     /*Y/N*/
   
     unsigned long               position_courante;      unsigned long               position_courante;
     unsigned long               longueur_definitions_chainees;      unsigned long               longueur_definitions_chainees;
Line 1375  typedef struct processus Line 1821  typedef struct processus
   
     int                         *pointeurs_caracteres;      int                         *pointeurs_caracteres;
     int                         nombre_caracteres;      int                         nombre_caracteres;
     struct instruction          *arbre_instructions;      struct_instruction          *arbre_instructions;
   
 /* Requetes                                             */  /* Requetes                                             */
   
Line 1418  typedef struct processus Line 1864  typedef struct processus
     pthread_t                   thread_fusible;      pthread_t                   thread_fusible;
     pthread_t                   thread_surveille_par_fusible;      pthread_t                   thread_surveille_par_fusible;
   
 #   ifndef Cygwin      volatile int                pointeur_signal_ecriture;
     stack_t                     pile_signal;      volatile int                pointeur_signal_lecture;
 #   else      volatile enum signaux_rpl   signaux_en_queue[LONGUEUR_QUEUE_SIGNAUX];
 #   define SA_ONSTACK           0      volatile logical1           demarrage_fils;
 #   define RTLD_LOCAL           0      volatile logical1           redemarrage_processus;
 #   endif  
   
 /* Contextes                                            */  /* Contextes                                            */
   
Line 1432  typedef struct processus Line 1877  typedef struct processus
   
 /* Variables                                            */  /* Variables                                            */
   
     struct_variable             *s_liste_variables;      // La liste des variables par niveau est doublement chaînée.
     unsigned long               nombre_variables;      // À tout moment, elle pointe sur le niveau le plus haut existant et
     unsigned long               nombre_variables_allouees;      // l_liste_variable_par_niveau->precedent renvoie la liste des
       // définitions. l_liste_variable_par_niveau->precedent->precedent pointe
       // sur la liste des variables globales.
       //
       // À l'initialisation :
       // l_liste_variables_par_niveau->suivant == l_liste_variables_par_niveau
       // l_liste_variables_par_niveau->precedent == l_liste_variables_par_niveau
   
       struct_arbre_variables      *s_arbre_variables;
       struct_liste_variables      *l_liste_variables_par_niveau;
       logical1                    niveau_supprime;
   
       struct_variable             *pointeur_variable_courante;
       struct_liste_variables      *pointeur_feuille_courante;
   
       int                         *pointeurs_caracteres_variables;
       int                         nombre_caracteres_variables;
   
     struct_variable_statique    *s_liste_variables_statiques;      struct_variable_statique    *s_liste_variables_statiques;
     unsigned long               nombre_variables_statiques;      unsigned long               nombre_variables_statiques;
Line 1445  typedef struct processus Line 1906  typedef struct processus
   
     unsigned long               niveau_courant;      unsigned long               niveau_courant;
     unsigned long               niveau_initial;      unsigned long               niveau_initial;
     unsigned long               position_variable_courante;  
     unsigned long               position_variable_statique_courante;      unsigned long               position_variable_statique_courante;
   
     logical1                    creation_variables_statiques;      logical1                    creation_variables_statiques;
Line 1460  typedef struct processus Line 1920  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 1666  typedef struct processus Line 2126  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 1681  typedef struct processus Line 2141  typedef struct processus
   
     unsigned char               traitement_interruption;  /* Y/N */      unsigned char               traitement_interruption;  /* Y/N */
     unsigned char               traitement_interruptible; /* Y/N */      unsigned char               traitement_interruptible; /* Y/N */
       unsigned char               traitement_at_poke;       /* Y/N */
   
       struct_objet                *at_exit;
       struct_objet                *at_poke;
   
 /* 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;
     volatile sig_atomic_t       var_volatile_traitement_retarde_stop;      volatile sig_atomic_t       var_volatile_traitement_retarde_stop;
     volatile sig_atomic_t       var_volatile_traitement_sigint;      volatile sig_atomic_t       var_volatile_traitement_sigint;
   
       volatile sig_atomic_t       var_volatile_processus_racine;
     volatile sig_atomic_t       var_volatile_processus_pere;      volatile sig_atomic_t       var_volatile_processus_pere;
     volatile sig_atomic_t       var_volatile_recursivite;      volatile sig_atomic_t       var_volatile_recursivite;
   
       volatile sig_atomic_t       arret_depuis_abort;
   
     volatile int                var_volatile_exception_gsl;      volatile int                var_volatile_exception_gsl;
   
 /* Autres                                               */  /* Autres                                               */
Line 1704  typedef struct processus Line 2171  typedef struct processus
     gsl_rng                     *generateur_aleatoire;      gsl_rng                     *generateur_aleatoire;
     const gsl_rng_type          *type_generateur_aleatoire;      const gsl_rng_type          *type_generateur_aleatoire;
   
       void                        *contexte_cas;
   
     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 1726  typedef struct processus Line 2195  typedef struct processus
   
     pid_t                       pid_processus_pere;      pid_t                       pid_processus_pere;
     pthread_t                   tid_processus_pere;      pthread_t                   tid_processus_pere;
       pthread_t                   tid;
   
     logical1                    processus_detache;      logical1                    processus_detache;
   
Line 1737  typedef struct processus Line 2207  typedef struct processus
     struct_liste_profilage2     *pile_profilage_fonctions;      struct_liste_profilage2     *pile_profilage_fonctions;
     struct timeval              horodatage_profilage;      struct timeval              horodatage_profilage;
   
     // Mutex spécifique au processus et donnant accès à la pile des processus      // Mutex spécifique au processus et donnant accès à la pile des processus
     pthread_mutex_t             mutex;      pthread_mutex_t             mutex;
       pthread_mutex_t             mutex_allocation;
   
     // Sémaphore autorisant les fork()      // Mutex autorisant les fork()
     sem_t                       semaphore_fork;      sem_t __PTR__               semaphore_fork;
   
 /* Mutexes                                          */  /* Mutexes                                          */
   
     struct_liste_chainee        *liste_mutexes;      struct_liste_chainee        *liste_mutexes;
     pthread_mutex_t             protection_liste_mutexes;      pthread_mutex_t             protection_liste_mutexes;
       unsigned int                sections_critiques;
   
   /* Drapeau nécessaire à RESTART                   */
   
 /* Gestion optimisée de la mémoire                  */      volatile logical1           requete_redemarrage;
   
   /* Gestion optimisée de la mémoire                    */
   
     double                      estimation_taille_pile_tampon;      double                      estimation_taille_pile_tampon;
     unsigned long               taille_pile_tampon;      unsigned long               taille_pile_tampon;
Line 1761  typedef struct processus Line 2237  typedef struct processus
     unsigned long               taille_pile_objets;      unsigned long               taille_pile_objets;
     struct_objet                *pile_objets;      struct_objet                *pile_objets;
   
 #   define TAILLE_CACHE 1024  #   define TAILLE_CACHE 16384
   
     unsigned long               *objets_adr[TAILLE_CACHE];      unsigned long               *objets_adr[TAILLE_CACHE];
     int                         pointeur_adr;      int                         pointeur_adr;
Line 1795  typedef struct processus Line 2271  typedef struct processus
   
     struct_liste_chainee        *maillons[TAILLE_CACHE];      struct_liste_chainee        *maillons[TAILLE_CACHE];
     int                         pointeur_maillons;      int                         pointeur_maillons;
 } struct_processus;  
 #endif  
   
 /*      struct_arbre_variables      *variables_noeud[TAILLE_CACHE];
 --------------------------------------------------------------------------------      int                         pointeur_variables_noeud;
   Structures instruction intrinseque  
 --------------------------------------------------------------------------------  
 */  
   
 #ifndef RPLARGS      struct_liste_variables      *variables_feuille[TAILLE_CACHE];
 typedef struct instruction      int                         pointeur_variables_feuille;
 {  
     struct instruction      **noeud;  
     void                    (*feuille)(struct_processus *);  
 } struct_instruction;  
 #endif  
   
       struct_variable             *variables_variable[TAILLE_CACHE];
       int                         pointeur_variables_variable;
   
       struct_arbre_variables      **variables_tableau_noeuds[TAILLE_CACHE];
       int                         pointeur_variables_tableau_noeuds;
   } struct_processus;
   #endif
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
Line 1841  typedef struct fonction Line 2314  typedef struct fonction
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Procédures d'exécution des mots-clef du langage RPL/2    Procédures d'exécution des mots-clef du langage RPL/2
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
 // BEGIN C PROTOTYPES  // BEGIN C PROTOTYPES
 void instruction_sensible_e(struct_processus *s_etat_processus);  void instruction_sensible_e(struct_processus *s_etat_processus);
 void instruction_sensible_i(struct_processus *s_etat_processus);  void instruction_sensible_i(struct_processus *s_etat_processus);
   void instruction_sensible_infinity(struct_processus *s_etat_processus);
   
 void instruction_abort(struct_processus *s_etat_processus);  void instruction_abort(struct_processus *s_etat_processus);
 void instruction_abs(struct_processus *s_etat_processus);  void instruction_abs(struct_processus *s_etat_processus);
Line 1865  void instruction_asl(struct_processus *s Line 2339  void instruction_asl(struct_processus *s
 void instruction_asr(struct_processus *s_etat_processus);  void instruction_asr(struct_processus *s_etat_processus);
 void instruction_atan(struct_processus *s_etat_processus);  void instruction_atan(struct_processus *s_etat_processus);
 void instruction_atanh(struct_processus *s_etat_processus);  void instruction_atanh(struct_processus *s_etat_processus);
   void instruction_atexit(struct_processus *s_etat_processus);
   void instruction_atpoke(struct_processus *s_etat_processus);
 void instruction_autoscale(struct_processus *s_etat_processus);  void instruction_autoscale(struct_processus *s_etat_processus);
 void instruction_axes(struct_processus *s_etat_processus);  void instruction_axes(struct_processus *s_etat_processus);
   
 void instruction_b_vers_r(struct_processus *s_etat_processus);  void instruction_b_vers_r(struct_processus *s_etat_processus);
 void instruction_backspace(struct_processus *s_etat_processus);  void instruction_backspace(struct_processus *s_etat_processus);
   void instruction_backtrace(struct_processus *s_etat_processus);
 void instruction_beep(struct_processus *s_etat_processus);  void instruction_beep(struct_processus *s_etat_processus);
 void instruction_bessel(struct_processus *s_etat_processus);  void instruction_bessel(struct_processus *s_etat_processus);
 void instruction_bin(struct_processus *s_etat_processus);  void instruction_bin(struct_processus *s_etat_processus);
Line 1884  void instruction_clear(struct_processus Line 2361  void instruction_clear(struct_processus
 void instruction_cllcd(struct_processus *s_etat_processus);  void instruction_cllcd(struct_processus *s_etat_processus);
 void instruction_clmf(struct_processus *s_etat_processus);  void instruction_clmf(struct_processus *s_etat_processus);
 void instruction_close(struct_processus *s_etat_processus);  void instruction_close(struct_processus *s_etat_processus);
   void instruction_clratexit(struct_processus *s_etat_processus);
   void instruction_clratpoke(struct_processus *s_etat_processus);
 void instruction_clrcntxt(struct_processus *s_etat_processus);  void instruction_clrcntxt(struct_processus *s_etat_processus);
 void instruction_clrerr(struct_processus *s_etat_processus);  void instruction_clrerr(struct_processus *s_etat_processus);
 void instruction_clrfuse(struct_processus *s_etat_processus);  void instruction_clrfuse(struct_processus *s_etat_processus);
Line 1912  void instruction_cosh(struct_processus * Line 2391  void instruction_cosh(struct_processus *
 void instruction_cov(struct_processus *s_etat_processus);  void instruction_cov(struct_processus *s_etat_processus);
 void instruction_cr(struct_processus *s_etat_processus);  void instruction_cr(struct_processus *s_etat_processus);
 void instruction_create(struct_processus *s_etat_processus);  void instruction_create(struct_processus *s_etat_processus);
   void instruction_critical(struct_processus *s_etat_processus);
 void instruction_crmtx(struct_processus *s_etat_processus);  void instruction_crmtx(struct_processus *s_etat_processus);
 void instruction_cross(struct_processus *s_etat_processus);  void instruction_cross(struct_processus *s_etat_processus);
 void instruction_crsmphr(struct_processus *s_etat_processus);  void instruction_crsmphr(struct_processus *s_etat_processus);
Line 1996  void instruction_fleche_str(struct_proce Line 2476  void instruction_fleche_str(struct_proce
 void instruction_fleche_table(struct_processus *s_etat_processus);  void instruction_fleche_table(struct_processus *s_etat_processus);
 void instruction_floor(struct_processus *s_etat_processus);  void instruction_floor(struct_processus *s_etat_processus);
 void instruction_for(struct_processus *s_etat_processus);  void instruction_for(struct_processus *s_etat_processus);
   void instruction_forall(struct_processus *s_etat_processus);
 void instruction_format(struct_processus *s_etat_processus);  void instruction_format(struct_processus *s_etat_processus);
 void instruction_fp(struct_processus *s_etat_processus);  void instruction_fp(struct_processus *s_etat_processus);
 void instruction_fs_test(struct_processus *s_etat_processus);  void instruction_fs_test(struct_processus *s_etat_processus);
Line 2039  void instruction_in(struct_processus *s_ Line 2520  void instruction_in(struct_processus *s_
 void instruction_incr(struct_processus *s_etat_processus);  void instruction_incr(struct_processus *s_etat_processus);
 void instruction_indep(struct_processus *s_etat_processus);  void instruction_indep(struct_processus *s_etat_processus);
 void instruction_input(struct_processus *s_etat_processus);  void instruction_input(struct_processus *s_etat_processus);
   void instruction_infinity(struct_processus *s_etat_processus);
 void instruction_inquire(struct_processus *s_etat_processus);  void instruction_inquire(struct_processus *s_etat_processus);
 void instruction_int(struct_processus *s_etat_processus);  void instruction_int(struct_processus *s_etat_processus);
 void instruction_interrupt(struct_processus *s_etat_processus);  void instruction_interrupt(struct_processus *s_etat_processus);
Line 2062  void instruction_lcd_fleche(struct_proce Line 2544  void instruction_lcd_fleche(struct_proce
 void instruction_lchol(struct_processus *s_etat_processus);  void instruction_lchol(struct_processus *s_etat_processus);
 void instruction_le(struct_processus *s_etat_processus);  void instruction_le(struct_processus *s_etat_processus);
 void instruction_legv(struct_processus *s_etat_processus);  void instruction_legv(struct_processus *s_etat_processus);
   void instruction_limit(struct_processus *s_etat_processus);
 void instruction_line(struct_processus *s_etat_processus);  void instruction_line(struct_processus *s_etat_processus);
 void instruction_list_fleche(struct_processus *s_etat_processus);  void instruction_list_fleche(struct_processus *s_etat_processus);
 void instruction_ln(struct_processus *s_etat_processus);  void instruction_ln(struct_processus *s_etat_processus);
Line 2075  void instruction_lq(struct_processus *s_ Line 2558  void instruction_lq(struct_processus *s_
 void instruction_lsq(struct_processus *s_etat_processus);  void instruction_lsq(struct_processus *s_etat_processus);
 void instruction_lt(struct_processus *s_etat_processus);  void instruction_lt(struct_processus *s_etat_processus);
 void instruction_lu(struct_processus *s_etat_processus);  void instruction_lu(struct_processus *s_etat_processus);
   void instruction_l_vers_t(struct_processus *s_etat_processus);
   
 void instruction_mant(struct_processus *s_etat_processus);  void instruction_mant(struct_processus *s_etat_processus);
 void instruction_mark(struct_processus *s_etat_processus);  void instruction_mark(struct_processus *s_etat_processus);
Line 2083  void instruction_maxs(struct_processus * Line 2567  void instruction_maxs(struct_processus *
 void instruction_mclrin(struct_processus *s_etat_processus);  void instruction_mclrin(struct_processus *s_etat_processus);
 void instruction_mean(struct_processus *s_etat_processus);  void instruction_mean(struct_processus *s_etat_processus);
 void instruction_mem(struct_processus *s_etat_processus);  void instruction_mem(struct_processus *s_etat_processus);
   void instruction_memlock(struct_processus *s_etat_processus);
   void instruction_memunlock(struct_processus *s_etat_processus);
 void instruction_min(struct_processus *s_etat_processus);  void instruction_min(struct_processus *s_etat_processus);
 void instruction_mins(struct_processus *s_etat_processus);  void instruction_mins(struct_processus *s_etat_processus);
 void instruction_mod(struct_processus *s_etat_processus);  void instruction_mod(struct_processus *s_etat_processus);
Line 2127  void instruction_pmax(struct_processus * Line 2613  void instruction_pmax(struct_processus *
 void instruction_pmin(struct_processus *s_etat_processus);  void instruction_pmin(struct_processus *s_etat_processus);
 void instruction_poke(struct_processus *s_etat_processus);  void instruction_poke(struct_processus *s_etat_processus);
 void instruction_polar(struct_processus *s_etat_processus);  void instruction_polar(struct_processus *s_etat_processus);
   void instruction_poll(struct_processus *s_etat_processus);
 void instruction_pos(struct_processus *s_etat_processus);  void instruction_pos(struct_processus *s_etat_processus);
 void instruction_pourcent(struct_processus *s_etat_processus);  void instruction_pourcent(struct_processus *s_etat_processus);
 void instruction_pourcent_ch(struct_processus *s_etat_processus);  void instruction_pourcent_ch(struct_processus *s_etat_processus);
Line 2137  void instruction_print(struct_processus Line 2624  void instruction_print(struct_processus
 void instruction_private(struct_processus *s_etat_processus);  void instruction_private(struct_processus *s_etat_processus);
 void instruction_prlcd(struct_processus *s_etat_processus);  void instruction_prlcd(struct_processus *s_etat_processus);
 void instruction_prmd(struct_processus *s_etat_processus);  void instruction_prmd(struct_processus *s_etat_processus);
   void instruction_procid(struct_processus *s_etat_processus);
 void instruction_prompt(struct_processus *s_etat_processus);  void instruction_prompt(struct_processus *s_etat_processus);
 void instruction_protect(struct_processus *s_etat_processus);  void instruction_protect(struct_processus *s_etat_processus);
 void instruction_prst(struct_processus *s_etat_processus);  void instruction_prst(struct_processus *s_etat_processus);
Line 2182  void instruction_read(struct_processus * Line 2670  void instruction_read(struct_processus *
 void instruction_recode(struct_processus *s_etat_processus);  void instruction_recode(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_relax(struct_processus *s_etat_processus);  void instruction_relax(struct_processus *s_etat_processus);
 void instruction_remove(struct_processus *s_etat_processus);  void instruction_remove(struct_processus *s_etat_processus);
 void instruction_res(struct_processus *s_etat_processus);  void instruction_res(struct_processus *s_etat_processus);
   void instruction_restart(struct_processus *s_etat_processus);
 void instruction_recall(struct_processus *s_etat_processus);  void instruction_recall(struct_processus *s_etat_processus);
 void instruction_regv(struct_processus *s_etat_processus);  void instruction_regv(struct_processus *s_etat_processus);
 void instruction_repeat(struct_processus *s_etat_processus);  void instruction_repeat(struct_processus *s_etat_processus);
Line 2250  void instruction_sqlquery(struct_process Line 2740  void instruction_sqlquery(struct_process
 void instruction_sqrt(struct_processus *s_etat_processus);  void instruction_sqrt(struct_processus *s_etat_processus);
 void instruction_sr(struct_processus *s_etat_processus);  void instruction_sr(struct_processus *s_etat_processus);
 void instruction_srb(struct_processus *s_etat_processus);  void instruction_srb(struct_processus *s_etat_processus);
   void instruction_srev(struct_processus *s_etat_processus);
 void instruction_sst(struct_processus *s_etat_processus);  void instruction_sst(struct_processus *s_etat_processus);
 void instruction_star_d(struct_processus *s_etat_processus);  void instruction_star_d(struct_processus *s_etat_processus);
 void instruction_star_h(struct_processus *s_etat_processus);  void instruction_star_h(struct_processus *s_etat_processus);
Line 2307  void instruction_trn(struct_processus *s Line 2798  void instruction_trn(struct_processus *s
 void instruction_trnc(struct_processus *s_etat_processus);  void instruction_trnc(struct_processus *s_etat_processus);
 void instruction_true(struct_processus *s_etat_processus);  void instruction_true(struct_processus *s_etat_processus);
 void instruction_type(struct_processus *s_etat_processus);  void instruction_type(struct_processus *s_etat_processus);
   void instruction_t_vers_l(struct_processus *s_etat_processus);
   
 void instruction_ucase(struct_processus *s_etat_processus);  void instruction_ucase(struct_processus *s_etat_processus);
 void instruction_uchol(struct_processus *s_etat_processus);  void instruction_uchol(struct_processus *s_etat_processus);
 void instruction_undo(struct_processus *s_etat_processus);  
 void instruction_unlock(struct_processus *s_etat_processus);  void instruction_unlock(struct_processus *s_etat_processus);
 void instruction_unprotect(struct_processus *s_etat_processus);  void instruction_unprotect(struct_processus *s_etat_processus);
 void instruction_until(struct_processus *s_etat_processus);  void instruction_until(struct_processus *s_etat_processus);
Line 2354  void instruction_yield(struct_processus Line 2845  void instruction_yield(struct_processus
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Procédures    Procédures
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 2365  void affichage_pile(struct_processus *s_ Line 2856  void affichage_pile(struct_processus *s_
         niveau_courant);          niveau_courant);
 #endif  #endif
   
 void *allocation(struct_processus *s_etat_processus, enum t_type type);  
 void *allocation_maillon(struct_processus *s_etat_processus);  void *allocation_maillon(struct_processus *s_etat_processus);
   
 #ifndef RPLARGS  #ifndef RPLARGS
 void analyse(struct_processus *s_etat_processus, void (*fonction)());  void analyse(struct_processus *s_etat_processus, void (*fonction)());
 inline void *analyse_instruction(struct_processus *s_etat_processus,  void *analyse_instruction(struct_processus *s_etat_processus,
         unsigned char *candidat);          unsigned char *candidat);
 void appel_gnuplot(struct_processus *s_etat_processus,  void appel_gnuplot(struct_processus *s_etat_processus,
         unsigned char persistance);          unsigned char persistance);
 void cf(struct_processus *s_etat_processus, unsigned char indice_drapeau);  void cf(struct_processus *s_etat_processus, unsigned char indice_drapeau);
 void cond(struct_processus *s_etat_processus,  void cond(struct_processus *s_etat_processus,
         struct_matrice *s_matrice, real8 *condition);          struct_matrice *s_matrice, real8 *condition);
   void conversion_chaine(struct_processus *s_etat_processus,
           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(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, 
           unsigned char *chaine_sortie, unsigned long longueur);
 void conversion_radians_vers_degres(real8 *angle);  void conversion_radians_vers_degres(real8 *angle);
   void copie_arbre_variables(struct_processus *s_etat_processus,
           struct_processus *s_nouvel_etat_processus);
 void correction_formateur_tex(struct_processus *s_etat_processus,  void correction_formateur_tex(struct_processus *s_etat_processus,
         unsigned char **ligne);          unsigned char **ligne);
 void debug_memoire_verification(struct_processus *s_etat_processus);  
 void depilement_pile_systeme(struct_processus *s_etat_processus);  void depilement_pile_systeme(struct_processus *s_etat_processus);
 void derivation(struct_processus *s_etat_processus,  void derivation(struct_processus *s_etat_processus,
         struct_objet **s_expression);          struct_objet **s_expression);
Line 2396  void deverrouillage_threads_concurrents( Line 2891  void deverrouillage_threads_concurrents(
 void ecriture_pile(struct_processus *s_etat_processus, file *flux,  void ecriture_pile(struct_processus *s_etat_processus, file *flux,
         struct_liste_chainee *l_element_courant, unsigned long niveau_courant);          struct_liste_chainee *l_element_courant, unsigned long niveau_courant);
 void ecriture_profil(struct_processus *s_etat_processus);  void ecriture_profil(struct_processus *s_etat_processus);
   void effacement_pile_systeme(struct_processus *s_etat_processus);
 void empilement_pile_systeme(struct_processus *s_etat_processus);  void empilement_pile_systeme(struct_processus *s_etat_processus);
 void encart(struct_processus *s_etat_processus, unsigned long duree);  void encart(struct_processus *s_etat_processus, unsigned long duree);
 void evaluation_romberg(struct_processus *s_etat_processus,  void evaluation_romberg(struct_processus *s_etat_processus,
Line 2423  void impression_tex(struct_processus *s_ Line 2919  void impression_tex(struct_processus *s_
 void informations(struct_processus *s_etat_processus);  void informations(struct_processus *s_etat_processus);
 void initialisation_allocateur(struct_processus *s_etat_processus);  void initialisation_allocateur(struct_processus *s_etat_processus);
 void initialisation_completion(void);  void initialisation_completion(void);
   void initialisation_contexte_cas(struct_processus *s_etat_processus);
 void initialisation_drapeaux(struct_processus *s_etat_processus);  void initialisation_drapeaux(struct_processus *s_etat_processus);
 void initialisation_generateur_aleatoire(struct_processus *s_etat_processus,  void initialisation_generateur_aleatoire(struct_processus *s_etat_processus,
         logical1 initialisation_automatique, unsigned long int racine);          logical1 initialisation_automatique, unsigned long int racine);
 void initialisation_instructions(struct_processus *s_etat_processus);  void initialisation_instructions(struct_processus *s_etat_processus);
   void initialisation_variables(struct_processus *s_etat_processus);
 #endif  #endif
   
 void initialisation_objet(struct_objet *s_objet);  void initialisation_objet(struct_objet *s_objet);
Line 2439  void insertion_thread_surveillance(struc Line 2937  void insertion_thread_surveillance(struc
 void integrale_romberg(struct_processus *s_etat_processus,  void integrale_romberg(struct_processus *s_etat_processus,
         struct_objet *s_expression, unsigned char *variable,          struct_objet *s_expression, unsigned char *variable,
         real8 a, real8 b, real8 precision);          real8 a, real8 b, real8 precision);
 void interruption1(int signal, siginfo_t *siginfo, void *context);  void interface_cas(struct_processus *s_etat_processus,
 void interruption2(int signal, siginfo_t *siginfo, void *context);          enum t_rplcas_commandes commande);
 void interruption3(int signal, siginfo_t *siginfo, void *context);  void interruption1(int signal);
 void interruption4(int signal, siginfo_t *siginfo, void *context);  void interruption2(int signal);
 void interruption5(int signal, siginfo_t *siginfo, void *context);  void interruption3(int signal);
 void interruption6(int signal, siginfo_t *siginfo, void *context);  void interruption4(int signal);
 void interruption7(int signal, siginfo_t *siginfo, void *context);  void interruption5(int signal);
 void interruption8(int signal, siginfo_t *siginfo, void *context);  void interruption6(int signal);
 void interruption9(int signal, siginfo_t *siginfo, void *context);  void interruption_depassement_pile(int urgence, stackoverflow_context_t scp);
 void interruption10(int signal, siginfo_t *siginfo, void *context);  
 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 2463  void liberation_maillon(struct_processus Line 2960  void liberation_maillon(struct_processus
 void liberation_allocateur(struct_processus *s_etat_processus);  void liberation_allocateur(struct_processus *s_etat_processus);
 void liberation_arbre_instructions(struct_processus *s_etat_processus,  void liberation_arbre_instructions(struct_processus *s_etat_processus,
         struct_instruction *arbre);          struct_instruction *arbre);
   void liberation_arbre_variables(struct_processus *s_etat_processus,
           struct_arbre_variables *arbre, logical1 definitions);
   void liberation_contexte_cas(struct_processus *s_etat_processus);
 void liberation_generateur_aleatoire(struct_processus *s_etat_processus);  void liberation_generateur_aleatoire(struct_processus *s_etat_processus);
 void liberation_threads(struct_processus *s_etat_processus);  void liberation_threads(struct_processus *s_etat_processus);
 void liberation_profil(struct_processus *s_etat_processus);  void liberation_profil(struct_processus *s_etat_processus);
Line 2479  void retrait_thread(struct_processus *s_ Line 2979  void retrait_thread(struct_processus *s_
 void retrait_thread_surveillance(struct_processus *s_etat_processus,  void retrait_thread_surveillance(struct_processus *s_etat_processus,
         struct_descripteur_thread *s_argument_thread);          struct_descripteur_thread *s_argument_thread);
 void rplcore(struct_processus *s_etat_processus);  void rplcore(struct_processus *s_etat_processus);
 inline void scrutation_injection(struct_processus *s_etat_processus);  #endif
   
   void scrutation_injection(struct_processus *s_etat_processus);
   
   #ifndef RPLARGS
   void scrutation_interruptions(struct_processus *s_etat_processus);
 void sf(struct_processus *s_etat_processus, unsigned char indice_drapeau);  void sf(struct_processus *s_etat_processus, unsigned char indice_drapeau);
 void *surveillance_processus(void *argument);  void *surveillance_processus(void *argument);
 void swap(void *variable_1, void *variable_2, unsigned long taille_octets);  void swap(void *variable_1, void *variable_2, unsigned long taille_octets);
   void trace(struct_processus *s_etat_processus, FILE *flux);
 void traitement_asynchrone_exceptions_gsl(struct_processus *s_etat_processus);  void traitement_asynchrone_exceptions_gsl(struct_processus *s_etat_processus);
 void traitement_exceptions_gsl(const char *reason, const char *file,  void traitement_exceptions_gsl(const char *reason, const char *file,
         int line, int gsl_errno);          int line, int gsl_errno);
Line 2508  void verrouillage_threads_concurrents(st Line 3014  void verrouillage_threads_concurrents(st
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Fonctions de sommation de vecteur dans perte de précision    Fonctions de gestion des signaux
   --------------------------------------------------------------------------------
   */
   
   #ifndef RPLARGS
   void creation_queue_signaux(struct_processus *s_etat_processus);
   void liberation_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,
           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);
   #endif
   
   /*
   --------------------------------------------------------------------------------
     Fonctions de sommation de vecteur dans perte de précision
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 2524  complex16 sommation_vecteur_complexe(com Line 3046  complex16 sommation_vecteur_complexe(com
 */  */
   
 #ifndef RPLARGS  #ifndef RPLARGS
 int rplinit(int argc, char *argv[], unsigned char ***resultats, char *rpl_home);  int rplinit(int argc, char *argv[], char *envp[],
           unsigned char ***resultats, char *rpl_home);
 #endif  #endif
   
 /*  /*
Line 2553  struct_vecteur *variance_statistique(str Line 3076  struct_vecteur *variance_statistique(str
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Gestion des bibliothèques    Gestion des bibliothèques
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 2582  struct_liste_chainee *sauvegarde_argumen Line 3105  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);
   unsigned char *analyse_flux(struct_processus *s_etat_processus,
           unsigned char *flux, long longueur);
 unsigned char *recherche_chemin_fichiers_temporaires(struct_processus  unsigned char *recherche_chemin_fichiers_temporaires(struct_processus
         *s_etat_processus);          *s_etat_processus);
 unsigned char *compactage(unsigned char *chaine);  unsigned char *compactage(unsigned char *chaine);
 unsigned char *conversion_majuscule(unsigned char *chaine);  unsigned char *conversion_majuscule(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 *extraction_chaine(unsigned char *chaine, unsigned long i,  unsigned char *extraction_chaine(unsigned char *chaine, unsigned long i,
         unsigned long j);          unsigned long j);
 unsigned char *formateur(struct_processus *s_etat_processus, long offset,  unsigned char *formateur(struct_processus *s_etat_processus, long offset,
Line 2596  unsigned char *formateur_fichier(struct_ Line 3122  unsigned char *formateur_fichier(struct_
         struct_objet *s_objet, struct_objet *s_format,          struct_objet *s_objet, struct_objet *s_format,
         long longueur, long longueur_champ, unsigned char format,          long longueur, long longueur_champ, unsigned char format,
         unsigned char type, long *longueur_effective, long *recursivite);          unsigned char type, long *longueur_effective, long *recursivite);
   unsigned char *formateur_flux(struct_processus *s_etat_processus,
           unsigned char *donnees, long *longueur);
 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,
         long longueur, long longueur_champ, unsigned char format);          long longueur, long longueur_champ, unsigned char format);
   unsigned char *formateur_fichier_binaire_nombre(struct_processus
           *s_etat_processus, void *valeur_numerique, unsigned char type,
           long longueur, long *longueur_conversion);
 unsigned char *formateur_fichier_reel(struct_processus *s_etat_processus,  unsigned char *formateur_fichier_reel(struct_processus *s_etat_processus,
         void *valeur_numerique, unsigned char type,          void *valeur_numerique, unsigned char type,
         long longueur, long longueur_champ, unsigned char format);          long longueur, long longueur_champ, unsigned char format);
Line 2607  unsigned char *formateur_nombre(struct_p Line 3138  unsigned char *formateur_nombre(struct_p
 unsigned char *formateur_reel(struct_processus *s_etat_processus,  unsigned char *formateur_reel(struct_processus *s_etat_processus,
         void *valeur_numerique, unsigned char type);          void *valeur_numerique, unsigned char type);
 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 *chaine, integer8 position);
 unsigned char *purification_chaine(unsigned char *chaine);  unsigned char *purification_chaine(unsigned char *chaine);
 unsigned char *reencodage(struct_processus *s_etat_processus,  unsigned char *reencodage(struct_processus *s_etat_processus,
         unsigned char *chaine_entree, unsigned char *codage_entree,          unsigned char *chaine_entree, unsigned char *codage_entree,
Line 2629  logical1 caracteristiques_fichier(struct Line 3162  logical1 caracteristiques_fichier(struct
         unsigned long *unite);          unsigned long *unite);
 logical1 controle(struct_processus *s_etat_processus, unsigned char *fichier,  logical1 controle(struct_processus *s_etat_processus, unsigned char *fichier,
         unsigned char *type, unsigned char *somme_candidate);          unsigned char *type, unsigned char *somme_candidate);
   logical1 controle_integrite(struct_processus *s_etat_processus,
           unsigned char *executable_candidat, unsigned char *executable);
 logical1 creation_variable(struct_processus *s_etat_processus,  logical1 creation_variable(struct_processus *s_etat_processus,
         struct_variable *s_variable,          struct_variable *s_variable,
         unsigned char autorisation_creation_variable_statique,          unsigned char autorisation_creation_variable_statique,
Line 2680  logical1 ecriture_pipe(struct_processus Line 3215  logical1 ecriture_pipe(struct_processus
         struct_objet *s_objet);          struct_objet *s_objet);
 logical1 recherche_variable(struct_processus *s_etat_processus,  logical1 recherche_variable(struct_processus *s_etat_processus,
         unsigned char *nom_variable);          unsigned char *nom_variable);
   logical1 recherche_variable_globale(struct_processus *s_etat_processus,
           unsigned char *nom_variable);
 logical1 recherche_variable_partagee(struct_processus *s_etat_processus,  logical1 recherche_variable_partagee(struct_processus *s_etat_processus,
         unsigned char *nom_variable, union_position_variable position,          unsigned char *nom_variable, union_position_variable position,
         unsigned char origine);          unsigned char origine);
Line 2690  logical1 test_cfsf(struct_processus *s_e Line 3227  logical1 test_cfsf(struct_processus *s_e
         unsigned char indice_drapeau);          unsigned char indice_drapeau);
 logical1 test_expression_rpn(unsigned char *chaine);  logical1 test_expression_rpn(unsigned char *chaine);
 logical1 test_fonction(unsigned char *chaine);  logical1 test_fonction(unsigned char *chaine);
   logical1 validation_chaine(unsigned char *chaine);
 #endif  #endif
   
 /*  /*
Line 2699  logical1 test_fonction(unsigned char *ch Line 3237  logical1 test_fonction(unsigned char *ch
 */  */
   
 #ifndef RPLARGS  #ifndef RPLARGS
 inline 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);
 inline 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 2712  inline ssize_t write_atomic(struct_proce Line 3250  inline ssize_t write_atomic(struct_proce
 */  */
   
 int alsprintf(unsigned char **strp, const char *fmt, ...);  int alsprintf(unsigned char **strp, const char *fmt, ...);
   int interruption_violation_access(void *adresse_fautive, int gravite);
   #ifndef RPLARGS
   int liste_variables(struct_processus *s_etat_processus,
           struct_tableau_variables *tableau, int position,
           struct_arbre_variables *l_element_courant);
   int nombre_variables(struct_processus *s_etat_processus,
           struct_arbre_variables *l_element_courant);
   int readline_analyse_syntaxique(int count, int key);
   int readline_effacement(int count, int key);
   #endif
 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,
Line 2728  int wrapper_instruction_intrinseque(void Line 3276  int wrapper_instruction_intrinseque(void
   
 #ifndef RPLARGS  #ifndef RPLARGS
 unsigned char longueur_entiers_binaires(struct_processus *s_etat_processus);  unsigned char longueur_entiers_binaires(struct_processus *s_etat_processus);
 unsigned char recherche_longueur_optimale(integer8 parametre);  
 #endif  #endif
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Fonctions retournant un INTEGER*8 (valeur binaire non signée)    Fonctions retournant un INTEGER*8 (valeur binaire non signée)
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 2749  logical8 masque_entiers_binaires(struct_ Line 3296  logical8 masque_entiers_binaires(struct_
   
 #ifndef RPLARGS  #ifndef RPLARGS
 integer8 occupation_memoire(struct_objet *s_objet);  integer8 occupation_memoire(struct_objet *s_objet);
   integer8 longueur_chaine(struct_processus *s_etat_processus,
           unsigned char *chaine);
   integer8 position_caractere_de_chaine(struct_processus *s_etat_processus,
           unsigned char *chaine, unsigned char *position);
 #endif  #endif
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   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 2793  struct_descripteur_fichier *descripteur_ Line 3344  struct_descripteur_fichier *descripteur_
 struct_objet *copie_objet(struct_processus *s_etat_processus,  struct_objet *copie_objet(struct_processus *s_etat_processus,
         struct_objet *s_objet, unsigned char type);          struct_objet *s_objet, unsigned char type);
   
   struct_objet *allocation(struct_processus *s_etat_processus, enum t_type type);
 #ifndef RPLARGS  #ifndef RPLARGS
 struct_objet *formateur_date(struct_processus *s_etat_processus,  struct_objet *formateur_date(struct_processus *s_etat_processus,
         struct timeval *temps);          struct timeval *temps);
Line 2805  struct_objet *simplification(struct_proc Line 3357  struct_objet *simplification(struct_proc
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Fonctions gérant les arbres de simplification    Fonctions gérant les arbres de simplification
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 2822  void simplification_arbre(struct_process Line 3374  void simplification_arbre(struct_process
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Fonctions gérant la complétion automatique    Fonctions gérant la complétion automatique
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 2834  char **completion_matches(); Line 3386  char **completion_matches();
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Arithmétique    Arithmétique
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 2880  void f77soustractionrc_(real8 *ra, compl Line 3432  void f77soustractionrc_(real8 *ra, compl
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Trigonométrie complexe    Trigonométrie complexe
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 2977  void zgeev_(unsigned char *calcul_vp_gau Line 3529  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 2990  void zggev_(unsigned char *calcul_vp_gau Line 3542  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 3005  void zgelsd_(integer4 *nombre_lignes_a, Line 3557  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 3066  void zgees_(unsigned char *calcul_vecteu Line 3618  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 3087  void zgelsy_(integer4 *m, integer4 *n, i Line 3639  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).
  */   */
   
 inline int test_arret(struct_processus *s_etat_processus);  int test_arret(struct_processus *s_etat_processus);
   
 #endif  #endif
   
Removed from v.1.20  
changed lines
  Added in v.1.176

CVSweb interface <joel.bertrand@systella.fr>