Diff for /rpl/src/rpl.h between versions 1.73 and 1.257

version 1.73, 2010/11/26 11:46:38 version 1.257, 2015/01/08 14:29:52
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.0.20    RPL/2 (R) version 4.1.20
   Copyright (C) 1989-2010 Dr. BERTRAND Joël    Copyright (C) 1989-2015 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 23 Line 23
 #ifndef INCLUSION_RPL  #ifndef INCLUSION_RPL
 #define INCLUSION_RPL  #define INCLUSION_RPL
   
 #define _GNU_SOURCE  #ifndef __RPLCAS
 #define _POSIX_C_SOURCE     200112L  #   define _GNU_SOURCE
   #   define _XOPEN_SOURCE        700
   #endif
   
 #define _REENTRANT  #define _REENTRANT
   
 #ifdef Darwin  #ifndef __RPLCAS
 #   define  _DARWIN_C_SOURCE  #   ifdef Darwin
 #endif  #       define  _DARWIN_C_SOURCE
   #   endif
   
 #ifdef OpenBSD  #   ifdef OpenBSD
 #   define _BSD_SOURCE  #       define _BSD_SOURCE
   #   endif
 #endif  #endif
   
 #ifdef OS2  #ifdef OS2
 #   define _BSD_SOURCE  #   ifndef __RPLCAS
 #   define _XOPEN_SOURCE    600  #       define _BSD_SOURCE
   #   endif
   
 #   include <types.h>  #   include <types.h>
     enum { SHUT_RD = 0, SHUT_WR, SHUT_RDWR };      enum { SHUT_RD = 0, SHUT_WR, SHUT_RDWR };
Line 50 Line 56
 #   define sched_yield(arg)  #   define sched_yield(arg)
 #endif  #endif
   
   #ifdef CYGWIN
   #   define SA_ONSTACK   0
   #endif
   
   
 /*  /*
 ================================================================================  ================================================================================
Line 59 Line 69
   
 #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 <stdarg.h>
   #include <poll.h>
   #include <signal.h>
   
 #ifndef RPLARGS  #ifndef RPLARGS
 #   include <sys/mman.h>  #   include <sys/mman.h>
Line 85 Line 98
 #   include <dlfcn.h>  #   include <dlfcn.h>
 #   include <fcntl.h>  #   include <fcntl.h>
 #   include <pthread.h>  #   include <pthread.h>
   #   include <regex.h>
   
 #   ifdef OS2  #   ifdef OS2
 #       undef pthread_mutexattr_settype  #       undef pthread_mutexattr_settype
Line 92 Line 106
 #   endif  #   endif
   
 #   include <pwd.h>  #   include <pwd.h>
   #   ifdef SHARED_MEMORY
 #   ifdef _BROKEN_SIGINFO  
 #       include <sys/ipc.h>  
 #       include <sys/shm.h>  #       include <sys/shm.h>
 #   endif  #   endif
   
Line 119 Line 131
                 ULONG   *nopened;                  ULONG   *nopened;
                 ULONG   allocated;                  ULONG   allocated;
             } sem_t;              } sem_t;
 #       else  #       else // IPCS_SYSV
             typedef struct              typedef struct
             {              {
                 int             sem;                  int             sem;
                   int             alloue;
                 unsigned char   *path;                  unsigned char   *path;
                 pid_t           pid;                  pid_t           pid;
                   pthread_t       tid;
             } sem_t;              } sem_t;
 #       endif  #       endif
   
 #       define SEM_FAILED   NULL  #       ifndef SEM_FAILED
   #           define SEM_FAILED   NULL
   #       endif
   
         sem_t *sem_open_SysV(const char *nom, int oflag, ...);          sem_t *sem_open_SysV(const char *nom, int oflag, ...);
         int sem_init_SysV(sem_t *sem, int shared, unsigned int value);          int sem_init_SysV(sem_t *sem, int shared, unsigned int value);
         int sem_close_SysV(sem_t *sem);          int sem_close_SysV(sem_t *sem);
         int sem_wait_SysV(sem_t *sem);          int sem_wait_SysV(sem_t *sem);
         int sem_trywait_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_post_SysV(sem_t *sem);
         int sem_getvalue_SysV(sem_t *sem, int *value);          int sem_getvalue_SysV(sem_t *sem, int *value);
         int sem_unlink_SysV(const char *nom);          int sem_unlink_SysV(char *nom);
         int sem_destroy_SysV(sem_t *sem);          int sem_destroy_SysV(sem_t *sem);
 #   endif  #   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 152 Line 168
 #   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"  #   include "openssl/evp.h"
   #   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
   
 #   include "sqlite3.h"  #   include "sqlite3.h"
   #   include "sigsegv.h"
   #   ifdef OS2
           // Bug de libsigsegv
   #       undef HAVE_STACK_OVERFLOW_RECOVERY
   #   endif
   
 #   define HAVE_INLINE  #   define HAVE_INLINE
 #   define GSL_RANGE_CHECK_OFF  #   define GSL_RANGE_CHECK_OFF
Line 172 Line 228
 #   include <ieeefp.h>  #   include <ieeefp.h>
 #endif  #endif
   
 // Définition spécifique à Hurd  // Définition spécifique à Hurd
 #ifndef PIPE_BUF  #ifndef PIPE_BUF
 #   define fpathconf (".", _PC_PIPE_BUF)  #   define fpathconf (".", _PC_PIPE_BUF)
 #endif  #endif
Line 200 Line 256
 #   endif  #   endif
 #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    Bugs spécifiques
 ================================================================================  ================================================================================
 */  */
   
 #ifdef _BROKEN_SIGINFO  // Néant
 #   define SIGHANDLER_ARGS  int signal  
 #   ifdef SA_SIGINFO  
 #       undef SA_SIGINFO  
 #   endif  
 #   define SA_SIGINFO   0  
   
 #   ifndef __BROKEN_SIGINFO_ROUTINES__  
   
 // pthread_kill() est une macro sous OS/2.  /*
 #       ifdef pthread_kill  ================================================================================
 #           undef pthread_kill    TYPES
 #       endif  ================================================================================
   */
   
 #       define kill(a, b)           kill_broken_siginfo(a, b)  typedef FILE                    file;
 #       define pthread_kill(a, b)   pthread_kill_broken_siginfo(a, b)  typedef unsigned char           t_8_bits;
 #   endif  
   
     int kill_broken_siginfo(pid_t pid, int signal);  #ifndef RPLARGS
     int pthread_kill_broken_siginfo(pthread_t tid, int signal);  #   include "rpltypes-conv.h"
     pid_t origine_signal(int signal);  
     int queue_in(pid_t pid, int signal);  
 #else  #else
 #   define SIGHANDLER_ARGS  int signal, siginfo_t *siginfo, void *context  #   include "rpltypes.h"
 #endif  #endif
   
 #ifdef OpenBSD  enum signaux_rpl
 #   ifdef PTHREAD_SCOPE_SYSTEM  {
 #       undef PTHREAD_SCOPE_SYSTEM      rpl_signull = 0,
       rpl_sigint,
       rpl_sigterm,
       rpl_sigstart,       // Signal envoyé par un père pour lancer son fils.
       rpl_sigcont,        // Signal de redémarrage d'un processus arrêté par
                           // SUSPEND
       rpl_sigstop,        // Signal d'arrêt envoyé par l'instruction STOP ou
                           // FUSE. (FSTOP)
       rpl_sigabort,       // Signal envoyé par l'instruction ABORT (à regrouper
                           // avec FABORT)
       rpl_sigurg,         // Signal d'arrêt urgent
       rpl_siginject,      // Signal indiquant la présence d'une donnée à lire
                           // envoyée depuis le père
       rpl_sigalrm,        // Signal d'alarme (erreur système) depuis un fils
       rpl_sighup,
       rpl_sigtstp,
       rpl_sigexcept,
       rpl_sigmax
   };
   
   #define LONGUEUR_QUEUE_SIGNAUX          1024
   
   // Une structure s_queue_signaux est créée par processus (et non par thread).
   // Elle est projetée dans un segment de mémoire partagée pour qu'elle soit
   // accessible à la fois du père et des fils.
   
   #ifndef RPLARGS
   typedef struct queue_signaux
   {
       volatile int                pointeur_lecture;
       volatile int                pointeur_ecriture;
       volatile logical1           requete_arret;
   
       pthread_t                   thread_signaux;
   
       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
 #   define PTHREAD_SCOPE_SYSTEM 0  
 #endif  #endif
   
 #ifdef OS2  #ifdef OS2
Line 254  union semun Line 362  union semun
 };  };
 #endif  #endif
   
   #ifndef RTLD_LOCAL
   #   define RTLD_LOCAL       0
   #endif
   
   #ifndef SIGSTKSZ
   #   define SIGSTKSZ         65536
   #endif
   
 /*  /*
 ================================================================================  ================================================================================
   SÉMAPHORES    SÉMAPHORES
 ================================================================================  ================================================================================
 */  */
   
 #ifdef IPCS_SYSV  #ifdef IPCS_SYSV
   #   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) i\
                           pthread_self(), \
                   #a, a, __FUNCTION__, __LINE__), fflush(stdout); \
                   if (value > 1) BUG(1, uprintf("Value %d\n", value)); \
                   sem_wait_SysV(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_SysV(a); })
   #   define sem_destroy(a) ({ int value; sem_getvalue(a, &value); \
                   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_init(a, b, c)    sem_init_SysV(a, b, c)
 #   define sem_destroy(a)       sem_destroy_SysV(a)  
 #   define sem_wait(a)          sem_wait_SysV(a)  
 #   define sem_trywait(a)       sem_trywait_SysV(a)  #   define sem_trywait(a)       sem_trywait_SysV(a)
 #   define sem_post(a)          sem_post_SysV(a)  #   define sem_timedwait(a, b)  sem_timedwait_SysV(a, b)
 #   define sem_getvalue(a, b)   sem_getvalue_SysV(a, b)  #   define sem_getvalue(a, b)   sem_getvalue_SysV(a, b)
 #   define sem_open(...)        sem_open_SysV(__VA_ARGS__)  #   define sem_open(...)        sem_open_SysV(__VA_ARGS__)
 #   define sem_close(a)         sem_close_SysV(a)  #   define sem_close(a)         sem_close_SysV(a)
 #   define sem_unlink(a)        sem_unlink_SysV(a)  #   define sem_unlink(a)        sem_unlink_SysV(a)
   #else
   #   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
 #endif  #endif
   
   
Line 282  union semun Line 441  union semun
   
 #ifndef RPLARGS  #ifndef RPLARGS
   
 // Signaux utilisés par défaut :  // Signaux utilisés par défaut :
 //  SIGINT  //  SIGINT
 //  SIGTSTP  //  SIGTSTP
 //  SIGCONT  //  SIGCONT
 //  SIGURG  
 //  SIGPIPE  //  SIGPIPE
   //  SIGUSR1 et SIGUSR2 sont utilisé par libsigsegv.
   //  SIGHUP
 //  SIGALRM  //  SIGALRM
   
 //  Arrêt par STOP  #   define SIGTEST                  255
 #   define SIGFSTOP                 SIGUSR1  
 //  Démarrage d'un processus fils  
 #   define SIGSTART                 SIGUSR2  
 //  Injection de données  
 #   define SIGINJECT                SIGQUIT  
 //  Arrêt général  
 #   ifndef OpenBSD  
 //  La libpthread d'OpenBSD utilise SIGPROF  
 #       define SIGABORT             SIGPROF  
 #   else  
 #       define SIGABORT             SIGTHR  
 #   endif  
 //  Arrêt d'un processus fils depuis autre chose que STOP  
 #   if defined(Darwin) || defined(OpenBSD)  
 #       define SIGFABORT            SIGINFO  
 #   else  
 #       define SIGFABORT            SIGPOLL  
 #   endif  
   
 //  Nombre d'interruptions disponibles  //  Nombre d'interruptions disponibles
 #   define d_NOMBRE_INTERRUPTIONS   64  #   define d_NOMBRE_INTERRUPTIONS   64
Line 316  union semun Line 458  union semun
   
 /*  /*
 ================================================================================  ================================================================================
   Granularité temporelle    Granularité temporelle
 ================================================================================  ================================================================================
 */  */
   
Line 351  union semun Line 493  union semun
   
 /*  /*
 ================================================================================  ================================================================================
   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
 ================================================================================  ================================================================================
 */  */
Line 373  typedef unsigned char   t_8_bits; Line 500  typedef unsigned char   t_8_bits;
 #ifndef RPLARGS  #ifndef RPLARGS
 #   ifdef SEMAPHORES_NOMMES  #   ifdef SEMAPHORES_NOMMES
 #       define LONGUEUR_NOM_SEMAPHORE   64  #       define LONGUEUR_NOM_SEMAPHORE   64
 #   endif  #       define __PTR__      *
   
 #   ifndef MAIN_RPL  
 #       ifdef _BROKEN_SIGINFO  
             extern int              *fifos_signaux;  
 #       endif  
   
         extern jmp_buf              contexte;  
         extern jmp_buf              contexte_initial;  
   
 #       ifdef SEMAPHORES_NOMMES  
         extern pthread_mutex_t      mutex_sem;  
 #       endif  
   
         extern pthread_key_t        semaphore_fork_processus_courant;  
   
         extern sem_t  
 #       ifdef SEMAPHORES_NOMMES  
         *  
 #       endif  
                                     semaphore_liste_threads;  
   
         extern sem_t  
 #       ifdef SEMAPHORES_NOMMES  
         *  
 #       endif  
                                     semaphore_gestionnaires_signaux;  
   
         extern sem_t  
 #       ifdef SEMAPHORES_NOMMES  
         *  
 #       endif  
                                     semaphore_gestionnaires_signaux_atomique;  
   
 #       ifdef SEMAPHORES_NOMMES  
         // 0 -> liste_threads  
         // 1 -> gestionnaire_signaux  
         // 2 -> gestionnaire_signaux_atomique  
         // 3 -> &((*s_etat_processus).semaphore_fork)  
             extern unsigned char    noms_semaphores[4][LONGUEUR_NOM_SEMAPHORE];  
             extern sem_t            *semaphores_nommes[4];  
 #       endif  
 #   else  #   else
 #       ifdef _BROKEN_SIGINFO  #       define __PTR__
             int                     *fifos_signaux;  
 #       endif  
   
         jmp_buf                     contexte;  
         jmp_buf                     contexte_initial;  
   
 #       ifdef SEMAPHORES_NOMMES  
         pthread_mutex_t             mutex_sem = PTHREAD_MUTEX_INITIALIZER;  
 #       endif  
   
         pthread_key_t               semaphore_fork_processus_courant;  
   
         sem_t  
 #       ifdef SEMAPHORES_NOMMES  
         *  
 #       endif  
                                     semaphore_liste_threads;  
   
         sem_t  
 #       ifdef SEMAPHORES_NOMMES  
         *  
 #       endif  
                                     semaphore_gestionnaires_signaux;  
   
         sem_t  
 #       ifdef SEMAPHORES_NOMMES  
         *  
 #       endif  
                                     semaphore_gestionnaires_signaux_atomique;  
   
 #       ifdef SEMAPHORES_NOMMES  
             unsigned char           noms_semaphores[4][LONGUEUR_NOM_SEMAPHORE];  
             sem_t                   *semaphores_nommes[4];  
 #       endif  
 #   endif  #   endif
 #endif  
   
 #ifdef SEMAPHORES_NOMMES      __EXTERN__ jmp_buf              contexte_ecriture;
 enum t_semaphore    { sem_liste_threads = 0,      __EXTERN__ jmp_buf              contexte_impression;
         sem_gestionnaires_signaux = 1,      __EXTERN__ jmp_buf              contexte_initial;
         sem_gestionnaires_signaux_atomique = 2,      __EXTERN__ jmp_buf              contexte_processus;
         sem_fork = 3 };      __EXTERN__ jmp_buf              contexte_thread;
   
 sem_t *sem_init2(unsigned int valeur, enum t_semaphore semaphore);      __EXTERN__ volatile int         signal_test;
 int sem_destroy2(sem_t *semaphore_p, enum t_semaphore semaphore);  
 int sem_getvalue2(sem_t *semaphore, int *valeur);      __EXTERN__ pid_t                pid_processus_pere;
   
       __EXTERN__ pthread_mutex_t      mutex_liste_threads
                                               __STATIC_MUTEX_INITIALIZATION__;
       __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;
   
   #   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_getvalue(semaphore, value) sem_getvalue2(semaphore, value)
 #define sem_post(semaphore) \  #define sem_post(semaphore) \
         ({ int r; pthread_mutex_lock(&mutex_sem); \          ({ int r; pthread_mutex_lock(&mutex_sem); \
Line 482  int sem_getvalue2(sem_t *semaphore, int Line 561  int sem_getvalue2(sem_t *semaphore, int
 ================================================================================  ================================================================================
 */  */
   
 // Par défaut, tout est redirigé vers stderr sauf indication explicite de  // Par défaut, tout est redirigé vers stderr sauf indication explicite de
 // stdout.  // stdout.
   
 #define printf(...) transliterated_fprintf(s_etat_processus, \  #define printf(...) transliterated_fprintf(s_etat_processus, \
Line 494  int sem_getvalue2(sem_t *semaphore, int Line 573  int sem_getvalue2(sem_t *semaphore, int
 #define ufprintf(flux, ...) transliterated_fprintf(NULL, \  #define ufprintf(flux, ...) transliterated_fprintf(NULL, \
             flux, __VA_ARGS__)              flux, __VA_ARGS__)
   
 // Tous les messages pour DISP, INPUT et les E/S par readline sont sur stderr.  
 // Cela évite aux messages envoyés par les gestionnaires de signaux d'être  
 // indéfiniment bloqués.  
   
 #ifdef SunOS  #ifdef SunOS
 #   define fopen(...) ({ FILE *desc; \  #   define fopen(...) ({ FILE *desc; \
             while((desc = fopen(__VA_ARGS__)) == NULL) \              while((desc = fopen(__VA_ARGS__)) == NULL) \
Line 508  int sem_getvalue2(sem_t *semaphore, int Line 583  int sem_getvalue2(sem_t *semaphore, int
 #   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 521  int sem_getvalue2(sem_t *semaphore, int Line 593  int sem_getvalue2(sem_t *semaphore, int
 #   define fflush(flux) fflush((flux == stdout) ? stderr : flux)  #   define fflush(flux) fflush((flux == stdout) ? stderr : flux)
 #endif  #endif
   
 // Ajout d'un timeout sur les fonctions pipe() pour éviter une erreur  // Ajout d'un timeout sur les fonctions pipe() pour éviter une erreur
 // système dans le cas où l'on a atteint le nombre maximale de fichiers  // système dans le cas où l'on a atteint le nombre maximale de fichiers
 // ouverts.  // ouverts.
   
 #define pipe(descripteurs) \  #define pipe(descripteurs) \
Line 541  int sem_getvalue2(sem_t *semaphore, int Line 613  int sem_getvalue2(sem_t *semaphore, int
         erreur; \          erreur; \
      })       })
   
 // Redéfinition de abs pour un fonctionnement en entier de type long long int  // Redéfinition de abs pour un fonctionnement en entier de type long long int
   
 #ifdef __GNUC__  #ifdef __GNUC__
 #   define abs(i) ({ typeof(i) _i; _i = (i); (_i >= 0) ? _i : -_i; })  #   define abs(i) ({ typeof(i) _i; _i = (i); (_i >= 0) ? _i : -_i; })
 // typeof() est une extension de gcc, mais est présent sur d'autres compilateurs  // typeof() est une extension de gcc, mais est présent sur d'autres compilateurs
 // comme Sun Studio. Dans le cas où typeof() n'existe pas, il est possible  // comme Sun Studio. Dans le cas où typeof() n'existe pas, il est possible
 // d'utiliser la macro suivante, mais elle possède un effet de bord dû à  // d'utiliser la macro suivante, mais elle possède un effet de bord dû à
 // l'évaluation multiple de l'argument.  // l'évaluation multiple de l'argument.
 #else  #else
 #   define abs(i) (((i) >= 0) ? (i) : (-i))  #   define abs(i) (((i) >= 0) ? (i) : (-i))
 #endif  #endif
Line 655  pid_t debug_fork(); Line 727  pid_t debug_fork();
         pthread_mutex_unlock(mutex)          pthread_mutex_unlock(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  
   
   
 /*  /*
 ================================================================================  ================================================================================
Line 723  pid_t debug_fork(); Line 778  pid_t debug_fork();
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Paramètres du système    Paramètres du système
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 742  pid_t debug_fork(); Line 797  pid_t debug_fork();
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Erreurs système    Erreurs système
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 768  pid_t debug_fork(); Line 823  pid_t debug_fork();
 #endif  #endif
   
   
 // -1 : erreur provoquée par une bibliothèque externe  // -1 : erreur provoquée par une bibliothèque externe
 #ifndef RPLARGS  #ifndef RPLARGS
 #   define d_es                                 2000  #   define d_es                                 2000
 #   define d_es_allocation_memoire              __erreur(2001)  #   define d_es_allocation_memoire              __erreur(2001)
Line 786  pid_t debug_fork(); Line 841  pid_t debug_fork();
 #   define d_es_contexte                        __erreur(2013)  #   define d_es_contexte                        __erreur(2013)
 #   define d_es_somme_controle                  __erreur(2014)  #   define d_es_somme_controle                  __erreur(2014)
 #   define d_es_semaphore                       __erreur(2015)  #   define d_es_semaphore                       __erreur(2015)
   #   define d_es_mutex_acquis_autre_thread       __erreur(2016)
 #endif  #endif
   
 /*  /*
Line 833  pid_t debug_fork(); Line 889  pid_t debug_fork();
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Erreurs à l'exécution    Erreurs à l'exécution
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
 // -1 : erreur provoquée par une bibliothèque externe  // -1 : erreur provoquée par une bibliothèque externe
 #ifndef RPLARGS  #ifndef RPLARGS
 #   define d_ex                                 0  #   define d_ex                                 0
 #   define d_ex_pile_vide                       __erreur(1)  #   define d_ex_pile_vide                       __erreur(1)
Line 922  pid_t debug_fork(); Line 978  pid_t debug_fork();
 #   define d_ex_clef_inexistante                __erreur(80)  #   define d_ex_clef_inexistante                __erreur(80)
 #   define d_ex_nom_implicite                   __erreur(81)  #   define d_ex_nom_implicite                   __erreur(81)
 #   define d_ex_version_bibliotheque            __erreur(82)  #   define d_ex_version_bibliotheque            __erreur(82)
   #   define d_ex_creation_variable_globale       __erreur(83)
   #   define d_ex_erreur_interne_rplcas           __erreur(84)
   #   define d_ex_fichier_corrompu                __erreur(85)
   #   define d_ex_mutex_acquis_autre_thread       __erreur(86)
   #   define d_ex_expression_reguliere            __erreur(87)
   #   define d_ex_instruction_indisponible        __erreur(88)
   #   define d_ex_chiffrement                     __erreur(89)
   #   define d_ex_chiffrement_indisponible        __erreur(90)
   #   define d_ex_longueur_clef_chiffrement       __erreur(91)
   #   define d_ex_taille_message                  __erreur(92)
 #endif  #endif
   
   
Line 972  pid_t debug_fork(); Line 1038  pid_t debug_fork();
 #define VIN __RPL_VIN  #define VIN __RPL_VIN
 #define VRL __RPL_VRL  #define VRL __RPL_VRL
   
   enum t_rplcas_commandes     { RPLCAS_INTEGRATION = 0, RPLCAS_LIMITE };
   
 enum t_type     { ADR = 0, ALG, BIN, CHN, CPL, FCH, FCT, INT, LST,  enum t_type     { ADR = 0, ALG, BIN, CHN, CPL, FCH, FCT, INT, LST,
                 MCX, MIN, MRL, MTX, NOM, NON, PRC, REL, RPN, SCK,                  MCX, MIN, MRL, MTX, NOM, NON, PRC, REL, RPN, SCK,
                 SLB, SPH, SQL, TBL, VCX, VIN, VRL };                  SLB, SPH, SQL, TBL, VCX, VIN, VRL };
   
     /*      /*
     ADR : adresse sur 32 bits (au moins) non signés (unsigned long)      ADR : adresse sur 64 bits signés.
             Adresse d'une définition à interpréter.              Adresse d'une définition à interpréter.
   
     ALG : expression algébrique (struct_liste_chainee *)      ALG : expression algébrique (struct_liste_chainee *)
             La liste chaînée contient la définition convertie en notation              La liste chaînée contient la définition convertie en notation
             polonaise inversée. Ce type diffère du type 'RPN' au niveau              polonaise inversée. Ce type diffère du type 'RPN' au niveau
             du format de sortie (notation algébrique).              du format de sortie (notation algébrique).
   
     BIN : entier binaire sur 64 bits (unsigned integer8 *)      BIN : entier binaire sur 64 bits (unsigned integer8 *)
             Sans objet.              Sans objet.
Line 999  enum t_type  { ADR = 0, ALG, BIN, CHN, C Line 1066  enum t_type  { ADR = 0, ALG, BIN, CHN, C
   
     FCH : descripteur de fichier (struct_fichier *).      FCH : descripteur de fichier (struct_fichier *).
   
     FCT : déclaration d'une fonction et de son nombre d'arguments      FCT : déclaration d'une fonction et de son nombre d'arguments
             (struct_fonction *). Ce type n'est nécessaire que dans le              (struct_fonction *). Ce type n'est nécessaire que dans le
             traitement des types 'ALG' et 'RPN'.              traitement des types 'ALG' et 'RPN'.
   
     INT : entier sur 64 bits (integer*8, integer8 *)      INT : entier sur 64 bits (integer*8, integer8 *)
Line 1008  enum t_type  { ADR = 0, ALG, BIN, CHN, C Line 1075  enum t_type  { ADR = 0, ALG, BIN, CHN, C
             Type C/Fortran : integer8              Type C/Fortran : integer8
   
     LST : liste (struct_liste_chainee *)      LST : liste (struct_liste_chainee *)
             Les objets sont enregistrés sous forme de liste chaînée récursive.              Les objets sont enregistrés sous forme de liste chaînée récursive.
             Cela permet de traiter des tableaux de données hétérogènes de              Cela permet de traiter des tableaux de données hétérogènes de
             grandes dimensions. Le nombre de dimensions maximal est fixé par              grandes dimensions. Le nombre de dimensions maximal est fixé par
             la mémoire de la station.              la mémoire de la station.
   
     MCX : matrice de complexes (struct_matrice *)      MCX : matrice de complexes (struct_matrice *)
             Sans objet.              Sans objet.
Line 1035  enum t_type  { ADR = 0, ALG, BIN, CHN, C Line 1102  enum t_type  { ADR = 0, ALG, BIN, CHN, C
             Sans objet.              Sans objet.
   
     RPN : definition (struct_liste_chainee *)      RPN : definition (struct_liste_chainee *)
             Ce type diffère du type 'ALG' au niveau du format de sortie              Ce type diffère du type 'ALG' au niveau du format de sortie
             (notation polonaise inversée).              (notation polonaise inversée).
   
     SCK : socket (struct_socket *)      SCK : socket (struct_socket *)
   
     SLB : bibliothèque dynamique partagée (struct_bibliotheque *)       SLB : bibliothèque dynamique partagée (struct_bibliotheque *) 
             Sans objet.              Sans objet.
   
     SPH : sémaphore nommé (struct_semaphore *)      SPH : sémaphore nommé (struct_semaphore *)
   
     SQL : connecteur sur une base de données SQL (struct_connecteur_sql *)      SQL : connecteur sur une base de données SQL (struct_connecteur_sql *)
   
     TBL : tableau multidimensionnel d'objets (struct_tableau *).      TBL : tableau multidimensionnel d'objets (struct_tableau *).
   
Line 1080  typedef struct objet Line 1147  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 1108  typedef struct fichier Line 1175  typedef struct fichier
 typedef struct rpl_mutex  typedef struct rpl_mutex
 {  {
     pthread_mutex_t     mutex;      pthread_mutex_t     mutex;
       pthread_t           tid;
 } struct_mutex;  } struct_mutex;
 #endif  #endif
   
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Structure sémaphore    Structure sémaphore
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 1146  typedef struct marque Line 1214  typedef struct marque
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Structure bibliothèque    Structure bibliothèque
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 1172  typedef struct bibliotheque Line 1240  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               type; // C (file *) ou S (sqlite *)
Line 1181  typedef struct descripteur_fichier Line 1249  typedef struct descripteur_fichier
     pid_t                       pid;      pid_t                       pid;
     pthread_t                   tid;      pthread_t                   tid;
   
     file                        *descripteur_c;      union
     sqlite3                     *descripteur_sqlite;      {
           file                    *descripteur_c;
           sqlite3                 *descripteur_sqlite;
       };
 } struct_descripteur_fichier;  } struct_descripteur_fichier;
 #endif  #endif
   
Line 1215  typedef struct connecteur_sql Line 1286  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 1228  typedef struct connecteur_sql Line 1300  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 1263  typedef struct socket Line 1339  typedef struct socket
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Structure liste chaînee    Structure liste chaînee
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 1277  typedef struct liste_chainee Line 1353  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 1302  typedef struct liste_profilage2 Line 1413  typedef struct liste_profilage2
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Structure contenant les fichiers graphiques (liste chaînée)    Structure contenant les fichiers graphiques (liste chaînée)
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 1334  typedef struct nom Line 1445  typedef struct nom
 {  {
     unsigned char               *nom;      unsigned char               *nom;
     logical1                    symbole;    /* d_vrai/d_faux */      logical1                    symbole;    /* d_vrai/d_faux */
     // symbole == d_vrai signifie que le nom a été introduit dans un      // symbole == d_vrai signifie que le nom a été introduit dans un
     // calcul sans les apostrophes.      // calcul sans les apostrophes.
 } struct_nom;  } struct_nom;
   
Line 1368  typedef struct descripteur_thread Line 1479  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 1378  typedef struct descripteur_thread Line 1491  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 1402  typedef struct liste_pile_systeme Line 1512  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 1419  typedef struct liste_pile_systeme Line 1527  typedef struct liste_pile_systeme
     clause :      clause :
     I : IF      I : IF
     R : IFERR      R : IFERR
     X : IFERR indiquant la présence d'une erreur.      X : IFERR indiquant la présence d'une erreur.
     T : THEN      T : THEN
     E : ELSE      E : ELSE
     Z : traitement en cours de ELSE      Z : traitement en cours de ELSE
Line 1428  typedef struct liste_pile_systeme Line 1536  typedef struct liste_pile_systeme
     W : WHILE      W : WHILE
     M : WHILE avec une clause fausse.      M : WHILE avec une clause fausse.
     S : SELECT      S : SELECT
     K : aucun cas CASE n'a encore été traité.      K : aucun cas CASE n'a encore été traité.
     C : au moins un cas de SELECT...CASE a été traité.      C : au moins un cas de SELECT...CASE a été traité.
     Q : traitement en cours d'un cas CASE.      Q : traitement en cours d'un cas CASE.
     F : traitement du cas DEFAULT      F : traitement du cas DEFAULT
     */      */
Line 1440  typedef struct liste_pile_systeme Line 1548  typedef struct liste_pile_systeme
     unsigned char               type_cloture;      unsigned char               type_cloture;
   
     /*      /*
     type clôture :      type clôture :
     C     SELECT  : END termine un test SELECT/DEFAULT/END.      C     SELECT   : END termine un test SELECT/DEFAULT/END.
     D     DO      : END termine une boucle DO/UNTIL/END.      D     DO       : END termine une boucle DO/UNTIL/END.
     I     IF      : END termine un test IF/THEN (ELSE)/END.      I     IF       : END termine un test IF/THEN (ELSE)/END.
     J     IFERR   : END termine un test IFERR/THEN (ELSE)/END.      J     IFERR    : END termine un test IFERR/THEN (ELSE)/END.
     K     CASE    : END termine un test CASE/THEN/END      K     CASE     : END termine un test CASE/THEN/END
     W     WHILE   : END termine une boucle WHILE/REPEAT/END.      W     WHILE    : END termine une boucle WHILE/REPEAT/END.
       Q     CRITICAL : END termine une section critique CRITICAL/END
   
     F     FOR     : NEXT ou STEP termine une boucle avec compteur.      F     FOR     : NEXT ou STEP termine une boucle avec compteur.
     S     START   : NEXT ou STEP termine une boucle sans compteur.      S     START   : NEXT ou STEP termine une boucle sans compteur.
     L     LOOP    : boucle utilisé dans le traitement de l'instruction RETURN.      L     LOOP    : boucle utilisé dans le traitement de l'instruction RETURN.
             Elle correspond à une boucle FOR ou START mais sans son              Elle correspond à une boucle FOR ou START mais sans son
             initialisation.              initialisation.
       A     FORALL  : NEXT termine une boucle sur un objet.
     */      */
   
     unsigned long               adresse_retour;      integer8                    adresse_retour;
     unsigned long               niveau_courant;      integer8                    niveau_courant;
     struct_objet                *pointeur_adresse_retour;      struct_liste_chainee        *pointeur_objet_retour;
 } struct_liste_pile_systeme;  } struct_liste_pile_systeme;
 #endif  #endif
   
Line 1471  typedef struct liste_pile_systeme Line 1581  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 1494  typedef struct variable Line 1604  typedef struct variable
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Structure variable partagée    Structure variable partagée
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 1505  typedef struct variable_partage Line 1615  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;
 {  } struct_variable_partagee;
     pthread_mutex_t                     mutex;  
   
     volatile struct_variable_partagee   *table;  
   
     volatile unsigned long              nombre_variables;  
     volatile unsigned long              nombre_variables_allouees;  
   
     unsigned long                       position_variable;  
 } struct_table_variables_partagees;  
   
 #endif  #endif
   
Line 1539  typedef struct variable_statique Line 1639  typedef struct variable_statique
     unsigned char           *nom;      unsigned char           *nom;
     unsigned char           origine;      unsigned char           origine;
   
     // Position de création de la variable statique dans le programme ou dans      // Position de création de la variable statique dans le programme ou dans
     // l'expression. 'origine' vaut 'P' pour programme ou 'E' pour expression.      // l'expression. 'origine' vaut 'P' pour programme ou 'E' pour expression.
   
     unsigned long           niveau;      integer8                niveau;
   
     union_position_variable variable_statique;      union_position_variable variable_statique;
   
Line 1559  typedef struct variable_statique Line 1659  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 1575  typedef struct vecteur Line 1675  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 1592  typedef struct matrice Line 1692  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 1606  typedef struct tableau Line 1706  typedef struct tableau
   
 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 1647  typedef struct rpl_arguments Line 1747  typedef struct rpl_arguments
 /* Traitement des erreurs                               */  /* Traitement des erreurs                               */
   
     unsigned char               *message_erreur;      unsigned char               *message_erreur;
     unsigned char               type_erreur;            /* S = système      unsigned char               type_erreur;            /* S = système
                                                            E = exécution */                                                             E = exécution */
     integer8                    erreur;      integer8                    erreur;
   
 /* Traitement des messages d'aide                       */  /* Traitement des messages d'aide                       */
Line 1670  typedef struct rpl_arguments Line 1770  typedef struct rpl_arguments
     void                        *s_etat_processus;      void                        *s_etat_processus;
 } struct_rpl_arguments;  } struct_rpl_arguments;
   
   /*
   --------------------------------------------------------------------------------
     Structure d'arbre des instructions intrinsèques
   --------------------------------------------------------------------------------
   */
   
   #ifndef RPLARGS
   typedef struct instruction
   {
       struct instruction      **noeuds;
       void                    (*feuille)(struct processus *);
   } struct_instruction;
   #endif
   
   /*
   --------------------------------------------------------------------------------
     Structure d'arbre des variables 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;
   
       integer8                            longueur_requise;
       int                                 classe;
   } struct_buffer;
   
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
Line 1709  typedef struct processus Line 1964  typedef struct processus
     unsigned char               traitement_cycle_exit;              /*N/E/C*/      unsigned char               traitement_cycle_exit;              /*N/E/C*/
     unsigned char               recherche_type;                     /*Y/N*/      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 1727  typedef struct processus Line 1982  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 1747  typedef struct processus Line 2002  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 1758  typedef struct processus Line 2012  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];
   
 #   if !defined(Cygwin)      volatile int                pointeur_signal_ecriture;
 #       if !(OpenBSD)      volatile int                pointeur_signal_lecture;
             stack_t             pile_signal;      volatile enum signaux_rpl   signaux_en_queue[LONGUEUR_QUEUE_SIGNAUX];
 #       else      volatile logical1           demarrage_fils;
 #           ifdef SA_ONSTACK      volatile logical1           redemarrage_processus;
 #               undef SA_ONSTACK  
 #           endif  
 #           define SA_ONSTACK   0  
 #       endif  
 #   else  
 #       define SA_ONSTACK       0  
 #       define RTLD_LOCAL       0  
 #   endif  
   
 /* Contextes                                            */  /* Contextes                                            */
   
Line 1780  typedef struct processus Line 2028  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 1808  typedef struct processus Line 2073  typedef struct processus
   
     struct_liste_chainee        *s_sockets;      struct_liste_chainee        *s_sockets;
   
 /*  Connecteurs aux bases de données                    */  /*  Connecteurs aux bases de données                   */
   
     struct_liste_chainee        *s_connecteurs_sql;      struct_liste_chainee        *s_connecteurs_sql;
   
 /* Bibliothèques dynamiques                             */  /* Bibliothèques dynamiques                                */
   
     struct_liste_chainee        *s_bibliotheques;      struct_liste_chainee        *s_bibliotheques;
     struct_instruction_externe  *s_instructions_externes;      struct_instruction_externe  *s_instructions_externes;
     unsigned long               nombre_instructions_externes;      integer8                    nombre_instructions_externes;
   
 /* Fichier d'impression                                 */  /* Fichier d'impression                                 */
   
Line 1966  typedef struct processus Line 2231  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 1990  typedef struct processus Line 2255  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 2004  typedef struct processus Line 2269  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 2014  typedef struct processus Line 2279  typedef struct processus
     unsigned char               masque_interruptions[d_NOMBRE_INTERRUPTIONS];      unsigned char               masque_interruptions[d_NOMBRE_INTERRUPTIONS];
   
     /*      /*
      * 'I' : interruption ignorée       * 'I' : interruption ignorée
      * 'Q' : interruption mise en queue pour un traitement ultérieur       * 'Q' : interruption mise en queue pour un traitement ultérieur
      * 'N' : traitement normal de l'interruption       * 'N' : traitement normal de l'interruption
      */       */
   
Line 2037  typedef struct processus Line 2302  typedef struct processus
 /* Variables volatiles                                  */  /* Variables volatiles                                  */
   
     volatile sig_atomic_t       var_volatile_alarme;      volatile sig_atomic_t       var_volatile_alarme;
     // Traitement de ctrl+C et des arrêts brutaux      // Traitement de ctrl+C et des arrêts brutaux
     volatile sig_atomic_t       var_volatile_requete_arret;      volatile sig_atomic_t       var_volatile_requete_arret;
     // Traitement de ctrl+Z      // Traitement de ctrl+Z
     volatile sig_atomic_t       var_volatile_requete_arret2;      volatile sig_atomic_t       var_volatile_requete_arret2;
Line 2059  typedef struct processus Line 2324  typedef struct processus
     gsl_rng                     *generateur_aleatoire;      gsl_rng                     *generateur_aleatoire;
     const gsl_rng_type          *type_generateur_aleatoire;      const gsl_rng_type          *type_generateur_aleatoire;
   
       void                        *contexte_cas;
   
     integer8                    nombre_arguments;      integer8                    nombre_arguments;
   
     /*      /*
      * Il s'agit du nombre d'arguments utilisé pour l'évaluation       * Il s'agit du nombre d'arguments utilisé pour l'évaluation
      * des expressions algébriques.       * des expressions algébriques.
      * -1 : la fonction ne peut être dans un objet de type ALG.       * -1 : la fonction ne peut être dans un objet de type ALG.
      * -2 : nombre d'arguments inconnu       * -2 : nombre d'arguments inconnu
      *  0 : la fonction doit apparaître en notation infixe       *  0 : la fonction doit apparaître en notation infixe
      * >0 : la fonction apparaît comme une fonction normale       * >0 : la fonction apparaît comme une fonction normale
      */       */
   
     logical1                    lancement_interactif;      logical1                    lancement_interactif;
Line 2077  typedef struct processus Line 2344  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 2092  typedef struct processus Line 2362  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;  
     pthread_mutex_t             mutex_allocation;      pthread_mutex_t             mutex_allocation;
       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      sem_t __PTR__               semaphore_fork;
 #   ifdef SEMAPHORES_NOMMES  
     *  
 #   endif  
                                 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             */
   
 /* Gestion optimisée de la mémoire                  */      logical1                    initialisation_scheduler;
   
   /* Drapeau nécessaire à RESTART                       */
   
       volatile logical1           requete_redemarrage;
   
   /* Gestion optimisée de la mémoire                    */
   
     double                      estimation_taille_pile_tampon;      double                      estimation_taille_pile_tampon;
     unsigned long               taille_pile_tampon;      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;
   
 #   ifndef DEBUG_MALLOC  #   define TAILLE_CACHE 1024
 #       define TAILLE_CACHE 16384  #   define CACHE(type, nom) \
 #   else      type                        *objets_##nom[TAILLE_CACHE]; \
 #       define TAILLE_CACHE 4      int                         pointeur_##nom;
 #   endif  
   #   define CACHE2(type, nom) \
     unsigned long               *objets_adr[TAILLE_CACHE];      type                        *nom[TAILLE_CACHE]; \
     int                         pointeur_adr;      int                         pointeur_##nom;
   
     logical8                    *objets_bin[TAILLE_CACHE];      CACHE(integer8, adr)
     int                         pointeur_bin;      CACHE(logical8, bin)
       CACHE(complex16, cpl)
     complex16                   *objets_cpl[TAILLE_CACHE];      CACHE(struct_fonction, fct)
     int                         pointeur_cpl;      CACHE(integer8, int)
       CACHE(struct_matrice, mat)
     struct fonction             *objets_fct[TAILLE_CACHE];      CACHE(struct_nom, nom)
     int                         pointeur_fct;      CACHE(real8, rel)
       CACHE(struct_tableau, tab)
     integer8                    *objets_int[TAILLE_CACHE];      CACHE(struct_vecteur, vec)
     int                         pointeur_int;  
       CACHE2(struct_liste_chainee, maillons)
     struct_matrice              *objets_mat[TAILLE_CACHE];      CACHE2(struct_arbre_variables, variables_noeud)
     int                         pointeur_mat;      CACHE2(struct_arbre_variables_partagees, variables_partagees_noeud)
       CACHE2(struct_liste_variables, variables_feuille)
     struct_nom                  *objets_nom[TAILLE_CACHE];      CACHE2(struct_variable, variables_variable)
     int                         pointeur_nom;      CACHE2(struct_arbre_variables *, variables_tableau_noeuds)
       CACHE2(struct_arbre_variables_partagees *,
     real8                       *objets_rel[TAILLE_CACHE];              variables_tableau_noeuds_partages)
     int                         pointeur_rel;  
       CACHE2(struct_buffer, enveloppes_buffers)
     struct_tableau              *objets_tab[TAILLE_CACHE];      unsigned char       ***cache_buffer;
     int                         pointeur_tab;      int                 *pointeur_cache_buffer;
   
     struct_vecteur              *objets_vec[TAILLE_CACHE];  
     int                         pointeur_vec;  
   
     struct_liste_chainee        *maillons[TAILLE_CACHE];  
     int                         pointeur_maillons;  
 } struct_processus;  } struct_processus;
 #endif  #endif
   
 /*  
 --------------------------------------------------------------------------------  
   Structures instruction intrinsèque  
 --------------------------------------------------------------------------------  
 */  
   
 #ifndef RPLARGS  
 typedef struct instruction  
 {  
     struct instruction      **noeud;  
     void                    (*feuille)(struct_processus *);  
 } struct_instruction;  
 #endif  
   
   
 /*  
 --------------------------------------------------------------------------------  
   Structure fonction  
 --------------------------------------------------------------------------------  
 */  
   
 #ifndef RPLARGS  
 typedef struct fonction  
 {  
     unsigned char                       *nom_fonction;  
     unsigned long                       nombre_arguments;  
   
     void                                (*fonction)(struct_processus *);  
   
     volatile struct_liste_chainee       *prediction_saut;  
     volatile logical1                   prediction_execution;  
 } struct_fonction;  
 #endif  
   
   
 /*  /*
 ================================================================================  ================================================================================
Line 2205  typedef struct fonction Line 2441  typedef struct fonction
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Procédures d'exécution des mots-clef du langage RPL/2    Procédures d'exécution des mots-clef du langage RPL/2
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
 // BEGIN C PROTOTYPES  // BEGIN C PROTOTYPES
 void instruction_sensible_e(struct_processus *s_etat_processus);  void instruction_sensible_e(struct_processus *s_etat_processus);
 void instruction_sensible_i(struct_processus *s_etat_processus);  void instruction_sensible_i(struct_processus *s_etat_processus);
   void instruction_sensible_infinity(struct_processus *s_etat_processus);
   
 void instruction_abort(struct_processus *s_etat_processus);  void instruction_abort(struct_processus *s_etat_processus);
 void instruction_abs(struct_processus *s_etat_processus);  void instruction_abs(struct_processus *s_etat_processus);
Line 2247  void instruction_ceil(struct_processus * Line 2484  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);
Line 2267  void instruction_col_fleche(struct_proce Line 2505  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 2281  void instruction_cosh(struct_processus * Line 2520  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 2306  void instruction_detach(struct_processus Line 2546  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 2332  void instruction_elseif(struct_processus Line 2573  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 2365  void instruction_fleche_str(struct_proce Line 2607  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 2408  void instruction_in(struct_processus *s_ Line 2651  void instruction_in(struct_processus *s_
 void instruction_incr(struct_processus *s_etat_processus);  void instruction_incr(struct_processus *s_etat_processus);
 void instruction_indep(struct_processus *s_etat_processus);  void instruction_indep(struct_processus *s_etat_processus);
 void instruction_input(struct_processus *s_etat_processus);  void instruction_input(struct_processus *s_etat_processus);
   void instruction_infinity(struct_processus *s_etat_processus);
 void instruction_inquire(struct_processus *s_etat_processus);  void instruction_inquire(struct_processus *s_etat_processus);
 void instruction_int(struct_processus *s_etat_processus);  void instruction_int(struct_processus *s_etat_processus);
 void instruction_interrupt(struct_processus *s_etat_processus);  void instruction_interrupt(struct_processus *s_etat_processus);
Line 2431  void instruction_lcd_fleche(struct_proce Line 2675  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 2444  void instruction_lq(struct_processus *s_ Line 2689  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 2498  void instruction_pmax(struct_processus * Line 2744  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 2554  void instruction_read(struct_processus * Line 2801  void instruction_read(struct_processus *
 void instruction_recode(struct_processus *s_etat_processus);  void instruction_recode(struct_processus *s_etat_processus);
 void instruction_recv(struct_processus *s_etat_processus);  void instruction_recv(struct_processus *s_etat_processus);
 void instruction_redraw(struct_processus *s_etat_processus);  void instruction_redraw(struct_processus *s_etat_processus);
   void instruction_regex(struct_processus *s_etat_processus);
 void instruction_relax(struct_processus *s_etat_processus);  void instruction_relax(struct_processus *s_etat_processus);
 void instruction_remove(struct_processus *s_etat_processus);  void instruction_remove(struct_processus *s_etat_processus);
 void instruction_res(struct_processus *s_etat_processus);  void instruction_res(struct_processus *s_etat_processus);
   void instruction_restart(struct_processus *s_etat_processus);
 void instruction_recall(struct_processus *s_etat_processus);  void instruction_recall(struct_processus *s_etat_processus);
 void instruction_regv(struct_processus *s_etat_processus);  void instruction_regv(struct_processus *s_etat_processus);
 void instruction_repeat(struct_processus *s_etat_processus);  void instruction_repeat(struct_processus *s_etat_processus);
Line 2565  void instruction_return(struct_processus Line 2814  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 2622  void instruction_sqlquery(struct_process Line 2873  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 2679  void instruction_trn(struct_processus *s Line 2931  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 2726  void instruction_yield(struct_processus Line 2979  void instruction_yield(struct_processus
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Procédures    Procédures
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
 #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
Line 2749  void appel_gnuplot(struct_processus *s_e Line 3000  void appel_gnuplot(struct_processus *s_e
 void cf(struct_processus *s_etat_processus, unsigned char indice_drapeau);  void cf(struct_processus *s_etat_processus, unsigned char indice_drapeau);
 void cond(struct_processus *s_etat_processus,  void cond(struct_processus *s_etat_processus,
         struct_matrice *s_matrice, real8 *condition);          struct_matrice *s_matrice, real8 *condition);
   void conversion_chaine(struct_processus *s_etat_processus,
           unsigned char *chaine, unsigned char type);
 void conversion_decimal_vers_hms(real8 *angle);  void conversion_decimal_vers_hms(real8 *angle);
 void conversion_degres_vers_radians(real8 *angle);  void conversion_degres_vers_radians(real8 *angle);
 void conversion_element_tex(unsigned char **element, unsigned char *fonction);  void conversion_element_tex(unsigned char **element, unsigned char *fonction);
Line 2756  void conversion_format(struct_processus Line 3009  void conversion_format(struct_processus
         unsigned char *chaine);          unsigned char *chaine);
 void conversion_hms_vers_decimal(real8 *angle);  void conversion_hms_vers_decimal(real8 *angle);
 void conversion_majuscule_limitee(unsigned char *chaine_entree,   void conversion_majuscule_limitee(unsigned char *chaine_entree, 
         unsigned char *chaine_sortie, unsigned long longueur);          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 2767  void determinant(struct_processus *s_eta Line 3022  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 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 2792  void formateur_elementaire_tex(struct_pr Line 3047  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 2813  void insertion_thread_surveillance(struc Line 3070  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(SIGHANDLER_ARGS);  void interface_cas(struct_processus *s_etat_processus,
 void interruption2(SIGHANDLER_ARGS);          enum t_rplcas_commandes commande);
 void interruption3(SIGHANDLER_ARGS);  void interruption1(int signal);
 void interruption4(SIGHANDLER_ARGS);  void interruption2(int signal);
 void interruption5(SIGHANDLER_ARGS);  void interruption3(int signal);
 void interruption6(SIGHANDLER_ARGS);  void interruption4(int signal);
 void interruption7(SIGHANDLER_ARGS);  void interruption5(int signal);
 void interruption8(SIGHANDLER_ARGS);  void interruption6(int signal);
 void interruption9(SIGHANDLER_ARGS);  void interruption_depassement_pile(int urgence, stackoverflow_context_t scp);
 void interruption10(SIGHANDLER_ARGS);  
 void interruption11(SIGHANDLER_ARGS);  
 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 2838  void liberation_maillon(struct_processus Line 3093  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 2854  void retrait_thread(struct_processus *s_ Line 3116  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);
   #endif
   
 void scrutation_injection(struct_processus *s_etat_processus);  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 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 2882  void valeurs_singulieres(struct_processu Line 3150  void valeurs_singulieres(struct_processu
 void verrouillage_threads_concurrents(struct_processus *s_etat_processus);  void verrouillage_threads_concurrents(struct_processus *s_etat_processus);
 #endif  #endif
   
   /*
   --------------------------------------------------------------------------------
     Fonctions de gestion des signaux
   --------------------------------------------------------------------------------
   */
   
 #ifndef RPLARGS  #ifndef RPLARGS
 #ifdef _BROKEN_SIGINFO  void creation_queue_signaux(struct_processus *s_etat_processus);
 void creation_fifos_signaux(struct_processus *s_etat_processus);  void liberation_queue_signaux(struct_processus *s_etat_processus);
 void destruction_fifos_signaux(struct_processus *s_etat_processus);  void destruction_queue_signaux(struct_processus *s_etat_processus);
 void liberation_fifos_signaux(struct_processus *s_etat_processus);  int envoi_signal_contexte(struct_processus *s_etat_processus,
 #endif          enum signaux_rpl signal);
   int envoi_signal_processus(pid_t pid, enum signaux_rpl signal);
   int envoi_signal_thread(pthread_t tid, enum signaux_rpl signal);
 #endif  #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 2908  complex16 sommation_vecteur_complexe(com Line 3184  complex16 sommation_vecteur_complexe(com
 */  */
   
 #ifndef RPLARGS  #ifndef RPLARGS
 int rplinit(int argc, char *argv[], unsigned char ***resultats, char *rpl_home);  int rplinit(int argc, char *argv[], char *envp[],
           unsigned char ***resultats, char *rpl_home);
 #endif  #endif
   
 /*  /*
Line 2919  int rplinit(int argc, char *argv[], unsi Line 3196  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_matrice *s_matrice,
         unsigned char type);          unsigned char type);
 struct_vecteur *moyenne_statistique(struct_matrice *s_matrice);  struct_vecteur *moyenne_statistique(struct_matrice *s_matrice);
 struct_vecteur *sommation_colonne_statistique(struct_matrice *s_matrice,  struct_vecteur *sommation_colonne_statistique(struct_matrice *s_matrice,
         unsigned long colonne);          integer8 colonne);
 struct_vecteur *sommation_produits_colonnes_statistiques(struct_matrice  struct_vecteur *sommation_produits_colonnes_statistiques(struct_matrice
         *s_matrice, unsigned long colonne_1, unsigned long colonne_2);          *s_matrice, integer8 colonne_1, integer8 colonne_2);
 struct_vecteur *sommation_statistique(struct_matrice *s_matrice);  struct_vecteur *sommation_statistique(struct_matrice *s_matrice);
 struct_vecteur *variance_statistique(struct_matrice *s_matrice,  struct_vecteur *variance_statistique(struct_matrice *s_matrice,
         unsigned char type);          unsigned char type);
Line 2937  struct_vecteur *variance_statistique(str Line 3214  struct_vecteur *variance_statistique(str
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Gestion des bibliothèques    Gestion des bibliothèques
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 2955  struct_liste_chainee *depilement_pile_op Line 3232  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 2966  struct_liste_chainee *sauvegarde_argumen Line 3243  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  unsigned char *analyse_flux(struct_processus *s_etat_processus,
         *s_etat_processus);          unsigned char *flux, integer8 longueur);
   unsigned char *chiffrement(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 *compactage(unsigned char *chaine);  unsigned char *compactage(unsigned char *chaine);
 unsigned char *conversion_majuscule(unsigned char *chaine);  unsigned char *conversion_majuscule(unsigned char *chaine);
 unsigned char *creation_nom_fichier(struct_processus *s_etat_processus,  unsigned char *creation_nom_fichier(struct_processus *s_etat_processus,
         unsigned char *chemin);          unsigned char *chemin);
 unsigned char *extraction_chaine(unsigned char *chaine, unsigned long i,  unsigned char *date_compilation();
         unsigned long j);  unsigned char *extraction_chaine(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);
   unsigned char *formateur_flux(struct_processus *s_etat_processus,
           unsigned char *donnees, integer8 *longueur);
 unsigned char *formateur_fichier_nombre(struct_processus *s_etat_processus,  unsigned char *formateur_fichier_nombre(struct_processus *s_etat_processus,
         void *valeur_numerique, unsigned char type,          void *valeur_numerique, unsigned char type,
         long longueur, long longueur_champ, unsigned char format);          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 *pointeur_ieme_caractere(struct_processus *s_etat_processus,
           unsigned char *chaine, integer8 position);
 unsigned char *purification_chaine(unsigned char *chaine);  unsigned char *purification_chaine(unsigned char *chaine);
   unsigned char *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 3008  unsigned char *transliteration(struct_pr Line 3300  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,  logical1 controle(struct_processus *s_etat_processus, unsigned char *fichier,
         unsigned char *type, unsigned char *somme_candidate);          unsigned char *type, unsigned char *somme_candidate);
   logical1 controle_integrite(struct_processus *s_etat_processus,
           unsigned char *executable_candidat, unsigned char *executable);
 logical1 creation_variable(struct_processus *s_etat_processus,  logical1 creation_variable(struct_processus *s_etat_processus,
         struct_variable *s_variable,          struct_variable *s_variable,
         unsigned char autorisation_creation_variable_statique,          unsigned char autorisation_creation_variable_statique,
Line 3029  logical1 destruction_fichier(unsigned ch Line 3324  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,  logical1 initialisation_fichier_acces_direct(struct_processus *s_etat_processus,
         sqlite3 *sqlite, logical1 binaire);          sqlite3 *sqlite, logical1 binaire);
 logical1 initialisation_fichier_acces_indexe(struct_processus *s_etat_processus,  logical1 initialisation_fichier_acces_indexe(struct_processus *s_etat_processus,
         sqlite3 *sqlite, integer8 position_clef, logical1 binaire);          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);
 #endif  #endif
Line 3057  logical1 sequenceur_optimise(struct_proc Line 3359  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 3064  logical1 ecriture_pipe(struct_processus Line 3367  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 3096  ssize_t write_atomic(struct_processus *s Line 3396  ssize_t write_atomic(struct_processus *s
 */  */
   
 int alsprintf(unsigned char **strp, const char *fmt, ...);  int alsprintf(unsigned char **strp, const char *fmt, ...);
   int interruption_violation_access(void *adresse_fautive, int gravite);
   #ifndef RPLARGS
   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 tex_fprintf(struct_processus *s_etat_processus,  int tex_fprintf(struct_processus *s_etat_processus,
         file *flux, const char *format, ...);          file *flux, const char *format, ...);
 int transliterated_fprintf(struct_processus *s_etat_processus, file *flux,  int transliterated_fprintf(struct_processus *s_etat_processus, file *flux,
Line 3112  int wrapper_instruction_intrinseque(void Line 3420  int wrapper_instruction_intrinseque(void
   
 #ifndef RPLARGS  #ifndef RPLARGS
 unsigned char longueur_entiers_binaires(struct_processus *s_etat_processus);  unsigned char longueur_entiers_binaires(struct_processus *s_etat_processus);
 unsigned char recherche_longueur_optimale(integer8 parametre);  
 #endif  #endif
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Fonctions retournant un INTEGER*8 (valeur binaire non signée)    Fonctions retournant un INTEGER*8 (valeur binaire non signée)
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 3133  logical8 masque_entiers_binaires(struct_ Line 3440  logical8 masque_entiers_binaires(struct_
   
 #ifndef RPLARGS  #ifndef RPLARGS
 integer8 occupation_memoire(struct_objet *s_objet);  integer8 occupation_memoire(struct_objet *s_objet);
   integer8 longueur_chaine(struct_processus *s_etat_processus,
           unsigned char *chaine);
   integer8 position_caractere_de_chaine(struct_processus *s_etat_processus,
           unsigned char *chaine, unsigned char *position);
 #endif  #endif
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Fonctions renvoyant une liste chaînée (pointeur sur *struct_liste_chainee)    Fonctions renvoyant une liste chaînée (pointeur sur *struct_liste_chainee)
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 3148  struct_liste_chainee *analyse_rpn(struct Line 3459  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,
           integer8 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 3177  struct_descripteur_fichier *descripteur_ Line 3501  struct_descripteur_fichier *descripteur_
 struct_objet *copie_objet(struct_processus *s_etat_processus,  struct_objet *copie_objet(struct_processus *s_etat_processus,
         struct_objet *s_objet, unsigned char type);          struct_objet *s_objet, unsigned char type);
   
   struct_objet *allocation(struct_processus *s_etat_processus, enum t_type type);
 #ifndef RPLARGS  #ifndef RPLARGS
 struct_objet *formateur_date(struct_processus *s_etat_processus,  struct_objet *formateur_date(struct_processus *s_etat_processus,
         struct timeval *temps);          struct timeval *temps);
   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
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Fonctions gérant la complétion automatique    Fonctions gérant la complétion automatique
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 3218  char **completion_matches(); Line 3546  char **completion_matches();
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Arithmétique    Arithmétique
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 3239  void f77multiplicationci_(complex16 *ca, Line 3567  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 3264  void f77soustractionrc_(real8 *ra, compl Line 3590  void f77soustractionrc_(real8 *ra, compl
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Trigonométrie complexe    Trigonométrie complexe
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
Line 3361  void zgeev_(unsigned char *calcul_vp_gau Line 3687  void zgeev_(unsigned char *calcul_vp_gau
         integer4 *erreur, integer4 longueur_1, integer4 longueur_2);          integer4 *erreur, integer4 longueur_1, integer4 longueur_2);
   
     /*      /*
      * Valeurs propres généralisées       * Valeurs propres généralisées
      */       */
   
 void zggev_(unsigned char *calcul_vp_gauches, unsigned char *calcul_vp_droits,  void zggev_(unsigned char *calcul_vp_gauches, unsigned char *calcul_vp_droits,
Line 3374  void zggev_(unsigned char *calcul_vp_gau Line 3700  void zggev_(unsigned char *calcul_vp_gau
         integer4 *erreur, integer4 longueur_1, integer4 longueur_2);          integer4 *erreur, integer4 longueur_1, integer4 longueur_2);
   
     /*      /*
      * Moindres carrés       * Moindres carrés
      */       */
   
 void dgelsd_(integer4 *nombre_lignes_a, integer4 *nombre_colonnes_a,  void dgelsd_(integer4 *nombre_lignes_a, integer4 *nombre_colonnes_a,
Line 3389  void zgelsd_(integer4 *nombre_lignes_a, Line 3715  void zgelsd_(integer4 *nombre_lignes_a,
         real8 *rwork, integer4 *iwork, integer4 *info);          real8 *rwork, integer4 *iwork, integer4 *info);
   
     /*      /*
      * Moindres carrés généralisé       * Moindres carrés généralisé
      */       */
   
     /*      /*
      * Décomposition en valeurs singulières       * Décomposition en valeurs singulières
      */       */
   
 void dgesvd_(unsigned char *jobu, unsigned char *jobvh,  void dgesvd_(unsigned char *jobu, unsigned char *jobvh,
Line 3450  void zgees_(unsigned char *calcul_vecteu Line 3776  void zgees_(unsigned char *calcul_vecteu
         real8 *rwork, logical4 *bwork, integer4 *info,          real8 *rwork, logical4 *bwork, integer4 *info,
         integer4 l1, integer4 l2);          integer4 l1, integer4 l2);
   
         /* Déterminant et rang */          /* Déterminant et rang */
 void dgecon_(unsigned char *norm, integer4 *n, real8 *a, integer4 *lda,  void dgecon_(unsigned char *norm, integer4 *n, real8 *a, integer4 *lda,
         real8 *anorm, real8 *rcond, real8 *work, integer4 *iwork,          real8 *anorm, real8 *rcond, real8 *work, integer4 *iwork,
         integer4 *info, integer4 l1);          integer4 *info, integer4 l1);
Line 3471  void zgelsy_(integer4 *m, integer4 *n, i Line 3797  void zgelsy_(integer4 *m, integer4 *n, i
 #endif  #endif
   
 /*  /*
  * Fonction testant la requête d'arrêt (nécessaire pour tester le   * Fonction testant la requête d'arrêt (nécessaire pour tester le
  * drapeau depuis une bibliothèque).   * drapeau depuis une bibliothèque).
  */   */
   
 int test_arret(struct_processus *s_etat_processus);  int test_arret(struct_processus *s_etat_processus);

Removed from v.1.73  
changed lines
  Added in v.1.257


CVSweb interface <joel.bertrand@systella.fr>