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

Diff for /rpl/src/rpl.h between versions 1.6 and 1.356

version 1.6, 2010/02/08 19:26:32 version 1.356, 2025/04/15 10:17:57
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.10    RPL/2 (R) version 4.1.36
   Copyright (C) 1989-2010 Dr. BERTRAND Joël    Copyright (C) 1989-2025 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 22 Line 22
   
 #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
   
   #ifndef __RPLCAS
   #   ifdef Darwin
   #       define  _DARWIN_C_SOURCE
   #   endif
   
   #   ifdef OpenBSD
   #       define _BSD_SOURCE
   #   endif
   
   #   ifdef FreeBSD
   #       define __BSD_VISIBLE    1
   #   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
   
   #ifdef CYGWIN
   #   define SA_ONSTACK   0
   #endif
   
   #ifdef BROKEN_SIGSEGV
   #   undef HAVE_STACK_OVERFLOW_RECOVERY
   #   undef HAVE_SIGSEGV_RECOVERY
   #endif
   
   #define DEBUG_TRACE     uprintf("[%d/%X] %s(%d)\n", \
           getpid(), pthread_self(), __FILE__, __LINE__);
   #define TEST_ABSENCE_FICHIER(nom) \
           { int ios; struct stat *buf; ios = stat(nom, buf); \
               if (ios == 0) BUG(1, uprintf("File %s found!\n", nom)); }
   
 /*  /*
 ================================================================================  ================================================================================
Line 32 Line 83
   
 #include <stdio.h>  #include <stdio.h>
 #include <stdlib.h>  #include <stdlib.h>
   #include <stdint.h>
 #include <math.h>  #include <math.h>
 #include <string.h>  #include <string.h>
 #include <strings.h>  #include <strings.h>
 #include <syslog.h>  #include <syslog.h>
 #include <errno.h>  #include <errno.h>
   #include <stdarg.h>
   #include <poll.h>
   #include <signal.h>
   #include <sys/time.h>
   #include <pthread.h>
   
 #ifndef RPLARGS  #ifndef RPLARGS
   #   include <sys/mman.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/types.h>  #   include <sys/types.h>
 #   include <sys/un.h>  #   include <sys/un.h>
 #   include <sys/wait.h>  #   include <sys/wait.h>
Line 55 Line 111
   
 #   include <dlfcn.h>  #   include <dlfcn.h>
 #   include <fcntl.h>  #   include <fcntl.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 <termios.h>  #   include <termios.h>
 #   include <time.h>  #   include <time.h>
 #   include <unistd.h>  #   include <unistd.h>
Line 69 Line 181
 #   include "readline.h"  #   include "readline.h"
 #   include "termcap.h"  #   include "termcap.h"
 #   include "iconv.h"  #   include "iconv.h"
   #   include "zlib.h"
   
   #   include "openssl/evp.h"
   #   ifndef RPLCXX
   #       ifndef OPENSSL_NO_MD2
   #           include "openssl/md2.h"
   #       endif
   #       ifndef OPENSSL_NO_MD4
   #           include "openssl/md4.h"
   #       endif
   #       ifndef OPENSSL_NO_MD5
   #           include "openssl/md5.h"
   #       endif
   #       ifndef OPENSSL_NO_MDC2
   #           include "openssl/mdc2.h"
   #       endif
   #       ifndef OPENSSL_NO_RIPEMD
   #           include "openssl/ripemd.h"
   #       endif
   #       ifndef OPENSSL_NO_SHA
   #           include "openssl/sha.h"
   #       endif
   #       ifndef OPENSSL_NO_WHIRLPOOL
   #           include "openssl/whrlpool.h"
   #       endif
   #       ifndef OPENSSL_NO_AES
   #           include "openssl/aes.h"
   #       endif
   #       ifndef OPENSSL_NO_CAMELLIA
   #           include "openssl/camellia.h"
   #       endif
   #       ifndef OPENSSL_NO_RC2
   #           include "openssl/rc2.h"
   #       endif
   #       ifndef OPENSSL_NO_IDEA
   #           include "openssl/idea.h"
   #       endif
   #   endif
   
   #   include "sqlite3.h"
   
   #   ifndef BROKEN_SIGSEGV
   #       include "sigsegv.h"
   #   endif
   
   #   ifdef OS2
           // Bug de libsigsegv
   #       undef HAVE_STACK_OVERFLOW_RECOVERY
   #   endif
   
 #   define HAVE_INLINE  
 #   define GSL_RANGE_CHECK_OFF  #   define GSL_RANGE_CHECK_OFF
 #   include "gsl/gsl_cdf.h"  #   include "gsl/gsl_cdf.h"
 #   include "gsl/gsl_cblas.h"  #   include "gsl/gsl_cblas.h"
Line 86 Line 246
 #   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 100 Line 265
 #   define postgresqlclose(arg)  #   define postgresqlclose(arg)
 #endif  #endif
   
 #ifdef LIBRPL  #include "librplprototypes.h"
 #   include "librplprototypes.h"  
   #ifndef RPLARGS
   #   ifndef UNIX_PATH_MAX
   #       pragma GCC diagnostic push
   #       pragma GCC diagnostic ignored "-Wunused-variable"
           static struct sockaddr_un sizecheck;
   #       define UNIX_PATH_MAX sizeof(sizecheck.sun_path)
   #       pragma GCC diagnostic pop
   #   endif
   #endif
   
   #ifdef MAIN_RPL
   #   define __EXTERN__
   #   define __STATIC_MUTEX_INITIALIZATION__ = PTHREAD_MUTEX_INITIALIZER
   #else
   #   define __EXTERN__                       extern
   #   define __STATIC_MUTEX_INITIALIZATION__
   #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,
       rpl_siguser         // Base des signaux à la discrétion de l'utilisateur
   };
   
   #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
   {
       volatile int                pointeur_lecture;
       volatile int                pointeur_ecriture;
       volatile logical1           requete_arret;
   
       pthread_t                   thread_signaux;
       pid_t                       controle;
   
       volatile struct
       {
           pid_t                   pid;
           enum signaux_rpl        signal;
       }                           queue[LONGUEUR_QUEUE_SIGNAUX];
   
   #   ifdef OS2
       sem_t                       semaphore;
       sem_t                       signalisation;
       sem_t                       arret_signalisation;
   #   endif
   } struct_queue_signaux;
   
   __EXTERN__ struct_queue_signaux *s_queue_signaux;
   __EXTERN__ int                  f_queue_signaux;
   
   #   ifndef OS2
       __EXTERN__ sem_t            *semaphore_queue_signaux;
       __EXTERN__ sem_t            *semaphore_signalisation;
       __EXTERN__ sem_t            *semaphore_arret_signalisation;
   #   endif
   #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
   #   ifdef DEBUG_SEMAPHORES
   #       define sem_init(a, b, c) ({ \
                   uprintf("[%d-%llu] Semaphore %s (%p) "\
                           "initialization at %s() " \
                   "line #%d <%d>\n", (int) getpid(), (unsigned long long) \
                           pthread_self(), \
                   #a, a, __FUNCTION__, __LINE__, value), fflush(stdout); \
                   sem_init_SysV(a, b, c); })
   #       define sem_wait(a) ({ int value; sem_getvalue(a, &value); \
                   uprintf("[%d-%llu] Semaphore %s (%p) "\
                   "waiting at %s() " \
                   "line #%d <%d>\n", (int) getpid(), (unsigned long long) i\
                           pthread_self(), \
                   #a, a, __FUNCTION__, __LINE__, value), fflush(stdout); \
                   sem_wait_SysV(a); })
   #       define sem_trywait(a) ({ int value; sem_getvalue(a, &value); \
                   uprintf("[%d-%llu] Semaphore %s (%p) "\
                   "trywaiting at %s() " \
                   "line #%d <%d>\n", (int) getpid(), (unsigned long long) i\
                           pthread_self(), \
                   #a, a, __FUNCTION__, __LINE__, value), fflush(stdout); \
                   sem_trywait_SysV(a); })
   #       define sem_post(a) ({ int value; sem_getvalue(a, &value); \
                   uprintf("[%d-%llu] Semaphore %s (%p) "\
                   "posting at %s() " \
                   "line #%d <%d>\n", (int) getpid(), (unsigned long long) \
                           pthread_self(), \
                   #a, a, __FUNCTION__, __LINE__, value), fflush(stdout); \
                   sem_post_SysV(a); })
   #       define sem_destroy(a) ({ int value; sem_getvalue(a, &value); \
                   uprintf("[%d-%llu] Semaphore %s (%p) "\
                   "destroying at %s() " \
                   "line #%d <%d>\n", (int) getpid(), (unsigned long long) \
                           pthread_self(), \
                   #a, a, __FUNCTION__, __LINE__, value), fflush(stdout); \
                   if (value == 0) BUG(1, uprintf("Value %d\n", value)); \
                   sem_destroy_SysV(a); })
   #   else
   #       define sem_destroy(a)       sem_destroy_SysV(a)
   #       define sem_wait(a)          sem_wait_SysV(a)
   #       define sem_post(a)          sem_post_SysV(a)
   #   endif
   
   #   define sem_init(a, b, c)    sem_init_SysV(a, b, c)
   #   define sem_trywait(a)       sem_trywait_SysV(a)
   #   define sem_timedwait(a, b)  sem_timedwait_SysV(a, b)
   #   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)
   #else
   #   ifdef DEBUG_SEMAPHORES
   #       define sem_init(a, b, c) ({ \
                   uprintf("[%d-%llu] Semaphore %s (%p) "\
                           "initialization at %s() " \
                   "line #%d <%d>\n", (int) getpid(), (unsigned long long) \
                           pthread_self(), \
                   #a, a, __FUNCTION__, __LINE__, c), fflush(stdout); \
                   sem_init(a, b, c); })
   #       define sem_wait(a) ({ int value; sem_getvalue(a, &value); \
                   uprintf("[%d-%llu] Semaphore %s (%p) "\
                   "waiting at %s() " \
                   "line #%d <%d>\n", (int) getpid(), (unsigned long long) \
                           pthread_self(), \
                   #a, a, __FUNCTION__, __LINE__, value), fflush(stdout); \
                   sem_wait(a); })
   #       define sem_trywait(a) ({ int value; sem_getvalue(a, &value); \
                   uprintf("[%d-%llu] Semaphore %s (%p) "\
                   "trywaiting at %s() " \
                   "line #%d <%d>\n", (int) getpid(), (unsigned long long) \
                           pthread_self(), \
                   #a, a, __FUNCTION__, __LINE__, value), fflush(stdout); \
                   sem_trywait(a); })
   #       define sem_post(a) ({ int value; sem_getvalue(a, &value); \
                   uprintf("[%d-%llu] Semaphore %s (%p) "\
                   "posting at %s() " \
                   "line #%d <%d>\n", (int) getpid(), (unsigned long long) \
                           pthread_self(), \
                   #a, a, __FUNCTION__, __LINE__, value), fflush(stdout); \
                   sem_post(a); })
   #       define sem_destroy(a) ({ int value; sem_getvalue(a, &value); \
                   uprintf("[%d-%llu] Semaphore %s (%p) "\
                   "destroying at %s() " \
                   "line #%d <%d>\n", (int) getpid(), (unsigned long long) \
                           pthread_self(), \
                   #a, a, __FUNCTION__, __LINE__, value), fflush(stdout); \
                   if (value == 0) BUG(1, uprintf("Value %d\n", value)); \
                   sem_destroy(a); })
   #   endif
 #endif  #endif
   
   
 /*  /*
 ================================================================================  ================================================================================
   SIGNAUX    SIGNAUX
Line 111 Line 496
 */  */
   
 #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
   
Line 155 Line 549
   
 /*  /*
 ================================================================================  ================================================================================
   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;  #       define __PTR__      *
   
     extern pthread_key_t            semaphore_fork_processus_courant;  
   
     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;  
   
     pthread_key_t                   semaphore_fork_processus_courant;  
   
     sem_t                           semaphore_liste_threads;  
     sem_t                           semaphore_gestionnaires_signaux;  
     sem_t                           semaphore_gestionnaires_signaux_atomique;  
 #   endif  #   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;
   
       __EXTERN__ pid_t                pid_processus_pere;
   
       __EXTERN__ pthread_mutex_t      mutex_sigaction;
       __EXTERN__ pthread_mutex_t      mutex_liste_threads;
       __EXTERN__ pthread_mutex_t      mutex_liste_threads_surveillance;
       __EXTERN__ pthread_mutex_t      mutex_creation_variable_partagee
                                               __STATIC_MUTEX_INITIALIZATION__;
       __EXTERN__ pthread_mutex_t      mutex_sections_critiques;
       __EXTERN__ pthread_mutex_t      mutex_liste_variables_partagees;
       __EXTERN__ pthread_mutex_t      mutex_sem __STATIC_MUTEX_INITIALIZATION__;
   
       __EXTERN__ volatile int         routine_recursive;
       __EXTERN__ volatile int         nombre_threads_surveillance_processus;
   
   #   define SEM_FORK                 0
   #   define SEM_QUEUE                1
   #   define SEM_SIGNALISATION        2
   #   define SEM_ARRET_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);
   #endif
   
   // 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.
   
   #ifdef Darwin
   #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 626  typedef unsigned char   t_8_bits;
             stderr, __VA_ARGS__)              stderr, __VA_ARGS__)
 #define fprintf(flux, ...) transliterated_fprintf(s_etat_processus, \  #define fprintf(flux, ...) transliterated_fprintf(s_etat_processus, \
             flux, __VA_ARGS__)              flux, __VA_ARGS__)
 #define uprintf(...) transliterated_fprintf(NULL, \  #define uprintf(...) std_fprintf(stderr, __VA_ARGS__)
             stderr, __VA_ARGS__)  #define ufprintf(flux, ...) std_fprintf(flux, __VA_ARGS__)
 #define ufprintf(flux, ...) transliterated_fprintf(NULL, \  
             flux, __VA_ARGS__)  
   
 // 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 238  typedef unsigned char   t_8_bits; Line 649  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  
 // système dans le cas où l'on a atteint le nombre maximale de fichiers  
 // ouverts.  
   
 #define pipe(descripteurs) \  
     ({ \  
         struct timespec temporisation; \  
         int erreur, nombre_echecs; \  
         nombre_echecs = 0; \  
         do \  
         { \  
             if ((erreur = pipe(descripteurs)) == 0) break; \  
             nombre_echecs++; \  
             temporisation.tv_sec = 0; \  
             temporisation.tv_nsec = ((long) 1000000000) * rand(); \  
             nanosleep(&temporisation, NULL); \  
         } while(nombre_echecs < 100); \  
         erreur; \  
      })  
   
 // Redéfinition de abs pour un fonctionnement en entier de type long long int  // Redéfinition de abs pour un fonctionnement en entier de type long long int
   
 #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
Line 270  typedef unsigned char   t_8_bits; Line 661  typedef unsigned char   t_8_bits;
 #   define abs(i) (((i) >= 0) ? (i) : (-i))  #   define abs(i) (((i) >= 0) ? (i) : (-i))
 #endif  #endif
   
 #define BUG(b, ...) \  #define NOTICE(m) \
         do { if (b) { uprintf("[%d] BUG! <%s()> at line #%d of %s\n", \      do \
         (int) getpid(), __FUNCTION__, __LINE__, __FILE__); \      { \
         __VA_ARGS__; fflush(stdout); \          ufprintf(stderr, "[%d-%llu] %s() from %s at line %d: %s\n", \
         pthread_kill(pthread_self(), SIGBUS); }} while(0)                  getpid(), (unsigned long long) pthread_self(), \
                   __FUNCTION__, __FILE__, __LINE__, m); \
           fflush(stderr); \
       } while(0)
   
 #define BACKTRACE(n) \  #ifdef __GLIBC__
   #   include <execinfo.h>
   #   define __BACKTRACE
   #   define BACKTRACE(n) \
     do \      do \
     { \      { \
         void            *buffer[n]; \          void            *buffer[n]; \
Line 291  typedef unsigned char   t_8_bits; Line 688  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); \              sys_free(appels); \
         } \          } \
         else \          else \
             uprintf("Nullified backtrace\n"); \              uprintf("Nullified backtrace\n"); \
Line 300  typedef unsigned char   t_8_bits; Line 697  typedef unsigned char   t_8_bits;
         fflush(stdout); \          fflush(stdout); \
         pthread_mutex_unlock(&mutex); \          pthread_mutex_unlock(&mutex); \
     } while(0)      } while(0)
   #else
   #   define BACKTRACE(n) NOTICE("BACKTRACE only defined in glibc")
   #endif
   
 #define NOTICE(m) \  #ifdef __BACKTRACE
     do \  #   define BUG(b, ...) \
     { \              do { if (b) { uprintf("[%d] BUG! <%s()> at line #%d of %s\n", \
         ufprintf(stderr, "[%d-%llu] %s() from %s at line %d: %s\n", \              (int) getpid(), __FUNCTION__, __LINE__, __FILE__); \
                 getpid(), pthread_self(), __FUNCTION__, __FILE__, __LINE__, \              __VA_ARGS__; fflush(stdout); \
                 m); \              BACKTRACE(64); \
         fflush(stderr); \              pthread_kill(pthread_self(), SIGBUS); }} while(0)
     } 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 317  typedef unsigned char   t_8_bits; Line 723  typedef unsigned char   t_8_bits;
 ================================================================================  ================================================================================
 */  */
   
   #ifdef DEBUG_MEMOIRE
   void analyse_post_mortem();
   void *debug_memoire_ajout(size_t taille, const unsigned char *fonction,
           unsigned long ligne, const unsigned char *argument);
   void debug_memoire_initialisation();
   void *debug_memoire_modification(void *pointeur, size_t taille,
           const unsigned char *fonction, unsigned long ligne,
           const unsigned char *argument);
   void debug_memoire_retrait(void *ptr);
   void debug_memoire_verification();
   
   #define free(s) debug_memoire_retrait(s)
   #ifdef RPLCXX
   #   define malloc(s) debug_memoire_ajout(s, \
                   const_cast<const unsigned char *> \
                   (reinterpret_cast<unsigned char *> \
                   (const_cast<char *>(__FUNCTION__))), __LINE__, \
                   const_cast<const unsigned char *> \
                   (reinterpret_cast<unsigned char *> \
                   (const_cast<char *>(#s))))
   #   define realloc(s, t) debug_memoire_modification(s, t, \
                   const_cast<const unsigned char *> \
                   (reinterpret_cast<unsigned char *> \
                   (const_cast<char *>(__FUNCTION__))), __LINE__, \
                   const_cast<const unsigned char *> \
                   (reinterpret_cast<unsigned char *> \
                   (const_cast<char *>(#t))))
   #else
   #   define malloc(s) debug_memoire_ajout(s, __FUNCTION__, __LINE__, \
                   (const unsigned char *) #s)
   #   define realloc(s, t) debug_memoire_modification(s, t, \
                   __FUNCTION__, __LINE__, (const unsigned char *) #t)
   #endif
   #define fork() debug_fork(s_etat_processus)
   #endif
   
 #ifdef DEBUG_RETURN  #ifdef DEBUG_RETURN
 #define return uprintf("[%d] Return from <%s()> at line #%d " \  #   define return uprintf("[%d] Return from <%s()> at line #%d " \
         "(%s [%d])\n", (int) getpid(), __FUNCTION__, \          "(%s [%d])\n", (int) getpid(), __FUNCTION__, \
         __LINE__, strerror(errno), errno); fflush(stdout); errno=0; return          __LINE__, strerror(errno), errno); fflush(stdout); errno = 0; return
 #endif  #endif
   
 #ifdef DEBUG_MUTEX  #ifdef DEBUG_MUTEX
 #define pthread_mutex_lock(mutex) uprintf("[%d-%llu] Mutex %s (%p) " \  #   define pthread_mutex_lock(mutex) uprintf("[%d-%llu] Mutex %s (%p) " \
         "locking at %s() " \          "locking at %s() " \
         "line #%d\n", (int) getpid(), (unsigned long long) pthread_self(), \          "line #%d\n", (int) getpid(), (unsigned long long) pthread_self(), \
         #mutex, mutex, __FUNCTION__, __LINE__), fflush(stdout), \          #mutex, mutex, __FUNCTION__, __LINE__), fflush(stdout), \
         pthread_mutex_lock(mutex)          pthread_mutex_lock(mutex)
 #define pthread_mutex_unlock(mutex) uprintf("[%d-%llu] Mutex %s (%p) " \  #   define pthread_mutex_unlock(mutex) uprintf("[%d-%llu] Mutex %s (%p) " \
         "unlocking at " \          "unlocking at " \
         "%s() line #%d\n", (int) getpid(), (unsigned long long) \          "%s() line #%d\n", (int) getpid(), (unsigned long long) \
         pthread_self(), #mutex, mutex, __FUNCTION__, __LINE__), \          pthread_self(), #mutex, mutex, __FUNCTION__, __LINE__), \
         fflush(stdout), \          fflush(stdout), \
         pthread_mutex_unlock(mutex)          pthread_mutex_unlock(mutex)
   #   define pthread_mutex_trylock(mutex) uprintf("[%d-%llu] Mutex %s (%p) " \
           "trylocking at " \
           "%s() line #%d\n", (int) getpid(), (unsigned long long) \
           pthread_self(), #mutex, mutex, __FUNCTION__, __LINE__), \
           fflush(stdout), \
           pthread_mutex_trylock(mutex)
 #endif  #endif
   
 #ifdef DEBUG_SEMAPHORES  
 #define sem_wait(a) ({ int value; sem_getvalue(a, &value); \  
         uprintf("[%d-%llu] Semaphore %s (%p) "\  
         "waiting at %s() " \  
         "line #%d\n", (int) getpid(), (unsigned long long) pthread_self(), \  
         #a, a, __FUNCTION__, __LINE__), fflush(stdout); \  
         if (value > 1) BUG(1, uprintf("Value %d\n", value)); sem_wait(a); })  
 #define sem_post(a) ({ int value; sem_getvalue(a, &value); \  
         uprintf("[%d-%llu] Semaphore %s (%p) "\  
         "posting at %s() " \  
         "line #%d\n", (int) getpid(), (unsigned long long) pthread_self(), \  
         #a, a, __FUNCTION__, __LINE__), fflush(stdout); \  
         if (value > 0) BUG(1, uprintf("Value %d\n", value)); sem_post(a); })  
 #define sem_destroy(a) ({ int value; sem_getvalue(a, &value); \  
         if (value == 0) BUG(1, uprintf("Value %d\n", value)); sem_destroy(a); })  
 #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 388  typedef unsigned char   t_8_bits; Line 804  typedef unsigned char   t_8_bits;
 #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 416  typedef unsigned char   t_8_bits; Line 833  typedef unsigned char   t_8_bits;
 #define d_SPH                   "Semaphore $n 'name'"  #define d_SPH                   "Semaphore $n 'name'"
 #define d_TAB                   "<[ table ]>"  #define d_TAB                   "<[ table ]>"
 #define d_MTX                   "Mutex $n"  #define d_MTX                   "Mutex $n"
   #define d_REC                   "|[ record ]|"
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
Line 442  typedef unsigned char   t_8_bits; Line 860  typedef unsigned char   t_8_bits;
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
 #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)  ({ int ios; ios = errno; \
                   if (strstr(__FUNCTION__, "recherche_variable") \
                   == NULL) { if(ios != 0) \
                   ufprintf(stderr, "LAST ERROR: %s\n", strerror(ios)); \
                   ufprintf(stderr, "ERROR %d AT %s() FROM %s LINE %d\n", \
                   i, __FUNCTION__, __FILE__, __LINE__); BACKTRACE(16); } i; })
   #   endif
   #else
   #   define __erreur(i)  i
   #   define __erreur_(i) i
   #endif
   
   #ifdef DEBUG_FICHIERS
   #   define open(a, ...) \
           ({ ufprintf(stderr, "[%d] OPEN %s AT %s() FROM %s LINE %d\n", \
           getpid(), a, \
           __FUNCTION__, __FILE__, __LINE__); open(a, __VA_ARGS__); })
   #   define pipe(a) \
           ({ ufprintf(stderr, "[%d] PIPE %s AT %s() FROM %s LINE %d\n", \
           getpid(), a, \
           __FUNCTION__, __FILE__, __LINE__); pipe(a); })
   #   define shm_open(a, ...) \
           ({ ufprintf(stderr, "[%d] SHM_OPEN %s AT %s() FROM %s LINE %d\n", \
           getpid(), a, \
           __FUNCTION__, __FILE__, __LINE__); shm_open(a, __VA_ARGS__); })
   #   define shm_unlink(a) \
           ({ ufprintf(stderr, "[%d] SHM_UNLINK %s AT %s() FROM %s LINE %d\n", \
           getpid(), a, \
           __FUNCTION__, __FILE__, __LINE__); shm_unlink(a); })
   #   define sem_open(a, ...) \
           ({ ufprintf(stderr, "[%d] SEM_OPEN %s AT %s() FROM %s LINE %d\n", \
           getpid(), a, \
           __FUNCTION__, __FILE__, __LINE__); sem_open(a, __VA_ARGS__); })
   #   define sem_unlink(a) \
           ({ ufprintf(stderr, "[%d] SEM_UNLINK %s AT %s() FROM %s LINE %d\n", \
           getpid(), a, \
           __FUNCTION__, __FILE__, __LINE__); sem_unlink(a); })
   #   define close(a) \
           ({ ufprintf(stderr, "[%d] CLOSE %s AT %s() FROM %s LINE %d\n", \
           getpid(), a, \
           __FUNCTION__, __FILE__, __LINE__); close(a); })
   #endif
   
 // -1 : erreur provoquée par une bibliothèque externe  // -1 : erreur provoquée par une bibliothèque externe
 #ifndef RPLARGS  #ifndef RPLARGS
 #   define d_es                                 2000  #   define d_es                                 2000
 #   define d_es_allocation_memoire              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                  __erreur(2014)
   #   define d_es_semaphore                       __erreur(2015)
   #   define d_es_mutex_acquis_autre_thread       __erreur(2016)
 #endif  #endif
   
 /*  /*
Line 470  typedef unsigned char   t_8_bits; Line 943  typedef unsigned char   t_8_bits;
   
 #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 491  typedef unsigned char   t_8_bits; Line 964  typedef unsigned char   t_8_bits;
   
 #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
   
 /*  /*
Line 514  typedef unsigned char   t_8_bits; Line 987  typedef unsigned char   t_8_bits;
 // -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)
 #endif  #   define d_ex_enregistrement_inexistant       __erreur(79)
   #   define d_ex_clef_inexistante                __erreur(80)
 /*  #   define d_ex_nom_implicite                   __erreur(81)
 --------------------------------------------------------------------------------  #   define d_ex_version_bibliotheque            __erreur(82)
   Erreurs de la ligne de commande  #   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)
 #ifndef RPLARGS  #   define d_ex_expression_reguliere            __erreur(87)
 #   define d_os                                 4000  #   define d_ex_instruction_indisponible        __erreur(88)
 #   define d_os_ligne_de_commande               4001  #   define d_ex_chiffrement                     __erreur(89)
 #   define d_os_fichier_introuvable             4002  #   define d_ex_chiffrement_indisponible        __erreur(90)
   #   define d_ex_longueur_clef_chiffrement       __erreur(91)
   #   define d_ex_taille_message                  __erreur(92)
   #   define d_ex_type_externe_dup                __erreur(93)
   #   define d_ex_type_externe_drop               __erreur(94)
   #   define d_ex_simplification                  __erreur(95)
 #endif  #endif
   
   
 /*  /*
 ================================================================================  ================================================================================
   STRUCTURES    STRUCTURES
Line 618  typedef unsigned char   t_8_bits; Line 1097  typedef unsigned char   t_8_bits;
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
 enum t_type     { ADR = 0, ALG, BIN, CHN, CPL, FCH, FCT, INT, LST,  #ifdef MIN
                 MCX, MIN, MRL, MTX, NOM, NON, PRC, REL, RPN, SCK,  #   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 EXT __RPL_EXT
   #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 REC __RPL_REC
   #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,
                               RPLCAS_SIMPLIFICATION };
   
   enum t_type     { ADR = 0, ALG, BIN, CHN, CPL, EXT, FCH, FCT, INT, LST,
                   MCX, MIN, MRL, MTX, NOM, NON, PRC, REC, REL, RPN, SCK,
                 SLB, SPH, SQL, TBL, VCX, VIN, VRL };                  SLB, SPH, SQL, TBL, VCX, VIN, VRL };
   
     /*      /*
     ADR : adresse sur 32 bits (au moins) non signés (unsigned long)      ADR : adresse sur 64 bits signés.
             Adresse d'une définition à interpréter.              Adresse d'une définition à interpréter.
   
     ALG : expression algébrique (struct_liste_chainee *)      ALG : expression algébrique (struct_liste_chainee *)
Line 635  enum t_type  { ADR = 0, ALG, BIN, CHN, C Line 1154  enum t_type  { ADR = 0, ALG, BIN, CHN, C
             Sans objet.              Sans objet.
             Type C/Fortran : unsigned integer8              Type C/Fortran : unsigned integer8
   
     CHN : chaine de caracteres (character*(*), unsigned char *)      CHN : chaine de caracteres (unsigned char *)
             Sans objet.              Sans objet.
   
     CPL : complexe sur 2*64 bits (complex*16, struct_complexe16 *)      CPL : complexe sur 2*64 bits (complex*16, struct_complexe16 *)
             Sans objet.              Sans objet.
             Type C/Fortran : complex16              Type C/Fortran : complex16
   
       EXT : type géré dans une bibliothèque externe.
   
     FCH : descripteur de fichier (struct_fichier *).      FCH : descripteur de fichier (struct_fichier *).
   
     FCT : déclaration d'une fonction et de son nombre d'arguments      FCT : déclaration d'une fonction et de son nombre d'arguments
Line 676  enum t_type  { ADR = 0, ALG, BIN, CHN, C Line 1197  enum t_type  { ADR = 0, ALG, BIN, CHN, C
     PRC : processus (struct_processus_fils *)      PRC : processus (struct_processus_fils *)
             Sans objet.              Sans objet.
   
       REC : enregistrement (struct_record *)
   
     REL : reel sur 64 bits (real*8, real8 *)      REL : reel sur 64 bits (real*8, real8 *)
             Sans objet.              Sans objet.
   
Line 707  enum t_type  { ADR = 0, ALG, BIN, CHN, C Line 1230  enum t_type  { ADR = 0, ALG, BIN, CHN, C
 typedef struct objet  typedef struct objet
 {  {
     enum t_type         type;      enum t_type         type;
       integer8            extension_type;
       void                *descripteur_bibliotheque;
   
     volatile long       nombre_occurrences;      volatile long       nombre_occurrences;
   
Line 725  typedef struct objet Line 1250  typedef struct objet
 #ifndef RPLARGS  #ifndef RPLARGS
 typedef struct fichier  typedef struct fichier
 {  {
     unsigned long               descripteur;      int                         descripteur;
   
     unsigned char               acces;          /* S/D/I */      unsigned char               acces;          /* S/D/I */
     unsigned char               binaire;        /* Y/N/F */      unsigned char               binaire;        /* Y/N/F */
Line 753  typedef struct fichier Line 1278  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
   
Line 817  typedef struct bibliotheque Line 1343  typedef struct bibliotheque
 #ifndef RPLARGS  #ifndef RPLARGS
 typedef struct descripteur_fichier  typedef struct descripteur_fichier
 {  {
     unsigned long               identifiant;      int                         identifiant;
   
     unsigned char               effacement;      unsigned char               effacement;
       unsigned char               type; // C (file *) ou S (sqlite *)
     unsigned char               *nom;      unsigned char               *nom;
   
     pid_t                       pid;      pid_t                       pid;
     pthread_t                   tid;      pthread_t                   tid;
   
     file                        *descripteur;      struct
       {
           file                    *descripteur_c;
           sqlite3                 *descripteur_sqlite;
       };
 } struct_descripteur_fichier;  } struct_descripteur_fichier;
 #endif  #endif
   
Line 858  typedef struct connecteur_sql Line 1389  typedef struct connecteur_sql
 #       ifdef POSTGRESQL_SUPPORT  #       ifdef POSTGRESQL_SUPPORT
             PGconn              *postgresql;              PGconn              *postgresql;
 #       endif  #       endif
           sqlite3                 *sqlite;
     } descripteur;      } descripteur;
 } struct_connecteur_sql;  } struct_connecteur_sql;
 #endif  #endif
Line 871  typedef struct connecteur_sql Line 1403  typedef struct connecteur_sql
             "POSTGRESQL") == 0) \              "POSTGRESQL") == 0) \
         postgresqlclose((*((struct_connecteur_sql *) (*s_objet).objet)) \          postgresqlclose((*((struct_connecteur_sql *) (*s_objet).objet)) \
                 .descripteur); \                  .descripteur); \
       else if (strcmp((*((struct_connecteur_sql *) (*s_objet).objet)).type, \
               "SQLITE") == 0) \
           sqlite3_close((*((struct_connecteur_sql *) (*s_objet).objet)) \
                   .descripteur.sqlite); \
     else \      else \
         BUG(1, uprintf("SQL type '%s' not allowed!", \          BUG(1, uprintf("SQL type '%s' not allowed!", \
                 (*((struct_connecteur_sql *) (*s_objet).objet)).type));                  (*((struct_connecteur_sql *) (*s_objet).objet)).type));
Line 882  typedef struct connecteur_sql Line 1418  typedef struct connecteur_sql
 */  */
   
 #ifndef RPLARGS  #ifndef RPLARGS
   
   #   define                      d_BIND_TO_DEVICE        0
   #   define                      d_BROADCAST             1
   #   define                      d_DONT_ROUTE            2
   #   define                      d_KEEP_ALIVE            3
   #   define                      d_PRIORITY              4
   #   define                      d_RECEIVE_BUFFER        5
   #   define                      d_FORCE_RECEIVE_BUFFER  6
   #   define                      d_SEND_BUFFER           7
   #   define                      d_FORCE_SEND_BUFFER     8
   #   define                      d_RECEIVING_TIMEOUT     9
   #   define                      d_SENDING_TIMEOUT       10
   #   define                      d_REUSE_ADDRESS         11
   
 typedef struct socket  typedef struct socket
 {  {
     int                         domaine;      int                         domaine;
Line 900  typedef struct socket Line 1450  typedef struct socket
     unsigned char               protection;      unsigned char               protection;
     unsigned char               type[19 + 1];      unsigned char               type[19 + 1];
   
       integer8                    options;
       int                         priorite;
       int                         buffer_reception;
       int                         buffer_emission;
       int                         timeout_emission;
       int                         timeout_reception;
   
     struct_objet                *format;      struct_objet                *format;
 } struct_socket;  } struct_socket;
 #endif  #endif
Line 920  typedef struct liste_chainee Line 1477  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 996  typedef struct descripteur_thread Line 1588  typedef struct descripteur_thread
   
     struct_objet                *argument;      struct_objet                *argument;
   
     pid_t                   pid;      pid_t                       pid;
     volatile pthread_t      tid;      volatile pthread_t          tid;
   
     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 1009  typedef struct descripteur_thread Line 1603  typedef struct descripteur_thread
     int                         pipe_injections[2];      int                         pipe_injections[2];
     int                         pipe_nombre_injections[2];      int                         pipe_nombre_injections[2];
     int                         pipe_interruptions[2];      int                         pipe_interruptions[2];
     int                         pipe_nombre_objets_attente[2];      //  pipe_nombre_elements_attente == 0 => initialisation ou terminaison
     int                         pipe_nombre_interruptions_attente[2];      //  pipe_nombre_elements_attente == 1 => objet en attente
       //  pipe_nombre_elements_attente == 2 => interruption en attente
       int                         pipe_nombre_elements_attente[2];
     int                         pipe_acquittement[2];      int                         pipe_acquittement[2];
   
     volatile integer8           nombre_objets_dans_pipe;      volatile integer8           nombre_objets_dans_pipe;
Line 1019  typedef struct descripteur_thread Line 1615  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 1043  typedef struct liste_pile_systeme Line 1636  typedef struct liste_pile_systeme
 {  {
     struct liste_pile_systeme   *suivant;      struct liste_pile_systeme   *suivant;
   
     struct_liste_chainee        *pointeur_objet_retour;  
   
     struct_objet                *indice_boucle;      struct_objet                *indice_boucle;
     struct_objet                *limite_indice_boucle;      struct_objet                *limite_indice_boucle;
     struct_objet                *objet_de_test;      struct_objet                *objet_de_test;
Line 1053  typedef struct liste_pile_systeme Line 1644  typedef struct liste_pile_systeme
     logical1                    creation_variables_statiques;      logical1                    creation_variables_statiques;
     logical1                    creation_variables_partagees;      logical1                    creation_variables_partagees;
     logical1                    evaluation_expression;      logical1                    evaluation_expression;
       logical1                    debug_programme;
   
     unsigned char               clause;      unsigned char               clause;
   
Line 1082  typedef struct liste_pile_systeme Line 1674  typedef struct liste_pile_systeme
   
     /*      /*
     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.
       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              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;      integer8                    adresse_retour;
     unsigned long               niveau_courant;      integer8                    niveau_courant;
       struct_liste_chainee        *pointeur_objet_retour;
 } struct_liste_pile_systeme;  } struct_liste_pile_systeme;
 #endif  #endif
   
Line 1110  typedef struct liste_pile_systeme Line 1706  typedef struct liste_pile_systeme
 #ifndef RPLARGS  #ifndef RPLARGS
 typedef union position_variable  typedef union position_variable
 {  {
     unsigned long       adresse;      integer8            adresse;
     struct_objet        *pointeur;      struct_objet        *pointeur;
 } union_position_variable;  } union_position_variable;
   
 typedef struct variable  typedef struct variable
 {  {
     unsigned char           *nom;      unsigned char           *nom;
     unsigned char           origine;      unsigned char           origine; // P(rogramme) ou E(valuation)
   
     unsigned long           niveau;      integer8                niveau;
   
     union_position_variable variable_statique;      union_position_variable variable_statique;
     union_position_variable variable_partagee;      union_position_variable variable_partagee;
Line 1144  typedef struct variable_partage Line 1740  typedef struct variable_partage
     unsigned char               *nom;      unsigned char               *nom;
     unsigned char               origine;      unsigned char               origine;
   
     unsigned long               niveau;      integer8                    niveau;
   
     union_position_variable     variable_partagee;      union_position_variable     variable_partagee;
   
     struct_objet                *objet;      struct_objet                *objet;
 } struct_variable_partagee;  
   
 typedef struct table_variables_partagees  
 {  
     pthread_mutex_t                     mutex;  
   
     volatile struct_variable_partagee   *table;      pthread_mutex_t             mutex;
   } struct_variable_partagee;
     volatile unsigned long              nombre_variables;  
     volatile unsigned long              nombre_variables_allouees;  
   
     unsigned long                       position_variable;  
 } struct_table_variables_partagees;  
   
 #endif  #endif
   
Line 1181  typedef struct variable_statique Line 1767  typedef struct variable_statique
     // 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;      integer8                niveau;
   
     union_position_variable variable_statique;      union_position_variable variable_statique;
   
Line 1198  typedef struct variable_statique Line 1784  typedef struct variable_statique
   
 typedef struct vecteur  typedef struct vecteur
 {  {
     unsigned long       taille;      integer8            taille;
   
     unsigned char       type; /* C (complex*16), R (real*8), I (integer*8) */      unsigned char       type; /* C (complex*16), R (real*8), I (integer*8) */
   
Line 1214  typedef struct vecteur Line 1800  typedef struct vecteur
   
 typedef struct matrice  typedef struct matrice
 {  {
     unsigned long       nombre_lignes;      integer8            nombre_lignes;
     unsigned long       nombre_colonnes;      integer8            nombre_colonnes;
   
     unsigned char       type; /* C (complex*16), R (real*8), I (integer*8) */      unsigned char       type; /* C (complex*16), R (real*8), I (integer*8) */
   
Line 1231  typedef struct matrice Line 1817  typedef struct matrice
   
 typedef struct tableau  typedef struct tableau
 {  {
     unsigned long       nombre_elements;      integer8            nombre_elements;
   
     struct_objet        **elements;      struct_objet        **elements;
 } struct_tableau;  } struct_tableau;
Line 1239  typedef struct tableau Line 1825  typedef struct tableau
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
     Structure enregistrement
   --------------------------------------------------------------------------------
   */
   
   typedef struct record
   {
       struct_objet        *noms;
       struct_objet        *donnees;
   } struct_record;
   
   
   /*
   --------------------------------------------------------------------------------
   Structure arbre    Structure arbre
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
 typedef struct arbre  typedef struct arbre
 {  {
     struct_objet        *objet;      struct_liste_chainee        *feuille;
   
     unsigned long       nombre_feuilles;      integer8                    nombre_branches;
     struct arbre        **feuilles;      struct arbre                **branches;
 } struct_arbre;  } struct_arbre;
   
   
Line 1263  typedef struct instruction_externe Line 1862  typedef struct instruction_externe
     unsigned char       *nom;      unsigned char       *nom;
     unsigned char       *nom_bibliotheque;      unsigned char       *nom_bibliotheque;
     void                *descripteur_bibliotheque;      void                *descripteur_bibliotheque;
       integer8            position_fleche;
 } struct_instruction_externe;  } struct_instruction_externe;
   
   
Line 1304  typedef struct rpl_arguments Line 1904  typedef struct rpl_arguments
     unsigned char               test_instruction;      unsigned char               test_instruction;
   
     integer8                    nombre_arguments;      integer8                    nombre_arguments;
     // Nombre d'arguments de la fonction, positif ou nul.      // Nombre d'arguments de la fonction
       // 0       : instruction infixe
       // positif : nombre d'arguments (notation algébrique possible)
       // -1      : notation algrébrique non autorisée
   
     void                        *s_etat_processus;      void                        *s_etat_processus;
 } struct_rpl_arguments;  } struct_rpl_arguments;
   
   /*
   --------------------------------------------------------------------------------
     Structure d'arbre des instructions intrinsèques
   --------------------------------------------------------------------------------
   */
   
   #ifndef RPLARGS
   typedef struct instruction
   {
       struct instruction      **noeuds;
       void                    (*feuille)(struct processus *);
   } struct_instruction;
   #endif
   
   /*
   --------------------------------------------------------------------------------
     Structure d'arbre des variables globales et locales
   --------------------------------------------------------------------------------
   */
   
   #ifndef RPLARGS
   typedef struct arbre_variables
   {
       unsigned int                        noeuds_utilises;
                                           // Nombre de noeuds utilisés dans le
                                           // tableau **noeuds
       signed int                          indice_tableau_pere;
                                           // Position de la structure dans le
                                           // tableau **noeuds du père
   
       struct arbre_variables              *noeud_pere;
       struct arbre_variables              **noeuds;
   
       struct liste_variables              *feuille;
       struct liste_variables_statiques    *feuille_statique;
   } struct_arbre_variables;
   
   typedef struct arbre_variables_partagees
   {
       unsigned int                        noeuds_utilises;
                                           // Nombre de noeuds utilisés dans le
                                           // tableau **noeuds
       signed int                          indice_tableau_pere;
                                           // Position de la structure dans le
                                           // tableau **noeuds du père
   
       struct arbre_variables_partagees    *noeud_pere;
       struct arbre_variables_partagees    **noeuds;
   
       struct liste_variables_partagees    *feuille;
   
       pthread_mutex_t                     mutex_feuille;
   } struct_arbre_variables_partagees;
   
   #define INITIALISATION_MUTEX(mutex) \
       do { \
           pthread_mutexattr_t     attributs_mutex; \
           pthread_mutexattr_init(&attributs_mutex); \
           pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_RECURSIVE); \
           pthread_mutex_init(&(mutex), &attributs_mutex); \
           pthread_mutexattr_destroy(&attributs_mutex); \
       } while(0)
   
   typedef struct tableau_variables
   {
       unsigned char           origine;
       unsigned char           *nom;       // pointeur sur la struct_variable
                                           // réelle et non copie de la chaîne
       integer8                niveau;
   
       struct_objet            *objet;     // pointeur sur l'objet et non copie
                                           // de l'objet.
   
       logical1                variable_verrouillee;
       logical1                variable_masquee;
       pthread_mutex_t         *mutex;
       union_position_variable variable_statique;
       union_position_variable variable_partagee;
   } struct_tableau_variables;
   
   // La liste des variables est une liste doublement chaînée et circulaire.
   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;
   
   // La liste des variables statiques et une liste double chaînée et non
   // circulaire.
   typedef struct liste_variables_statiques
   {
       struct liste_variables_statiques    *suivant;
       struct liste_variables_statiques    *precedent;
       struct liste_variables_statiques    *reference;
       struct_arbre_variables              *feuille;
       struct_variable_statique            *variable;
   } struct_liste_variables_statiques;
   
   typedef struct liste_variables_partagees
   {
       struct liste_variables_partagees    *suivant;
       struct liste_variables_partagees    *precedent;
       struct liste_variables_partagees    *reference;
       struct_arbre_variables_partagees    *feuille;
       struct_variable_partagee            *variable;
       pthread_t                           tid;
       pid_t                               pid;
   } struct_liste_variables_partagees;
   #endif
   
   
   /*
   --------------------------------------------------------------------------------
     Structure fonction
   --------------------------------------------------------------------------------
   */
   
   #ifndef RPLARGS
   typedef struct fonction
   {
       unsigned char                       *nom_fonction;
       integer8                            nombre_arguments;
   
       void                                (*fonction)(struct processus *);
   
       volatile struct_liste_chainee       *prediction_saut;
       volatile logical1                   prediction_execution;
   } struct_fonction;
   #endif
   
   
   /*
   --------------------------------------------------------------------------------
     Structure buffer
   --------------------------------------------------------------------------------
   */
   
   typedef struct buffer
   {
       unsigned char                       *buffer;
   
       size_t                              longueur_requise;
       int                                 classe;
   } struct_buffer;
   
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
Line 1331  typedef struct processus Line 2089  typedef struct processus
     unsigned char               *nom_fichier_source;      unsigned char               *nom_fichier_source;
     unsigned char               *nom_fichier_historique;      unsigned char               *nom_fichier_historique;
   
       unsigned char               autorisation_conversion_chaine;     /*Y/N*/
     unsigned char               autorisation_empilement_programme;  /*Y/N*/      unsigned char               autorisation_empilement_programme;  /*Y/N*/
     unsigned char               autorisation_evaluation_nom;        /*Y/N*/      unsigned char               autorisation_evaluation_nom;        /*Y/N*/
       unsigned char               autorisation_nom_implicite;         /*Y/N*/
     unsigned char               evaluation_forcee;                  /*Y/N*/      unsigned char               evaluation_forcee;                  /*Y/N*/
     unsigned char               instruction_valide;                 /*Y/N*/      unsigned char               instruction_valide;                 /*Y/N*/
     unsigned char               instruction_intrinseque;            /*Y/I/N*/      unsigned char               instruction_intrinseque;            /*Y/I/N*/
       unsigned char               instruction_sensible;               /*Y/N*/
     unsigned char               test_instruction;                   /*Y/N*/      unsigned char               test_instruction;                   /*Y/N*/
     unsigned char               affichage_arguments;                /*Y/N*/      unsigned char               affichage_arguments;                /*Y/N*/
     unsigned char               constante_symbolique;               /*Y/N*/      unsigned char               constante_symbolique;               /*Y/N*/
Line 1344  typedef struct processus Line 2105  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;      integer8                    position_courante;
     unsigned long               longueur_definitions_chainees;      integer8                    longueur_definitions_chainees;
   
 /* Pointeurs sur les instructions                       */  /* Pointeurs sur les instructions                       */
   
     int                         *pointeurs_caracteres;      int                         *pointeurs_caracteres;
     int                         nombre_caracteres;      int                         nombre_caracteres;
     struct instruction          *arbre_instructions;      struct_instruction          *arbre_instructions;
   
 /* Requetes                                             */  /* Requetes                                             */
   
Line 1363  typedef struct processus Line 2125  typedef struct processus
     struct_liste_chainee        *l_base_pile;      struct_liste_chainee        *l_base_pile;
     struct_liste_chainee        *l_base_pile_last;      struct_liste_chainee        *l_base_pile_last;
   
     unsigned long               hauteur_pile_operationnelle;      integer8                    hauteur_pile_operationnelle;
   
 /* Piles systemes                                       */  /* Piles systemes                                       */
   
     struct_liste_pile_systeme   *l_base_pile_systeme;      struct_liste_pile_systeme   *l_base_pile_systeme;
   
     unsigned long               hauteur_pile_systeme;      integer8                    hauteur_pile_systeme;
   
 /* Gestion des processus                                */  /* Gestion des processus                                */
   
Line 1383  typedef struct processus Line 2145  typedef struct processus
     int                         pipe_injections;      int                         pipe_injections;
     int                         pipe_nombre_injections;      int                         pipe_nombre_injections;
     int                         pipe_interruptions;      int                         pipe_interruptions;
     int                         pipe_nombre_objets_attente;      int                         pipe_nombre_elements_attente;
     int                         pipe_nombre_interruptions_attente;  
     int                         nombre_objets_envoyes_non_lus;      int                         nombre_objets_envoyes_non_lus;
     int                         nombre_objets_injectes;      int                         nombre_objets_injectes;
   
Line 1394  typedef struct processus Line 2155  typedef struct processus
     logical1                    presence_fusible;      logical1                    presence_fusible;
     pthread_t                   thread_fusible;      pthread_t                   thread_fusible;
     pthread_t                   thread_surveille_par_fusible;      pthread_t                   thread_surveille_par_fusible;
       pthread_t                   thread_signaux;
       int                         pipe_signaux[2];
   
     stack_t                     pile_signal;      volatile int                pointeur_signal_ecriture;
       volatile int                pointeur_signal_lecture;
       volatile enum signaux_rpl   signaux_en_queue[LONGUEUR_QUEUE_SIGNAUX];
       volatile logical1           demarrage_fils;
       volatile logical1           redemarrage_processus;
   
 /* Contextes                                            */  /* Contextes                                            */
   
Line 1404  typedef struct processus Line 2171  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
     struct_variable_statique    *s_liste_variables_statiques;      // sur la liste des variables globales.
     unsigned long               nombre_variables_statiques;      //
     unsigned long               nombre_variables_statiques_allouees;      // À l'initialisation :
       // l_liste_variables_par_niveau->suivant == l_liste_variables_par_niveau
     struct_table_variables_partagees      // l_liste_variables_par_niveau->precedent == l_liste_variables_par_niveau
                                 *s_liste_variables_partagees;  
       struct_arbre_variables      *s_arbre_variables;
     unsigned long               niveau_courant;      struct_liste_variables      *l_liste_variables_par_niveau;
     unsigned long               niveau_initial;      struct_liste_variables_statiques
     unsigned long               position_variable_courante;                                  *l_liste_variables_statiques;
     unsigned long               position_variable_statique_courante;  
       struct_arbre_variables_partagees
                                   **s_arbre_variables_partagees;
       struct_liste_variables_partagees
                                   **l_liste_variables_partagees;
   
       logical1                    niveau_supprime;
   
       struct_variable             *pointeur_variable_courante;
       struct_liste_variables      *pointeur_feuille_courante;
       struct_variable_statique    *pointeur_variable_statique_courante;
       struct_variable_partagee    *pointeur_variable_partagee_courante;
   
       int                         *pointeurs_caracteres_variables;
       int                         nombre_caracteres_variables;
   
       integer8                    niveau_courant;
       integer8                    niveau_initial;
   
     logical1                    creation_variables_statiques;      logical1                    creation_variables_statiques;
     logical1                    creation_variables_partagees;      logical1                    creation_variables_partagees;
Line 1440  typedef struct processus Line 2224  typedef struct processus
   
     struct_liste_chainee        *s_bibliotheques;      struct_liste_chainee        *s_bibliotheques;
     struct_instruction_externe  *s_instructions_externes;      struct_instruction_externe  *s_instructions_externes;
     unsigned long               nombre_instructions_externes;      integer8                    nombre_instructions_externes;
   
 /* Fichier d'impression                                 */  /* Fichier d'impression                                 */
   
Line 1590  typedef struct processus Line 2374  typedef struct processus
 /* Traitement des exceptions                            */  /* Traitement des exceptions                            */
   
     logical1                    arret_si_exception;      logical1                    arret_si_exception;
     unsigned int                exception;      int                         exception;
     unsigned int                derniere_exception;      int                         derniere_exception;
     unsigned int                exception_processus_fils;      int                         exception_processus_fils;
   
 /* Traitement des erreurs                               */  /* Traitement des erreurs                               */
   
     unsigned int                erreur_compilation;      int                         erreur_compilation;
     unsigned int                erreur_execution;      volatile int                erreur_execution;
     unsigned int                erreur_systeme;      volatile int                erreur_systeme;
   
     struct_objet                *s_objet_errone;      struct_objet                *s_objet_errone;
     struct_objet                *s_objet_erreur;      struct_objet                *s_objet_erreur;
   
     logical1                    erreur_scrutation;      logical1                    erreur_scrutation;
   
     volatile unsigned int       erreur_systeme_processus_fils;      volatile int                erreur_systeme_processus_fils;
     unsigned int                erreur_execution_processus_fils;      int                         erreur_execution_processus_fils;
   
     pid_t                       pid_erreur_processus_fils;      pid_t                       pid_erreur_processus_fils;
   
Line 1614  typedef struct processus Line 2398  typedef struct processus
   
     integer8                    derniere_erreur_fonction_externe;      integer8                    derniere_erreur_fonction_externe;
   
     unsigned int                derniere_erreur_systeme;      int                         derniere_erreur_systeme;
     unsigned int                derniere_erreur_execution;      int                         derniere_erreur_execution;
     unsigned int                derniere_erreur_evaluation;      int                         derniere_erreur_evaluation;
   
     unsigned char               *instruction_derniere_erreur;      unsigned char               *instruction_derniere_erreur;
   
     unsigned long               niveau_derniere_erreur;      integer8                    niveau_derniere_erreur;
   
     logical1                    core;      logical1                    core;
     logical1                    invalidation_message_erreur;      logical1                    invalidation_message_erreur;
Line 1628  typedef struct processus Line 2412  typedef struct processus
 /* Debug                                                */  /* Debug                                                */
   
     logical1                    debug;      logical1                    debug;
     integer8                    type_debug;      logical8                    type_debug;
     logical1                    debug_programme;      logical1                    debug_programme;
     logical1                    execution_pas_suivant;      logical1                    execution_pas_suivant;
     logical1                    traitement_instruction_halt;      logical1                    traitement_instruction_halt;
Line 1653  typedef struct processus Line 2437  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                                  */
   
Line 1664  typedef struct processus Line 2452  typedef struct processus
     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                                               */
   
       char                        *rpl_home;
   
     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;
   
     /*      /*
Line 1692  typedef struct processus Line 2487  typedef struct processus
     unsigned char               retour_routine_evaluation;      unsigned char               retour_routine_evaluation;
     unsigned char               *localisation;      unsigned char               *localisation;
   
     unsigned long               niveau_recursivite;      integer8                    niveau_recursivite;
   
     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;
   
       enum t_type                 type_en_cours;
   
 /* Profilage                                            */  /* Profilage                                            */
   
     logical1                    profilage;      logical1                    profilage;
Line 1707  typedef struct processus Line 2505  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      pthread_mutex_t             mutex_allocation;
     pthread_mutex_t             mutex;      pthread_mutex_t             mutex_allocation_buffer;
       pthread_mutex_t             mutex_interruptions;
       pthread_mutex_t             mutex_pile_processus;
       pthread_mutex_t             mutex_signaux;
   
     // 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;
   
   /* Variable d'initialisation pour SCHED             */
   
       logical1                    initialisation_scheduler;
   
   /* Drapeau nécessaire à RESTART                     */
   
       volatile logical1           requete_redemarrage;
   
 /* Gestion optimisée de la mémoire                  */  /* Gestion optimisée de la mémoire                  */
   
     double                      estimation_taille_pile_tampon;      double                      estimation_taille_pile_tampon;
     unsigned long               taille_pile_tampon;      integer8                    taille_pile_tampon;
     struct_liste_chainee        *pile_tampon;      struct_liste_chainee        *pile_tampon;
   
     double                      estimation_taille_pile_systeme_tampon;      double                      estimation_taille_pile_systeme_tampon;
     unsigned long               taille_pile_systeme_tampon;      integer8                    taille_pile_systeme_tampon;
     struct_liste_pile_systeme   *pile_systeme_tampon;      struct_liste_pile_systeme   *pile_systeme_tampon;
   
     unsigned long               taille_pile_objets;      integer8                    taille_pile_objets;
     struct_objet                *pile_objets;      struct_objet                *pile_objets;
   
 #   define TAILLE_CACHE 1024  #   define TAILLE_CACHE         1024
   #   define CACHE(type, nom) \
     unsigned long               *objets_adr[TAILLE_CACHE];      type                        *objets_##nom[TAILLE_CACHE]; \
     int                         pointeur_adr;      volatile int                pointeur_##nom;
   
     logical8                    *objets_bin[TAILLE_CACHE];  #   define CACHE2(type, nom) \
     int                         pointeur_bin;      type                        *nom[TAILLE_CACHE]; \
       volatile int                pointeur_##nom;
     complex16                   *objets_cpl[TAILLE_CACHE];  
     int                         pointeur_cpl;      CACHE(integer8, adr)
       CACHE(logical8, bin)
     struct fonction             *objets_fct[TAILLE_CACHE];      CACHE(complex16, cpl)
     int                         pointeur_fct;      CACHE(struct_fonction, fct)
       CACHE(integer8, int)
     integer8                    *objets_int[TAILLE_CACHE];      CACHE(struct_matrice, mat)
     int                         pointeur_int;      CACHE(struct_nom, nom)
       CACHE(struct_record, rec)
     struct_matrice              *objets_mat[TAILLE_CACHE];      CACHE(real8, rel)
     int                         pointeur_mat;      CACHE(struct_tableau, tab)
       CACHE(struct_vecteur, vec)
     struct_nom                  *objets_nom[TAILLE_CACHE];  
     int                         pointeur_nom;      CACHE2(struct_liste_chainee, maillons)
       CACHE2(struct_arbre_variables, variables_noeud)
     real8                       *objets_rel[TAILLE_CACHE];      CACHE2(struct_arbre_variables_partagees, variables_partagees_noeud)
     int                         pointeur_rel;      CACHE2(struct_liste_variables, variables_feuille)
       CACHE2(struct_variable, variables_variable)
     struct_tableau              *objets_tab[TAILLE_CACHE];      CACHE2(struct_arbre_variables *, variables_tableau_noeuds)
     int                         pointeur_tab;      CACHE2(struct_arbre_variables_partagees *,
               variables_tableau_noeuds_partages)
     struct_vecteur              *objets_vec[TAILLE_CACHE];  
     int                         pointeur_vec;      CACHE2(struct_buffer, enveloppes_buffers)
       unsigned char               ***cache_buffer;
     struct_liste_chainee        *maillons[TAILLE_CACHE];      int                         *pointeur_cache_buffer;
     int                         pointeur_maillons;  
 } struct_processus;  } struct_processus;
 #endif  #endif
   
 /*  #ifdef DEBUG_MEMOIRE
 --------------------------------------------------------------------------------  pid_t debug_fork(struct_processus *s_etat_processus);
   Structures instruction intrinseque  
 --------------------------------------------------------------------------------  
 */  
   
 #ifndef RPLARGS  
 typedef struct instruction  
 {  
     struct instruction      **noeud;  
     void                    (*feuille)(struct_processus *);  
 } struct_instruction;  
 #endif  #endif
   
   
 /*  /*
 --------------------------------------------------------------------------------  ================================================================================
   Structure fonction    MISE EN PLACE DE L'ALLOCATEUR SPÉCIFIQUE
 --------------------------------------------------------------------------------  ================================================================================*/
 */  
   
 #ifndef RPLARGS  #ifndef DEBUG_MEMOIRE
 typedef struct fonction  #   define malloc(a)            rpl_malloc(s_etat_processus, a)
 {  #   define realloc(a, b)        rpl_realloc(s_etat_processus, a, b)
     unsigned char                       *nom_fonction;  #   define free(a)              rpl_free(s_etat_processus, a)
     unsigned long                       nombre_arguments;  #endif
   
     void                                (*fonction)(struct_processus *);  void *rpl_malloc(struct_processus *s_etat_processus, size_t s);
   void *rpl_realloc(struct_processus *s_etat_processus, void *ptr, size_t s);
   void rpl_free(struct_processus *s_etat_processus, void *ptr);
   void *sys_malloc(size_t s);
   void *sys_realloc(void *ptr, size_t s);
   void sys_free(void *ptr);
   
     volatile struct_liste_chainee       *prediction_saut;  /*
     volatile logical1                   prediction_execution;   * Wrapper de readline() pour que la fonction renvoie un pointeur sur un
 } struct_fonction;   * buffer alloué par rpl_malloc().
 #endif   */
   
   #define readline(s) readline_wrapper(s_etat_processus, s)
   unsigned char *readline_wrapper(struct_processus *s_etat_processus,
           unsigned char *s);
   
   
 /*  /*
Line 1818  typedef struct fonction Line 2625  typedef struct fonction
 // 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 1835  void instruction_asl(struct_processus *s Line 2643  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 1850  void instruction_ceil(struct_processus * Line 2661  void instruction_ceil(struct_processus *
 void instruction_centr(struct_processus *s_etat_processus);  void instruction_centr(struct_processus *s_etat_processus);
 void instruction_cf(struct_processus *s_etat_processus);  void instruction_cf(struct_processus *s_etat_processus);
 void instruction_chr(struct_processus *s_etat_processus);  void instruction_chr(struct_processus *s_etat_processus);
   void instruction_cipher(struct_processus *s_etat_processus);
 void instruction_clear(struct_processus *s_etat_processus);  void instruction_clear(struct_processus *s_etat_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);
 void instruction_clrmtx(struct_processus *s_etat_processus);  void instruction_clrmtx(struct_processus *s_etat_processus);
   void instruction_clrsock(struct_processus *s_etat_processus);
 void instruction_clrsmphr(struct_processus *s_etat_processus);  void instruction_clrsmphr(struct_processus *s_etat_processus);
 void instruction_clrswi(struct_processus *s_etat_processus);  void instruction_clrswi(struct_processus *s_etat_processus);
 void instruction_cls(struct_processus *s_etat_processus);  void instruction_cls(struct_processus *s_etat_processus);
Line 1868  void instruction_col_fleche(struct_proce Line 2683  void instruction_col_fleche(struct_proce
 void instruction_col_moins(struct_processus *s_etat_processus);  void instruction_col_moins(struct_processus *s_etat_processus);
 void instruction_col_plus(struct_processus *s_etat_processus);  void instruction_col_plus(struct_processus *s_etat_processus);
 void instruction_comb(struct_processus *s_etat_processus);  void instruction_comb(struct_processus *s_etat_processus);
   void instruction_compress(struct_processus *s_etat_processus);
 void instruction_con(struct_processus *s_etat_processus);  void instruction_con(struct_processus *s_etat_processus);
 void instruction_cond(struct_processus *s_etat_processus);  void instruction_cond(struct_processus *s_etat_processus);
 void instruction_cont(struct_processus *s_etat_processus);  void instruction_cont(struct_processus *s_etat_processus);
Line 1882  void instruction_cosh(struct_processus * Line 2698  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 1907  void instruction_detach(struct_processus Line 2724  void instruction_detach(struct_processus
 void instruction_dft(struct_processus *s_etat_processus);  void instruction_dft(struct_processus *s_etat_processus);
 void instruction_dgtiz(struct_processus *s_etat_processus);  void instruction_dgtiz(struct_processus *s_etat_processus);
 void instruction_diag_fleche(struct_processus *s_etat_processus);  void instruction_diag_fleche(struct_processus *s_etat_processus);
   void instruction_digest(struct_processus *s_etat_processus);
 void instruction_disp(struct_processus *s_etat_processus);  void instruction_disp(struct_processus *s_etat_processus);
 void instruction_division(struct_processus *s_etat_processus);  void instruction_division(struct_processus *s_etat_processus);
 void instruction_do(struct_processus *s_etat_processus);  void instruction_do(struct_processus *s_etat_processus);
Line 1933  void instruction_elseif(struct_processus Line 2751  void instruction_elseif(struct_processus
 void instruction_end(struct_processus *s_etat_processus);  void instruction_end(struct_processus *s_etat_processus);
 void instruction_eng(struct_processus *s_etat_processus);  void instruction_eng(struct_processus *s_etat_processus);
 void instruction_epsilon(struct_processus *s_etat_processus);  void instruction_epsilon(struct_processus *s_etat_processus);
   void instruction_eqv(struct_processus *s_etat_processus);
 void instruction_erase(struct_processus *s_etat_processus);  void instruction_erase(struct_processus *s_etat_processus);
 void instruction_errm(struct_processus *s_etat_processus);  void instruction_errm(struct_processus *s_etat_processus);
 void instruction_errn(struct_processus *s_etat_processus);  void instruction_errn(struct_processus *s_etat_processus);
Line 1966  void instruction_fleche_str(struct_proce Line 2785  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 2004  void instruction_ifft(struct_processus * Line 2824  void instruction_ifft(struct_processus *
 void instruction_ift(struct_processus *s_etat_processus);  void instruction_ift(struct_processus *s_etat_processus);
 void instruction_ifte(struct_processus *s_etat_processus);  void instruction_ifte(struct_processus *s_etat_processus);
 void instruction_im(struct_processus *s_etat_processus);  void instruction_im(struct_processus *s_etat_processus);
   void instruction_implicit(struct_processus *s_etat_processus);
 void instruction_in(struct_processus *s_etat_processus);  void instruction_in(struct_processus *s_etat_processus);
 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 2031  void instruction_lcd_fleche(struct_proce Line 2853  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 2044  void instruction_lq(struct_processus *s_ Line 2867  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 2052  void instruction_maxs(struct_processus * Line 2876  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 2062  void instruction_mtxtrylock(struct_proce Line 2888  void instruction_mtxtrylock(struct_proce
 void instruction_mtxunlock(struct_processus *s_etat_processus);  void instruction_mtxunlock(struct_processus *s_etat_processus);
 void instruction_multiplication(struct_processus *s_etat_processus);  void instruction_multiplication(struct_processus *s_etat_processus);
   
   void instruction_nbrcpus(struct_processus *s_etat_prorcessus);
 void instruction_ne(struct_processus *s_etat_processus);  void instruction_ne(struct_processus *s_etat_processus);
 void instruction_neg(struct_processus *s_etat_processus);  void instruction_neg(struct_processus *s_etat_processus);
 void instruction_next(struct_processus *s_etat_processus);  void instruction_next(struct_processus *s_etat_processus);
Line 2096  void instruction_pmax(struct_processus * Line 2923  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 2106  void instruction_print(struct_processus Line 2934  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 2149  void instruction_rdz(struct_processus *s Line 2978  void instruction_rdz(struct_processus *s
 void instruction_re(struct_processus *s_etat_processus);  void instruction_re(struct_processus *s_etat_processus);
 void instruction_read(struct_processus *s_etat_processus);  void instruction_read(struct_processus *s_etat_processus);
 void instruction_recode(struct_processus *s_etat_processus);  void instruction_recode(struct_processus *s_etat_processus);
   void instruction_record(struct_processus *s_etat_processus);
 void instruction_recv(struct_processus *s_etat_processus);  void instruction_recv(struct_processus *s_etat_processus);
 void instruction_redraw(struct_processus *s_etat_processus);  void instruction_redraw(struct_processus *s_etat_processus);
   void instruction_regex(struct_processus *s_etat_processus);
 void instruction_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 2162  void instruction_return(struct_processus Line 2994  void instruction_return(struct_processus
 void instruction_revlist(struct_processus *s_etat_processus);  void instruction_revlist(struct_processus *s_etat_processus);
 void instruction_rewind(struct_processus *s_etat_processus);  void instruction_rewind(struct_processus *s_etat_processus);
 void instruction_rfuse(struct_processus *s_etat_processus);  void instruction_rfuse(struct_processus *s_etat_processus);
   void instruction_rgdl(struct_processus *s_etat_processus);
   void instruction_rgdr(struct_processus *s_etat_processus);
 void instruction_rl(struct_processus *s_etat_processus);  void instruction_rl(struct_processus *s_etat_processus);
 void instruction_rlb(struct_processus *s_etat_processus);  void instruction_rlb(struct_processus *s_etat_processus);
 void instruction_rnd(struct_processus *s_etat_processus);  void instruction_rnd(struct_processus *s_etat_processus);
Line 2219  void instruction_sqlquery(struct_process Line 3053  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 2276  void instruction_trn(struct_processus *s Line 3111  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_uncompress(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 2330  void instruction_yield(struct_processus Line 3166  void instruction_yield(struct_processus
 #ifndef RPLARGS  #ifndef RPLARGS
 void affectation_interruptions_logicielles(struct_processus *s_etat_processus);  void affectation_interruptions_logicielles(struct_processus *s_etat_processus);
 void affichage_pile(struct_processus *s_etat_processus,  void affichage_pile(struct_processus *s_etat_processus,
         struct_liste_chainee *l_element_courant, unsigned long          struct_liste_chainee *l_element_courant, integer8 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(struct_processus *s_etat_processus,
           unsigned char **element, unsigned char *fonction);
 void conversion_format(struct_processus *s_etat_processus,  void conversion_format(struct_processus *s_etat_processus,
         unsigned char *chaine);          unsigned char *chaine);
 void conversion_hms_vers_decimal(real8 *angle);  void conversion_hms_vers_decimal(real8 *angle);
   void conversion_majuscule_limitee(
           unsigned char *chaine_entree, unsigned char *chaine_sortie,
           integer8 longueur);
 void conversion_radians_vers_degres(real8 *angle);  void conversion_radians_vers_degres(real8 *angle);
   void copie_arbre_variables(struct_processus *s_etat_processus,
           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 depilement_pile_systeme(struct_processus *s_etat_processus);  void depilement_pile_systeme(struct_processus *s_etat_processus);
Line 2362  void determinant(struct_processus *s_eta Line 3204  void determinant(struct_processus *s_eta
         void *valeur);          void *valeur);
 void deverrouillage_threads_concurrents(struct_processus *s_etat_processus);  void deverrouillage_threads_concurrents(struct_processus *s_etat_processus);
 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, integer8 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, integer8 duree);
 void evaluation_romberg(struct_processus *s_etat_processus,  void evaluation_romberg(struct_processus *s_etat_processus,
         struct_objet *s_expression, unsigned char *variable, real8 *point,          struct_objet *s_expression, unsigned char *variable, real8 *point,
         real8 *valeur, logical1 *validite);          real8 *valeur, logical1 *validite);
Line 2386  void formateur_elementaire_tex(struct_pr Line 3229  void formateur_elementaire_tex(struct_pr
         file *fichier, struct_objet *s_objet, unsigned char environnement);          file *fichier, struct_objet *s_objet, unsigned char environnement);
 void impression_pile(struct_processus *s_etat_processus,  void impression_pile(struct_processus *s_etat_processus,
             struct_liste_chainee *l_element_courant,              struct_liste_chainee *l_element_courant,
             unsigned char methode, unsigned long niveau_courant);              unsigned char methode, integer8 niveau_courant);
 void impression_tex(struct_processus *s_etat_processus);  void impression_tex(struct_processus *s_etat_processus);
 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, integer8 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 2407  void insertion_thread_surveillance(struc Line 3252  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);  #ifdef HAVE_SIGSEGV_RECOVERY
 void interruption10(int signal, siginfo_t *siginfo, void *context);      void interruption_depassement_pile(int urgence,
               stackoverflow_context_t scp);
   #endif
 void inversion_matrice(struct_processus *s_etat_processus,  void inversion_matrice(struct_processus *s_etat_processus,
         struct_matrice *s_matrice);          struct_matrice *s_matrice);
 void lancement_daemon(struct_processus *s_etat_processus);  void lancement_daemon(struct_processus *s_etat_processus);
Line 2431  void liberation_maillon(struct_processus Line 3278  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_arbre_variables_partagees(struct_processus *s_etat_processus,
           struct_arbre_variables_partagees *arbre);
   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_mutexes_arbre_variables_partagees(struct_processus
           *s_etat_processus, struct_arbre_variables_partagees *l_element_courant);
 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);
 void localisation_courante(struct_processus *s_etat_processus);  void localisation_courante(struct_processus *s_etat_processus);
Line 2447  void retrait_thread(struct_processus *s_ Line 3301  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, integer8 taille_octets);
   void *thread_signaux(void *argument);
   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);
 void traitement_interruptions_logicielles(struct_processus *s_etat_processus);  void traitement_interruptions_logicielles(struct_processus *s_etat_processus);
 void tri_base_symboles_externes(struct_processus *s_etat_processus);  void tri_base_symboles_externes(struct_processus *s_etat_processus);
 void tri_vecteur(real8 *vecteur, unsigned long taille);  void tri_vecteur(real8 *vecteur, integer8 taille);
 void valeurs_propres(struct_processus *s_etat_processus,  void valeurs_propres(struct_processus *s_etat_processus,
         struct_matrice *s_matrice,          struct_matrice *s_matrice,
         struct_vecteur *s_valeurs_propres,          struct_vecteur *s_valeurs_propres,
Line 2476  void verrouillage_threads_concurrents(st Line 3337  void verrouillage_threads_concurrents(st
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
     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,
           logical1 test_ouverture);
   int envoi_signal_thread(struct_processus *s_etat_processus,
           pthread_t tid, enum signaux_rpl signal);
   #endif
   
   /*
   --------------------------------------------------------------------------------
   Fonctions de sommation de vecteur dans perte de précision    Fonctions de sommation de vecteur dans perte de précision
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
 real8 sommation_vecteur_reel(real8 *vecteur, unsigned long *taille,  real8 sommation_vecteur_reel(real8 *vecteur, integer8 *taille,
         logical1 *erreur_memoire);          logical1 *erreur_memoire);
 complex16 sommation_vecteur_complexe(complex16 *vecteur, unsigned long *taille,  complex16 sommation_vecteur_complexe(complex16 *vecteur, integer8 *taille,
         logical1 *erreur_memoire);          logical1 *erreur_memoire);
   
 /*  /*
Line 2492  complex16 sommation_vecteur_complexe(com Line 3371  complex16 sommation_vecteur_complexe(com
 */  */
   
 #ifndef RPLARGS  #ifndef RPLARGS
 int rplinit(int argc, char *argv[], unsigned char ***resultats);  int rplinit(int argc, char *argv[], char *envp[],
           unsigned char ***resultats, char *rpl_home);
 #endif  #endif
   
 /*  /*
Line 2503  int rplinit(int argc, char *argv[], unsi Line 3383  int rplinit(int argc, char *argv[], unsi
   
 #ifndef RPLARGS  #ifndef RPLARGS
 real8 correlation_statistique(struct_matrice *s_matrice,  real8 correlation_statistique(struct_matrice *s_matrice,
         unsigned long colonne_1, unsigned long colonne_2, logical1 *erreur);          integer8 colonne_1, integer8 colonne_2, logical1 *erreur);
 real8 covariance_statistique(struct_matrice *s_matrice,  real8 covariance_statistique(struct_matrice *s_matrice,
         unsigned long colonne_1, unsigned long colonne_2,          integer8 colonne_1, integer8 colonne_2,
         unsigned char type, logical1 *erreur);          unsigned char type, logical1 *erreur);
 struct_vecteur *ecart_type_statistique(struct_matrice *s_matrice,  struct_vecteur *ecart_type_statistique(struct_processus *s_etat_processus,
         unsigned char type);          struct_matrice *s_matrice, unsigned char type);
 struct_vecteur *moyenne_statistique(struct_matrice *s_matrice);  struct_vecteur *moyenne_statistique(struct_processus *s_etat_processus,
 struct_vecteur *sommation_colonne_statistique(struct_matrice *s_matrice,          struct_matrice *s_matrice);
         unsigned long colonne);  struct_vecteur *sommation_colonne_statistique(
 struct_vecteur *sommation_produits_colonnes_statistiques(struct_matrice          struct_processus *s_etat_processus, struct_matrice *s_matrice,
         *s_matrice, unsigned long colonne_1, unsigned long colonne_2);          integer8 colonne);
 struct_vecteur *sommation_statistique(struct_matrice *s_matrice);  struct_vecteur *sommation_produits_colonnes_statistiques(
 struct_vecteur *variance_statistique(struct_matrice *s_matrice,          struct_processus *s_etat_processus, struct_matrice
         unsigned char type);          *s_matrice, integer8 colonne_1, integer8 colonne_2);
   struct_vecteur *sommation_statistique(struct_processus *s_etat_processus,
           struct_matrice *s_matrice);
   struct_vecteur *variance_statistique(struct_processus *s_etat_processus,
           struct_matrice *s_matrice, unsigned char type);
 #endif  #endif
   
 /*  /*
Line 2539  struct_liste_chainee *depilement_pile_op Line 3423  struct_liste_chainee *depilement_pile_op
 struct_liste_chainee *empilement_pile_operationnelle(struct_rpl_arguments  struct_liste_chainee *empilement_pile_operationnelle(struct_rpl_arguments
         *s_rpl_arguments, struct_objet *s_objet);          *s_rpl_arguments, struct_objet *s_objet);
 struct_liste_chainee *sauvegarde_arguments(struct_rpl_arguments  struct_liste_chainee *sauvegarde_arguments(struct_rpl_arguments
         *s_rpl_arguments, unsigned long nombre_arguments);          *s_rpl_arguments, integer8 nombre_arguments);
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
Line 2550  struct_liste_chainee *sauvegarde_argumen Line 3434  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 *recherche_chemin_fichiers_temporaires(struct_processus  #endif
         *s_etat_processus);  unsigned char *analyse_flux(struct_processus *s_etat_processus,
 unsigned char *compactage(unsigned char *chaine);          unsigned char *flux, integer8 longueur);
 unsigned char *conversion_majuscule(unsigned char *chaine);  #ifndef RPLARGS
   unsigned char *chiffrement(struct_processus *s_etat_processus,
           const EVP_CIPHER *type_chiffrement,
           logical1 encodage, unsigned char *message, integer8 longueur_message,
           unsigned char *clef, integer8 longueur_clef,
           unsigned char *vecteur_initialisation,
           integer8 *longueur_message_chiffre,
           unsigned char padding);
   unsigned char *compactage(struct_processus *s_etat_processus,
           unsigned char *chaine);
   unsigned char *conversion_majuscule(struct_processus *s_etat_processus,
           unsigned char *chaine);
 unsigned char *creation_nom_fichier(struct_processus *s_etat_processus,  unsigned char *creation_nom_fichier(struct_processus *s_etat_processus,
         unsigned char *chemin);          unsigned char *chemin);
 unsigned char *extraction_chaine(unsigned char *chaine, unsigned long i,  unsigned char *date_compilation(struct_processus *s_etat_processus);
         unsigned long j);  unsigned char *extraction_chaine(struct_processus *s_etat_processus,
           unsigned char *chaine, integer8 i, integer8 j);
 unsigned char *formateur(struct_processus *s_etat_processus, long offset,  unsigned char *formateur(struct_processus *s_etat_processus, long offset,
         struct_objet *s_objet);          struct_objet *s_objet);
 unsigned char *formateur_fichier(struct_processus *s_etat_processus,  unsigned char *formateur_fichier(struct_processus *s_etat_processus,
         struct_objet *s_objet, struct_objet *s_format,          struct_objet *s_objet, struct_objet *s_format,
         long longueur, long longueur_champ, unsigned char format,          integer8 longueur, integer8 longueur_champ, unsigned char format,
         unsigned char type, long *longueur_effective, long *recursivite);          unsigned char type, integer8 *longueur_effective, integer8 *recursivite,
           logical1 export_fichier);
   #endif
   unsigned char *formateur_flux(struct_processus *s_etat_processus,
           unsigned char *donnees, integer8 *longueur);
   #ifndef RPLARGS
 unsigned char *formateur_fichier_nombre(struct_processus *s_etat_processus,  unsigned char *formateur_fichier_nombre(struct_processus *s_etat_processus,
         void *valeur_numerique, unsigned char type,          void *valeur_numerique, unsigned char type,
         long longueur, long longueur_champ, unsigned char format);          integer8 longueur, integer8 longueur_champ, unsigned char format);
   unsigned char *formateur_fichier_binaire_nombre(struct_processus
           *s_etat_processus, void *valeur_numerique, unsigned char type_entree,
           unsigned char type, integer8 longueur, integer8 *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);          integer8 longueur, integer8 longueur_champ, unsigned char format);
 unsigned char *formateur_nombre(struct_processus *s_etat_processus,  unsigned char *formateur_nombre(struct_processus *s_etat_processus,
         void *valeur_numerique, unsigned char type);          void *valeur_numerique, unsigned char type);
 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 *purification_chaine(unsigned char *chaine);  unsigned char *pointeur_ieme_caractere(struct_processus *s_etat_processus,
           unsigned char *chaine, integer8 position);
   unsigned char *purification_chaine(struct_processus *s_etat_processus,
           unsigned char *chaine);
   unsigned char *recherche_chemin_fichiers_temporaires(struct_processus
           *s_etat_processus);
 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,
         unsigned char *codage_sortie);          unsigned char *codage_sortie);
Line 2592  unsigned char *transliteration(struct_pr Line 3501  unsigned char *transliteration(struct_pr
   
 #ifndef RPLARGS  #ifndef RPLARGS
 logical1 analyse_syntaxique(struct_processus *s_etat_processus);  logical1 analyse_syntaxique(struct_processus *s_etat_processus);
   logical1 arret_thread_signaux(struct_processus *s_etat_processus);
 logical1 caracteristiques_fichier(struct_processus *s_etat_processus,  logical1 caracteristiques_fichier(struct_processus *s_etat_processus,
         unsigned char *nom, logical1 *existence, logical1 *ouverture,          unsigned char *nom, logical1 *existence, logical1 *ouverture,
         unsigned long *unite);          unsigned long *unite);
   logical1 controle(struct_processus *s_etat_processus, unsigned char *fichier,
           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 2611  logical1 destruction_fichier(unsigned ch Line 3525  logical1 destruction_fichier(unsigned ch
 logical1 empilement(struct_processus *s_etat_processus,  logical1 empilement(struct_processus *s_etat_processus,
         struct_liste_chainee **l_base_liste, struct_objet *s_objet);          struct_liste_chainee **l_base_liste, struct_objet *s_objet);
 logical1 empilement_pile_last(struct_processus *s_etat_processus,  logical1 empilement_pile_last(struct_processus *s_etat_processus,
         unsigned long nombre_arguments);          integer8 nombre_arguments);
 logical1 evaluation(struct_processus *s_etat_processus, struct_objet *s_objet,  logical1 evaluation(struct_processus *s_etat_processus, struct_objet *s_objet,
         unsigned char type_evaluation);          unsigned char type_evaluation);
   logical1 initialisation_fichier_acces_direct(struct_processus *s_etat_processus,
           sqlite3 *sqlite, logical1 binaire);
   logical1 initialisation_fichier_acces_indexe(struct_processus *s_etat_processus,
           sqlite3 *sqlite, integer8 position_clef, logical1 binaire);
   logical1 lancement_thread_signaux(struct_processus *s_etat_processus);
 logical1 recherche_instruction_suivante(struct_processus *s_etat_processus);  logical1 recherche_instruction_suivante(struct_processus *s_etat_processus);
   logical1 recherche_instruction_suivante_recursive(
           struct_processus *s_etat_processus, integer8 recursivite);
 logical1 retrait_variable(struct_processus *s_etat_processus,  logical1 retrait_variable(struct_processus *s_etat_processus,
         unsigned char *nom_variable, unsigned char type);          unsigned char *nom_variable, unsigned char type);
 logical1 retrait_variable_par_niveau(struct_processus *s_etat_processus);  logical1 retrait_variables_par_niveau(struct_processus *s_etat_processus);
 logical1 retrait_variable_partagee(struct_processus *s_etat_processus,  logical1 retrait_variable_partagee(struct_processus *s_etat_processus,
         unsigned char *nom_variable, union_position_variable position);          unsigned char *nom_variable, union_position_variable position);
   logical1 retrait_variables_partagees_locales(
           struct_processus *s_etat_processus);
 logical1 retrait_variable_statique(struct_processus *s_etat_processus,  logical1 retrait_variable_statique(struct_processus *s_etat_processus,
         unsigned char *nom_variable, union_position_variable position);          unsigned char *nom_variable, union_position_variable position);
   logical1 retrait_variables_statiques_locales(
           struct_processus *s_etat_processus);
 logical1 sequenceur(struct_processus *s_etat_processus);  logical1 sequenceur(struct_processus *s_etat_processus);
 logical1 sequenceur_optimise(struct_processus *s_etat_processus);  logical1 sequenceur_optimise(struct_processus *s_etat_processus,
           struct_liste_chainee *l_bibliotheques);
 #endif  #endif
   
 /*  /*
Line 2635  logical1 sequenceur_optimise(struct_proc Line 3561  logical1 sequenceur_optimise(struct_proc
 logical1 depassement_addition(integer8 *a, integer8 *b, integer8 *resultat);  logical1 depassement_addition(integer8 *a, integer8 *b, integer8 *resultat);
 logical1 depassement_multiplication(integer8 *a, integer8 *b,  logical1 depassement_multiplication(integer8 *a, integer8 *b,
         integer8 *resultat);          integer8 *resultat);
   logical1 depassement_soustraction(integer8 *a, integer8 *b, integer8 *resultat);
 logical1 depassement_puissance(integer8 *a, integer8 *b, integer8 *resultat);  logical1 depassement_puissance(integer8 *a, integer8 *b, integer8 *resultat);
   
 #ifndef RPLARGS  #ifndef RPLARGS
Line 2642  logical1 ecriture_pipe(struct_processus Line 3569  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_partagee(struct_processus *s_etat_processus,  logical1 recherche_variable_globale(struct_processus *s_etat_processus,
         unsigned char *nom_variable, union_position_variable position,          unsigned char *nom_variable);
         unsigned char origine);  
 logical1 recherche_variable_statique(struct_processus *s_etat_processus,  
         unsigned char *nom_variable, union_position_variable position,  
         unsigned char origine);  
 logical1 test_cfsf(struct_processus *s_etat_processus,  logical1 test_cfsf(struct_processus *s_etat_processus,
         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 2661  logical1 test_fonction(unsigned char *ch Line 3585  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);
   ssize_t read_atomic_signal(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 2673  inline ssize_t write_atomic(struct_proce Line 3599  inline ssize_t write_atomic(struct_proce
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
 int alsprintf(unsigned char **strp, const char *fmt, ...);  int alsprintf(struct_processus *s_etat_processus,
           unsigned char **strp, const char *fmt, ...);
   #ifndef RPLARGS
   int association_etat_processus_readline();
   #endif
   int interruption_violation_access(void *adresse_fautive, int gravite);
   #ifndef RPLARGS
   int initialisation_etat_processus_readline();
   int liberation_etat_processus_readline();
   integer8 liste_variables(struct_processus *s_etat_processus,
           struct_tableau_variables *tableau);
   integer8 nombre_variables(struct_processus *s_etat_processus);
   int readline_analyse_syntaxique(int count, int key);
   int readline_effacement(int count, int key);
   #endif
   int std_fprintf(file *flux, const char *format, ...);
   int tex_fprintf(struct_processus *s_etat_processus,
           file *flux, const char *format, ...);
 int transliterated_fprintf(struct_processus *s_etat_processus, file *flux,  int transliterated_fprintf(struct_processus *s_etat_processus, file *flux,
         const char *format, ...);          const char *format, ...);
 int valsprintf(unsigned char **strp, const char *fmt, va_list ap);  int valsprintf(struct_processus *s_etat_processus,
           unsigned char **strp, const char *fmt, va_list ap);
 int wrapper_instruction_intrinseque(void (*fonction)(),  int wrapper_instruction_intrinseque(void (*fonction)(),
         struct_rpl_arguments *rpl_arguments);          struct_rpl_arguments *rpl_arguments);
   
Line 2688  int wrapper_instruction_intrinseque(void Line 3632  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
   
 /*  /*
Line 2709  logical8 masque_entiers_binaires(struct_ Line 3652  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
   
 /*  /*
Line 2724  struct_liste_chainee *analyse_rpn(struct Line 3671  struct_liste_chainee *analyse_rpn(struct
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
     Allocateur de buffers à cache
   --------------------------------------------------------------------------------
   */
   
   void initialisation_allocateur_buffer(struct_processus *s_etat_processus);
   void liberation_allocateur_buffer(struct_processus *s_etat_pocessus);
   struct_buffer *allocation_buffer(struct_processus *s_etat_processus,
           size_t longueur);
   void liberation_buffer(struct_processus *s_etat_processus,
           struct_buffer *buffer);
   
   /*
   --------------------------------------------------------------------------------
   Fonctions renvoyant une copie de la structure de description des processus    Fonctions renvoyant une copie de la structure de description des processus
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
Line 2734  struct_processus *copie_etat_processus(s Line 3694  struct_processus *copie_etat_processus(s
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Fonctions renvoyant un pointeur sur un fichier (file *)    Fonctions renvoyant un pointeur sur un fichier (file *) ou un descripteur
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
 #ifndef RPLARGS  #ifndef RPLARGS
 file *creation_fichier_tex(struct_processus *s_etat_processus);  file *creation_fichier_tex(struct_processus *s_etat_processus);
 file *descripteur_fichier(struct_processus *s_etat_processus,  struct_descripteur_fichier *descripteur_fichier(struct_processus
         struct_fichier *s_fichier);          *s_etat_processus, struct_fichier *s_fichier);
 #endif  #endif
   
 /*  /*
Line 2753  file *descripteur_fichier(struct_process Line 3713  file *descripteur_fichier(struct_process
 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);
   struct_objet *lecture_fichier_non_formate(struct_processus *s_etat_processus,
           void *argument, integer8 longueur_buffer, logical1 recursivite);
 struct_objet *lecture_pipe(struct_processus *s_etat_processus, int pipe);  struct_objet *lecture_pipe(struct_processus *s_etat_processus, int pipe);
 struct_objet *parametres_sql(struct_processus *s_etat_processus,  struct_objet *parametres_sql(struct_processus *s_etat_processus,
         struct_objet *s_parametres);          struct_objet *s_parametres);
 struct_objet *simplification(struct_processus *s_etat_processus,  struct_objet *simplification(struct_processus *s_etat_processus,
         struct_objet *s_objet);          struct_objet *s_objet);
 #endif  
   struct_arbre_variables *allocation_noeud(struct_processus *s_etat_processus);
   struct_arbre_variables **allocation_tableau_noeuds(
           struct_processus *s_etat_processus);
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Fonctions gérant les arbres de simplification    Fonctions renvoyant un pointeur sur une *struct_liste_variables_statiques
     ou *struct_liste_variables_partagees
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
 #ifndef RPLARGS  struct_liste_variables_statiques *recherche_variable_statique(struct_processus
 struct_arbre *creation_arbre(struct_processus *s_etat_processus,          *s_etat_processus, unsigned char *nom_variable,
         struct_objet **t_objets, unsigned long indice,          union_position_variable position, unsigned char origine);
         unsigned long indice_maximal);  struct_liste_variables_partagees *recherche_variable_partagee(struct_processus
 void liberation_arbre(struct_processus *s_etat_processus,          *s_etat_processus, unsigned char *nom_variable,
         struct_arbre *s_noeud);          union_position_variable position, unsigned char origine);
 void parcours_arbre(struct_processus *s_etat_processus, struct_arbre *s_noeud);  
 void simplification_arbre(struct_processus *s_etat_processus,  
         struct_arbre *s_noeud);  
 #endif  #endif
   
 /*  /*
Line 2815  void f77multiplicationci_(complex16 *ca, Line 3779  void f77multiplicationci_(complex16 *ca,
 void f77multiplicationcr_(complex16 *ca, real8 *rb, complex16 *resultat);  void f77multiplicationcr_(complex16 *ca, real8 *rb, complex16 *resultat);
   
 void f77puissancecc_(complex16 *ca, complex16 *cb, complex16 *resultat);  void f77puissancecc_(complex16 *ca, complex16 *cb, complex16 *resultat);
 void f77puissanceci_(complex16 *ca, integer8 *ib, complex16 *resultat,  void f77puissanceci_(complex16 *ca, integer8 *ib, complex16 *resultat);
         integer4 *troncature);  
 void f77puissancecr_(complex16 *ca, real8 *rb, complex16 *resultat);  void f77puissancecr_(complex16 *ca, real8 *rb, complex16 *resultat);
 void f77puissanceic_(integer8 *ia, complex16 *cb, complex16 *resultat);  void f77puissanceic_(integer8 *ia, complex16 *cb, complex16 *resultat);
 void f77puissanceii_(integer8 *ia, integer8 *ib, integer8 *resultat);  void f77puissanceii_(integer8 *ia, integer8 *ib, integer8 *resultat);
 void f77puissanceir_(integer8 *ia, real8 *rb, real8 *resultat);  void f77puissanceir_(integer8 *ia, real8 *rb, real8 *resultat);
 void f77puissancerc_(real8 *ra, complex16 *cb, complex16 *resultat);  void f77puissancerc_(real8 *ra, complex16 *cb, complex16 *resultat);
 void f77puissanceri_(real8 *ra, integer8 *ib, real8 *resultat,  void f77puissanceri_(real8 *ra, integer8 *ib, real8 *resultat);
         integer4 *troncature);  
 void f77puissancerr_(real8 *ra, real8 *rb, real8 *resultat);  void f77puissancerr_(real8 *ra, real8 *rb, real8 *resultat);
   
 void f77racinecarreec_(complex16 *ca, complex16 *resultat);  void f77racinecarreec_(complex16 *ca, complex16 *resultat);
Line 3051  void zgelsy_(integer4 *m, integer4 *n, i Line 4013  void zgelsy_(integer4 *m, integer4 *n, i
  * 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.6  
changed lines
  Added in v.1.356

CVSweb interface <joel.bertrand@systella.fr>