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

Diff for /rpl/src/rpl.h between versions 1.178 and 1.278

version 1.178, 2012/10/03 09:42:04 version 1.278, 2015/10/22 18:37:09
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.11    RPL/2 (R) version 4.1.23
   Copyright (C) 1989-2012 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 38 Line 38
 #   ifdef OpenBSD  #   ifdef OpenBSD
 #       define _BSD_SOURCE  #       define _BSD_SOURCE
 #   endif  #   endif
   
   #   ifdef FreeBSD
   #       define __BSD_VISIBLE    1
   #   endif
 #endif  #endif
   
 #ifdef OS2  #ifdef OS2
Line 56 Line 60
 #   define sched_yield(arg)  #   define sched_yield(arg)
 #endif  #endif
   
   #ifdef CYGWIN
   #   define SA_ONSTACK   0
   #endif
   
   
 /*  /*
 ================================================================================  ================================================================================
Line 65 Line 73
   
 #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>
Line 72 Line 81
 #include <errno.h>  #include <errno.h>
 #include <stdarg.h>  #include <stdarg.h>
 #include <poll.h>  #include <poll.h>
   #include <signal.h>
   
 #ifndef RPLARGS  #ifndef RPLARGS
 #   include <sys/mman.h>  #   include <sys/mman.h>
Line 153 Line 163
 #   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 163 Line 172
 #   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"  #   include "sigsegv.h"
 #   ifdef OS2  #   ifdef OS2
Line 172 Line 216
 #       undef HAVE_STACK_OVERFLOW_RECOVERY  #       undef HAVE_STACK_OVERFLOW_RECOVERY
 #   endif  #   endif
   
 #   define HAVE_INLINE  
 #   define GSL_RANGE_CHECK_OFF  #   define GSL_RANGE_CHECK_OFF
 #   include "gsl/gsl_cdf.h"  #   include "gsl/gsl_cdf.h"
 #   include "gsl/gsl_cblas.h"  #   include "gsl/gsl_cblas.h"
Line 278  enum signaux_rpl Line 321  enum signaux_rpl
 #ifndef RPLARGS  #ifndef RPLARGS
 typedef struct queue_signaux  typedef struct queue_signaux
 {  {
 #   ifndef IPCS_SYSV  
 #       ifndef SEMAPHORES_NOMMES  
             sem_t               semaphore;  
             sem_t               signalisation;  
 #       endif  
 #   else  
         sem_t                   semaphore;  
         sem_t                   signalisation;  
 #   endif  
   
     volatile int                pointeur_lecture;      volatile int                pointeur_lecture;
     volatile int                pointeur_ecriture;      volatile int                pointeur_ecriture;
     pthread_t                   thread_signaux;  
     volatile logical1           requete_arret;      volatile logical1           requete_arret;
   
       pthread_t                   thread_signaux;
       pid_t                       controle;
   
     volatile struct      volatile struct
     {      {
         pid_t                   pid;          pid_t                   pid;
         enum signaux_rpl        signal;          enum signaux_rpl        signal;
     }                           queue[LONGUEUR_QUEUE_SIGNAUX];      }                           queue[LONGUEUR_QUEUE_SIGNAUX];
   
   #   ifdef OS2
       sem_t                       semaphore;
       sem_t                       signalisation;
       sem_t                       arret_signalisation;
   #   endif
 } struct_queue_signaux;  } struct_queue_signaux;
   
 __EXTERN__ struct_queue_signaux     *s_queue_signaux;  __EXTERN__ struct_queue_signaux *s_queue_signaux;
 __EXTERN__ int                      f_queue_signaux;  __EXTERN__ int                  f_queue_signaux;
   
 #   ifdef SEMAPHORES_NOMMES  #   ifndef OS2
         __EXTERN__ sem_t            *semaphore_queue_signaux;      __EXTERN__ sem_t            *semaphore_queue_signaux;
         __EXTERN__ sem_t            *semaphore_signalisation;      __EXTERN__ sem_t            *semaphore_signalisation;
       __EXTERN__ sem_t            *semaphore_arret_signalisation;
 #   endif  #   endif
 #endif  #endif
   
 #ifdef OS2  
 #   define readline(s) readline_wrapper(s)  
     unsigned char *readline_wrapper(unsigned char *s);  
 #endif  
   
 #if ! defined(UNION_SEMUN) && defined(IPCS_SYSV)  #if ! defined(UNION_SEMUN) && defined(IPCS_SYSV)
 union semun  union semun
 {  {
Line 332  union semun Line 369  union semun
 #   define SIGSTKSZ         65536  #   define SIGSTKSZ         65536
 #endif  #endif
   
   
 /*  /*
 ================================================================================  ================================================================================
   SÉMAPHORES    SÉMAPHORES
Line 339  union semun Line 377  union semun
 */  */
   
 #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_timedwait(a, b)  sem_timedwait_SysV(a, b)  #   define sem_timedwait(a, b)  sem_timedwait_SysV(a, b)
 #   define sem_post(a)          sem_post_SysV(a)  
 #   define sem_getvalue(a, b)   sem_getvalue_SysV(a, b)  #   define sem_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 419  union semun Line 500  union semun
 #ifndef RPLARGS  #ifndef RPLARGS
 #   ifdef SEMAPHORES_NOMMES  #   ifdef SEMAPHORES_NOMMES
 #       define LONGUEUR_NOM_SEMAPHORE   64  #       define LONGUEUR_NOM_SEMAPHORE   64
 #   endif  
   
 #   ifdef SEMAPHORES_NOMMES  
 #       define __PTR__      *  #       define __PTR__      *
 #   else  #   else
 #       define __PTR__  #       define __PTR__
Line 437  union semun Line 515  union semun
   
     __EXTERN__ pid_t                pid_processus_pere;      __EXTERN__ pid_t                pid_processus_pere;
   
 #   ifdef SEMAPHORES_NOMMES  
     __EXTERN__ pthread_mutex_t      mutex_sem __STATIC_MUTEX_INITIALIZATION__;  
 #   endif  
   
     __EXTERN__ pthread_mutex_t      mutex_liste_threads      __EXTERN__ pthread_mutex_t      mutex_liste_threads
                                             __STATIC_MUTEX_INITIALIZATION__;                                              __STATIC_MUTEX_INITIALIZATION__;
     __EXTERN__ pthread_mutex_t      mutex_gestionnaires_signaux_atomique      __EXTERN__ pthread_mutex_t      mutex_creation_variable_partagee
                                             __STATIC_MUTEX_INITIALIZATION__;                                              __STATIC_MUTEX_INITIALIZATION__;
     __EXTERN__ pthread_mutex_t      mutex_sections_critiques;      __EXTERN__ pthread_mutex_t      mutex_sections_critiques;
       __EXTERN__ pthread_mutex_t      mutex_liste_variables_partagees;
     __EXTERN__ sem_t __PTR__        semaphore_gestionnaires_signaux;      __EXTERN__ pthread_mutex_t      mutex_sem __STATIC_MUTEX_INITIALIZATION__;
   
     __EXTERN__ volatile int         routine_recursive;      __EXTERN__ volatile int         routine_recursive;
 #endif  
   
 #ifdef SEMAPHORES_NOMMES  #   define SEM_FORK                 0
 #define SEM_FORK            0  #   define SEM_QUEUE                1
 #define SEM_QUEUE           1  #   define SEM_SIGNALISATION        2
 #define SEM_SIGNAUX         2  #   define SEM_ARRET_SIGNALISATION  3
 #define SEM_SIGNALISATION   3  
 sem_t *sem_init2(unsigned int valeur, pid_t pid, int ordre);      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);      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_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_destroy3(sem_t *semaphore_p, pid_t pid, pthread_t tid, int ordre);
 int sem_getvalue2(sem_t *semaphore, int *valeur);      int sem_getvalue2(sem_t *semaphore, int *valeur);
 sem_t *sem_open2(pid_t pid, int ordre);      sem_t *sem_open2(pid_t pid, int ordre);
   #endif
   
 // Le mutex est là uniquement pour pouvoir émuler le comportement  // Le mutex est là uniquement pour pouvoir émuler le comportement
 // de sem_getvalue() sur un système comme MacOS X qui ne possède pas  // de sem_getvalue() sur un système comme MacOS X qui ne possède pas
 // cette fonction.  // cette fonction.
   
   #ifdef Darwin
 #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 493  sem_t *sem_open2(pid_t pid, int ordre); Line 568  sem_t *sem_open2(pid_t pid, int ordre);
             stderr, __VA_ARGS__)              stderr, __VA_ARGS__)
 #define fprintf(flux, ...) transliterated_fprintf(s_etat_processus, \  #define fprintf(flux, ...) transliterated_fprintf(s_etat_processus, \
             flux, __VA_ARGS__)              flux, __VA_ARGS__)
 #define uprintf(...) transliterated_fprintf(NULL, \  #define uprintf(...) std_fprintf(stderr, __VA_ARGS__)
             stderr, __VA_ARGS__)  #define ufprintf(flux, ...) std_fprintf(flux, __VA_ARGS__)
 #define ufprintf(flux, ...) transliterated_fprintf(NULL, \  
             flux, __VA_ARGS__)  
   
 #ifdef SunOS  #ifdef SunOS
 #   define fopen(...) ({ FILE *desc; \  #   define fopen(...) ({ FILE *desc; \
Line 578  sem_t *sem_open2(pid_t pid, int ordre); Line 651  sem_t *sem_open2(pid_t pid, int ordre);
         { \          { \
             for(i = 0; i < nb; i++) \              for(i = 0; i < nb; i++) \
                 uprintf("    %s\n", appels[i]); \                  uprintf("    %s\n", appels[i]); \
             free(appels); \              sys_free(appels); \
         } \          } \
         else \          else \
             uprintf("Nullified backtrace\n"); \              uprintf("Nullified backtrace\n"); \
Line 652  pid_t debug_fork(); Line 725  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 717  pid_t debug_fork(); Line 773  pid_t debug_fork();
 #define d_SPH                   "Semaphore $n 'name'"  #define d_SPH                   "Semaphore $n 'name'"
 #define d_TAB                   "<[ table ]>"  #define d_TAB                   "<[ table ]>"
 #define d_MTX                   "Mutex $n"  #define d_MTX                   "Mutex $n"
   #define d_REC                   "Record /'name_1', ..., 'name_n'/"
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
Line 926  pid_t debug_fork(); Line 983  pid_t debug_fork();
 #   define d_ex_mutex_acquis_autre_thread       __erreur(86)  #   define d_ex_mutex_acquis_autre_thread       __erreur(86)
 #   define d_ex_expression_reguliere            __erreur(87)  #   define d_ex_expression_reguliere            __erreur(87)
 #   define d_ex_instruction_indisponible        __erreur(88)  #   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 965  pid_t debug_fork(); Line 1026  pid_t debug_fork();
 #define NOM __RPL_NOM  #define NOM __RPL_NOM
 #define NON __RPL_NON  #define NON __RPL_NON
 #define PRC __RPL_PRC  #define PRC __RPL_PRC
   #define REC __RPL_REC
 #define REL __RPL_REL  #define REL __RPL_REL
 #define RPN __RPL_RPN  #define RPN __RPL_RPN
 #define SCK __RPL_SCK  #define SCK __RPL_SCK
Line 979  pid_t debug_fork(); Line 1041  pid_t debug_fork();
 enum t_rplcas_commandes     { RPLCAS_INTEGRATION = 0, RPLCAS_LIMITE };  enum t_rplcas_commandes     { RPLCAS_INTEGRATION = 0, RPLCAS_LIMITE };
   
 enum t_type     { ADR = 0, ALG, BIN, CHN, CPL, FCH, FCT, INT, LST,  enum t_type     { ADR = 0, ALG, BIN, CHN, CPL, FCH, FCT, INT, LST,
                 MCX, MIN, MRL, MTX, NOM, NON, PRC, REL, RPN, SCK,                  MCX, MIN, MRL, MTX, NOM, NON, PRC, REC, REL, RPN, SCK,
                 SLB, SPH, SQL, TBL, VCX, VIN, VRL };                  SLB, SPH, SQL, TBL, VCX, VIN, VRL };
   
     /*      /*
     ADR : adresse sur 32 bits (au moins) non signés (unsigned long)      ADR : adresse sur 64 bits signés.
             Adresse d'une définition à interpréter.              Adresse d'une définition à interpréter.
   
     ALG : expression algébrique (struct_liste_chainee *)      ALG : expression algébrique (struct_liste_chainee *)
Line 995  enum t_type  { ADR = 0, ALG, BIN, CHN, C Line 1057  enum t_type  { ADR = 0, ALG, BIN, CHN, C
             Sans objet.              Sans objet.
             Type C/Fortran : unsigned integer8              Type C/Fortran : unsigned integer8
   
     CHN : chaine de caracteres (character*(*), unsigned char *)      CHN : chaine de caracteres (unsigned char *)
             Sans objet.              Sans objet.
   
     CPL : complexe sur 2*64 bits (complex*16, struct_complexe16 *)      CPL : complexe sur 2*64 bits (complex*16, struct_complexe16 *)
Line 1085  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 1178  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 1224  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 1237  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 1248  typedef struct connecteur_sql Line 1315  typedef struct connecteur_sql
 */  */
   
 #ifndef RPLARGS  #ifndef RPLARGS
   
   #   define                      d_BIND_TO_DEVICE        0
   #   define                      d_BROADCAST             1
   #   define                      d_DONT_ROUTE            2
   #   define                      d_KEEP_ALIVE            3
   #   define                      d_PRIORITY              4
   #   define                      d_RECEIVE_BUFFER        5
   #   define                      d_FORCE_RECEIVE_BUFFER  6
   #   define                      d_SEND_BUFFER           7
   #   define                      d_FORCE_SEND_BUFFER     8
   #   define                      d_RECEIVING_TIMEOUT     9
   #   define                      d_SENDING_TIMEOUT       10
   #   define                      d_REUSE_ADDRESS         11
   
 typedef struct socket  typedef struct socket
 {  {
     int                         domaine;      int                         domaine;
Line 1266  typedef struct socket Line 1347  typedef struct socket
     unsigned char               protection;      unsigned char               protection;
     unsigned char               type[19 + 1];      unsigned char               type[19 + 1];
   
       integer8                    options;
       int                         priorite;
       int                         buffer_reception;
       int                         buffer_emission;
       int                         timeout_emission;
       int                         timeout_reception;
   
     struct_objet                *format;      struct_objet                *format;
 } struct_socket;  } struct_socket;
 #endif  #endif
Line 1412  typedef struct descripteur_thread Line 1500  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 1443  typedef struct liste_pile_systeme Line 1533  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 1498  typedef struct liste_pile_systeme Line 1586  typedef struct liste_pile_systeme
     A     FORALL  : NEXT termine une boucle sur un objet.      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 1514  typedef struct liste_pile_systeme Line 1602  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;
   
Line 1523  typedef struct variable Line 1611  typedef struct variable
     unsigned char           *nom;      unsigned char           *nom;
     unsigned char           origine; // P(rogramme) ou E(valuation)      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 1548  typedef struct variable_partage Line 1636  typedef struct variable_partage
     unsigned char               *nom;      unsigned char               *nom;
     unsigned char               origine;      unsigned char               origine;
   
     unsigned long               niveau;      integer8                    niveau;
   
     union_position_variable     variable_partagee;      union_position_variable     variable_partagee;
   
     struct_objet                *objet;      struct_objet                *objet;
 } struct_variable_partagee;  
   
 typedef struct table_variables_partagees  
 {  
     pthread_mutex_t                     mutex;  
   
     volatile struct_variable_partagee   *table;  
   
     volatile unsigned long              nombre_variables;  
     volatile unsigned long              nombre_variables_allouees;  
   
     unsigned long                       position_variable;      pthread_mutex_t             mutex;
 } struct_table_variables_partagees;  } struct_variable_partagee;
   
 #endif  #endif
   
Line 1585  typedef struct variable_statique Line 1663  typedef struct variable_statique
     // Position de création de la variable statique dans le programme ou dans      // Position de création de la variable statique dans le programme ou dans
     // l'expression. 'origine' vaut 'P' pour programme ou 'E' pour expression.      // l'expression. 'origine' vaut 'P' pour programme ou 'E' pour expression.
   
     unsigned long           niveau;      integer8                niveau;
   
     union_position_variable variable_statique;      union_position_variable variable_statique;
   
Line 1602  typedef struct variable_statique Line 1680  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 1618  typedef struct vecteur Line 1696  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 1635  typedef struct matrice Line 1713  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 1649  typedef struct tableau Line 1727  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 1736  typedef struct instruction Line 1814  typedef struct instruction
 #ifndef RPLARGS  #ifndef RPLARGS
 typedef struct arbre_variables  typedef struct arbre_variables
 {  {
     unsigned int            noeuds_utilises;      unsigned int                        noeuds_utilises;
     signed int              indice_tableau_pere;                                          // Nombre de noeuds utilisés dans le
     struct arbre_variables  *noeud_pere;                                          // tableau **noeuds
     struct arbre_variables  **noeuds;      signed int                          indice_tableau_pere;
     struct liste_variables  *feuille;                                          // 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;  } 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  typedef struct tableau_variables
 {  {
     unsigned char           origine;      unsigned char           origine;
     unsigned char           *nom;       // pointeur sur la struct_variable      unsigned char           *nom;       // pointeur sur la struct_variable
                                         // réelle et non copie de la chaîne                                          // réelle et non copie de la chaîne
     unsigned long           niveau;      integer8                niveau;
   
     struct_objet            *objet;     // pointeur sur l'objet et non copie      struct_objet            *objet;     // pointeur sur l'objet et non copie
                                         // de l'objet.                                          // de l'objet.
   
     logical1                variable_verrouillee;      logical1                variable_verrouillee;
       logical1                variable_masquee;
       pthread_mutex_t         *mutex;
     union_position_variable variable_statique;      union_position_variable variable_statique;
     union_position_variable variable_partagee;      union_position_variable variable_partagee;
 } struct_tableau_variables;  } struct_tableau_variables;
   
   // La liste des variables est une liste doublement chaînée et circulaire.
 typedef struct liste_variables  typedef struct liste_variables
 {  {
     union      union
Line 1774  typedef struct liste_variables Line 1888  typedef struct liste_variables
     struct liste_variables              *precedent;      struct liste_variables              *precedent;
 } struct_liste_variables;  } struct_liste_variables;
   
   // La liste des variables statiques et une liste double chaînée et non
   // 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  #endif
   
   
   /*
   --------------------------------------------------------------------------------
     Structure fonction
   --------------------------------------------------------------------------------
   */
   
   #ifndef RPLARGS
   typedef struct fonction
   {
       unsigned char                       *nom_fonction;
       integer8                            nombre_arguments;
   
       void                                (*fonction)(struct processus *);
   
       volatile struct_liste_chainee       *prediction_saut;
       volatile logical1                   prediction_execution;
   } struct_fonction;
   #endif
   
   
   /*
   --------------------------------------------------------------------------------
     Structure buffer
   --------------------------------------------------------------------------------
   */
   
   typedef struct buffer
   {
       unsigned char                       *buffer;
   
       size_t                              longueur_requise;
       int                                 classe;
   } struct_buffer;
   
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Structure processus    Structure processus
Line 1814  typedef struct processus Line 1985  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                       */
   
Line 1832  typedef struct processus Line 2003  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 1852  typedef struct processus Line 2023  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 1863  typedef struct processus Line 2033  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];
   
     volatile int                pointeur_signal_ecriture;      volatile int                pointeur_signal_ecriture;
     volatile int                pointeur_signal_lecture;      volatile int                pointeur_signal_lecture;
Line 1889  typedef struct processus Line 2061  typedef struct processus
   
     struct_arbre_variables      *s_arbre_variables;      struct_arbre_variables      *s_arbre_variables;
     struct_liste_variables      *l_liste_variables_par_niveau;      struct_liste_variables      *l_liste_variables_par_niveau;
       struct_liste_variables_statiques
                                   *l_liste_variables_statiques;
   
       struct_arbre_variables_partagees
                                   **s_arbre_variables_partagees;
       struct_liste_variables_partagees
                                   **l_liste_variables_partagees;
   
     logical1                    niveau_supprime;      logical1                    niveau_supprime;
   
     struct_variable             *pointeur_variable_courante;      struct_variable             *pointeur_variable_courante;
     struct_liste_variables      *pointeur_feuille_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                         *pointeurs_caracteres_variables;
     int                         nombre_caracteres_variables;      int                         nombre_caracteres_variables;
   
     struct_variable_statique    *s_liste_variables_statiques;      integer8                    niveau_courant;
     unsigned long               nombre_variables_statiques;      integer8                    niveau_initial;
     unsigned long               nombre_variables_statiques_allouees;  
   
     struct_table_variables_partagees  
                                 *s_liste_variables_partagees;  
   
     unsigned long               niveau_courant;  
     unsigned long               niveau_initial;  
     unsigned long               position_variable_statique_courante;  
   
     logical1                    creation_variables_statiques;      logical1                    creation_variables_statiques;
     logical1                    creation_variables_partagees;      logical1                    creation_variables_partagees;
Line 1928  typedef struct processus Line 2102  typedef struct processus
   
     struct_liste_chainee        *s_bibliotheques;      struct_liste_chainee        *s_bibliotheques;
     struct_instruction_externe  *s_instructions_externes;      struct_instruction_externe  *s_instructions_externes;
     unsigned long               nombre_instructions_externes;      integer8                    nombre_instructions_externes;
   
 /* Fichier d'impression                                 */  /* Fichier d'impression                                 */
   
Line 2078  typedef struct processus Line 2252  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 2102  typedef struct processus Line 2276  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 2116  typedef struct processus Line 2290  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 2191  typedef struct processus Line 2365  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;
Line 2199  typedef struct processus Line 2373  typedef struct processus
   
     logical1                    processus_detache;      logical1                    processus_detache;
   
       enum t_type                 type_en_cours;
   
 /* Profilage                                            */  /* Profilage                                            */
   
     logical1                    profilage;      logical1                    profilage;
Line 2207  typedef struct processus Line 2383  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_allocation_buffer;
       pthread_mutex_t             mutex_interruptions;
       pthread_mutex_t             mutex_pile_processus;
       pthread_mutex_t             mutex_signaux;
   
     // Mutex autorisant les fork()      // Mutex autorisant les fork()
     sem_t __PTR__               semaphore_fork;      sem_t __PTR__               semaphore_fork;
Line 2220  typedef struct processus Line 2398  typedef struct processus
     pthread_mutex_t             protection_liste_mutexes;      pthread_mutex_t             protection_liste_mutexes;
     unsigned int                sections_critiques;      unsigned int                sections_critiques;
   
 /* Drapeau nécessaire à RESTART                 */  /* Variable d'initialisation pour SCHED             */
   
       logical1                    initialisation_scheduler;
   
   /* Drapeau nécessaire à RESTART                     */
   
     volatile logical1           requete_redemarrage;      volatile logical1           requete_redemarrage;
   
 /* Gestion optimisée de la mémoire                  */  /* Gestion optimisée de la mémoire                  */
   
     double                      estimation_taille_pile_tampon;      double                      estimation_taille_pile_tampon;
     unsigned long               taille_pile_tampon;      integer8                    taille_pile_tampon;
     struct_liste_chainee        *pile_tampon;      struct_liste_chainee        *pile_tampon;
   
     double                      estimation_taille_pile_systeme_tampon;      double                      estimation_taille_pile_systeme_tampon;
     unsigned long               taille_pile_systeme_tampon;      integer8                    taille_pile_systeme_tampon;
     struct_liste_pile_systeme   *pile_systeme_tampon;      struct_liste_pile_systeme   *pile_systeme_tampon;
   
     unsigned long               taille_pile_objets;      integer8                    taille_pile_objets;
     struct_objet                *pile_objets;      struct_objet                *pile_objets;
   
 #   define TAILLE_CACHE 16384  #   define TAILLE_CACHE         1024
   #   define CACHE(type, nom) \
     unsigned long               *objets_adr[TAILLE_CACHE];      type                        *objets_##nom[TAILLE_CACHE]; \
     int                         pointeur_adr;      volatile int                pointeur_##nom;
   
     logical8                    *objets_bin[TAILLE_CACHE];  #   define CACHE2(type, nom) \
     int                         pointeur_bin;      type                        *nom[TAILLE_CACHE]; \
       volatile int                pointeur_##nom;
     complex16                   *objets_cpl[TAILLE_CACHE];  
     int                         pointeur_cpl;      CACHE(integer8, adr)
       CACHE(logical8, bin)
     struct fonction             *objets_fct[TAILLE_CACHE];      CACHE(complex16, cpl)
     int                         pointeur_fct;      CACHE(struct_fonction, fct)
       CACHE(integer8, int)
     integer8                    *objets_int[TAILLE_CACHE];      CACHE(struct_matrice, mat)
     int                         pointeur_int;      CACHE(struct_nom, nom)
       CACHE(real8, rel)
     struct_matrice              *objets_mat[TAILLE_CACHE];      CACHE(struct_tableau, tab)
     int                         pointeur_mat;      CACHE(struct_vecteur, vec)
   
     struct_nom                  *objets_nom[TAILLE_CACHE];      CACHE2(struct_liste_chainee, maillons)
     int                         pointeur_nom;      CACHE2(struct_arbre_variables, variables_noeud)
       CACHE2(struct_arbre_variables_partagees, variables_partagees_noeud)
     real8                       *objets_rel[TAILLE_CACHE];      CACHE2(struct_liste_variables, variables_feuille)
     int                         pointeur_rel;      CACHE2(struct_variable, variables_variable)
       CACHE2(struct_arbre_variables *, variables_tableau_noeuds)
     struct_tableau              *objets_tab[TAILLE_CACHE];      CACHE2(struct_arbre_variables_partagees *,
     int                         pointeur_tab;              variables_tableau_noeuds_partages)
   
     struct_vecteur              *objets_vec[TAILLE_CACHE];      CACHE2(struct_buffer, enveloppes_buffers)
     int                         pointeur_vec;      unsigned char       ***cache_buffer;
       int                 *pointeur_cache_buffer;
     struct_liste_chainee        *maillons[TAILLE_CACHE];  
     int                         pointeur_maillons;  
   
     struct_arbre_variables      *variables_noeud[TAILLE_CACHE];  
     int                         pointeur_variables_noeud;  
   
     struct_liste_variables      *variables_feuille[TAILLE_CACHE];  
     int                         pointeur_variables_feuille;  
   
     struct_variable             *variables_variable[TAILLE_CACHE];  
     int                         pointeur_variables_variable;  
   
     struct_arbre_variables      **variables_tableau_noeuds[TAILLE_CACHE];  
     int                         pointeur_variables_tableau_noeuds;  
 } struct_processus;  } struct_processus;
 #endif  #endif
   
   
 /*  /*
 --------------------------------------------------------------------------------  ================================================================================
   Structure fonction    MISE EN PLACE DE L'ALLOCATEUR SPÉCIFIQUE
 --------------------------------------------------------------------------------  ================================================================================*/
 */  
   
 #ifndef RPLARGS  #ifndef DEBUG_MEMOIRE
 typedef struct fonction  #   define malloc(a)            rpl_malloc(s_etat_processus, a)
 {  #   define realloc(a, b)        rpl_realloc(s_etat_processus, a, b)
     unsigned char                       *nom_fonction;  #   define free(a)              rpl_free(s_etat_processus, a)
     unsigned long                       nombre_arguments;  #endif
   
     void                                (*fonction)(struct_processus *);  void *rpl_malloc(struct_processus *s_etat_processus, size_t s);
   void *rpl_realloc(struct_processus *s_etat_processus, void *ptr, size_t s);
   void rpl_free(struct_processus *s_etat_processus, void *ptr);
   void *sys_malloc(size_t s);
   void sys_free(void *ptr);
   
     volatile struct_liste_chainee       *prediction_saut;  /*
     volatile logical1                   prediction_execution;   * Wrapper de readline() pour que la fonction renvoie un pointeur sur un
 } struct_fonction;   * buffer alloué par rpl_malloc().
 #endif   */
   
   #define readline(s) readline_wrapper(s_etat_processus, s)
   unsigned char *readline_wrapper(struct_processus *s_etat_processus,
           unsigned char *s);
   
   
 /*  /*
Line 2357  void instruction_ceil(struct_processus * Line 2533  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 2377  void instruction_col_fleche(struct_proce Line 2554  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 2417  void instruction_detach(struct_processus Line 2595  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 2443  void instruction_elseif(struct_processus Line 2622  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 2683  void instruction_return(struct_processus Line 2863  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 2802  void instruction_t_vers_l(struct_process Line 2984  void instruction_t_vers_l(struct_process
   
 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_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 2852  void instruction_yield(struct_processus Line 3035  void instruction_yield(struct_processus
 #ifndef RPLARGS  #ifndef RPLARGS
 void affectation_interruptions_logicielles(struct_processus *s_etat_processus);  void affectation_interruptions_logicielles(struct_processus *s_etat_processus);
 void affichage_pile(struct_processus *s_etat_processus,  void affichage_pile(struct_processus *s_etat_processus,
         struct_liste_chainee *l_element_courant, unsigned long          struct_liste_chainee *l_element_courant, integer8 niveau_courant);
         niveau_courant);  
 #endif  #endif
   
 void *allocation_maillon(struct_processus *s_etat_processus);  void *allocation_maillon(struct_processus *s_etat_processus);
Line 2871  void conversion_chaine(struct_processus Line 3053  void conversion_chaine(struct_processus
         unsigned char *chaine, unsigned char type);          unsigned char *chaine, unsigned char type);
 void conversion_decimal_vers_hms(real8 *angle);  void conversion_decimal_vers_hms(real8 *angle);
 void conversion_degres_vers_radians(real8 *angle);  void conversion_degres_vers_radians(real8 *angle);
 void conversion_element_tex(unsigned char **element, unsigned char *fonction);  void conversion_element_tex(struct_processus *s_etat_processus,
           unsigned char **element, unsigned char *fonction);
 void conversion_format(struct_processus *s_etat_processus,  void conversion_format(struct_processus *s_etat_processus,
         unsigned char *chaine);          unsigned char *chaine);
 void conversion_hms_vers_decimal(real8 *angle);  void conversion_hms_vers_decimal(real8 *angle);
 void conversion_majuscule_limitee(unsigned char *chaine_entree,   void conversion_majuscule_limitee(
         unsigned char *chaine_sortie, unsigned long longueur);          unsigned char *chaine_entree, unsigned char *chaine_sortie,
           integer8 longueur);
 void conversion_radians_vers_degres(real8 *angle);  void conversion_radians_vers_degres(real8 *angle);
 void copie_arbre_variables(struct_processus *s_etat_processus,  void copie_arbre_variables(struct_processus *s_etat_processus,
         struct_processus *s_nouvel_etat_processus);          struct_processus *s_nouvel_etat_processus);
Line 2889  void determinant(struct_processus *s_eta Line 3073  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 2914  void formateur_elementaire_tex(struct_pr Line 3098  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);
Line 2922  void initialisation_completion(void); Line 3106  void initialisation_completion(void);
 void initialisation_contexte_cas(struct_processus *s_etat_processus);  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);  void initialisation_variables(struct_processus *s_etat_processus);
 #endif  #endif
Line 2962  void liberation_arbre_instructions(struc Line 3146  void liberation_arbre_instructions(struc
         struct_instruction *arbre);          struct_instruction *arbre);
 void liberation_arbre_variables(struct_processus *s_etat_processus,  void liberation_arbre_variables(struct_processus *s_etat_processus,
         struct_arbre_variables *arbre, logical1 definitions);          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_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 2975  void profilage(struct_processus *s_etat_ Line 3163  void profilage(struct_processus *s_etat_
 void rang(struct_processus *s_etat_processus, struct_matrice *s_matrice,  void rang(struct_processus *s_etat_processus, struct_matrice *s_matrice,
         integer8 *valeur);          integer8 *valeur);
 void recherche_type(struct_processus *s_etat_processus);  void recherche_type(struct_processus *s_etat_processus);
   void reinitialisation_mutexes_variables_partagees(
           struct_processus *s_etat_processus);
 void retrait_thread(struct_processus *s_etat_processus);  void retrait_thread(struct_processus *s_etat_processus);
 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);
Line 2987  void scrutation_injection(struct_process Line 3177  void scrutation_injection(struct_process
 void scrutation_interruptions(struct_processus *s_etat_processus);  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 3034  int envoi_signal_thread(pthread_t tid, e Line 3225  int envoi_signal_thread(pthread_t tid, e
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
 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 3058  int rplinit(int argc, char *argv[], char Line 3249  int rplinit(int argc, char *argv[], char
   
 #ifndef RPLARGS  #ifndef RPLARGS
 real8 correlation_statistique(struct_matrice *s_matrice,  real8 correlation_statistique(struct_matrice *s_matrice,
         unsigned long colonne_1, unsigned long colonne_2, logical1 *erreur);          integer8 colonne_1, integer8 colonne_2, logical1 *erreur);
 real8 covariance_statistique(struct_matrice *s_matrice,  real8 covariance_statistique(struct_matrice *s_matrice,
         unsigned long colonne_1, unsigned long colonne_2,          integer8 colonne_1, integer8 colonne_2,
         unsigned char type, logical1 *erreur);          unsigned char type, logical1 *erreur);
 struct_vecteur *ecart_type_statistique(struct_matrice *s_matrice,  struct_vecteur *ecart_type_statistique(struct_processus *s_etat_processus,
         unsigned char type);          struct_matrice *s_matrice, unsigned char type);
 struct_vecteur *moyenne_statistique(struct_matrice *s_matrice);  struct_vecteur *moyenne_statistique(struct_processus *s_etat_processus,
 struct_vecteur *sommation_colonne_statistique(struct_matrice *s_matrice,          struct_matrice *s_matrice);
         unsigned long colonne);  struct_vecteur *sommation_colonne_statistique(
 struct_vecteur *sommation_produits_colonnes_statistiques(struct_matrice          struct_processus *s_etat_processus, struct_matrice *s_matrice,
         *s_matrice, unsigned long colonne_1, unsigned long colonne_2);          integer8 colonne);
 struct_vecteur *sommation_statistique(struct_matrice *s_matrice);  struct_vecteur *sommation_produits_colonnes_statistiques(
 struct_vecteur *variance_statistique(struct_matrice *s_matrice,          struct_processus *s_etat_processus, struct_matrice
         unsigned char type);          *s_matrice, integer8 colonne_1, integer8 colonne_2);
   struct_vecteur *sommation_statistique(struct_processus *s_etat_processus,
           struct_matrice *s_matrice);
   struct_vecteur *variance_statistique(struct_processus *s_etat_processus,
           struct_matrice *s_matrice, unsigned char type);
 #endif  #endif
   
 /*  /*
Line 3094  struct_liste_chainee *depilement_pile_op Line 3289  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 3106  struct_liste_chainee *sauvegarde_argumen Line 3301  struct_liste_chainee *sauvegarde_argumen
 unsigned char *analyse_algebrique(struct_processus *s_etat_processus,  unsigned char *analyse_algebrique(struct_processus *s_etat_processus,
         unsigned char *chaine_algebrique, struct_liste_chainee **l_base_liste);          unsigned char *chaine_algebrique, struct_liste_chainee **l_base_liste);
 unsigned char *analyse_flux(struct_processus *s_etat_processus,  unsigned char *analyse_flux(struct_processus *s_etat_processus,
         unsigned char *flux, long longueur);          unsigned char *flux, integer8 longueur);
 unsigned char *recherche_chemin_fichiers_temporaires(struct_processus  unsigned char *chiffrement(struct_processus *s_etat_processus,
         *s_etat_processus);          const EVP_CIPHER *type_chiffrement,
 unsigned char *compactage(unsigned char *chaine);          logical1 encodage, unsigned char *message, integer8 longueur_message,
 unsigned char *conversion_majuscule(unsigned char *chaine);          unsigned char *clef, integer8 longueur_clef,
           unsigned char *vecteur_initialisation,
           integer8 *longueur_message_chiffre);
   unsigned char *compactage(struct_processus *s_etat_processus,
           unsigned char *chaine);
   unsigned char *conversion_majuscule(struct_processus *s_etat_processus,
           unsigned char *chaine);
 unsigned char *creation_nom_fichier(struct_processus *s_etat_processus,  unsigned char *creation_nom_fichier(struct_processus *s_etat_processus,
         unsigned char *chemin);          unsigned char *chemin);
 unsigned char *date_compilation();  unsigned char *date_compilation(struct_processus *s_etat_processus);
 unsigned char *extraction_chaine(unsigned char *chaine, unsigned long i,  unsigned char *extraction_chaine(struct_processus *s_etat_processus,
         unsigned long j);          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 *formateur_flux(struct_processus *s_etat_processus,
         unsigned char *donnees, long *longueur);          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  unsigned char *formateur_fichier_binaire_nombre(struct_processus
         *s_etat_processus, void *valeur_numerique, unsigned char type,          *s_etat_processus, void *valeur_numerique, unsigned char type_entree,
         long longueur, long *longueur_conversion);          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,
Line 3140  unsigned char *formateur_reel(struct_pro Line 3342  unsigned char *formateur_reel(struct_pro
 unsigned char *messages(struct_processus *s_etat_processus);  unsigned char *messages(struct_processus *s_etat_processus);
 unsigned char *pointeur_ieme_caractere(struct_processus *s_etat_processus,  unsigned char *pointeur_ieme_caractere(struct_processus *s_etat_processus,
         unsigned char *chaine, integer8 position);          unsigned char *chaine, integer8 position);
 unsigned char *purification_chaine(unsigned char *chaine);  unsigned char *purification_chaine(struct_processus *s_etat_processus,
           unsigned char *chaine);
   unsigned char *recherche_chemin_fichiers_temporaires(struct_processus
           *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 3157  unsigned char *transliteration(struct_pr Line 3362  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);
Line 3180  logical1 destruction_fichier(unsigned ch Line 3386  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 3208  logical1 sequenceur_optimise(struct_proc Line 3421  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 3217  logical1 recherche_variable(struct_proce Line 3431  logical1 recherche_variable(struct_proce
         unsigned char *nom_variable);          unsigned char *nom_variable);
 logical1 recherche_variable_globale(struct_processus *s_etat_processus,  logical1 recherche_variable_globale(struct_processus *s_etat_processus,
         unsigned char *nom_variable);          unsigned char *nom_variable);
 logical1 recherche_variable_partagee(struct_processus *s_etat_processus,  
         unsigned char *nom_variable, union_position_variable position,  
         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);
Line 3249  ssize_t write_atomic(struct_processus *s Line 3457  ssize_t write_atomic(struct_processus *s
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
 int alsprintf(unsigned char **strp, const char *fmt, ...);  int alsprintf(struct_processus *s_etat_processus,
           unsigned char **strp, const char *fmt, ...);
   #ifndef RPLARGS
   int association_etat_processus_readline();
   #endif
 int interruption_violation_access(void *adresse_fautive, int gravite);  int interruption_violation_access(void *adresse_fautive, int gravite);
 #ifndef RPLARGS  #ifndef RPLARGS
 int liste_variables(struct_processus *s_etat_processus,  int initialisation_etat_processus_readline();
         struct_tableau_variables *tableau, int position,  int liberation_etat_processus_readline();
         struct_arbre_variables *l_element_courant);  integer8 liste_variables(struct_processus *s_etat_processus,
 int nombre_variables(struct_processus *s_etat_processus,          struct_tableau_variables *tableau);
         struct_arbre_variables *l_element_courant);  integer8 nombre_variables(struct_processus *s_etat_processus);
 int readline_analyse_syntaxique(int count, int key);  int readline_analyse_syntaxique(int count, int key);
 int readline_effacement(int count, int key);  int readline_effacement(int count, int key);
 #endif  #endif
   int std_fprintf(file *flux, const char *format, ...);
 int tex_fprintf(struct_processus *s_etat_processus,  int tex_fprintf(struct_processus *s_etat_processus,
         file *flux, const char *format, ...);          file *flux, const char *format, ...);
 int transliterated_fprintf(struct_processus *s_etat_processus, file *flux,  int transliterated_fprintf(struct_processus *s_etat_processus, file *flux,
         const char *format, ...);          const char *format, ...);
 int valsprintf(unsigned char **strp, const char *fmt, va_list ap);  int valsprintf(struct_processus *s_etat_processus,
           unsigned char **strp, const char *fmt, va_list ap);
 int wrapper_instruction_intrinseque(void (*fonction)(),  int wrapper_instruction_intrinseque(void (*fonction)(),
         struct_rpl_arguments *rpl_arguments);          struct_rpl_arguments *rpl_arguments);
   
Line 3315  struct_liste_chainee *analyse_rpn(struct Line 3529  struct_liste_chainee *analyse_rpn(struct
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
     Allocateur de buffers à cache
   --------------------------------------------------------------------------------
   */
   
   void initialisation_allocateur_buffer(struct_processus *s_etat_processus);
   void liberation_allocateur_buffer(struct_processus *s_etat_pocessus);
   struct_buffer *allocation_buffer(struct_processus *s_etat_processus,
           size_t longueur);
   void liberation_buffer(struct_processus *s_etat_processus,
           struct_buffer *buffer);
   
   /*
   --------------------------------------------------------------------------------
   Fonctions renvoyant une copie de la structure de description des processus    Fonctions renvoyant une copie de la structure de description des processus
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
Line 3348  struct_objet *allocation(struct_processu Line 3575  struct_objet *allocation(struct_processu
 #ifndef RPLARGS  #ifndef RPLARGS
 struct_objet *formateur_date(struct_processus *s_etat_processus,  struct_objet *formateur_date(struct_processus *s_etat_processus,
         struct timeval *temps);          struct timeval *temps);
   struct_objet *lecture_fichier_non_formate(struct_processus *s_etat_processus,
           void *argument, integer8 longueur_buffer, logical1 recursivite);
 struct_objet *lecture_pipe(struct_processus *s_etat_processus, int pipe);  struct_objet *lecture_pipe(struct_processus *s_etat_processus, int pipe);
 struct_objet *parametres_sql(struct_processus *s_etat_processus,  struct_objet *parametres_sql(struct_processus *s_etat_processus,
         struct_objet *s_parametres);          struct_objet *s_parametres);
 struct_objet *simplification(struct_processus *s_etat_processus,  struct_objet *simplification(struct_processus *s_etat_processus,
         struct_objet *s_objet);          struct_objet *s_objet);
 #endif  
   struct_arbre_variables *allocation_noeud(struct_processus *s_etat_processus);
   struct_arbre_variables **allocation_tableau_noeuds(
           struct_processus *s_etat_processus);
   
 /*  /*
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
   Fonctions gérant les arbres de simplification    Fonctions renvoyant un pointeur sur une *struct_liste_variables_statiques
     ou *struct_liste_variables_partagees
 --------------------------------------------------------------------------------  --------------------------------------------------------------------------------
 */  */
   
 #ifndef RPLARGS  struct_liste_variables_statiques *recherche_variable_statique(struct_processus
 struct_arbre *creation_arbre(struct_processus *s_etat_processus,          *s_etat_processus, unsigned char *nom_variable,
         struct_objet **t_objets, unsigned long indice,          union_position_variable position, unsigned char origine);
         unsigned long indice_maximal);  struct_liste_variables_partagees *recherche_variable_partagee(struct_processus
 void liberation_arbre(struct_processus *s_etat_processus,          *s_etat_processus, unsigned char *nom_variable,
         struct_arbre *s_noeud);          union_position_variable position, unsigned char origine);
 void parcours_arbre(struct_processus *s_etat_processus, struct_arbre *s_noeud);  
 void simplification_arbre(struct_processus *s_etat_processus,  
         struct_arbre *s_noeud);  
 #endif  #endif
   
 /*  /*
Line 3407  void f77multiplicationci_(complex16 *ca, Line 3637  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);
Removed from v.1.178  
changed lines
  Added in v.1.278

CVSweb interface <joel.bertrand@systella.fr>